Question

i am trying to copy an custom sqlite database into android and it is giving me error.

public class DataBaseHelper extends SQLiteOpenHelper
{
private static String TAG = "DataBaseHelper"; // Tag just for the LogCat window
private static String DB_PATH = "/data/data/mypackagename/databases/";//path of our database
private static String DB_NAME ="application-database";// Database name
private SQLiteDatabase mDataBase; 
private final Context mContext;


public DataBaseHelper(Context context) 
{
    super(context, DB_NAME, null, 1);
    DB_PATH = "/data/data/" + context.getPackageName() + "/databases/";
    this.mContext = context;
}   

public void createDataBase() throws IOException
{
    //If database not exists copy it from the assets

    boolean mDataBaseExist = checkDataBase();
    if(!mDataBaseExist)
    {
        this.getReadableDatabase();
        this.close();
        try 
        {
            //Copy the database from assests
            copyDataBase();
            Log.e(TAG, "createDatabase database created");
        } 
        catch (IOException mIOException) 
        {
            throw new Error("ErrorCopyingDataBase");
        }
    }
}




private void copyDataBase() throws IOException
    {
        InputStream mInput = mContext.getAssets().open(DB_NAME);
        String outFileName = DB_PATH + DB_NAME;
        OutputStream mOutput = new FileOutputStream(outFileName);
        byte[] mBuffer = new byte[1024];
        int mLength;
        while ((mLength = mInput.read(mBuffer))>0)
        {
            mOutput.write(mBuffer, 0, mLength);
        }
        mOutput.flush();
        mOutput.close();
        mInput.close();
    }

When i am at InputStream mInput = mContext.getAssets().open(DB_NAME);

it gives an exception and program goes directly to

 catch (IOException mIOException) 
        {
            throw new Error("ErrorCopyingDataBase");
        }

The database is in assets folder please tell me what is the problem

Answer 1

Please try this

public class DBConnect extends SQLiteOpenHelper 
{
    public String DB_PATH;
    public String DB_NAME;
    public final String DB_PART1_NAME="Database.sqlite";

    public SQLiteDatabase db;
    private final Context myContext;
    private final String TAG="DBConnect";
    private final static int DATABASE_VERSION = 1;

