SQLitePlugin.java

/*
 * Copyright (c) 2015, Andrzej Porebski
 * Copyright (c) 2012-2015, Chris Brody
 * Copyright (c) 2005-2010, Nitobi Software Inc.
 * Copyright (c) 2010, IBM Corporation
 */

package io.liteglue;

import android.content.Context;

import com.facebook.common.logging.FLog;
import com.facebook.react.bridge.Arguments;
import com.facebook.react.bridge.Callback;
import com.facebook.react.bridge.ReactApplicationContext;
import com.facebook.react.bridge.ReactContextBaseJavaModule;
import com.facebook.react.bridge.ReactMethod;
import com.facebook.react.bridge.ReadableArray;
import com.facebook.react.bridge.ReadableMap;
import com.facebook.react.bridge.ReadableType;
import com.facebook.react.bridge.WritableArray;
import com.facebook.react.bridge.WritableMap;

import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.lang.IllegalArgumentException;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;

public class SQLitePlugin extends ReactContextBaseJavaModule {

    public static final String TAG = SQLitePlugin.class.getSimpleName();

    /**
     * Multiple database runner map (static).
     * NOTE: no public static accessor to db (runner) map since it would not work with db threading.
     * FUTURE put DBRunner into a public class that can provide external accessor.
     */
    static ConcurrentHashMap<String, DBRunner> dbrmap = new ConcurrentHashMap<String, DBRunner>();

    /**
     * SQLiteGlueConnector (instance of SQLiteConnector) for NDK version:
     */
    static SQLiteConnector connector = new SQLiteConnector();

    protected ExecutorService threadPool;
    private Context context;

    public SQLitePlugin(ReactApplicationContext reactContext) {
        super(reactContext);
        this.context = reactContext.getApplicationContext();
        this.threadPool = Executors.newCachedThreadPool();
    }

    /**
     * Required React Native method
     */
    @Override
    public String getName() {
        return "SQLite";
    }

    @ReactMethod
    public void open(ReadableMap args, Callback success, Callback error) {
        String actionAsString = "open";
        try {
            this.execute(actionAsString, args, new CallbackContext(success, error));
        } catch (Exception ex){
            error.invoke("Unexpected error:"+ex.getMessage());
        }
    }

    @ReactMethod
    public void close(ReadableMap args, Callback success, Callback error) {
        String actionAsString = "close";
        try {
            this.execute(actionAsString, args, new CallbackContext(success, error));
        } catch (Exception ex){
            error.invoke("Unexpected error"+ex.getMessage());
        }
    }

    @ReactMethod
    public void attach(ReadableMap args, Callback success, Callback error) {
        String actionAsString = "attach";
        try {
            this.execute(actionAsString, args, new CallbackContext(success, error));
        } catch (Exception ex){
            error.invoke("Unexpected error"+ex.getMessage());
        }
    }

    @ReactMethod
    public void delete(ReadableMap args, Callback success, Callback error) {
        String actionAsString = "delete";
        try {
            this.execute(actionAsString, args, new CallbackContext(success, error));
        } catch (Exception ex){
            error.invoke("Unexpected error"+ex.getMessage());
        }
    }

    @ReactMethod
    public void backgroundExecuteSqlBatch(ReadableMap args, Callback success, Callback error) {
        String actionAsString = "backgroundExecuteSqlBatch";
        try {
            this.execute(actionAsString, args, new CallbackContext(success, error));
        } catch (Exception ex){
            error.invoke("Unexpected error"+ex.getMessage());
        }
    }

    @ReactMethod
    public void executeSqlBatch(ReadableMap args, Callback success, Callback error) {
        String actionAsString = "executeSqlBatch";
        try {
            this.execute(actionAsString, args, new CallbackContext(success, error));
        } catch (Exception ex){
            error.invoke("Unexpected error");
        }
    }

    @ReactMethod
    public void echoStringValue(ReadableMap args, Callback success, Callback error) {
        String actionAsString = "echoStringValue";
        try {
            this.execute(actionAsString, args, new CallbackContext(success, error));
        } catch (Exception ex){
            error.invoke("Unexpected error");
        }
    }

