SprogCoder

Android SQLite Database Design Pattern - Extensible, Blocking and Simple

2012-06-24T16:28:00.000-07:00

This post is in response to my need to have an Android Database that will:

A) Never ever get into an illegal state, i.e. errors occur if you create/write/read tables at the same time.
B) Split up management of Database tables by creating classes for each one, but still using one single Database.
C) Reuse common Database functionality by creating helper methods.
D) Works at least in Android 2.1+.

Here is that solution - tested using multiple threads. I use a global application context to create the database, namely 'MyApplication.java' which is copied at the bottom of this post.

AbstractDBAdapter.java - Base class holding Database and helper methods.

public class AbstractDBAdapter
{

   private static final String DB_NAME = "CountriesDatabase";
   private static final String DB_TAG = "Countries Database Tag";
   private static final int DB_VERSION = 1;
   
   private volatile static DatabaseHelper mDbHelper;
   
   private static final Object lock = new Object();

   protected static final String COUNTRIES_TABLE_NAME = "CountriesTable";
   private static final String COUNTRIES_TABLE_CREATE = "CREATE TABLE " + COUNTRIES_TABLE_NAME
         + " (COUNTRY_NAME TEXT, COUNTRY_CAPITAL TEXT);";
   private static final String COUNTRIES_TABLE_DROP = "DROP TABLE IF EXISTS " + COUNTRIES_TABLE_NAME + ";";

   /**
    * Constructor - takes the context to allow the Database to be opened/created
    * 
    * @param context the Context within which to work
    */
   protected AbstractDBAdapter(Context context)
   {
      if (mDbHelper == null)
      {
         synchronized (AbstractDBAdapter.class)
         {
            if (mDbHelper == null)
            {
               if (context == null)
               {
                  throw new RuntimeException("Context is null!");
               }
               mDbHelper = new DatabaseHelper(context);
            }
         }
      }
   }

   /**
    * Helper Methods
    */
   private Cursor getCursor(String tableName, String args)
   {
      String SQL_STATEMENT = "";
      if (args != null)
      {
         SQL_STATEMENT = "SELECT * FROM " + tableName + " WHERE " + args;
      }
      else
      {
         SQL_STATEMENT = "SELECT * FROM " + tableName;
      }
      Cursor c = mDbHelper.getReadableDatabase().rawQuery(SQL_STATEMENT, null);
      return c;
   }

   protected String getString(String tableName, String args, String columnIndex)
   {
      synchronized (lock)
      {
         String text = "";
         Cursor c = getCursor(tableName, args);
         if (c.moveToFirst())
         {
            text = c.getString(c.getColumnIndex(columnIndex));
         }
         c.close();
         mDbHelper.getReadableDatabase().close();
         return text;
      }
   }

   protected String insertRow(String tableName, ContentValues cv)
   {
      synchronized (lock)
      {
         long result = mDbHelper.getWritableDatabase().insertOrThrow(tableName, null, cv);
         mDbHelper.getWritableDatabase().close();
         if (result == -1)
         {
            // String stringResult = (result == -1) ? "Row Already Exists" : "Row Added";
         }
         return Long.toString(result);
      }
   }
   
   /**
    * Internal Database
    */
   private static class DatabaseHelper extends SQLiteOpenHelper
   {

      DatabaseHelper(Context context)
      {
         super(context, DB_NAME, null, DB_VERSION);
         Log.v(DB_TAG, "DatabaseHelper() - Database " + DB_NAME + " Ready - Version: " + DB_VERSION);
      }

      @Override
      public void onCreate(SQLiteDatabase db)
      {
         db.execSQL(COUNTRIES_TABLE_CREATE);
         Log.v(DB_TAG, "onCreate() - Created New Database - DatabaseName: " + DB_NAME);
      }

      @Override
      public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)
      {
         db.execSQL(COUNTRIES_TABLE_DROP);
         onCreate(db);
         Log.v(DB_TAG, "onUpgrade() - Upgrading Database - DatabaseName: " + DB_NAME);
      }
   }

}

DBAdapterCountry.java - Class that manages the table 'CountriesTable'. Extends AbstractDBAdapter.java.

public class DBAdapterCountry extends AbstractDBAdapter
{

   /**
    * Singleton Instance Creation
    */
   private volatile static DBAdapterCountry INSTANCE;