    /**
     * Constructor Takes and keeps a reference of the passed context in order to
     * access to the application assets and resources.
     * 
     * @param context
     * @param db_name
     */
    public DBConnect(Context context,String db_name) 
    {
        super(context, db_name, null, DATABASE_VERSION);
        this.myContext = context; 
        DB_PATH = Global.DB_PATH;
        DB_NAME = db_name;
        try{
            createDataBase();
            openDataBase();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * Creates a empty database on the system and rewrites it with your own
     * database.
     * */
    public void createDataBase() throws Exception 
     {
        boolean dbExist = checkDataBase();
        if (dbExist){
            System.out.println("Database Exist");
        }
        else
        {
            this.getReadableDatabase();
            try{
                copyDataBase();
            }catch (Exception e){
                throw new Error(e.getMessage());
            }
        }
     }

    /**
     * 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;
        try 
        {
            String myPath = DB_PATH + DB_NAME;
            checkDB = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READWRITE);
        }catch (Exception e){
            System.out.println("database does't exist yet.");
        }

        if (checkDB != null){
            checkDB.close();
            System.out.println("My db is:- " + checkDB.isOpen());
            return true;
        }
        else 
            return false;
     }

    public void copyCacheToMain(DBConnect objCache)throws IOException 
    {
        // Open your local db as the input stream
        String inFileName = objCache.DB_PATH + objCache.DB_NAME;
        InputStream myInput = new FileInputStream(inFileName);

        // Path to the just created empty db
        String outFileName = DB_PATH + DB_NAME;

        // Open the empty db as the output stream
        OutputStream myOutput = new FileOutputStream(outFileName);

        // transfer bytes from the inputfile to the outputfile
        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();
        Log.d("CTM","Cache To Main Database Copied !");
     }
    /**
     * 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 Exception 
    {
        try {
            if(DB_NAME.equalsIgnoreCase(Global.DB_MAIN))
            {
                InputStream myInput = myContext.getAssets().open(DB_PART1_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);
                }
                myInput.close();
                myOutput.flush();
                myOutput.close();
            }
            else {
                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);
                }
                myInput.close();
                myOutput.flush();
                myOutput.close();
            }
            System.out.println(DB_NAME+"Database Copied !");
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        }
    }

    public void openDataBase() throws SQLException 
    {
        // Open the database
        String myPath = DB_PATH + DB_NAME;
        db = SQLiteDatabase.openDatabase(myPath, null,SQLiteDatabase.OPEN_READWRITE);
    }

    @Override
    public synchronized void close() 
    {
        if (db != null)
            db.close();
        System.out.println("My db is:- " + db.isOpen());
        super.close();
    }

    public synchronized void execNonQuery(String sql) {
        try {
            db.execSQL(sql);
            Log.d("SQL",sql );          
        } catch (Exception e) {
            Log.e("Err",e.getMessage());            
        } finally {
            //closeDb();    
        }
    }
    public synchronized Cursor execQuery(String sql) {
        Cursor cursor=null;
        try {
            cursor = db.rawQuery(sql, null);
            Log.d("SQL",sql );          
        } catch (Exception e) {
            Log.e("Err",e.getMessage());            
        } finally {
            //closeDb();    
        }
        return cursor;
    }
    public synchronized Cursor execQuery(String sql, String[] selectionArgs) {
        Cursor cursor=null;
        try {
            cursor = db.rawQuery(sql, selectionArgs);
            Log.d("SQL",sql );          
        } catch (Exception e) {
            Log.e("Err",e.getMessage());            
        } finally {
            //closeDb();    
        }
        return cursor;
    }
    public long insert(String tblName, Object myObj)
    {
        ContentValues initialValues = new ContentValues();
        long result = -1;

        Field[] fields =  myObj.getClass().getFields();

            try{
                for (Field field : fields){
                    initialValues.put(field.getName(), (String) field.get(myObj));
//                  Log.i(TAG, field.getName()+" = "+initialValues.getAsString(field.getName()));
                }
                result = db.insertOrThrow(tblName, null, initialValues);
            } catch (IllegalArgumentException e) {              
                e.printStackTrace();
            } catch (IllegalAccessException e) {                
                e.printStackTrace();
            }catch (SQLException e) {
                e.printStackTrace();
            }catch (Exception e) {
                e.printStackTrace();
            }
        return result;
    }

    /**
     * 
     * @param sqlQuery SQL query to be fired
     * @param myObj Object to be fetched
     * @return Returns a Vector object containing raws fetched by the sqlQuery
     */

    public ArrayList<Object> fetchAllRows(String sqlQuery, Object myObj)
    {
        ArrayList<Object> records = new ArrayList<Object>();
        Object newObj;
        Cursor cursor = execQuery(sqlQuery);

        if (cursor != null) {
            while (cursor.moveToNext()) {
                //          System.out.println("Test While");
                newObj = ClassUtils.newObject(myObj);
                for (int i = 0; i < cursor.getColumnCount(); i++) {
                    String key = cursor.getColumnName(i);
                    String value = cursor.getString(i);
                    if (value == null) {
                        value = "";
                    }
                    ClassUtils.objectMapping(newObj, key, value);
                }
                records.add(newObj);
            }
            cursor.close();
        }
        return records;
    }

    @Override
    public void onCreate(SQLiteDatabase db) 
    {

    }
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) 
    {

    }
}

write below code into your first activity

    Global.context = this;
    Global.dbMain = new DBConnect(this, Global.DB_MAIN);

make one Global.java file in that write below code and make your variables global

public class Global 
{
    public static String DB_PATH = "data/data/YOUR_PACKAGE_NAME/databases/";
    public static final String DB_MAIN = "Database.sqlite";

    public static Context context;
    public static DBConnect dbMain;
}

Now suppose you want to select something from your table then write below code,

Global.dbMain.openDataBase();
System.out.println("database open ");
    try
    {
      Cursor c = Global.dbMain.execQuery("select * from tableName", null);
      while(c.moveToNext())
       {
         System.out.println("in while");
         String str= c.getString(1);
       }
      c.close();
    }
    catch(Exception e)
    {
      e.printStackTrace();
    }
Global.dbMain.close();