android - studio - ¿Cómo utilizar la Biblioteca de persistencia de sala con una base de datos rellenada previamente?

room persistence library example

Question

Me gustaría usar Room con una base de datos rellenada previamente, pero no puedo entender cómo decirle a Room dónde encontrar mi base de datos.

Ahora lo puse en src/main/assets/databases y cuando creo la instancia para la base de datos de Room la creo de esta manera:

Room.databaseBuilder(
    getApplicationContext(),
    AppDatabase.class,
    "justintrain.db"
)
.allowMainThreadQueries()
.build();

De esta manera, creo que está creando una nueva base de datos cada vez, o de todos modos, no está utilizando la pre-poblada.

¿Cómo puedo encontrar mi base de datos?

Answer 1

Así es como lo resolví, y cómo puede enviar su aplicación con una base de datos previamente poblada (hasta Room v. Alpha5)

• ponga su SQLite DB database_name.db en la carpeta de assets/databases

• tome los archivos de este repositorio y sqlAsset en un paquete llamado ie sqlAsset

• en su clase AppDatabase , modifique el código de creación de DB de su sala en consecuencia:

  Room.databaseBuilder(context.getApplicationContext(), 
                       AppDatabase.class, 
                       "database_name.db")
  .openHelperFactory(new AssetSQLiteOpenHelperFactory())
  .allowMainThreadQueries()
  .build();

Tenga en cuenta que debe usar "database_name.db" y no getDatabasePath() u otros métodos: solo necesita el nombre del archivo.

Answer 2

Estaba teniendo el mismo problema, así que creé una biblioteca que hace exactamente eso. la respuesta aceptada funciona pero creo que es más fácil usar una biblioteca.

AppDatabase db = RoomAsset
    .databaseBuilder(context.getApplicationContext(), AppDatabase.class, "database_name.db")
    .build(); 

Agréguelo a su raíz build.gradle al final de los repositorios:

allprojects {
    repositories {
        ...
        maven { url "https://jitpack.io" }
    }
}

Agregar la dependencia

dependencies {
    // ... other dependencies
    implementation ''com.github.humazed:RoomAsset:v1.0''
}

Puede encontrar la biblioteca aquí: https://github.com/humazed/RoomAsset

Answer 3

Solución similar con espacio sin usar bibliotecas externas: 1. Copie su base de datos en la carpeta de activos 2. Copie su base de datos de la carpeta de activos

public class MainActivity extends AppCompatActivity {

public static AppDatabase db;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    copyDatabase(getApplicationContext(), "yourdatabase.db");

    db = Room.databaseBuilder(getApplicationContext(), .class, "yourdatabase.db").allowMainThreadQueries().build();
}

private void copyDatabase(Context context, String databaseName) {
    final File dbPath = context.getDatabasePath(databaseName);

    // If the database already exists, return
    if (dbPath.exists()) {
        Log.d("Activity", "db Path Exists");
        return;
    }

    // Make sure we have a path to the file
    dbPath.getParentFile().mkdirs();

    // Try to copy database file
    try {
        final InputStream inputStream = context.getAssets().open(databaseName);
        final OutputStream output = new FileOutputStream(dbPath);

        byte[] buffer = new byte[8192];
        int length;

        while ((length = inputStream.read(buffer, 0, 8192)) > 0) {
            output.write(buffer, 0, length);
        }

        output.flush();
        output.close();
        inputStream.close();
    }
    catch (IOException e) {
        Log.d("Activity", "Failed to open file", e);
        e.printStackTrace();
    }
}

}

Answer 4

simplemente copie assets/databases de assets/databases en app/databases
y luego agregar addMigrations() en databaseBuilder
mantendrá sus datos

Answer 5

Solución simple sin ninguna otra biblioteca externa.

Room se basa en el código de marco de Android existente para crear o abrir una base de datos. Si observa el código fuente de FrameworkSQLiteOpenHelper (versión de SQLiteOpenHelper de SQLiteOpenHelper ), internamente llama a SQLiteOpenHelper.getReadableDatabase() y a otros métodos donde sea necesario.

Entonces, la solución más simple es simplemente copiar el archivo DB del directorio de activos a mContext.getDatabasePath("my-database.sqlite") antes de crear el DB con Room.

En su caso, el código se ve así:

private final String DB_NAME = "my-database.sqlite";

private MyDatabase buildDatabase(Context context) {
    final File dbFile = context.getDatabasePath(DB_NAME);

    if(!dbFile.exists()) {
        copyDatabaseFile(dbFile.getAbsolutePath());
    }

    return Room.databaseBuilder(context.getApplicationContext(),
        MyDatabase.class, DB_NAME)
        .build();
}

private void copyDatabaseFile(String destinationPath) {
    // code to copy the file from assets/database directory to destinationPath
}

Este enlace tiene el código necesario para copiar el DB - enlace con código