   static DBAdapterCountry getInstance()
   {
      if (INSTANCE == null)
      {
         synchronized (DBAdapterCountry.class)
         {
            if (INSTANCE == null)
            {
               INSTANCE = new DBAdapterCountry(MyApplication.getAppContext());
            }
         }
      }
      return INSTANCE;
   }

   private DBAdapterCountry(Context context)
   {
      super(context);
   }

   /**
    * Class
    */
   public void addCountry(String countryName, String countryCapital)
   {
      ContentValues cv = new ContentValues();
      cv.put("COUNTRY_NAME", countryName);
      cv.put("COUNTRY_CAPITAL", countryCapital);
      insertRow(COUNTRIES_TABLE_NAME, cv);
   }

   public String getCountryCapital(String countryName)
   {
      String args = "COUNTRY_NAME='" + countryName + "'";
      return getString(COUNTRIES_TABLE_NAME, args, "COUNTRY_CAPITAL");
   }
   
}

DatabaseActivity.java - Activity used to test the Database.

public class DatabaseActivity extends Activity
{
   @Override
   public void onCreate(Bundle savedInstanceState)
   {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);
      
      // Thread 1 
      Thread thread1 = new Thread(new Runnable()
      {
         public void run()
         {
            DBAdapterCountry.getInstance().addCountry("England", "London");
            Log.v("MyTag", DBAdapterCountry.getInstance().getCountryCapital("England"));
         }
      });
      
      // Thread 2
      Thread thread2 = new Thread(new Runnable()
      {
         public void run()
         {
            DBAdapterCountry.getInstance().addCountry("France", "Paris");
            Log.v("MyTag", DBAdapterCountry.getInstance().getCountryCapital("France"));
         }
      });
      
      // Thread 3
      Thread thread3 = new Thread(new Runnable()
      {
         public void run()
         {
            DBAdapterCountry.getInstance().addCountry("Spain", "Madrid");
            Log.v("MyTag", DBAdapterCountry.getInstance().getCountryCapital("Spain"));
         }
      });

      thread1.start();
      thread2.start();
      thread3.start();
   }
}

MyApplcation.java - Started when application is loaded - contains global application context. The line android:name=".MyApplication also needs to be added in your AndroidManifest.xml to make it start when your application starts.

public class MyApplication extends Application
{

   private static Context context;

   public void onCreate()
   {
      super.onCreate();
      MyApplication.context = getApplicationContext();
   }

   public static Context getAppContext()
   {
      return context;
   }

}

If you stick to this pattern of Database creation you can simply add a new adapter class, along with a create/drop SQL statement whenever you want to add a new table. And if you need any other helper methods like getInt you can add them to AbstractDBAdapter.java.

I believe this approach makes Database code management a lot simpler, cohesive, cuts down lines of code and most importantly does not cause the Database to get into an illegal state.

Any comments on this approach are welcome! :)

Android Intents - Passing Serializable Custom Objects to an Activity

2012-01-16T09:33:00.000-08:00

The passing of custom objects to an Activity using Intents can seem very confusing - honestly I never quite worked out how to use Parcelable. It seemed like a lot of code for passing a custom object to one of my activities. The method of passing objects I settled for was one that required the least amount of code and did the job.

That method is to implement Serializable for the object's class you want to pass to an activity. Then simply pass that serialized object into the intent and grab it when the activity is started. This stackoverflow question does point out its downfalls however, so beware, the most important downfalls for me would be that its slow and can cause increased gc activity. I promise I will spend time with Parcelable and write a blog post on it, and make it as easy as possible to understand!

Here is our custom object we are going to pass to another activity, notice it implements Serializable, this is very important as when we use putExtra(String name, Serializable value) in our intent it takes a Serializable parameter.

import java.io.Serializable;

public class Present implements Serializable
{

 private final String text;

 public Present(String text)
 {
  this.text = text;
 }

 public String getText()
 {
  return text;
 }

}

Now in the activity class where you start another activity using an intent, use this code.

Present myPresent = new Present ("Red Bike");
Intent intent = new Intent(this, SecondActivity.class); // replace with own Activity class
intent.putExtra("present", myPresent);
startActivity(intent);

From the 'SecondActivity' class you can get the object back by doing this:

