External sqlite database for an Android app

Create Sqlite Database and Tables by using Sqlite Manager 

Create new table called “android_metadata”

CREATE TABLE "android_metadata" ("locale" TEXT DEFAULT 'en_US')

Now insert a  text ‘en_US’ in the “android_metadata” table:

INSERT INTO "android_metadata" VALUES ('en_US')

INSERT INTO "android_metadata" VALUES ('en_US')

Now Create DatabaseHelper class 

package com.test.database;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import android.annotation.SuppressLint;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteException;
import android.database.sqlite.SQLiteOpenHelper;

public class DatabaseHelper extends SQLiteOpenHelper{
  
    //The Android's default system path of your application database.
    String DB_PATH =null;
 
    private static String DB_NAME = "TestDB";
    private static String TB_Name = "Test";
 
    private SQLiteDatabase myDataBase; 
    
    private final Context myContext;
 
    /**
     * Constructor
     * Takes and keeps a reference of the passed context in order to access to the application assets and resources.
     * @param context
     */
    @SuppressLint("SdCardPath")
 public DatabaseHelper(Context context) {
 
     super(context, DB_NAME, null, 1);
        this.myContext = context;
        DB_PATH="/data/data/"+myContext.getPackageName()+"/databases/";
    } 
 
  /**
     * Creates a empty database on the system and rewrites it with your own database.
     * */
    public void createDataBase() throws IOException{
 
     boolean dbExist = checkDataBase();
 
     if(dbExist){
      //do nothing - database already exist
     }else{
 
      //By calling this method and empty database will be created into the default system path
               //of your application so we are gonna be able to overwrite that database with our database.
         this.getReadableDatabase();
 
         try {
 
       copyDataBase();
 
      } catch (IOException e) {
 
          throw new Error("Error copying database"+e);
 
         }
     }
 
    }
 
    /**
     * Check if the database already exist to avoid re-copying the file each time you open the application.
     * @return true if it exists, false if it doesn't
     */
    private boolean checkDataBase(){

        SQLiteDatabase checkDB = null;
         boolean checkdatabase = false;
        try{
            String myPath = DB_PATH + DB_NAME;
             File dbfile = new File(myPath);
           // checkDB = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READONLY);
          checkdatabase =dbfile.exists();
        }catch(SQLiteException e){
          //database does't exist yet.
       }

        return checkdatabase;
    }
    /**
     * Copies your database from your local assets-folder to the just created empty database in the
     * system folder, from where it can be accessed and handled.
     * This is done by transfering bytestream.
     * */
    private void copyDataBase() throws IOException{
 
      InputStream myInput = myContext.getAssets().open(DB_NAME);  
       String outFileName = DB_PATH + DB_NAME;  
       OutputStream myOutput = new FileOutputStream(outFileName);  
       byte[] buffer = new byte[1024];  
       int length;  
       while ((length = myInput.read(buffer)) > 0) {  
        myOutput.write(buffer, 0, length);  
       }  
       
       // Close the streams  
       myOutput.flush();  
       myOutput.close();  
       myInput.close();  
    }
 
    public void openDataBase() throws SQLException{
 
     //Open the database
        String myPath = DB_PATH + DB_NAME;
     myDataBase = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READWRITE);
 
    }
 
    @Override
 public synchronized void close() {
 
         if(myDataBase != null)
          myDataBase.close();
 
         super.close();
 
 }
    
 @Override
 public void onCreate(SQLiteDatabase db) {
 
 }
 
 @Override
 public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
 
 }
  // Updating single contact
 public int updateContact(String steVale) {
     SQLiteDatabase db = this.getWritableDatabase();
  
     ContentValues values = new ContentValues();
     values.put("Name",steVale);
     String where= "Name = asd";
     return db.update(TB_Name, values, where,null );
 }
 
    // Deleting single contact
 public void deleteContact(String str) {
  try{
  SQLiteDatabase db = this.getWritableDatabase();
  db.execSQL("DELETE  FROM "+TB_Name+" WHERE Name = '"+str+"'");
  db.close();
  }catch(Exception e){}
 }
 
  // Insertion Contacts
  public void insertContact(String data) {
      SQLiteDatabase db = this.getWritableDatabase();
   
      ContentValues values = new ContentValues();
      values.put("Name", data);
       db.insert(TB_Name, null, values);
  }
  
  // Execute Query
  public Cursor getData(String qry)
  {
   return myDataBase.rawQuery(qry, null);
  }
}

Use DatabaseHelper class

DatabaseHelper myDbHelper;
 // Open Database 
    try{ 
        myDbHelper =new DatabaseHelper(context);
        myDbHelper.createDataBase();
        myDbHelper.openDataBase();
        }
        catch(Exception e)
        {
         Toast.makeText(context, "Error"+e, Toast.LENGTH_LONG).show();
        } 
       
 //Insert Value in database Table
 myDbHelper.insertContact(editInput.getText().toString());
 
 // Fetch data from database Table
        ArrayList<String> strData=new ArrayList<String>();
 Cursor curCalllog= myDbHelper.getData("Select * from Test");
      if(curCalllog != null && curCalllog.moveToFirst()) {
    while(!curCalllog.isAfterLast())
    {
     strData.add(curCalllog.getString(0));
     curCalllog.moveToNext();
    }
   }

Bishnu