    protected ExecutorService getThreadPool(){
        return this.threadPool;
    }

    protected Context getContext(){
        return this.context;
    }

    /**
     * Executes the request and returns PluginResult.
     *
     * @param actionAsString The action to execute.
     * @param args   JSONArray of arguments for the plugin.
     * @param cbc    Callback context from Cordova API
     * @return       Whether the action was valid.
     */
    protected boolean execute(String actionAsString, ReadableMap args, CallbackContext cbc) throws Exception{

        Action action;
        try {
            action = Action.valueOf(actionAsString);
        } catch (IllegalArgumentException ex) {
            // shouldn't ever happen
            FLog.e(TAG, "unexpected error", ex);
            cbc.error("Unexpected error executing processing SQLite query");
            throw ex;
        }
        try {
            return executeAndPossiblyThrow(action, args, cbc);
        } catch (Exception ex) {
            FLog.e(TAG, "unexpected error", ex);
            cbc.error("Unexpected error executing processing SQLite query");
            throw ex;
        }
    }

    private boolean executeAndPossiblyThrow(Action action, ReadableMap args, CallbackContext cbc){
        String dbname;

        switch (action) {
            case echoStringValue:
                String echo_value = SQLitePluginConverter.getString(args,"value","");
                cbc.success(echo_value);
                break;

            case open:
                dbname = SQLitePluginConverter.getString(args,"name","");
                // open database and start reading its queue
                this.startDatabase(dbname, args, cbc);
                break;

            case close:
                dbname = SQLitePluginConverter.getString(args,"path","");
                // put request in the q to close the db
                this.closeDatabase(dbname, cbc);
                break;

            case attach:
                dbname = SQLitePluginConverter.getString(args,"path","");
                String dbAlias = SQLitePluginConverter.getString(args,"dbAlias","");
                String dbNameToAttach = SQLitePluginConverter.getString(args,"dbName","");
                this.attachDatabase(dbname,dbNameToAttach,dbAlias,cbc);
                break;

            case delete:
                dbname = SQLitePluginConverter.getString(args,"path","");
                deleteDatabase(dbname, cbc);
                break;

            case executeSqlBatch:
            case backgroundExecuteSqlBatch:
                String [] queries;
                String [] queryIDs = null;
                ReadableArray[] queryParams = null;
                ReadableMap dbArgs = (ReadableMap) SQLitePluginConverter.get(args,"dbargs",null);
                dbname = SQLitePluginConverter.getString(dbArgs,"dbname","");
                ReadableArray txArgs = (ReadableArray) SQLitePluginConverter.get(args,"executes",null);

                if (txArgs.isNull(0)) {
                    queries = new String[0];
                } else {
                    int len = txArgs.size();
                    queries = new String[len];
                    queryIDs = new String[len];
                    queryParams = new ReadableArray[len];

                    for (int i = 0; i < len; i++) {
                        ReadableMap queryArgs = (ReadableMap) SQLitePluginConverter.get(txArgs,i,null);
                        queries[i] = SQLitePluginConverter.getString(queryArgs,"sql","");
                        queryIDs[i] = SQLitePluginConverter.getString(queryArgs,"qid","");
                        queryParams[i] = (ReadableArray) SQLitePluginConverter.get(queryArgs,"params",null);
                    }
                }

                // put db query in the queue to be executed in the db thread:
                DBQuery q = new DBQuery(queries, queryIDs, queryParams, cbc);
                DBRunner r = dbrmap.get(dbname);
                if (r != null) {
                    try {
                        r.q.put(q);
                    } catch(Exception ex) {
                        FLog.e(TAG, "couldn't add to queue", ex);
                        cbc.error("couldn't add to queue");
                    }
                } else {
                    cbc.error("database not open");
                }
                break;
        }

        return true;
    }

