一、SQLiteOpenHelper 调用入口

/**
 * Open the database according to the flags {@link #OPEN_READWRITE}
 * {@link #OPEN_READONLY} {@link #CREATE_IF_NECESSARY} and/or {@link #NO_LOCALIZED_COLLATORS}.
 *
 * <p>Sets the locale of the database to the  the system's current locale.
 * Call {@link #setLocale} if you would like something else.</p>
 *
 * <p>Accepts input param: a concrete instance of {@link DatabaseErrorHandler} to be
 * used to handle corruption when sqlite reports database corruption.</p>
 *
 * @param path to database file to open and/or create
 * @param factory an optional factory class that is called to instantiate a
 *            cursor when query is called, or null for default
 * @param flags to control database access mode
 * @param errorHandler the {@link DatabaseErrorHandler} obj to be used to handle corruption
 * when sqlite reports database corruption
 * @return the newly opened database
 * @throws SQLiteException if the database cannot be opened
 */
public static SQLiteDatabase openDatabase(String path, CursorFactory factory, int flags, DatabaseErrorHandler errorHandler) {
    // 创建 SQLiteDatabase 对象
    SQLiteDatabase db = new SQLiteDatabase(path, flags, factory, errorHandler);
    // 创建连接池，打开主连接
    db.open();
    return db;
}

1. SQLiteDatabase 构造方法，创建 SQLiteDatabase 对象

private SQLiteDatabase(String path, int openFlags, CursorFactory cursorFactory, DatabaseErrorHandler errorHandler) {
    // mCursorFactory 默认为 null
    mCursorFactory = cursorFactory;
    // 创建 onCorruption 的回调处理对象，DefaultDatabaseErrorHandler 的处理是删除数据库文件
    // 可以通过 SQLiteOpenHelper 的构造方法传入，用于自定义数据库损坏时的操作
    mErrorHandler = errorHandler != null ? errorHandler : new DefaultDatabaseErrorHandler();
    mConfigurationLocked = new SQLiteDatabaseConfiguration(path, openFlags);
}

2. db.open() 初始化连接池

private void open() {
    try {
        try {
            // 创建连接池，打开主连接
            openInner();
        } catch (SQLiteDatabaseCorruptException ex) {
            // 默认处理是，若数据库已关闭(连接池赋值为 null)，则删除数据库文件
            onCorruption();
            // 再次尝试
            openInner();
        }
    } catch (SQLiteException ex) {
        Log.e(TAG, "Failed to open database '" + getLabel() + "'.", ex);
        // 如果连接池不为 null，则关闭连接池
        close();
        throw ex;
    }
}

