/** 
   * 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. 
   * 
   * 
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.
 
   * 
   * @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(); 
    } 
  }