    /**
     * Clean up and close all open databases.
     */
    public void closeAllOpenDatabases() {
        while (!dbrmap.isEmpty()) {
            String dbname = dbrmap.keySet().iterator().next();

            this.closeDatabaseNow(dbname);

            DBRunner r = dbrmap.get(dbname);
            try {
                // stop the db runner thread:
                r.q.put(new DBQuery());
            } catch(Exception ex) {
                FLog.e(TAG, "couldn't stop db thread for db: " + dbname,ex);
            }
            dbrmap.remove(dbname);
        }
    }

    /**
     *
     * @param dbname - The name of the database file
     * @param options - options passed in from JS
     * @param cbc - JS callback context
     */
    private void startDatabase(String dbname, ReadableMap options, CallbackContext cbc) {
        // TODO: is it an issue that we can orphan an existing thread?  What should we do here?
        // If we re-use the existing DBRunner it might be in the process of closing...
        DBRunner r = dbrmap.get(dbname);

        // Brody TODO: It may be better to terminate the existing db thread here & start a new one, instead.
        if (r != null) {
            // don't orphan the existing thread; just re-open the existing database.
            // In the worst case it might be in the process of closing, but even that's less serious
            // than orphaning the old DBRunner.
            cbc.success("database started");
        } else {
            r = new DBRunner(dbname, options, cbc);
            dbrmap.put(dbname, r);
            this.getThreadPool().execute(r);
        }
    }

    /**
     * Open a database.
     *
     * @param dbname   The name of the database file
     */
    private SQLiteAndroidDatabase openDatabase(String dbname, String assetFilePath, int openFlags, CallbackContext cbc, boolean old_impl) throws Exception {
        InputStream in = null;
        File dbfile = null;
        try {
            boolean assetImportError = false;
            boolean assetImportRequested = assetFilePath != null && assetFilePath.length() > 0;
            if (assetImportRequested) {
                if (assetFilePath.compareTo("1") == 0) {
                    assetFilePath = "www/" + dbname;
                    in = this.getContext().getAssets().open(assetFilePath);
                    try {
                        in = this.getContext().getAssets().open(assetFilePath);
                        FLog.v(TAG, "Pre-populated DB asset FOUND  in app bundle www subdirectory: " + assetFilePath);
                    } catch (Exception ex){
                        assetImportError = true;
                        FLog.e(TAG, "pre-populated DB asset NOT FOUND in app bundle www subdirectory: " + assetFilePath);
                    }
                } else if (assetFilePath.charAt(0) == '~') {
                    assetFilePath = assetFilePath.startsWith("~/") ? assetFilePath.substring(2) : assetFilePath.substring(1);
                    try {
                        in = this.getContext().getAssets().open(assetFilePath);
                        FLog.v(TAG, "Pre-populated DB asset FOUND in app bundle subdirectory: " + assetFilePath);
                    } catch (Exception ex){
                        assetImportError = true;
                        FLog.e(TAG, "pre-populated DB asset NOT FOUND in app bundle www subdirectory: " + assetFilePath);
                    }
                } else {
                    File filesDir = this.getContext().getFilesDir();
                    assetFilePath = assetFilePath.startsWith("/") ? assetFilePath.substring(1) : assetFilePath;

                    try {
                        File assetFile = new File(filesDir, assetFilePath);
                        in = new FileInputStream(assetFile);
                        FLog.v(TAG, "Pre-populated DB asset FOUND in Files subdirectory: " + assetFile.getCanonicalPath());
                        if (openFlags == SQLiteOpenFlags.READONLY) {
                            dbfile = assetFile;
                            FLog.v(TAG, "Detected read-only mode request for external asset.");
                        }
                    } catch (Exception ex){
                        assetImportError = true;
                        FLog.e(TAG, "Error opening pre-populated DB asset in app bundle www subdirectory: " + assetFilePath);
                    }
                }
            }

            if (dbfile == null) {
                openFlags = SQLiteOpenFlags.CREATE | SQLiteOpenFlags.READWRITE;
                dbfile = this.getContext().getDatabasePath(dbname);

                if (!dbfile.exists() && assetImportRequested) {
                    if (assetImportError || in == null) {
                        FLog.e(TAG, "Unable to import pre-populated db asset");
                        throw new Exception("Unable to import pre-populated db asset");
                    } else {
                        FLog.v(TAG, "Copying pre-populated db asset to destination");
                        try {
                            this.createFromAssets(dbname, dbfile, in);
                        } catch (Exception ex){
                            FLog.e(TAG, "Error importing pre-populated DB asset", ex);
                            throw new Exception("Error importing pre-populated DB asset");
                        }
                    }
                }

                if (!dbfile.exists()) {
                    dbfile.getParentFile().mkdirs();
                }
            }

            // Pass in mode to open call
            SQLiteAndroidDatabase mydb = old_impl ? new SQLiteAndroidDatabase() : new SQLiteDatabaseNDK();
            mydb.open(dbfile, openFlags);

            if (cbc != null)
                cbc.success("database open");

            return mydb;
        } finally {
            closeQuietly(in);
        }
    }