Intent intent = getIntent();
Present myPresent = (Present)intent.getSerializableExtra("present");
Log.v("Tag", "My Present is: " + myPresent.getText());

Now you should be able to send and receive custom objects to other activities!

Android Custom Logging - Enable/Disable Logs

2012-01-12T09:11:00.000-08:00

Part of the Android 'Preparing for Release' onto the Android Market is to remove all Log messages and have the android:debuggable="false" in the manifest file. This is outlined here in the section called 'Turn off logging and debugging'.

Removing all logs can be difficult, however you might still decide, that's okay I will comment all my logs out! This would not be a bad idea but its not the most efficient by far, an alternative is to add 'if' statements for every Log in your app that points to a global boolean flag...however that is also not easy with lots of Log calls.

The solution that I adopted was create a wrapper class around the Log class called MyLog. Then by replacing all instances of Log in my Android app with MyLog, I was then able to have an 'on off' switch for Log calls...the code looked a little bit like this:

import android.util.Log;

public class MyLog
{
 
 private MyLog()
 {
  
 }

 private static boolean LOG_ENABLED = true;

 public static void d(String tag, String msg)
 {
  if (LOG_ENABLED)
   Log.d(tag, msg);
 }
 
 public static void d(String tag, String msg, Throwable tr)
 {
  if (LOG_ENABLED)
   Log.d(tag, msg, tr);
 }

 public static void e(String tag, String msg)
 {
  if (LOG_ENABLED)
   Log.e(tag, msg);
 }

 public static void e(String tag, String msg, Throwable tr)
 {
  if (LOG_ENABLED)
   Log.e(tag, msg, tr);
 }

 public static void i(String tag, String msg)
 {
  if (LOG_ENABLED)
   Log.i(tag, msg);
 }

 public static void i(String tag, String msg, Throwable tr)
 {
  if (LOG_ENABLED)
   Log.i(tag, msg, tr);
 }
 
 public static void v(String tag, String msg)
 {
  if (LOG_ENABLED)
   Log.v(tag, msg);
 }
 
 public static void v(String tag, String msg, Throwable tr)
 {
  if (LOG_ENABLED)
   Log.v(tag, msg, tr);
 }
 
 public static void w(String tag, Throwable tr)
 {
  if (LOG_ENABLED)
   Log.w(tag, tr);
 }
 
 public static void w(String tag, String msg, Throwable tr)
 {
  if (LOG_ENABLED)
   Log.w(tag, msg, tr);
 }

 public static void w(String tag, String msg)
 {
  if (LOG_ENABLED)
   Log.w(tag, msg);
 }
 
}

Example Log from MyLog:

MyLog.v("Tag","Hello World!");

As you may have guessed to turn the logs off you change the code to LOG_ENABLED = false, this allows you to easily switch between development and publishing versions of the code.

Java Message Box (Alert Popup)

2011-10-23T02:34:00.000-07:00

A simple alternative to printing out messages in the console, this code will popup a message box in Java similar to that of Javascript alert("hello").

The code can be modified to include several types of message box types such as an error icon or different button options. Have a look JOptionPane in the JavaDoc's for more information on these.

import javax.swing.JOptionPane;

/**
 * Displays a popup message box in Java
 */
public class MessageBox
{

  /**
   * Displays a popup message box with the Information Message icon and button "Okay"
   * 
   * @param message the message to display in the popup
   */
   public static void MessageBoxOkayInfo(String message)
   {
     JOptionPane.showMessageDialog(null, message, "Alert",
     JOptionPane.INFORMATION_MESSAGE);
   }
}

To try this code use this snippet.

MessageBox.MessageBoxOkayInfo("Hello World!");

Java Custom Component - Colored Progress Bar

2011-10-10T13:21:00.000-07:00

After getting slightly bored of the standard Java components available to me I decided to spice things up a little. I wanted to be able to have a clean, colourful and customizable progress bar. I also wanted the progress bar to be able to change colour at certain values, such as when it reaches a low percent it will go red.

Essentially I extend JComponent and use paintComponent method which is called automatically by Java to draw the progress bar.

This code can be easily extended and customized to change/add more colours as well as editing the percentages of the bar as to when it will change colour

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.RenderingHints;

import javax.swing.JComponent;

public class ProgressBarColored extends JComponent
{

