Come inserire il database esistente nel file .apk?

Question

Ho un database di pre-costruzione per lo più di oggetti stringa. Voglio sapere come inserire il mio file apk in modo che il database sarà già creato quando l'utente installa il database.

Answer 1

ho trovato un buon esempio di questo: Using your own SQLite database in Android applications

In sostanza, si esporta il database creato come un file sql e conservarla nello asset-cartella. All'avvio del primo programma, si importano i dati del file nel database finale.

Penso che sia l'approccio migliore, tuttavia i tuoi dati saranno presenti due volte nell'apk e nel db, utilizzando un po 'più spazio di archiviazione.

Answer 2

Ho appena iniziato a sviluppare per Android, e sono stato sorpreso di scoprire che il raggruppamento di un database statico è non facile da fare. Così ho fatto l'unica cosa ragionevole: ho creato una biblioteca che fa proprio questo. Esempio di utilizzo:

import android.database.sqlite.SQLiteDatabase; 
import kiwidrew.staticdb.StaticDatabase; 

public class BlahBlah extends Activity { 
    public void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.main); 
    SQLiteDatabase db = StaticDatabase.openDatabase(this, "assets/foobar.db"); 
    // Do normal database stuff with 'db'... 
    } 
} 

Si ottiene di nuovo un oggetto SQLiteDatabase standard, con l'unica restrizione è che non supporta la scrittura. (Ovviamente!)

Si noti che questo avrà esito negativo a meno che il database non sia memorizzato in .apk senza compressione. Aggiungere il database SQLite con il comando aapt -0 o modificare il tuo build.xml per passare il flag <nocompress extension="db" /> al tag <aapt> ...

ottenere il codice a http://bitbucket.org/kiwidrew/android-staticdb.

Nota: ho appena finito di scriverlo e ho effettuato solo test di base finora. Segnalazioni di bug sarebbero apprezzate!

Answer 3

Non esiste un modo semplice per leggere direttamente il database dalle risorse. Dovresti copiare il tuo database dalle risorse alla cartella dati nella prima esecuzione, quindi quando ogni volta che la tua app si avvia, dovresti controllare il database nella cartella dei dati e copiarlo di nuovo se il database non esiste.

Questi passaggi aiutano:

1) eseguire questi comandi sul database, se android_metadata tabella non esiste nel database, Android non poteva aprire il database .:

CREATE TABLE android_metadata(locale TEXT DEFAULT 'en_US') 
INSERT INTO android_metadata VALUES('en_US') 

2) Chunk il tuo database perché Android non supporta la lettura di un file con dimensione superiore a 1 MB dalle risorse.

codice

Questo pitone pezzetti il ​​database:

def chunk_file(file_name): 
    input_file = open(file_name, "rb") 

    chunk_counter = 0; 
    while True: 
     chunk = input_file.read(512 * 1024) # 512 KB 
     if chunk: 
      output_file_name = file_name + "." + str(chunk_counter).zfill(4) 

      output_file = open(output_file_name, "wb") 
      output_file.write(chunk) 
      output_file.close() 

      chunk_counter += 1 
     else: 
      break 

    input_file.close() 
    return 

# Input: database.db 
# Output: database.db.0000, database.db.0001, database.db.0002, ... 
chunk_file("database.db") 

Poi messo database.db.0000, database.db.0001, database.db.0002, ... nella cartella asset.

3) Controllare il database esistente nella cartella dati all'avvio dell'app.

public static boolean databaseExists() { 

    boolean result = false; 

    SQLiteDatabase checkDB = null; 

    try { 
     checkDB = SQLiteDatabase.openDatabase(
       getApplicationContext().getFilesDir().getPath() + "/database.db", 
       null, SQLiteDatabase.OPEN_READONLY); 
     result = true; 
    } catch (SQLiteException exception) { 
     result = false; 
    } 

    if (checkDB != null) { 

     checkDB.close(); 

    } 

    return result; 
} 

4) Se il database non esiste nella cartella di dati, copiare il database dalle risorse alla cartella di dati.

public static void copyDatabase() throws IOException { 
    AssetManager assets = getApplicationContext().getAssets(); 

    // database.db.0000, database.db.0001, database.db.0002, ... --> databaseChunks. 
    String[] databaseChunks = assets.list(""); 
    Arrays.sort(databaseChunks); 

    OutputStream databaseStream = new FileOutputStream(
      getApplicationContext().getFilesDir().getPath() + "/database.db"); 

    for (int i = 0; i < databaseChunks.length; i++) { 
     String databaseChunkName = databaseChunks[i]; 

     InputStream chunkStream = assets.open(databaseChunkName); 

     int length; 
     byte[] buffer = new byte[1024]; 
     while ((length = chunkStream.read(buffer)) > 0) { 
      databaseStream.write(buffer, 0, length); 
     } 

     chunkStream.close(); 
    } 

    databaseStream.close(); 

    return; 
} 

5) È possibile connettersi al database ora:

SQLiteDatabase database = SQLiteDatabase.openDatabase(
      getApplicationContext().getFilesDir().getPath() + "/database.db", 
      null, SQLiteDatabase.OPEN_READONLY); 
// ... 
database.close();