    /**
     * If a prepopulated DB file exists in the assets folder it is copied to the dbPath.
     * Only runs the first time the app runs.
     *
     * @param dbName The name of the database file - could be used as filename for imported asset
     * @param dbfile The File of the destination db
     * @param assetFileInputStream input file stream for pre-populated db asset
     */
    private void createFromAssets(String dbName, File dbfile, InputStream assetFileInputStream) throws Exception
    {
        OutputStream out = null;
        try {
            String dbPath = dbfile.getAbsolutePath();
            dbPath = dbPath.substring(0, dbPath.lastIndexOf("/") + 1);

            File dbPathFile = new File(dbPath);
            if (!dbPathFile.exists())
                dbPathFile.mkdirs();

            File newDbFile = new File(dbPath + dbName);
            out = new FileOutputStream(newDbFile);

            // XXX TODO: this is very primitive, other alternatives at:
            // http://www.journaldev.com/861/4-ways-to-copy-file-in-java
            byte[] buf = new byte[1024];
            int len;
            while ((len = assetFileInputStream.read(buf)) > 0)
                out.write(buf, 0, len);

            FLog.v(TAG, "Copied pre-populated DB content to: " + newDbFile.getAbsolutePath());
        } finally {
            closeQuietly(out);
        }
    }

    /**
     * Close a database (in another thread).
     *
     * @param dbname   The name of the database file
     */
    private void closeDatabase(String dbname, CallbackContext cbc) {
        DBRunner r = dbrmap.get(dbname);
        if (r != null) {
            try {
                r.q.put(new DBQuery(false, cbc));
            } catch(Exception ex) {
                if (cbc != null) {
                    cbc.error("couldn't close database" + ex);
                }
                FLog.e(TAG, "couldn't close database", ex);
            }
        } else {
            if (cbc != null) {
                cbc.success("couldn't close database");
            }
        }
    }

    /**
     * Close a database (in the current thread).
     *
     * @param dbname   The name of the database file
     */
    private void closeDatabaseNow(String dbname) {
        DBRunner r = dbrmap.get(dbname);

        if (r != null) {
            SQLiteAndroidDatabase mydb = r.mydb;

            if (mydb != null)
                mydb.closeDatabaseNow();
        }
    }

    /**
     * Attach a database
     *
     * @param dbName - The name of the database file
     * @param dbNameToAttach - The name of the database file to attach
     * @param dbAlias - The alias of the attached database
     * @param cbc - JS callback
     */
    private void attachDatabase(String dbName, String dbNameToAttach, String dbAlias, CallbackContext cbc) {
        DBRunner runner = dbrmap.get(dbName);
        if (runner != null) {
            File dbfile = this.getContext().getDatabasePath(dbNameToAttach);
            String filePathToAttached = dbfile.getAbsolutePath();
            String stmt = "ATTACH DATABASE '" + filePathToAttached + "' AS " + dbAlias;
            // TODO: remove qid it's hardcoded in js to be 1111 always anyway
            DBQuery query = new DBQuery(new String[]{stmt}, new String[]{"1111"}, null, cbc);
            try {
                runner.q.put(query);
            } catch (InterruptedException ex) {
                cbc.error("Can't put querry into the queue");
            }
        } else {
            cbc.error("Can't attach to database - it's not open yet");
        }
    }

