Android pre-populated Database

Today I am going to show you how to create an android application which comes with a pre-populated database. The database file has to be stored in assets directory.

Every file that is stored in Assets directory is compressed. Prior to Android 2.3, any compressed asset file with an uncompressed size of over 1 MB cannot be read from the APK. The limit on the uncompressed size of compressed assets was removed in Android 2.3. So someday in the future, when you don’t have to worry about Android versions lower than 2.3, you can avoid this heartache. (source: Brian Hardy-Dealing with Asset Compression in Android Apps

So if you have a database file over 1 mb and you write an application that supports Android versions prior to 2.3 you have 2 options

Split your database file in chunks which are smaller than 1Mb.

Ship your file with an extension from the following and it will not be compressed. (This will increase your .apk file size by the size of database file):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


//extract from Package.cpp in the aapt source code, on which types of files are not compressed by default:

/* these formats are already compressed, or don't compress well */
static const char* kNoCompressExt[] = {
    ".jpg", ".jpeg", ".png", ".gif",
    ".wav", ".mp2", ".mp3", ".ogg", ".aac",
    ".mpg", ".mpeg", ".mid", ".midi", ".smf", ".jet",
    ".rtttl", ".imy", ".xmf", ".mp4", ".m4a",
    ".m4v", ".3gp", ".3gpp", ".3g2", ".3gpp2",
    ".amr", ".awb", ".wma", ".wmv"
};

Then create your pre-populated database file which has android_metadata table in it and insert a record. (Android creates automatically this table when you are creating your database in a traditional way in SQLiteOpenHelper onCreate() method.) :

1
2
3
4
5


-- create table
CREATE TABLE android_metadata (locale TEXT );

-- insert record
INSERT INTO android_metadata VALUES('en_US');

Then create your class which extends SQLiteOpenHelper like this:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177


public class DatabaseHelper extends SQLiteOpenHelper {

private static final String TAG = "DatabaseHelper";
private static final int DATABASE_VERSION = 1;

// database file name.
private static final String DB_NAME = "mp.jet";

private final Context myContext;

private static SQLiteDatabase myWritableDb;

/**
 * Constructor takes and keeps a reference of the passed context in order to
 * access to the application assets and resources.
 * 
 * @param context
 *            the application context
 */
public DatabaseHelper(Context context) {

	super(context, DB_NAME, null, 1);
	this.myContext = context;
}

@Override
public void onCreate(SQLiteDatabase db) {
}

@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
}

/**
 * Returns a writable database instance in order not to open and close many
 * SQLiteDatabase objects simultaneously
 * 
 * @return a writable instance to SQLiteDatabase
 */
public SQLiteDatabase getMyWritableDatabase() {
	if (myWritableDb == null || (!myWritableDb.isOpen())) {
		myWritableDb = this.getWritableDatabase();
	}

	return myWritableDb;
}

@Override
public void close() {
	super.close();
	if (myWritableDb != null) {
		myWritableDb.close();
		myWritableDb = null;
	}
}

/**
 * Creates an empty database on the system and rewrites it with your own
 * database.
 * */
public void createDataBase() throws IOException {

	boolean dbExist = databaseExists();

	if (dbExist) {
		// do nothing , database already exists
	} else {

		/**
		 * By calling this method and empty database will be created into
		 * the default system path of your application so we are gonna be
		 * able to overwrite that database with our database.
		 */
		this.getReadableDatabase();

		// release all opened database objects
		// if you omit this line you will get a "no such table exception"
		// and
		// the application will crash ONLY in the first run.
		this.close();

		try {

			copyDataBase();
		} catch (IOException e) {

			throw new Error("Error copying database");

		}
	}

}

/**
 * Check if the database already exist to avoid re-copying the file each
 * time you open the application.
 * 
 * @return true if it exists, false if it doesn't
 */
private boolean databaseExists() {

	SQLiteDatabase checkDB = null;

	try {
		String myPath = getDatabasePath();
		checkDB = SQLiteDatabase.openDatabase(myPath, null,
				SQLiteDatabase.OPEN_READONLY);

	} catch (SQLiteException e) {
		// database does not exist yet.
	}

	if (checkDB != null) {
		checkDB.close();
	}

	return checkDB != null ? true : false;
}

/**
 * Copies your database from your local assets-folder to the just created
 * empty database in the system folder, from where it can be accessed and
 * handled. This is done by transferring bytestream.
 * */
private void copyDataBase() throws IOException {
	Log.d(TAG, "copyDatabase()");

	// Open your local db as the input stream
	InputStream myInput = myContext.getAssets().open(DB_NAME);

	// Path to the just created empty db
	String outFileName = getDatabasePath();

	// Open the empty db as the output stream
	OutputStream myOutput = new FileOutputStream(outFileName);

	// transfer bytes from the inputfile to the outputfile
	byte[] buffer = new byte[1024];
	int length;
	while ((length = myInput.read(buffer)) > 0) {
		myOutput.write(buffer, 0, length);
	}

	SQLiteDatabase checkDB = null; // get a reference to the db.

	try {

		checkDB = SQLiteDatabase.openDatabase(getDatabasePath(), null,
				SQLiteDatabase.OPEN_READWRITE);

		// once the db has been copied, set the new version..
		checkDB.setVersion(DATABASE_VERSION);
		checkDB.close();
	} catch (SQLiteException e) {
		// database does?t exist yet.
	}

	// Close the streams
	myOutput.flush();
	myOutput.close();
	myInput.close();

}

/**
 * Get absolute path to database file. The Android's default system path of
 * your application database is /data/data/&ltpackage
 * name&gt/databases/&ltdatabase name&gt
 * 
 * @return path to database file
 */
private String getDatabasePath() {
	// The Android's default system path of your application database.
	// /data/data/<package name>/databases/<databasename>
	return myContext.getFilesDir().getParentFile().getAbsolutePath()
			+ "/databases/" + DB_NAME;
}