PawSQLite-Cordova-Adapter/src/android/DB.java

package org.n0m.pawsqlite;

import java.io.File;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import android.util.Log;

import android.database.sqlite.SQLiteDatabase;
import android.database.SQLException;
import android.database.Cursor;


class DB {
  private static final String TAG = "PawSQLite";

  public final String dbName;
  private File dbFile;
  
  public SQLiteDatabase db;


  public DB (File dbFile, String dbName) {
    this.dbFile = dbFile;
    this.dbName = dbName;
  }

  public void handleRequest(DBRequest request) {
    try {
      switch(request.action) {
        case VERSION:
          version(request.callback);
          break;
        case OPEN:
          open(request.callback);
          break;
        case SQL:
          sql(request.args, request.callback);
          break;
        case CLOSE:
          close(request.callback);
          break;
        case DELETE:
          delete(request.callback);
          break;
        default:
          request.callback.error("Unrecognised Action");
      }
    } catch (JSONException e) {
      request.callback.error("JSONException", e);
    }
  }

  public void open(CallbackWrapper callback) throws JSONException {
    if (db == null || !db.isOpen()) {
      db = SQLiteDatabase.openOrCreateDatabase(dbFile, null);
    }

    JSONObject response = new JSONObject();
    response.put("path", db.getPath());
    response.put("version", db.getVersion());
    callback.success(response);
  }


  public void delete(CallbackWrapper callback) {
    if (db == null) {
      if(SQLiteDatabase.deleteDatabase(dbFile)) {
        callback.success();
      } else {
        callback.error("Unable to Delete Database",
          "SQLiteDatabase.deleteDatabase returned false");
      }
    } else {
      callback.error("Unable to Delete Database",
        "Database is currently open");
    }
  }
  
  public void sql(JSONArray args, CallbackWrapper callback) throws JSONException {
    if (db == null) {
      callback.error(
        "DB Not open",
        "Database: " + dbName + " is not open"
      );
    }

    String query = args.optString(0);
    // Remove query from args
    args.remove(0);

    QueryWrapper queryWrapper = new QueryWrapper(db, query, args);

    JSONObject result;
    try {
      result = queryWrapper.execute();
    } catch (SQLException e) {
      callback.error("SQLException", e);
      return;
    } catch (Exception e) {
      callback.error("Exception", e);
      return;
    }

    callback.success(result);
  }
  
  public void close(CallbackWrapper callback) {
    if (db != null) {
      db.close();
    }    
    callback.success();
  }

  public void version(CallbackWrapper callback) throws JSONException {
    String query = "select sqlite_version() AS sqlite_version";
    SQLiteDatabase db = SQLiteDatabase.openOrCreateDatabase(":memory:", null);
    Cursor cursor = db.rawQuery(query, null);
    String sqliteVersion = "";
    if (cursor.moveToNext()) {
      sqliteVersion = cursor.getString(0);
    }
    cursor.close();
    db.close();
    
    JSONObject result = new JSONObject();
    result.put("version", sqliteVersion);
    callback.success(result);
  }
}