    private void deleteDatabase(String dbname, CallbackContext cbc) {
        DBRunner r = dbrmap.get(dbname);
        if (r != null) {
            try {
                r.q.put(new DBQuery(true, cbc));
            } catch(Exception ex) {
                if (cbc != null) {
                    cbc.error("couldn't close database" + ex);
                }
                FLog.e(TAG, "couldn't close database", ex);
            }
        } else {
            boolean deleteResult = this.deleteDatabaseNow(dbname);
            if (deleteResult) {
                cbc.success("database deleted");
            } else {
                cbc.error("couldn't delete database");
            }
        }
    }

    /**
     * Delete a database.
     *
     * @param dbname   The name of the database file
     *
     * @return true if successful or false if an exception was encountered
     */
    private boolean deleteDatabaseNow(String dbname) {
        File dbfile = this.getContext().getDatabasePath(dbname);

        try {
            return this.getContext().deleteDatabase(dbfile.getAbsolutePath());
        } catch (Exception ex) {
            FLog.e(TAG, "couldn't delete database", ex);
            return false;
        }
    }

    private void closeQuietly(Closeable closeable) {
        if (closeable != null) {
            try {
                closeable.close();
            } catch (IOException ex) {
                // ignore
            }
        }
    }

    // NOTE: class hierarchy is ugly, done to reduce number of modules for manual installation.
    // FUTURE TBD SQLiteDatabaseNDK class belongs in its own module.
    class SQLiteDatabaseNDK extends SQLiteAndroidDatabase {
        SQLiteConnection mydb;

        /**
         * Open a database.
         *
         * @param dbFile   The database File specification
         */
        @Override
        void open(File dbFile) throws Exception {
            this.open(dbFile, SQLiteOpenFlags.READWRITE | SQLiteOpenFlags.CREATE);
        }

        /**
         * Open a database.
         *
         * @param dbFile   The database File specification
         */
        @Override
        void open(File dbFile, int mode) throws Exception {
            mydb = connector.newSQLiteConnection(dbFile.getAbsolutePath(),mode);
        }

        /**
         * Close a database (in the current thread).
         */
        @Override
        void closeDatabaseNow() {
            try {
                if (mydb != null)
                    mydb.dispose();
            } catch (Exception ex) {
                FLog.e(TAG, "couldn't close database, ignoring", ex);
            }
        }

        /**
         * Ignore Android bug workaround for NDK version
         */
        @Override
        void bugWorkaround() { }

        /**
         * Executes a batch request and sends the results via cbc.
         *
         * @param queryarr   Array of query strings
         * @param queryParams Array of JSON query parameters
         * @param queryIDs   Array of query ids
         * @param cbc        Callback context from Cordova API
         */
        @Override
        void executeSqlBatch( String[] queryarr, ReadableArray[]  queryParams,
                              String[] queryIDs, CallbackContext cbc) {

            if (mydb == null) {
                // not allowed - can only happen if someone has closed (and possibly deleted) a database and then re-used the database
                cbc.error("database has been closed");
                return;
            }

            int len = queryarr.length;
            WritableArray batchResults = Arguments.createArray();

            for (int i = 0; i < len; i++) {
                String query_id = queryIDs[i];

                WritableMap queryResult = null;
                String errorMessage = "unknown";

                try {
                    String query = queryarr[i];

                    long lastTotal = mydb.getTotalChanges();
                    queryResult = this.executeSqlStatementNDK(query, queryParams != null ? queryParams[i] : null, cbc);
                    long newTotal = mydb.getTotalChanges();
                    long rowsAffected = newTotal - lastTotal;

                    queryResult.putDouble("rowsAffected", rowsAffected);
                    if (rowsAffected > 0) {
                        long insertId = mydb.getLastInsertRowid();
                        if (insertId > 0) {
                            queryResult.putDouble("insertId", insertId);
                        }
                    }
                } catch (Exception ex) {
                    errorMessage = ex.getMessage();
                    FLog.e(TAG, "SQLitePlugin.executeSql[Batch]() failed", ex);
                }

                try {
                    if (queryResult != null) {
                        WritableMap r = Arguments.createMap();
                        r.putString("qid", query_id);

                        r.putString("type", "success");
                        r.putMap("result", queryResult);

                        batchResults.pushMap(r);
                    } else {
                        WritableMap r = Arguments.createMap();
                        r.putString("qid", query_id);
                        r.putString("type", "error");

                        WritableMap er = Arguments.createMap();
                        er.putString("message", errorMessage);
                        r.putMap("result", er);

                        batchResults.pushMap(r);
                    }
                } catch (Exception ex) {
                    FLog.e(TAG, "SQLitePlugin.executeSql[Batch]() failed", ex);
                }
            }

            cbc.success(batchResults);
        }

