/**    * Create and/or open a database that will be used for reading and writing.    * Once opened successfully, the database is cached, so you can call this    * method every time you need to write to the database. Make sure to call    * {@link #close} when you no longer need it.    *    * <p>Errors such as bad permissions or a full disk may cause this operation    * to fail, but future attempts may succeed if the problem is fixed.</p>    *    * @throws SQLiteException if the database cannot be opened for writing    * @return a read/write database object valid until {@link #close} is called    */   public synchronized SQLiteDatabase getWritableDatabase() {     if (mDatabase != null && mDatabase.isOpen() && !mDatabase.isReadOnly()) {       return mDatabase; // The database is already open for business     }      if (mIsInitializing) {       throw new IllegalStateException("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.      boolean success = false;     SQLiteDatabase db = null;     if (mDatabase != null) mDatabase.lock();     try {       mIsInitializing = true;       if (mName == null) {         db = SQLiteDatabase.create(null);       } else {         db = mContext.openOrCreateDatabase(mName, 0, mFactory);       }        int version = 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();       }     }   }    /**    * Create and/or open a database. This will be the same object returned by    * {@link #getWritableDatabase} unless some problem, such as a full disk,    * requires the database to be opened read-only. In that case, a read-only    * database object will be returned. If the problem is fixed, a future call    * to {@link #getWritableDatabase} may succeed, in which case the read-only    * database object will be closed and the read/write object will be returned    * in the future.    *    * @throws SQLiteException if the database cannot be opened    * @return a database object valid until {@link #getWritableDatabase}    *   or {@link #close} is called.    */   public synchronized SQLiteDatabase getReadableDatabase() {     if (mDatabase != null && mDatabase.isOpen()) {       return mDatabase; // The database is already open for business     }      if (mIsInitializing) {       throw new IllegalStateException("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);     }      SQLiteDatabase db = null;     try {       mIsInitializing = true;       String path = mContext.getDatabasePath(mName).getPath();       db = SQLiteDatabase.openDatabase(path, mFactory, SQLiteDatabase.OPEN_READONLY);       if (db.getVersion() != mNewVersion) {         throw new SQLiteException("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();     }   }