content: package me.rahul.plugins.sqlDB;
  
  import android.util.Log;
  
  import org.apache.cordova.CallbackContext;
  import org.apache.cordova.CordovaPlugin;
  import org.apache.cordova.PluginResult;
  import org.json.JSONArray;
  import org.json.JSONException;
  import org.json.JSONObject;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  
  /**
   * This class echoes a string called from JavaScript.
   */
  public class sqlDB extends CordovaPlugin {
  
      public static String dbname = "dbname";
      PluginResult plresult = new PluginResult(PluginResult.Status.NO_RESULT);
  
      private void sendPluginResponse(int code, String msg, boolean error, CallbackContext callbackContext) {
          JSONObject response = new JSONObject();
          try {
              response.put("message", msg);
              response.put("code", code);
              if (error) {
                  plresult = new PluginResult(PluginResult.Status.ERROR,
                          response);
              } else {
                  plresult = new PluginResult(PluginResult.Status.OK, response);
              }
          } catch (JSONException e) {
              // TODO Auto-generated catch block
              e.printStackTrace();
              plresult = new PluginResult(PluginResult.Status.ERROR,
                      e.getMessage());
          }
          callbackContext.sendPluginResult(plresult);
      }
  
      @Override
      public boolean execute(String action, JSONArray args,
                             CallbackContext callbackContext) throws JSONException {
  
          if (action.equalsIgnoreCase("copy")) {
              this.copyDB(args.getString(0), "www", callbackContext);
              return true;
          } else if (action.equalsIgnoreCase("remove")) {
              String db = args.getString(0);
              File path = cordova.getActivity().getDatabasePath(db);
              Boolean fileExists = path.exists();
              if (fileExists) {
                  boolean deleted = path.delete();
                  if (deleted) {
                      sendPluginResponse(200, "Database Deleted", false, callbackContext);
                  } else {
                      sendPluginResponse(400, "Unable to Delete", true, callbackContext);
                  }
              } else {
                  sendPluginResponse(404, "Invalid DB Location or DB Doesn't Exists", true, callbackContext);
              }
              return true;
          } else if (action.equalsIgnoreCase("copyDbToStorage")) {
              String db = args.getString(0);
              String dest = args.getString(2);
              boolean overwrite = args.getBoolean(3);
              this.copyDbToStorage(db, dest, overwrite, callbackContext);
              return true;
          } else if (action.equalsIgnoreCase("copyDbFromStorage")) {
              String db = args.getString(0);
              String src = args.getString(2);
              boolean deleteolddb = args.getBoolean(3);
              this.copyDbFromStorage(db, src, deleteolddb, callbackContext);
              return true;
          } else if (action.equalsIgnoreCase("checkDbOnStorage")) {
              String db = args.getString(0);
              String src = args.getString(1);
              this.checkDbOnStorage(db, src, callbackContext);
              return true;
          } else {
              plresult = new PluginResult(PluginResult.Status.INVALID_ACTION);
              callbackContext.sendPluginResult(plresult);
              return false;
          }
      }
  
      private void copyDB(final String dbName, final String src, final CallbackContext callbackContext) {
  
          final File dbpath;
          dbname = dbName;
          JSONObject response = new JSONObject();
          final DatabaseHelper dbhelper = new DatabaseHelper(this.cordova
                  .getActivity().getApplicationContext());
          dbpath = this.cordova.getActivity().getDatabasePath(dbname);
          Boolean dbexists = dbpath.exists();
          Log.d("CordovaLog", "DatabasePath = " + dbpath + "&&&& dbname = " + dbname + "&&&&DB Exists =" + dbexists);
  
          if (dbexists) {
              sendPluginResponse(516, "DB Already Exists", true, callbackContext);
          } else {
              cordova.getThreadPool().execute(new Runnable() {
  
                  @Override
                  public void run() {
                      PluginResult plresult;
  
                      // TODO Auto-generated method stub
  //                    try {
  //                        dbhelper.createdatabase(dbpath, src, callbackContext);
  ////						plResult = new PluginResult(PluginResult.Status.OK);
  ////						callbackContext.sendPluginResult(plResult);
  //                        //sendPluginResponse(200,"Db Copied", false, callbackContext);
  //                    } catch (Exception e) {
  //
  ////						plResult = new PluginResult(PluginResult.Status.ERROR,
  ////								e.getMessage());
  ////						callbackContext.sendPluginResult(plResult);
  //                        sendPluginResponse(400, e.getMessage(), true, callbackContext);
  //                    }
                      InputStream myInput = null;
                      JSONObject response = new JSONObject();
                      try {
                          myInput = cordova.getActivity().getAssets().open("www/" + dbName);
  
                          OutputStream myOutput = new FileOutputStream(dbpath);
                          byte[] buffer = new byte[1024];
                          while ((myInput.read(buffer)) > -1) {
                              myOutput.write(buffer);
                          }
  
                          myOutput.flush();
                          myOutput.close();
                          myInput.close();
                          try {
                              response.put("message", "Db Copied");
                              response.put("code", 200);
                              plresult = new PluginResult(PluginResult.Status.OK,response);
                              callbackContext.sendPluginResult(plresult);
                          } catch (JSONException err) {
                              throw new Error(err.getMessage());
                          }
                      } catch (Exception e) {
                          Log.d("Cordova", "Try Error = "+e.getMessage());
                          try {
                              dbhelper.createdatabase(dbpath, src, callbackContext);
                          } catch (Exception err) {
                              sendPluginResponse(400, e.getMessage(), true, callbackContext);
                          }
                      }
                  }
  
              });
          }
      }
  
  
      private void newCopyDB(File source, File destination, CallbackContext callbackContext) {
          try {
              InputStream myInput = new FileInputStream(source);
              OutputStream myOutput = new FileOutputStream(destination);
              byte[] buffer = new byte[1024];
              while ((myInput.read(buffer)) > -1) {
                  myOutput.write(buffer);
              }
  
              myOutput.flush();
              myOutput.close();
              myInput.close();
              sendPluginResponse(200, "DB Copied Successfully", false, callbackContext);
          } catch (IOException e) {
              sendPluginResponse(400, e.getMessage(), true, callbackContext);
          }
      }
  
      private void copyDbFromStorage(String db, String src, boolean deleteolddb, final CallbackContext callbackContext) {
          File source;
          if (src.indexOf("file://") != -1) {
              source = new File(src.replace("file://", ""));
          } else {
              source = new File(src);
          }
  
          if (source.exists()) {
              if (deleteolddb) {
                  File path = cordova.getActivity().getDatabasePath(db);
                  Boolean fileExists = path.exists();
                  if (fileExists) {
                      boolean deleted = path.delete();
                      if (deleted) {
                          this.copyDB(db, source.getAbsolutePath(), callbackContext);
                      } else {
                          sendPluginResponse(400, "Unable to Delete", true, callbackContext);
                      }
                  } else {
                      sendPluginResponse(404, "Old DB Doesn't Exists", true, callbackContext);
                  }
              } else {
                  this.copyDB(db, source.getAbsolutePath(), callbackContext);
              }
          } else {
              sendPluginResponse(404, "Invalid DB Source Location", true, callbackContext);
          }
      }
  
      private void checkDbOnStorage(String db, String src, final CallbackContext callbackContext) {
          File source;
          if (src.indexOf("file://") != -1) {
              source = new File(src.replace("file://", "")+db);
          } else {
              source = new File(src+db);
          }
          if (source.exists()) {
              sendPluginResponse(200, "DB File Exists At Source Location", false, callbackContext);
          } else {
              sendPluginResponse(404, "Invalid DB Source Location", true, callbackContext);
          }
  
      }
  
      private void copyDbToStorage(String dbname, String dest, boolean overwrite, final CallbackContext callbackContext) {
  
          File source = cordova.getActivity().getDatabasePath(dbname);
          File destFolder;
          File destination;
  
          if (dest.indexOf("file://") != -1) {
              destination = new File(dest.replace("file://", "") + dbname);
              destFolder = new File(dest.replace("file://", ""));
          } else {
              destination = new File(dest + dbname);
              destFolder = new File(dest);
          }
  
  
          if (!destFolder.exists()) {
              destFolder.mkdirs();
          }
  
          if (!destFolder.exists()) {
              sendPluginResponse(404, "Invalid output DB Location", true, callbackContext);
              return;
          }
  
          //Check if the db exists at source
          if (source.exists()) {
              //check if the db file is already present at destination and overwrite flag is false
              if(destination.exists() && !overwrite) {
                  sendPluginResponse(400, "DB already exists at destination", true, callbackContext);
              } else {
                  this.newCopyDB(source, destination, callbackContext);
              }
          } else {
              sendPluginResponse(404, "Invalid DB Location or DB Doesn't Exists", true, callbackContext);
          }
      }
  }
  