        /**
         * Get rows results from query cursor.
         *
         * @return results in string form
         */
        private WritableMap executeSqlStatementNDK(String query, ReadableArray queryArgs,
                                                   CallbackContext cbc) throws Exception {
            WritableMap rowsResult = Arguments.createMap();

            boolean hasRows;

            SQLiteStatement myStatement = null;
            try {
                try {
                    myStatement = mydb.prepareStatement(query);
                    if (queryArgs != null) {
                        for (int i = 0; i < queryArgs.size(); ++i) {
                            ReadableType type = queryArgs.getType(i);
                            if (type == ReadableType.Number){
                                double tmp = queryArgs.getDouble(i);
                                if (tmp == (long) tmp) {
                                    myStatement.bindLong(i + 1, (long) tmp);
                                } else {
                                    myStatement.bindDouble(i + 1, tmp);
                                }
                            } else if (queryArgs.isNull(i)) {
                                myStatement.bindNull(i + 1);
                            } else {
                                myStatement.bindTextNativeString(i + 1, SQLitePluginConverter.getString(queryArgs,i,""));
                            }
                        }
                    }

                    hasRows = myStatement.step();
                } catch (Exception ex) {
                    FLog.e(TAG, "SQLitePlugin.executeSql[Batch]() failed", ex);
                    throw ex;
                }

                // If query result has rows
                if (hasRows) {
                    WritableArray rowsArrayResult = Arguments.createArray();
                    String key;
                    int colCount = myStatement.getColumnCount();

                    // Build up JSON result object for each row
                    do {
                        WritableMap row = Arguments.createMap();
                        for (int i = 0; i < colCount; ++i) {
                            key = myStatement.getColumnName(i);

                            switch (myStatement.getColumnType(i)) {
                                case SQLColumnType.NULL:
                                    row.putNull(key);
                                    break;

                                case SQLColumnType.REAL:
                                    row.putDouble(key, myStatement.getColumnDouble(i));
                                    break;

                                case SQLColumnType.INTEGER:
                                    row.putDouble(key, myStatement.getColumnLong(i));
                                    break;

                                case SQLColumnType.BLOB:
                                case SQLColumnType.TEXT:
                                default:
                                    row.putString(key, myStatement.getColumnTextNativeString(i));
                            }

                        }

                        rowsArrayResult.pushMap(row);
                    } while (myStatement.step());

                    rowsResult.putArray("rows", rowsArrayResult);
                }
            } finally {
                if (myStatement != null) {
                    myStatement.dispose();
                }
            }

            return rowsResult;
        }
    }

    private class DBRunner implements Runnable {
        final String dbname;
        private String assetFilename;
        private boolean oldImpl;
        private boolean androidLockWorkaround;
        final int openFlags;
        final BlockingQueue<DBQuery> q;
        final CallbackContext openCbc;

        SQLiteAndroidDatabase mydb;

