How to use an existing database with an Android application

java

database-integration

sqlite

room

byAnton Shumikhin·Feb 22, 2025

To incorporate an existing SQLite DB (i.e., mydatabase.db) into your Android app, first place the database file in the assets folder. Then, make sure to copy it into the app's data directory only once, which should be done during the app's initial launch. This can all be handled using SQLiteOpenHelper for database access:

private void copyDatabase(Context context) throws IOException {
    InputStream is = context.getAssets().open("mydatabase.db");
    // If DB is not too heavy, might also consider getting a cup of coffee ☕
    String outPath = context.getDatabasePath("mydatabase.db").getPath();
    try (OutputStream os = new FileOutputStream(outPath)) {
        byte[] buffer = new byte[1024];
        int bytes;
        while ((bytes = is.read(buffer)) > 0) {
            os.write(buffer, 0, bytes);  // Persistence is key, keep going!
        }
    }
    is.close(); // Be kind, rewind. Or rather, close your streams.
}

Employ the copyDatabase() method in your SQLiteOpenHelper, especially if your beloved database doesn't yet exist. Subsequently, perform all your data operations using SQLiteDatabase.

Solid database integration: Key steps

When establishing a strong connection with your pre-existing database (it's a relationship, you know), make sure to keep in mind cross-version compatibility and conduct IOExceptions handling in a graceful manner. Here, we delve deeper into these topics for smoother database integration:

Navigating Android's versions: File path differences

private static String getDatabasePath(Context context) {
    // Jelly Bean, sounds yum. But remember, we're here on a mission 🕶️
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
        return context.getApplicationInfo().dataDir + "/databases/";
    } else {
        // For the record, Bean may not always mean jelly.
        return "/data/data/" + context.getPackageName() + "/databases/";
    }
}

Ensuring safe passage: Proper database copying

public void createDataBase() throws IOException {
    boolean dbExist = checkDataBase();  // Or in other words, "Knock, knock... Anybody home?"
    if (!dbExist) {
        this.getReadableDatabase();  // Get a readable instance, our ticket to glory.
        try {
            copyDataBase();  // Aaand... PASTE it, Ninja style!
        } catch (IOException e) {
            // Oops, looks like someone has messed up.
            throw new Error("Error copying database");
        }
    }
}

private boolean checkDataBase() {
    // Well, the name says it all. Check if our DB is in the house.
}

Fishing for data: Proper DB querying

public Cursor fetchData() {
    // Java, meet Database. Database, meet Java.
    SQLiteDatabase db = this.getReadableDatabase();
    try {
        // It's like the Database Lounge, but with more data
        return db.query("myTable", null, null, null, null, null, null);
    } finally {
        // The curtains fall, the stage is clear. Until next time, be sure to close the DB connection.
    }
}

Make sure to arm yourself with a contingency plan for all possible database states and exceptions to maintain your app's grace under pressure.

SQLiteOpenHelper: The data management wizard

Extend SQLiteOpenHelper to facilitate handling the lifecycle of your SQLite database, which encompasses the opening and closing of connections, schema upgrades if needed, and management of instances effectively.

The art of playing with Cursors and Adapters

public class TestAdapter {
    // This is your playground for open/close database calls, as well as query operations.
}

Learn to command the Cursor instances, this will allow you to iterate over query results smoothly, extract rows and columns efficiently, and bind data to views using adapters.

Harnessing the power of Room

@Database(entities = {MyEntity.class}, version = 1)
public abstract class AppDatabase extends RoomDatabase {
    // Your kingdom of Database access methods waits here.
}

Take full advantage of the simplicity and robustness of Room to handle your database operations, which in turn reduces boilerplate code while increasing compile-time safety.

explain-codes / Java / How to use an existing database with an Android application

Linked

H2 in-memory database. Table not found



Unrecognized Attribute name MODULE (class com.sun.tools.javac.util.SharedNameTable$NameImpl)



Spring Boot - Cannot determine embedded database driver class for database type NONE



Get generated id after insert



Any good ORM tools for Android development?

