Could Someone Explain What This Line Does?

In this blog: http://www.reigndesign.com/blog/using-your-own-sqlite-database-in-android-applications/ It is one line this.getReadableDatabase();, I don't understand what it does, b

Solution 1:

From the function implementation you can see that this api opens the database by calling getWritableDatabase(). In case it fails due to some reason, it opens the db in a read-only mode.

publicsynchronized SQLiteDatabase getReadableDatabase() {
    if (mDatabase != null && mDatabase.isOpen()) {
        return mDatabase;  // The database is already open for business
    }

    if (mIsInitializing) {
        thrownewIllegalStateException("getReadableDatabase called recursively");
    }

    try {
        return getWritableDatabase();
    } catch (SQLiteException e) {
        if (mName == null) throw e;  // Can't open a temp database read-only!
        Log.e(TAG, "Couldn't open " + mName + " for writing (will try read-only):", e);
    }

    SQLiteDatabasedb=null;
    try {
        mIsInitializing = true;
        Stringpath= mContext.getDatabasePath(mName).getPath();
        db = SQLiteDatabase.openDatabase(path, mFactory, SQLiteDatabase.OPEN_READONLY);
        if (db.getVersion() != mNewVersion) {
            thrownewSQLiteException("Can't upgrade read-only database from version " +
                    db.getVersion() + " to " + mNewVersion + ": " + path);
        }

        onOpen(db);
        Log.w(TAG, "Opened " + mName + " in read-only mode");
        mDatabase = db;
        return mDatabase;
    } finally {
        mIsInitializing = false;
        if (db != null && db != mDatabase) db.close();
    }
}

Here is the implementation of getWritableDatabase()

publicsynchronized SQLiteDatabase getWritableDatabase() {
    if (mDatabase != null && mDatabase.isOpen() && !mDatabase.isReadOnly()) {
        return mDatabase;  // The database is already open for business
    }

    if (mIsInitializing) {
        thrownewIllegalStateException("getWritableDatabase called recursively");
    }

    // If we have a read-only database open, someone could be using it// (though they shouldn't), which would cause a lock to be held on// the file, and our attempts to open the database read-write would// fail waiting for the file lock.  To prevent that, we acquire the// lock on the read-only database, which shuts out other users.booleansuccess=false;
    SQLiteDatabasedb=null;
    if (mDatabase != null) mDatabase.lock();
    try {
        mIsInitializing = true;
        if (mName == null) {
            db = SQLiteDatabase.create(null);
        } else {
            db = mContext.openOrCreateDatabase(mName, 0, mFactory);
        }

        intversion= db.getVersion();
        if (version != mNewVersion) {
            db.beginTransaction();
            try {
                if (version == 0) {
                    onCreate(db);
                } else {
                    onUpgrade(db, version, mNewVersion);
                }
                db.setVersion(mNewVersion);
                db.setTransactionSuccessful();
            } finally {
                db.endTransaction();
            }
        }

        onOpen(db);
        success = true;
        return db;
    } finally {
        mIsInitializing = false;
        if (success) {
            if (mDatabase != null) {
                try { mDatabase.close(); } catch (Exception e) { }
                mDatabase.unlock();
            }
            mDatabase = db;
        } else {
            if (mDatabase != null) mDatabase.unlock();
            if (db != null) db.close();
        }
    }
}

Solution 2:

this.getReadableDatabase(); calls the method getReadableDatabase(); from the SQLiteOpenHelper class. This is possible because DataBaseHelper is a subclass of SQLiteOpenHelper. This is determined by this line.

publicclassDataBaseHelperextendsSQLiteOpenHelper

Solution 3:

This class is a subclass of the SQLiteOpenHelper.

Take from the reference of the method: [1]

Create and/or open a database that will be used for reading and writing. The first time this is called, the database will be opened and onCreate(SQLiteDatabase), onUpgrade(SQLiteDatabase, int, int) and/or onOpen(SQLiteDatabase) will be called.

So it basically just prepares the SQLiteDatabase for you and handles the setup lifecycle with update etc.

[1] http://developer.android.com/reference/android/database/sqlite/SQLiteOpenHelper.html#getReadableDatabase%28%29