Below is a class called DbExportImport. Once you’ve set it up with the correct values, all you need to do is call exportDb(), importDb() or restoreDb() from your application to perform the necessary operations.

This is also useful as a temporary measure when changing your package name or key for application signing, as your application will be newly installed and you will lose your database.

I have only left in a few comments, so for any clarification, leave a comment and I’ll make it a little clearer.

package testCode;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.FileChannel;

import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteException;
import android.os.Environment;
import android.text.format.DateFormat;
import android.util.Log;

public class DbExportImport {

	public static final String TAG = DbExportImport.class.getName();

	/** Directory that files are to be read from and written to **/
	protected static final File DATABASE_DIRECTORY =
		new File(Environment.getExternalStorageDirectory(),"MyDirectory");

	/** File path of Db to be imported **/
	protected static final File IMPORT_FILE =
		new File(DATABASE_DIRECTORY,"MyDb.db");

	public static final String PACKAGE_NAME = "com.example.app";
	public static final String DATABASE_NAME = "example.db";
	public static final String DATABASE_TABLE = "entryTable";

	/** Contains: /data/data/com.example.app/databases/example.db **/
	private static final File DATA_DIRECTORY_DATABASE =
			new File(Environment.getDataDirectory() +
			"/data/" + PACKAGE_NAME +
			"/databases/" + DATABASE_NAME );

	/** Saves the application database to the
	 * export directory under MyDb.db **/
	protected static  boolean exportDb(){
		if( ! SdIsPresent() ) return false;

		File dbFile = DATA_DIRECTORY_DATABASE;
		String filename = "MyDb.db";

		File exportDir = DATABASE_DIRECTORY;
		File file = new File(exportDir, filename);

		if (!exportDir.exists()) {
			exportDir.mkdirs();
		}

		try {
			file.createNewFile();
			copyFile(dbFile, file);
			return true;
		} catch (IOException e) {
			e.printStackTrace();
			return false;
		}
	}

	/** Replaces current database with the IMPORT_FILE if
	 * import database is valid and of the correct type **/
	protected static boolean restoreDb(){
		if( ! SdIsPresent() ) return false;

		File exportFile = DATA_DIRECTORY_DATABASE;
		File importFile = IMPORT_FILE;

		if( ! checkDbIsValid(importFile) ) return false;

		if (!importFile.exists()) {
			Log.d(TAG, "File does not exist");
			return false;
		}

		try {
			exportFile.createNewFile();
			copyFile(importFile, exportFile);
			return true;
		} catch (IOException e) {
			e.printStackTrace();
			return false;
		}
	}

	/** Imports the file at IMPORT_FILE **/
	protected static boolean importIntoDb(Context ctx){
		if( ! SdIsPresent() ) return false;

		File importFile = IMPORT_FILE;

		if( ! checkDbIsValid(importFile) ) return false;

		try{
			SQLiteDatabase sqlDb = SQLiteDatabase.openDatabase
					(importFile.getPath(), null, SQLiteDatabase.OPEN_READONLY);

			Cursor cursor = sqlDb.query(true, DATABASE_TABLE,
		    		null, null, null, null, null, null, null
		    );

			DbAdapter dbAdapter = new DbAdapter(ctx);
			dbAdapter.open();

			final int titleColumn = cursor.getColumnIndexOrThrow("title");
			final int timestampColumn = cursor.getColumnIndexOrThrow("timestamp");

			// Adds all items in cursor to current database
			cursor.moveToPosition(-1);
			while(cursor.moveToNext()){
				dbAdapter.createQuote(
						cursor.getString(titleColumn),
						cursor.getString(timestampColumn)
				);
			}

			sqlDb.close();
			cursor.close();
			dbAdapter.close();
		} catch( Exception e ){
			e.printStackTrace();
			return false;
		}

		return true;
	}

	/** Given an SQLite database file, this checks if the file
	 * is a valid SQLite database and that it contains all the
	 * columns represented by DbAdapter.ALL_COLUMN_KEYS **/
	protected static boolean checkDbIsValid( File db ){
		try{
			SQLiteDatabase sqlDb = SQLiteDatabase.openDatabase
				(db.getPath(), null, SQLiteDatabase.OPEN_READONLY);

			Cursor cursor = sqlDb.query(true, DATABASE_TABLE,
            		null, null, null, null, null, null, null
            );

			// ALL_COLUMN_KEYS should be an array of keys of essential columns.
			// Throws exception if any column is missing
			for( String s : DbAdapter.ALL_COLUMN_KEYS ){
				cursor.getColumnIndexOrThrow(s);
			}

			sqlDb.close();
			cursor.close();
		} catch( IllegalArgumentException e ) {
			Log.d(TAG, "Database valid but not the right type");
			e.printStackTrace();
			return false;
		} catch( SQLiteException e ) {
			Log.d(TAG, "Database file is invalid.");
			e.printStackTrace();
			return false;
		} catch( Exception e){
			Log.d(TAG, "checkDbIsValid encountered an exception");
			e.printStackTrace();
			return false;
		}

		return true;
	}

	private static void copyFile(File src, File dst) throws IOException {
		FileChannel inChannel = new FileInputStream(src).getChannel();
		FileChannel outChannel = new FileOutputStream(dst).getChannel();
		try {
			inChannel.transferTo(0, inChannel.size(), outChannel);
		} finally {
			if (inChannel != null)
				inChannel.close();
			if (outChannel != null)
				outChannel.close();
		}
	}

	/** Returns whether an SD card is present and writable **/
	public static boolean SdIsPresent() {
		return Environment.getExternalStorageState().equals(
				Environment.MEDIA_MOUNTED);
	}
}

Now if you change or format your device, or even want to send your entire database to another person, you only need to back up your database to your SD card and restore again when you’re ready.

The difference between import and restore is simple:

If you import, you will add entries from the backed-up database to your existing database. If you restore, you will replace your own database with the backed-up one.

I’ve done it in quite a few different ways:

• Mount SD card as a removable storage device via USB
• Run an FTP server on my phone and transfer files over wifi
• Bluetooth file transfer

But these are all tedious because they’re all manual and they take too long.

Then I realised that ADB push and ADB shell are run from the command line/terminal, which means I can run a batch script. (A batch script is a text file with commands written that all run one after another in the command line)

Now all I need to do is click the file on my desktop and the files get updated within a fraction of a second on my phone.

So here’s an example version of my batch file that automatically updates a folder on my phone:

adb shell rm -r /sdcard/MyUpdateFolder

adb shell mkdir /sdcard/MyUpdateFolder

adb push C:/MyUpdateFolder /sdcard/MyUpdateFolder

‘rm -r’ delete the folder and everything in it.

‘mkdir’ creates a folder by that name.

‘push’ copies the folder contents from the first argument to the second argument.

Note for those running emulators on their computers: Add ‘-d’ after the word adb on each line to send the commands to a device and not an emulator.

All that’s left is to write it up in Notepad and save it as Filename.bat. After that, just double-click the file and the operation should run in a fraction of a second.