 private static final long serialVersionUID = 1L;

 private Rectangle clipRect = new Rectangle(); // creating new rectangular area to draw on

 private double accuracy = 100; // how accurately the progress bar is drawn
 private double percentage; // progress bar percentage (%)
 private double maximumValue = 100; // maximum value of progress bar
 private double value = 0; // value of progress bar

 private volatile Color backgroundColor = Color.black; // background color of progress bar
 
 private volatile Color foregroundColor;
 private Color startColor = new Color(0, 255, 0); // green color when progress bar is high %
 private Color middleColor = new Color(255, 255, 0); // yellow color when progress bar is medium %
 private Color endColor = new Color(204, 0, 0); // red color when progress bar is low %

 private int hPadding = 10; // horizontal padding
 private int vPadding = 10; // vertical padding

 /**
  * 
  * Creates a new ProgressBarColored with a maximum value and initial starting value
  * 
  * @param maximumValue
  * @param initialValue
  */
 public ProgressBarColored(final int maximumValue, int initialValue)
 {
  this.maximumValue = maximumValue;
  this.value = initialValue;
  this.setDoubleBuffered(true);
  setValue(value);
 }

 
 protected void paintComponent(Graphics g)
 {
  accuracy = getWidth() / maximumValue;

  g.getClipBounds(clipRect); // get progress bar's drawing area
  Graphics2D g2d = (Graphics2D) g.create(); // create Graphics2D object based on clipped graphics area
 
  g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); // setting rendering hints
  
  drawBackground(g2d); // draw progress bar background
  drawForground(g2d); // draw progress bar progress graphic in foreground
  
  g2d.dispose(); // clean up
 }


 private void drawBackground(Graphics2D g2d)
 {
  g2d.setColor(backgroundColor);
  g2d.fillRect(hPadding/2, vPadding/2, getWidth() - hPadding , getHeight() - vPadding);
 }

 private void drawForground(Graphics2D g2d)
 {
  g2d.setColor(foregroundColor);
  g2d.fillRect(hPadding/2, vPadding/2, (int) ((getWidth() - hPadding) / ((maximumValue * accuracy) / (value * accuracy))), getHeight() - vPadding);
 }

 /**
  * 
  * Sets the value of the progress bar and automatically assigns the color of it
  * 
  * @param newValue
  */
 public void setValue(double newValue)
 {
  value = newValue;
  accuracy = getWidth() / maximumValue;
  percentage = ((getValue() * 1.0) / getMaximum()) * 100;
  if (percentage == 100) // when between 40% and 100%
  {
   setForeground(startColor);
  }
  else if (percentage >= 20 && percentage < 40) // when between 20% and 40%
  {
   setForeground(middleColor);
  }
  else if (percentage >= 0 && percentage < 20) // when between 0% and 20%
  {
   setForeground(endColor);
  }
  repaint();
 }
 
 public double getValue()
 {
  return value;
 }

 public void setMaximum(double newMaximumValue)
 {
  maximumValue = newMaximumValue;
  repaint();
 }
 
 public double getMaximum()
 {
  return maximumValue;
 }

 @Override
 public void setForeground(Color color)
 {
  this.foregroundColor = color;
 }
 
 @Override
 public Color getForeground()
 {
  return foregroundColor;
 }

 @Override
 public void setBackground(Color color)
 {
  this.backgroundColor = color;
 }

 @Override
 public Color getBackground()
 {
  return backgroundColor;
 }
 
 @Override
 public Dimension getPreferredSize()
 {
  return new Dimension(100, 30);
 }
 
 @Override
 public Dimension getMinimumSize()
 {
  return new Dimension(10, 5);
 }

}

Here is some example code that will enable you to test the component using a timer decreasing from 100 to 0. Copy and paste this code somewhere in a gui to test it out.

...
ProgressBarColored progressBarColored = new ProgressBarColored(100, 100);
...
for (int i = 0; i <= 100; i++)
{
 try
 {
  Thread.sleep(50);
  progressBarColored.setValue(100 - i);
 }
 catch (InterruptedException e)
 {
  e.printStackTrace();
 }
}

Below is a screenshot of the progress bar within an interface with a low percentage, the percent is between 20 and 40 percent so the color is yellow.

Any feedback or questions are welcome!