private void openInner() {
    synchronized (mLock) {
        // assert 断言，为 true 时则继续执行
        assert mConnectionPoolLocked == null;
        // 创建连接池，打开主连接
        mConnectionPoolLocked = SQLiteConnectionPool.open(mConfigurationLocked);
        mCloseGuardLocked.open("close");
    }

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

二、初始化 SQLiteConnectionPool

1. SQLiteConnectionPool.open() 调用入口

/**
 * 创建连接池，打开主连接
 * Opens a connection pool for the specified database.
 *
 * @param configuration The database configuration.
 * @return The connection pool.
 *
 * @throws SQLiteException if a database error occurs.
 */
public static SQLiteConnectionPool open(SQLiteDatabaseConfiguration configuration) {
    if (configuration == null) {
        throw new IllegalArgumentException("configuration must not be null.");
    }

    // Create the pool.
    SQLiteConnectionPool pool = new SQLiteConnectionPool(configuration);
    // 打开主连接
    pool.open(); // might throw
    return pool;
}

2. SQLiteConnectionPool 构造方法，创建连接池对象

private SQLiteConnectionPool(SQLiteDatabaseConfiguration configuration) {
    // 保存数据库配置项
    mConfiguration = new SQLiteDatabaseConfiguration(configuration);
    // 设置连接池最大连接数
    // 1. 默认情况下，连接数量为 1
    // 2. 开启多线程并发功能后，连接数量由系统配置，最少有两条
    setMaxConnectionPoolSizeLocked();
}

/**
 * 设置连接池最大连接数
 * 1. 默认情况下，连接数量为 1
 * 2. 开启多线程并发功能后，连接数量由系统配置，最少有两条
 */
private void setMaxConnectionPoolSizeLocked() {
    if ((mConfiguration.openFlags & SQLiteDatabase.ENABLE_WRITE_AHEAD_LOGGING) != 0) {
        // 开启了多线程并发功能，该功能默认不开启
        // 连接数量由系统配置，最少有两条
        mMaxConnectionPoolSize = SQLiteGlobal.getWALConnectionPoolSize();
    } else {
        // TODO: We don't actually need to restrict the connection pool size to 1
        // for non-WAL databases.  There might be reasons to use connection pooling
        // with other journal modes.  For now, enabling connection pooling and
        // using WAL are the same thing in the API.
        // 注意此处，连接数量默认为 1
        mMaxConnectionPoolSize = 1;
    }
}

/**
 * 返回值 >= 2
 * Gets the connection pool size when in WAL mode.
 */
public static int getWALConnectionPoolSize() {
    int value = SystemProperties.getInt("debug.sqlite.wal.poolsize",
            Resources.getSystem().getInteger(com.android.internal.R.integer.db_connection_pool_size));
    return Math.max(2, value);
}

三、 打开连接池主连接

/**
 * 打开主连接
 * Might throw
 */
private void open() {
    // Open the primary connection.
    // This might throw if the database is corrupt.
    // 打开主连接
    mAvailablePrimaryConnection = openConnectionLocked(mConfiguration, true /*primaryConnection*/); // might throw

    // Mark the pool as being open for business.
    mIsOpen = true;
    mCloseGuard.open("close");
}

// Might throw.
private SQLiteConnection openConnectionLocked(SQLiteDatabaseConfiguration configuration, boolean primaryConnection) {
    final int connectionId = mNextConnectionId++;
    return SQLiteConnection.open(this, configuration, connectionId, primaryConnection); // might throw
}

1. 创建连接(主连接)

/**
 * 1. 创建连接
 * 2. 打开连接
 *
 * @param pool
 * @param configuration
 * @param connectionId
 * @param primaryConnection 是否是主连接
 * @return
 */
// Called by SQLiteConnectionPool only.
static SQLiteConnection open(SQLiteConnectionPool pool, SQLiteDatabaseConfiguration configuration, int connectionId, boolean primaryConnection) {
    // 创建连接
    SQLiteConnection connection = new SQLiteConnection(pool, configuration, connectionId, primaryConnection);
    try {
        // 打开连接
        connection.open();
        return connection;
    } catch (SQLiteException ex) {
        connection.dispose(false);
        throw ex;
    }
}

2. SQLiteConnection 构造方法

private SQLiteConnection(SQLiteConnectionPool pool, SQLiteDatabaseConfiguration configuration, int connectionId, boolean primaryConnection) {
    mPool = pool;
    mConfiguration = new SQLiteDatabaseConfiguration(configuration);
    mConnectionId = connectionId;
    // 是否为主连接
    mIsPrimaryConnection = primaryConnection;
    // 是否是只读连接
    mIsReadOnlyConnection = (configuration.openFlags & SQLiteDatabase.OPEN_READONLY) != 0;
    mPreparedStatementCache = new SQLiteConnection.PreparedStatementCache(mConfiguration.maxSqlCacheSize);
    mCloseGuard.open("close");
}

3. 打开连接

private void open() {
    // 调用 native 方法打开连接
    mConnectionPtr = nativeOpen(mConfiguration.path, mConfiguration.openFlags, mConfiguration.label, SQLiteDebug.DEBUG_SQL_STATEMENTS, SQLiteDebug.DEBUG_SQL_TIME);
    // 如果是只读连接或者数据库只存在于内存中，则不做任何处理
    setPageSize();
    // 如果是只读连接则不做任何处理
    setForeignKeyModeFromConfiguration();
    // 如果是只读连接或者数据库只存在于内存中，则不做任何处理
    setWalModeFromConfiguration();
    // 如果是只读连接或者数据库只存在于内存中，则不做任何处理
    setJournalSizeLimit();
    // 如果是只读连接或者数据库只存在于内存中，则不做任何处理
    setAutoCheckpointInterval();
    setLocaleFromConfiguration();

    // Register custom functions.
    final int functionCount = mConfiguration.customFunctions.size();
    for (int i = 0; i < functionCount; i++) {
        SQLiteCustomFunction function = mConfiguration.customFunctions.get(i);
        nativeRegisterCustomFunction(mConnectionPtr, function);
    }
}