        DBRunner(final String dbname, ReadableMap options, CallbackContext cbc) {
            this.dbname = dbname;
            int openFlags = SQLiteOpenFlags.CREATE | SQLiteOpenFlags.READWRITE;
            try {
                this.assetFilename = SQLitePluginConverter.getString(options,"assetFilename",null);
                if (this.assetFilename != null && this.assetFilename.length() > 0) {
                    boolean readOnly = SQLitePluginConverter.getBoolean(options,"readOnly",false);
                    openFlags = readOnly ? SQLiteOpenFlags.READONLY : openFlags;
                }
            } catch (Exception ex){
                FLog.e(TAG,"Error retrieving assetFilename or mode from options:",ex);
            }
            this.openFlags = openFlags;
            this.oldImpl = SQLitePluginConverter.getBoolean(options,"androidOldDatabaseImplementation",false);
            FLog.v(TAG, "Android db implementation: " + (oldImpl ? "OLD" : "sqlite4java (NDK)"));
            this.androidLockWorkaround = this.oldImpl && SQLitePluginConverter.getBoolean(options,"androidLockWorkaround",false);
            if (this.androidLockWorkaround)
                FLog.i(TAG, "Android db closing/locking workaround applied");

            this.q = new LinkedBlockingQueue<>();
            this.openCbc = cbc;
        }

        public void run() {
            try {
                this.mydb = openDatabase(dbname, this.assetFilename, this.openFlags, this.openCbc, this.oldImpl);
            } catch (Exception ex) {
                FLog.e(TAG, "Error opening database, stopping db thread", ex);
                if (this.openCbc != null) {
                    this.openCbc.error("Can't open database." + ex);
                }
                dbrmap.remove(dbname);
                return;
            }

            DBQuery dbq = null;

            try {
                dbq = q.take();

                while (!dbq.stop) {
                    mydb.executeSqlBatch(dbq.queries, dbq.queryParams, dbq.queryIDs, dbq.cbc);

                    // NOTE: androidLock[Bug]Workaround is not necessary and IGNORED for sqlite4java (NDK version).
                    if (this.androidLockWorkaround && dbq.queries.length == 1 && dbq.queries[0].equals("COMMIT"))
                        mydb.bugWorkaround();

                    dbq = q.take();
                }
            } catch (Exception ex) {
                FLog.e(TAG, "unexpected error", ex);
            }

            if (dbq != null && dbq.close) {
                try {
                    closeDatabaseNow(dbname);

                    dbrmap.remove(dbname); // (should) remove ourself

                    if (!dbq.delete) {
                        dbq.cbc.success("database deleted");
                    } else {
                        try {
                            boolean deleteResult = deleteDatabaseNow(dbname);
                            if (deleteResult) {
                                dbq.cbc.success("database deleted");
                            } else {
                                dbq.cbc.error("couldn't delete database");
                            }
                        } catch (Exception ex) {
                            FLog.e(TAG, "couldn't delete database", ex);
                            dbq.cbc.error("couldn't delete database: " + ex);
                        }
                    }
                } catch (Exception ex) {
                    FLog.e(TAG, "couldn't close database", ex);
                    if (dbq.cbc != null) {
                        dbq.cbc.error("couldn't close database: " + ex);
                    }
                }
            }
        }
    }

    private final class DBQuery {
        // XXX TODO replace with DBRunner action enum:
        final boolean stop;
        final boolean close;
        final boolean delete;
        final String[] queries;
        final String[] queryIDs;
        final ReadableArray[] queryParams;
        final CallbackContext cbc;

        DBQuery(String[] myqueries, String[] qids, ReadableArray[] params, CallbackContext c) {
            this.stop = false;
            this.close = false;
            this.delete = false;
            this.queries = myqueries;
            this.queryIDs = qids;
            this.queryParams = params;
            this.cbc = c;
        }

        DBQuery(boolean delete, CallbackContext cbc) {
            this.stop = true;
            this.close = true;
            this.delete = delete;
            this.queries = null;
            this.queryIDs = null;
            this.queryParams = null;
            this.cbc = cbc;
        }

        // signal the DBRunner thread to stop:
        DBQuery() {
            this.stop = true;
            this.close = false;
            this.delete = false;
            this.queries = null;
            this.queryIDs = null;
            this.queryParams = null;
            this.cbc = null;
        }
    }

    private enum Action {
        open,
        close,
        attach,
        delete,
        executeSqlBatch,
        backgroundExecuteSqlBatch,
        echoStringValue
    }
}

/* vim: set expandtab : */