Fixed #1352 - Crash when running with SQLCipher

- Multiple SQLite connections with SQLCipher could cause crashes in the native codes.
- We decided to use single connection with Android API version 20 or lower, And use multiple connections with API 21 or higher.

Author: hideki

src/main/java/com/couchbase/lite/storage/SQLiteStorageEngineBase.java

@@ -44,6 +44,14 @@ public abstract class SQLiteStorageEngineBase implements SQLiteStorageEngine {
 
     abstract protected String getICUDatabasePath();
 
+    /**
+     * Gets the connection pool size when in WAL mode.
+     *
+     * Maximum number of database connections opened and managed by framework layer
+     * to handle queries on each database when using Write-Ahead Logging.
+     */
+    abstract protected int getWALConnectionPoolSize();
+
     @Override
     public boolean open(String path, SymmetricKey encryptionKey) throws SQLException {
         if(database != null && database.isOpen())
@@ -61,6 +69,7 @@ public boolean open(String path, SymmetricKey encryptionKey) throws SQLException
             SQLiteDatabase.setDatabasePlatformSupport(getDatabasePlatformSupport());
             database = SQLiteDatabase.openDatabase(path, null,
                     SQLiteDatabase.CREATE_IF_NECESSARY | SQLiteDatabase.ENABLE_WRITE_AHEAD_LOGGING,
+                    getWALConnectionPoolSize(),
                     null, new ConnectionListener());
             Log.v(Log.TAG_DATABASE, "%s: Opened Android sqlite db", this);
         } catch(SQLiteDatabaseCorruptException e) {

vendor/sqlite/src/java/com/couchbase/lite/internal/database/sqlite/SQLiteConnectionPool.java

@@ -22,8 +22,8 @@
 package com.couchbase.lite.internal.database.sqlite;
 
 import com.couchbase.lite.internal.database.CancellationSignal;
-import com.couchbase.lite.internal.database.log.DLog;
 import com.couchbase.lite.internal.database.OperationCanceledException;
+import com.couchbase.lite.internal.database.log.DLog;
 import com.couchbase.lite.internal.database.util.PrefixPrinter;
 import com.couchbase.lite.internal.database.util.Printer;
 
@@ -152,7 +152,7 @@ private SQLiteConnectionPool(com.couchbase.lite.internal.database.sqlite.SQLiteD
                                  com.couchbase.lite.internal.database.sqlite.SQLiteConnectionListener connectionListener) {
         mConfiguration = new com.couchbase.lite.internal.database.sqlite.SQLiteDatabaseConfiguration(configuration);
         mConnectionListener = connectionListener;
-        setMaxConnectionPoolSizeLocked();
+        setMaxConnectionPoolSizeLocked(configuration.walConnectionPoolSize);
     }
 
     @Override
@@ -309,11 +309,11 @@ public void reconfigure(com.couchbase.lite.internal.database.sqlite.SQLiteDataba
 
                 mAvailablePrimaryConnection = newPrimaryConnection;
                 mConfiguration.updateParametersFrom(configuration);
-                setMaxConnectionPoolSizeLocked();
+                setMaxConnectionPoolSizeLocked(configuration.walConnectionPoolSize);
             } else {
                 // Reconfigure the database connections in place.
                 mConfiguration.updateParametersFrom(configuration);
-                setMaxConnectionPoolSizeLocked();
+                setMaxConnectionPoolSizeLocked(configuration.walConnectionPoolSize);
 
                 closeExcessConnectionsAndLogExceptionsLocked();
                 reconfigureAllConnectionsLocked();
@@ -931,9 +931,12 @@ private static int getPriority(int connectionFlags) {
         return (connectionFlags & CONNECTION_FLAG_INTERACTIVE) != 0 ? 1 : 0;
     }
 
-    private void setMaxConnectionPoolSizeLocked() {
+    private void setMaxConnectionPoolSizeLocked(int walConnectionPoolSize) {
         if ((mConfiguration.openFlags & com.couchbase.lite.internal.database.sqlite.SQLiteDatabase.ENABLE_WRITE_AHEAD_LOGGING) != 0) {
-            mMaxConnectionPoolSize = com.couchbase.lite.internal.database.sqlite.SQLiteGlobal.getWALConnectionPoolSize();
+            if (walConnectionPoolSize > 0)
+                mMaxConnectionPoolSize = walConnectionPoolSize;
+            else
+                mMaxConnectionPoolSize = com.couchbase.lite.internal.database.sqlite.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

vendor/sqlite/src/java/com/couchbase/lite/internal/database/sqlite/SQLiteDatabase.java

@@ -246,11 +246,12 @@ protected SQLiteSession initialValue() {
         SQLiteNativeLibrary.load();
     }
 
-    private SQLiteDatabase(String path, int openFlags, CursorFactory cursorFactory,
-            DatabaseErrorHandler errorHandler, com.couchbase.lite.internal.database.sqlite.SQLiteConnectionListener connectionListener) {
+    private SQLiteDatabase(String path, int openFlags, int walConnectionPoolSize,
+                           CursorFactory cursorFactory,
+                           DatabaseErrorHandler errorHandler, com.couchbase.lite.internal.database.sqlite.SQLiteConnectionListener connectionListener) {
         mCursorFactory = cursorFactory;
         mErrorHandler = errorHandler;
-        mConfigurationLocked = new com.couchbase.lite.internal.database.sqlite.SQLiteDatabaseConfiguration(path, openFlags);
+        mConfigurationLocked = new com.couchbase.lite.internal.database.sqlite.SQLiteDatabaseConfiguration(path, openFlags, walConnectionPoolSize);
         mConnectionListener = connectionListener;
     }
 
@@ -667,8 +668,8 @@ public static SQLiteDatabase openDatabase(String path, CursorFactory factory, in
      * @throws com.couchbase.lite.internal.database.sqlite.exception.SQLiteException if the database cannot be opened
      */
     public static SQLiteDatabase openDatabase(String path, CursorFactory factory, int flags,
-            DatabaseErrorHandler errorHandler) {
-        return openDatabase(path, factory, flags, errorHandler, null);
+                                              DatabaseErrorHandler errorHandler) {
+        return openDatabase(path, factory, flags, 0, errorHandler, null);
     }
 
     /**
@@ -682,14 +683,18 @@ public static SQLiteDatabase openDatabase(String path, CursorFactory factory, in
      * @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 walConnectionPoolSize maximum connection pool size
      * @param errorHandler the {@link DatabaseErrorHandler} obj to be used to handle corruption
      * when sqlite reports database corruption
      * @return the newly opened database
      * @throws com.couchbase.lite.internal.database.sqlite.exception.SQLiteException if the database cannot be opened
      */
-    public static SQLiteDatabase openDatabase(String path, CursorFactory factory, int flags,
-            DatabaseErrorHandler errorHandler, com.couchbase.lite.internal.database.sqlite.SQLiteConnectionListener connectionListener) {
-        SQLiteDatabase db = new SQLiteDatabase(path, flags, factory, errorHandler, connectionListener);
+    public static SQLiteDatabase openDatabase(
+            String path, CursorFactory factory, int flags,
+            int walConnectionPoolSize,
+            DatabaseErrorHandler errorHandler,
+            com.couchbase.lite.internal.database.sqlite.SQLiteConnectionListener connectionListener) {
+        SQLiteDatabase db = new SQLiteDatabase(path, flags, walConnectionPoolSize, factory, errorHandler, connectionListener);
         db.open();
         return db;
     }

vendor/sqlite/src/java/com/couchbase/lite/internal/database/sqlite/SQLiteDatabaseConfiguration.java

@@ -87,21 +87,29 @@ public final class SQLiteDatabaseConfiguration {
      */
     public boolean foreignKeyConstraintsEnabled;
 
+    /**
+     * Maximum number of database connections opened and managed by framework layer
+     * to handle queries on each database when using Write-Ahead Logging.
+     */
+    public int walConnectionPoolSize = 0;
+
     /**
      * Creates a database configuration with the required parameters for opening a
      * database and default values for all other parameters.
      *
      * @param path The database path.
      * @param openFlags Open flags for the database, such as {@link SQLiteDatabase#OPEN_READWRITE}.
+     * @param walConnectionPoolSize
      */
-    public SQLiteDatabaseConfiguration(String path, int openFlags) {
+    public SQLiteDatabaseConfiguration(String path, int openFlags, int walConnectionPoolSize) {
         if (path == null) {
             throw new IllegalArgumentException("path must not be null.");
         }
 
         this.path = path;
         label = stripPathForLogs(path);
         this.openFlags = openFlags;
+        this.walConnectionPoolSize = walConnectionPoolSize;
 
         // Set default values for optional parameters.
         maxSqlCacheSize = 25;