Application crash only on device but not on emultor
<p>The error:
04-24 08:48:10.779: INFO/Database(31359): sqlite returned: error code = 14, msg = cannot open file at source line 25467</p>

<p>What could be the error that could disturb just the device and not the emulator?</p>

<p>Where i should start to check ?</p>

<pre><code>    public class DBHelper extends SQLiteOpenHelper {

private static String DB_PATH = "";
private static final String DB_NAME = "med.sqlite";
private SQLiteDatabase myDataBase;
private final Context myContext;

private static DBHelper mDBConnection;

/**
 * Constructor 
 * Takes and keeps a reference of the passed context in order to access to the application assets and resources.
 * @param context
 */
private DBHelper(Context context) {
    super(context, DB_NAME, null, 1);
    this.myContext = context;
    DB_PATH = "/data/data/"+ context.getApplicationContext().getPackageName()   + "/databases/";
    // The Android's default system path of your application database is
    // "/data/data/mypackagename/databases/"
}

/**
 * getting Instance
 * @param context
 * @return DBAdapter
 */
public static synchronized DBHelper getDBAdapterInstance(Context context) {
    if (mDBConnection == null) {
        mDBConnection = new DBHelper(context);
    }
    return mDBConnection;
}

/**
 * Creates an 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 following method 
        // 1) an empty database will be created into the default system path of your application 
        // 2) than we overwrite that database with our database.
        this.getReadableDatabase();
        try {
            copyDataBase();
        } catch (IOException e) {
            throw new Error("Error copying database");
        }
    }
}

/**
 * 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_READONLY);

    } catch (SQLiteException e) {
        // database does't exist yet.
    }
    if (checkDB != null) {
        checkDB.close();
    }
    return checkDB != null ? true : false;
}

/**
 * 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 {
        // Open your local db as the input stream
    InputStream myInput = myContext.getAssets().open(DB_NAME);
        // 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)) &gt; 0) {
        myOutput.write(buffer, 0, length);
    }
        // Close the streams
    myOutput.flush();
    myOutput.close();
    myInput.close();
}

/**
 * Open the database
 * @throws SQLException
 */
public void openDataBase() throws SQLException {
    String myPath = DB_PATH + DB_NAME;

    myDataBase = SQLiteDatabase.openDatabase(myPath, null,SQLiteDatabase.OPEN_READWRITE);       
}

/**
 * Close the database if exist
 */
@Override
public synchronized void close()
{
    if (myDataBase != null)
        myDataBase.close();
    super.close();
}

/**
 * Call on creating data base for example for creating tables at run time
 */
@Override
public void onCreate(SQLiteDatabase db)
{
}

/**
 * can used for drop tables then call onCreate(db) function to create tables again - upgrade
 */
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)
{
}

// ----------------------- CRUD Functions ------------------------------

/**
 * This function used to select the records from DB.
 * @param tableName
 * @param tableColumns
 * @param whereClase
 * @param whereArgs
 * @param groupBy
 * @param having
 * @param orderBy
 * @return A Cursor object, which is positioned before the first entry.
 */
public Cursor selectRecordsFromDB(String tableName, String[] tableColumns,
        String whereClase, String whereArgs[], String groupBy,
        String having, String orderBy)
{
    return myDataBase.query(tableName, tableColumns, whereClase, whereArgs,
            groupBy, having, orderBy);
}



/**
 * select records from db and return in list
 * @param tableName
 * @param tableColumns
 * @param whereClase
 * @param whereArgs
 * @param groupBy
 * @param having
 * @param orderBy
 * @return ArrayList&lt;ArrayList&lt;String&gt;&gt;
 */
public ArrayList&lt;ArrayList&lt;String&gt;&gt; selectRecordsFromDBList(String tableName, String[] tableColumns,
        String whereClase, String whereArgs[], String groupBy,
        String having, String orderBy)
{       

    ArrayList&lt;ArrayList&lt;String&gt;&gt; retList = new ArrayList&lt;ArrayList&lt;String&gt;&gt;();
      ArrayList&lt;String&gt; list = new ArrayList&lt;String&gt;();
      Cursor cursor = myDataBase.query(tableName, tableColumns, whereClase, whereArgs,
                groupBy, having, orderBy);        
      if (cursor.moveToFirst()) {
         do {
             list = new ArrayList&lt;String&gt;();
             for(int i=0; i&lt;cursor.getColumnCount(); i++){                   
                 list.add( cursor.getString(i) );
             }   
             retList.add(list);
         } while (cursor.moveToNext());
      }
      if (cursor != null &amp;&amp; !cursor.isClosed()) {
         cursor.close();
      }
      return retList;

}   

/**
 * This function used to insert the Record in DB. 
 * @param tableName
 * @param nullColumnHack
 * @param initialValues
 * @return the row ID of the newly inserted row, or -1 if an error occurred
 */
public long insertRecordsInDB(String tableName, String nullColumnHack,
        ContentValues initialValues) {
    return myDataBase.insert(tableName, nullColumnHack, initialValues);
}

/**
 * This function used to update the Record in DB.
 * @param tableName
 * @param initialValues
 * @param whereClause
 * @param whereArgs
 * @return true / false on updating one or more records
 */
public boolean updateRecordInDB(String tableName,
        ContentValues initialValues, String whereClause, String whereArgs[]) {
    return myDataBase.update(tableName, initialValues, whereClause,
            whereArgs) &gt; 0;             
}

