private SQLiteDatabase getDatabaseLocked(boolean writable) {
    //已经有缓存了，直接返回。
    if (mDatabase != null) {
        if (!mDatabase.isOpen()) {
            // Darn!  The user closed the database by calling mDatabase.close().
            mDatabase = null;
        } else if (!writable || !mDatabase.isReadOnly()) {
            // The database is already open for business.
            return mDatabase;
        }
    }
    //创建、打开、升级数据库是耗时操作，所以我们需要阻断执行完成前的调用
    if (mIsInitializing) {
        throw new IllegalStateException("getDatabase called recursively");
    }

    SQLiteDatabase db = mDatabase;
    try {
        mIsInitializing = true;
        if (db != null) {
            //已经创建过，reopen
            if (writable && db.isReadOnly()) {
                db.reopenReadWrite();
            }
        } else if (mName == null) {
            // in-memory DB.
            db = SQLiteDatabase.create(null);
        } else {
            // 创建一个新的DB
            try {
                if (DEBUG_STRICT_READONLY && !writable) {
                    // read-only DB
                    //@@ key: 获取db文件所在的绝对路径
                    final String path = mContext.getDatabasePath(mName).getPath();
                    db = SQLiteDatabase.openDatabase(path, mFactory,
                            SQLiteDatabase.OPEN_READONLY, mErrorHandler);
                } else {
                    // writable DB
                    //@@ key: mName, 传进来的.db filename, 也是数据库所在的位置指定
                    db = mContext.openOrCreateDatabase(mName, mEnableWriteAheadLogging ?
                            Context.MODE_ENABLE_WRITE_AHEAD_LOGGING : 0,
                            mFactory, mErrorHandler);
                }
            } catch (SQLiteException ex) {
                if (writable) {
                    throw ex;
                }
                Log.e(TAG, "Couldn't open " + mName
                        + " for writing (will try read-only):", ex);
                //打开writable DB出错，重新尝试以read-only 方法打开
                final String path = mContext.getDatabasePath(mName).getPath();
                db = SQLiteDatabase.openDatabase(path, mFactory,
                        SQLiteDatabase.OPEN_READONLY, mErrorHandler);
            }
        }
        //配置刚刚打开的DB。（由子类来实现）
        onConfigure(db);

        final int version = db.getVersion();
        if (version != mNewVersion) {
            //不能升级read-only的数据库
            if (db.isReadOnly()) {
                throw new SQLiteException("Can't upgrade read-only database from version " +
                        db.getVersion() + " to " + mNewVersion + ": " + mName);
            }
            //小于最低支持的版本，直接删除重新创建一个.
            if (version > 0 && version < mMinimumSupportedVersion) {
                File databaseFile = new File(db.getPath());
                //提供回调
                onBeforeDelete(db);
                db.close();
                if (SQLiteDatabase.deleteDatabase(databaseFile)) {
                    //删除成功，重新获取一个
                    mIsInitializing = false;
                    return getDatabaseLocked(writable);
                } else {
                    throw new IllegalStateException("Unable to delete obsolete database "
                            + mName + " with version " + version);
                }
            } else {
                //根据版本进行操作
                db.beginTransaction();
                try {
                    if (version == 0) {
                        //版本=0， 第一次创建的数据库
                        onCreate(db);
                    } else {
                        //数据库已经被降级
                        if (version > mNewVersion) {
                            onDowngrade(db, version, mNewVersion);
                        } else {
                            //升级
                            onUpgrade(db, version, mNewVersion);
                        }
                    }
                    db.setVersion(mNewVersion);
                    db.setTransactionSuccessful();
                } finally {
                    db.endTransaction();
                }
            }
        }
        //回调并记录
        onOpen(db);
        if (db.isReadOnly()) {
            Log.w(TAG, "Opened " + mName + " in read-only mode");
        }

        mDatabase = db;
        return db;
    } finally {
        mIsInitializing = false;
        if (db != null && db != mDatabase) {
            db.close();
        }
    }
}

public static SQLiteDatabase openOrCreateDatabase(String path, CursorFactory factory,
        DatabaseErrorHandler errorHandler) {
    return openDatabase(path, factory, CREATE_IF_NECESSARY, errorHandler);
}


public static SQLiteDatabase openDatabase(String path, CursorFactory factory, int flags,
        DatabaseErrorHandler errorHandler) {
    SQLiteDatabase db = new SQLiteDatabase(path, flags, factory, errorHandler);
    db.open();
    return db;
}


private void open() {
    try {
        try {
            //根据在构造器中传入的配置打开，第一次尝试
            openInner();
        } catch (SQLiteDatabaseCorruptException ex) {
            //失败之后先进行错误通知，再重试一次。
            onCorruption();
            openInner();
        }
    } catch (SQLiteException ex) {
        Log.e(TAG, "Failed to open database '" + getLabel() + "'.", ex);
        close();
        throw ex;
    }
}

private void openInner() {
    synchronized (mLock) {
        assert mConnectionPoolLocked == null;
        mConnectionPoolLocked = SQLiteConnectionPool.open(mConfigurationLocked);
        mCloseGuardLocked.open("close");
    }

    synchronized (sActiveDatabases) {
        sActiveDatabases.put(this, null);
    }
}