android - resueltos - Archivo DB en la carpeta de activos. ¿Será actualizado?

manual android studio avanzado

Question

Soy nuevo en el tema de SQLite para Android. Esto es lo que tengo:

• Tengo db.sqlite en mi carpeta de assets .
• La intención de la db es LEER SOLAMENTE. El usuario no le escribirá.
• Cuando la aplicación se actualice, db.sqlite se reemplazará por una nueva base de datos (eliminaré el archivo antiguo del proyecto y agregaré el nuevo).

Lo que me preocupa es:

• ¿Se borrará el antiguo archivo db? (eso es lo que quiero; reemplazar el viejo por el nuevo)
  • ¿Por qué preguntar? Porque cuando depuro mi aplicación, cada vez que actualizo el archivo db, necesito desinstalar la aplicación del dispositivo para forzar la actualización. ¿Los usuarios deberán hacer lo mismo cuando actualicen mi aplicación desde Play Store? Tengo miedo de eso.
• ¿Esto se verá afectado por la forma en que implemento onCreate(SQLiteDatabase) y onUpgrade (SQLiteDatabase, int, int) ?
  • En caso afirmativo, ¿cuál es la forma correcta de implementarlos para cumplir con mis requisitos?

Así es como extiendo la clase SQLiteOpenHelper . Seguí un tutorial que encontré en internet:

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;    
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;
import android.util.Log;

public class DataBaseHelper extends SQLiteOpenHelper{

    //The Android''s default system path of your application database.
    private static String DB_PATH = "/data/data/com.mydomain.myapp/databases/";
    private static String DB_NAME = "db.sqlite";
    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
     **/
    public DataBaseHelper(Context context) {

        super(context, DB_NAME, null, 1);
        this.myContext = context;
    }   

  /**
     * 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
            Log.i("myapp", "database already exist");
        }else{
            Log.i("myapp", "database NOT exist");

            //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");

            }
        }

    }

    /**
     * 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))>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) {

    }

  // My public helper methods to access and get content from the database go here

Answer 1

Después de mucho buscar. He encontrado que esta base de datos de carpetas de activos es de solo lectura. no puede actualizar la base de datos en la carpeta de activos. Supongamos que la próxima versión de su aplicación se publique en Google Play Store con la nueva base de datos actualizada en la carpeta Assert. si el nombre de ambas bases de datos en assert son iguales (en la aplicación anterior y la nueva), el sistema Android solo leerá el archivo de la base de datos anterior. Porque el sistema de archivos no puede contener dos archivos con el mismo nombre. Lo que debe hacer es cambiar el nombre del nuevo archivo de base de datos en dataOpenhelper.class. como database_1.db.

public class DatabaseOpenHelper extends SQLiteAssetHelper {
    private static final String DATABASE_NAME = "dbbasic_5.db";
    private static final int DATABASE_VERSION = 3;
    private Context contaxtDB;

    // ********* reminder **********
   //  only change database_name = like dbbasic_5.6.7.8  .
    // *******   do not change database_version
    //

    public DatabaseOpenHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
        contaxtDB = context;
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        super.onUpgrade(db, oldVersion, newVersion);

    }


}

Answer 2

No puede reemplazar la base de datos en onUpgrade() porque en este método la base de datos ya está en uso. Debe hacerlo antes de que la base de datos esté abierta, como en un constructor de su DatabaseHelper . Como no puede usar onUpgrade() , debe administrar las versiones de la base de datos por sí mismo. Usar SharedPreferences es una buena manera de hacerlo. Comprueba si su base de datos existe (si ya está copiada del directorio de assets ) y verifica la versión si existe la base de datos. Ahora puede eliminar la base de datos antigua y copiar una nueva de los assets . Ver implementación a continuación.

Para marcar su aplicación actualizada, se publica con la nueva base de datos en assets solo en constante constante DATABASE_VERSION .

private static class DatabaseHelper extends SQLiteOpenHelper {

    private static final String DATABASE_NAME = "database.db";
    private static final int DATABASE_VERSION = 1;
    private static final String SP_KEY_DB_VER = "db_ver";
    private final Context mContext;

    public DatabaseHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
        mContext = context;
        initialize();
    }

    /**
     * Initializes database. Creates database if doesn''t exist.
     */
    private void initialize() {
        if (databaseExists()) {
            SharedPreferences prefs = PreferenceManager
                    .getDefaultSharedPreferences(mContext);
            int dbVersion = prefs.getInt(SP_KEY_DB_VER, 1);
            if (DATABASE_VERSION != dbVersion) {
                File dbFile = mContext.getDatabasePath(DATABASE_NAME);
                if (!dbFile.delete()) {
                    Log.w(TAG, "Unable to update database");
                }
            }
        }
        if (!databaseExists()) {
            createDatabase();
        }
    }