/**
 * This function used to update the Record in DB.
 * @param tableName
 * @param initialValues
 * @param whereClause
 * @param whereArgs
 * @return 0 in case of failure otherwise return no of row(s) are updated
 */
public int updateRecordsInDB(String tableName,
        ContentValues initialValues, String whereClause, String whereArgs[]) {
    return myDataBase.update(tableName, initialValues, whereClause, whereArgs);     
}

/**
 * This function used to delete the Record in DB.
 * @param tableName
 * @param whereClause
 * @param whereArgs
 * @return 0 in case of failure otherwise return no of row(s) are deleted.
 */
public int deleteRecordInDB(String tableName, String whereClause,
        String[] whereArgs) {
    return myDataBase.delete(tableName, whereClause, whereArgs);
}


/**
 * apply raw Query
 * @param query
 * @param selectionArgs
 * @return Cursor
 */
public Cursor selectRecordsFromDB(String query, String[] selectionArgs) {
    return myDataBase.rawQuery(query, selectionArgs);       
}


/**
 * apply raw query and return result in list
 * @param query
 * @param selectionArgs
 * @return ArrayList&lt;ArrayList&lt;String&gt;&gt;
 */
public ArrayList&lt;ArrayList&lt;String&gt;&gt; selectRecordsFromDBList(String query, String[] selectionArgs) {       
      ArrayList&lt;ArrayList&lt;String&gt;&gt; retList = new ArrayList&lt;ArrayList&lt;String&gt;&gt;();
      ArrayList&lt;String&gt; list = new ArrayList&lt;String&gt;();
      Cursor cursor = myDataBase.rawQuery(query, selectionArgs);

      if (cursor.moveToFirst()) {
         do {
             list = new ArrayList&lt;String&gt;();
             for(int i=0; i&lt;cursor.getColumnCount(); i++){                   
                 list.add( cursor.getString(i) );
             }   
             retList.add(list);
         } while (cursor.moveToNext());
      }
      if (cursor != null &amp;&amp; !cursor.isClosed()) {
         cursor.close();
      }

      return retList;
   }
</code></pre>

<p>}</p>

<pre><code>  04-24 12:04:14.289: INFO/Database(3807): sqlite returned: error code = 14, msg =     cannot open file at source line 25467
  04-24 12:04:14.289: ERROR/Database(3807):     sqlite3_open_v2("/data/data/com.TravelPharm/databases/Medicaments.sqlite", &amp;handle, 1, NULL) failed
  04-24 12:04:14.299: DEBUG/RegisterService(431): insert plugin size 1
  04-24 12:04:14.339: DEBUG/asset(3807): Data exceeds UNCOMPRESS_DATA_MAX (17304576 vs  4194304)
  04-24 12:04:14.339: WARN/System.err(3807): java.io.IOException
04-24 12:04:14.339: WARN/System.err(3807):     at android.content.res.AssetManager.readAsset(Native Method)
04-24 12:04:14.339: WARN/System.err(3807):     at android.content.res.AssetManager.access$700(AssetManager.java:36)
04-24 12:04:14.339: WARN/System.err(3807):     at android.content.res.AssetManager$AssetInputStream.read(AssetManager.java:571)
04-24 12:04:14.339: WARN/System.err(3807):     at com.TravelPharm.DBHelper.copyDataBase(DBHelper.java:116)
04-24 12:04:14.339: WARN/System.err(3807):     at com.TravelPharm.DBHelper.createDataBase(DBHelper.java:73)
04-24 12:04:14.339: WARN/System.err(3807):     at com.TravelPharm.TravelPharm.SumofDetails(TravelPharm.java:286)
04-24 12:04:14.339: WARN/System.err(3807):     at com.TravelPharm.TravelPharm.onCreate(TravelPharm.java:61)
04-24 12:04:14.339: WARN/System.err(3807):     at android.app.Instrumentation.callActivityOnCreate(Instrumentation.java:1069)
04-24 12:04:14.339: WARN/System.err(3807):     at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:2751)
04-24 12:04:14.339: WARN/System.err(3807):     at android.app.ActivityThread.handleLaunchActivity(ActivityThread.java:2803)
04-24 12:04:14.339: WARN/System.err(3807):     at android.app.ActivityThread.access$2300(ActivityThread.java:135)
04-24 12:04:14.339: WARN/System.err(3807):     at android.app.ActivityThread$H.handleMessage(ActivityThread.java:2136)
04-24 12:04:14.339: WARN/System.err(3807):     at android.os.Handler.dispatchMessage(Handler.java:99)
04-24 12:04:14.339: WARN/System.err(3807):     at android.os.Looper.loop(Looper.java:144)
04-24 12:04:14.339: WARN/System.err(3807):     at android.app.ActivityThread.main(ActivityThread.java:4937)
04-24 12:04:14.339: WARN/System.err(3807):     at java.lang.reflect.Method.invokeNative(Native Method)
04-24 12:04:14.339: WARN/System.err(3807):     at java.lang.reflect.Method.invoke(Method.java:521)
04-24 12:04:14.339: WARN/System.err(3807):     at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:868)
04-24 12:04:14.339: WARN/System.err(3807):     at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:626)
04-24 12:04:14.339: WARN/System.err(3807):     at dalvik.system.NativeStart.main(Native Method)
</code></pre>

<p>Thanks for helping!!</p>