    /**
     * Returns true if database file exists, false otherwise.
     * @return
     */
    private boolean databaseExists() {
        File dbFile = mContext.getDatabasePath(DATABASE_NAME);
        return dbFile.exists();
    }

    /**
     * Creates database by copying it from assets directory.
     */
    private void createDatabase() {
        String parentPath = mContext.getDatabasePath(DATABASE_NAME).getParent();
        String path = mContext.getDatabasePath(DATABASE_NAME).getPath();

        File file = new File(parentPath);
        if (!file.exists()) {
            if (!file.mkdir()) {
                Log.w(TAG, "Unable to create database directory");
                return;
            }
        }

        InputStream is = null;
        OutputStream os = null;
        try {
            is = mContext.getAssets().open(DATABASE_NAME);
            os = new FileOutputStream(path);

            byte[] buffer = new byte[1024];
            int length;
            while ((length = is.read(buffer)) > 0) {
                os.write(buffer, 0, length);
            }
            os.flush();
            SharedPreferences prefs = PreferenceManager
                    .getDefaultSharedPreferences(mContext);
            SharedPreferences.Editor editor = prefs.edit();
            editor.putInt(SP_KEY_DB_VER, DATABASE_VERSION);
            editor.commit();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
    }

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

Answer 3

este esta funcionando bien, pruébalo

public class DatabaseHelper extends SQLiteOpenHelper {

private static final int DATABASE_VERSION = 3;
private static final String SP_KEY_DB_VER = "db_ver";
private static final String DATABASE_NAME = "db.db";
private static String DB_PATH = "/data/data/APP_PACKAGE/databases/";
    static SQLiteDatabase db;
    public Context context;

SessionManager session;

    public DatabaseHelper(Context context) {
            super(context, DATABASE_NAME, null, DATABASE_VERSION);
            this.context = context;
            session = SessionManager.getInstance(context);;
            //initialize();
        }

    public void createDataBase() throws IOException {
            if (!checkDataBase()) {
                getWritableDatabase();
                copyDataBase();
            }
        }

    public boolean checkDataBase() {
            /**/
            boolean found = new File(DB_PATH + DATABASE_NAME).exists();
            if(found)
            {
                int dbVersion = Integer.valueOf(session.getData(SP_KEY_DB_VER, "1"));
                if (DATABASE_VERSION != dbVersion) {
                    File dbFile = context.getDatabasePath(DATABASE_NAME);
                    if (!dbFile.delete()) {
                        Log.w("Warning: ", "Unable to update database");
                    }
                    found = false;
                }
            }
            return found;
        }

        public void copyDataBase() throws IOException {
            InputStream myInput = this.context.getAssets().open(DATABASE_NAME);
            OutputStream myOutput = new FileOutputStream(DB_PATH + DATABASE_NAME);
            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();
            session.saveData(SP_KEY_DB_VER, String.valueOf(DATABASE_VERSION));
            //int dbVersion = prefs.in(SP_KEY_DB_VER, 3);
        }

        public void openDataBase() throws SQLException {
            db = SQLiteDatabase.openDatabase(DB_PATH + DATABASE_NAME, null, 0);
        }
    }

MainActivity -> OnCreate

db = new DatabaseHelper(context);
try {
   db.createDataBase();
} catch (IOException ioe) {
   throw new Error("Unable to create database");
}

db.openDataBase();