Envoyer une application avec une base de données

Question

Si votre application nécessite une base de données et qu'elle intègre des données, quel est le meilleur moyen de l'expédier? Devrais-je:

1. Précréez la base de données SQLite et incluez-la dans le .apk?

2. Inclure les commandes SQL avec l'application et lui demander de créer la base de données et d'insérer les données lors de la première utilisation?

Les inconvénients que je vois sont:

1. Des incompatibilités de version SQLite possibles pourraient causer des problèmes et je ne sais pas pour l'instant où la base de données doit aller et comment y accéder.

2. La création et le remplissage de la base de données sur le périphérique peuvent prendre beaucoup de temps.

Aucune suggestion? Des indications sur la documentation concernant tout problème seraient grandement appréciées.

Answer 1

Je viens de trouver un moyen de faire cela dans ReignDesign blog dans un article intitulé tilisation de votre propre base de données SQLite dans Android applications . En gros, vous créez une base de données, la placez dans votre répertoire assets dans votre apk, et lors de la première utilisation, copiez-la dans le répertoire _/data/data/YOUR_PACKAGE/databases/_.

Answer 2

Il existe deux options pour créer et mettre à jour des bases de données.

L’une consiste à créer une base de données en externe, puis à la placer dans le dossier des actifs du projet, puis à copier la base de données complète à partir de là. C'est beaucoup plus rapide si la base de données contient beaucoup de tables et d'autres composants. Les mises à niveau sont déclenchées en modifiant le numéro de version de la base de données dans le fichier res/values ​​/ strings.xml. Les mises à niveau seraient alors effectuées. en créant une nouvelle base de données en externe, en remplaçant l’ancienne base de données du dossier d’actifs par la nouvelle base de données, en sauvegardant l’ancienne base de données dans le stockage interne sous un autre nom, en copiant la nouvelle base de données du dossier d’actifs dans le stockage interne, en transférant toutes les données du fichier. ancienne base de données (précédemment renommée) dans la nouvelle base de données et enfin suppression de l’ancienne base de données. Vous pouvez créer une base de données à l’origine en utilisant le plug-in SQLite Manager FireFox pour exécuter vos instructions SQL de création.

L'autre option consiste à créer une base de données en interne à partir d'un fichier SQL. Ce n'est pas aussi rapide, mais le retard ne serait probablement pas perceptible par les utilisateurs si la base de données ne contient que quelques tables. Les mises à niveau sont déclenchées en modifiant le numéro de version de la base de données dans le fichier res/values ​​/ strings.xml. Les mises à niveau seraient alors effectuées. en traitant un fichier SQL de mise à niveau. Les données de la base de données resteront inchangées sauf lorsque son conteneur sera supprimé, par exemple en supprimant une table.

L'exemple ci-dessous montre comment utiliser l'une ou l'autre méthode.

Voici un exemple de fichier create_database.sql. Il doit être placé dans le dossier des actifs du projet pour la méthode interne ou copié dans le "Exécuter SQL" de SQLite Manager pour créer la base de données pour la méthode externe. ( NOTE: Notez le commentaire sur la table requise par Android.)

--Android requires a table named 'Android_metadata' with a 'locale' column
CREATE TABLE "Android_metadata" ("locale" TEXT DEFAULT 'en_US');
INSERT INTO "Android_metadata" VALUES ('en_US');

CREATE TABLE "kitchen_table";
CREATE TABLE "coffee_table";
CREATE TABLE "pool_table";
CREATE TABLE "dining_room_table";
CREATE TABLE "card_table"; 

Voici un exemple de fichier update_database.sql. Il doit être placé dans le dossier des actifs du projet pour la méthode interne ou copié dans le "Exécuter SQL" de SQLite Manager pour créer la base de données pour la méthode externe. ( REMARQUE: notez que les trois types de commentaires SQL seront ignorés par l'analyseur SQL inclus dans cet exemple.)

--CREATE TABLE "kitchen_table";  This is one type of comment in sql.  It is ignored by parseSql.
/*
 * CREATE TABLE "coffee_table"; This is a second type of comment in sql.  It is ignored by parseSql.
 */
{
CREATE TABLE "pool_table";  This is a third type of comment in sql.  It is ignored by parseSql.
}
/* CREATE TABLE "dining_room_table"; This is a second type of comment in sql.  It is ignored by parseSql. */
{ CREATE TABLE "card_table"; This is a third type of comment in sql.  It is ignored by parseSql. }

--DROP TABLE "picnic_table"; Uncomment this if picnic table was previously created and now is being replaced.
CREATE TABLE "picnic_table" ("plates" TEXT);
INSERT INTO "picnic_table" VALUES ('paper');

Voici une entrée à ajouter au fichier /res/values/strings.xml pour le numéro de version de la base de données.

<item type="string" name="databaseVersion" format="integer">1</item>

Voici une activité qui accède à la base de données et l’utilise ensuite. ( Remarque: vous souhaiterez peut-être exécuter le code de la base de données dans un thread distinct s'il utilise beaucoup de ressources. )

package Android.example;

import Android.app.Activity;
import Android.database.sqlite.SQLiteDatabase;
import Android.os.Bundle;

/**
 * @author Danny Remington - MacroSolve
 * 
 *         Activity for demonstrating how to use a sqlite database.
 */
public class Database extends Activity {
     /** Called when the activity is first created. */
     @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        DatabaseHelper myDbHelper;
        SQLiteDatabase myDb = null;

        myDbHelper = new DatabaseHelper(this);
        /*
         * Database must be initialized before it can be used. This will ensure
         * that the database exists and is the current version.
         */
         myDbHelper.initializeDataBase();

         try {
            // A reference to the database can be obtained after initialization.
            myDb = myDbHelper.getWritableDatabase();
            /*
             * Place code to use database here.
             */
         } catch (Exception ex) {
            ex.printStackTrace();
         } finally {
            try {
                myDbHelper.close();
            } catch (Exception ex) {
                ex.printStackTrace();
            } finally {
                myDb.close();
            }
        }

    }
}

Voici la classe d'assistance de base de données dans laquelle la base de données est créée ou mise à jour si nécessaire. (REMARQUE: Android nécessite la création d'une classe qui étend SQLiteOpenHelper pour pouvoir fonctionner avec une base de données Sqlite.)

package Android.example;

import Java.io.FileOutputStream;
import Java.io.IOException;
import Java.io.InputStream;
import Java.io.OutputStream;

import Android.content.Context;
import Android.database.sqlite.SQLiteDatabase;
import Android.database.sqlite.SQLiteOpenHelper;

/**
 * @author Danny Remington - MacroSolve
 * 
 *         Helper class for sqlite database.
 */
public class DatabaseHelper extends SQLiteOpenHelper {

    /*
     * The Android's default system path of the application database in internal
     * storage. The package of the application is part of the path of the
     * directory.
     */
    private static String DB_DIR = "/data/data/Android.example/databases/";
    private static String DB_NAME = "database.sqlite";
    private static String DB_PATH = DB_DIR + DB_NAME;
    private static String OLD_DB_PATH = DB_DIR + "old_" + DB_NAME;

    private final Context myContext;

    private boolean createDatabase = false;
    private boolean upgradeDatabase = false;

    /**
     * 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, context.getResources().getInteger(
                R.string.databaseVersion));
        myContext = context;
        // Get the path of the database that is based on the context.
        DB_PATH = myContext.getDatabasePath(DB_NAME).getAbsolutePath();
    }

    /**
     * Upgrade the database in internal storage if it exists but is not current. 
     * Create a new empty database in internal storage if it does not exist.
     */
    public void initializeDataBase() {
        /*
         * Creates or updates the database in internal storage if it is needed
         * before opening the database. In all cases opening the database copies
         * the database in internal storage to the cache.
         */
        getWritableDatabase();

        if (createDatabase) {
            /*
             * If the database is created by the copy method, then the creation
             * code needs to go here. This method consists of copying the new
             * database from assets into internal storage and then caching it.
             */
            try {
                /*
                 * Write over the empty data that was created in internal
                 * storage with the one in assets and then cache it.
                 */
                copyDataBase();
            } catch (IOException e) {
                throw new Error("Error copying database");
            }
        } else if (upgradeDatabase) {
            /*
             * If the database is upgraded by the copy and reload method, then
             * the upgrade code needs to go here. This method consists of
             * renaming the old database in internal storage, create an empty
             * new database in internal storage, copying the database from
             * assets to the new database in internal storage, caching the new
             * database from internal storage, loading the data from the old
             * database into the new database in the cache and then deleting the
             * old database from internal storage.
             */
            try {
                FileHelper.copyFile(DB_PATH, OLD_DB_PATH);
                copyDataBase();
                SQLiteDatabase old_db = SQLiteDatabase.openDatabase(OLD_DB_PATH, null, SQLiteDatabase.OPEN_READWRITE);
                SQLiteDatabase new_db = SQLiteDatabase.openDatabase(DB_PATH,null, SQLiteDatabase.OPEN_READWRITE);
                /*
                 * Add code to load data into the new database from the old
                 * database and then delete the old database from internal
                 * storage after all data has been transferred.
                 */
            } catch (IOException e) {
                throw new Error("Error copying database");
            }
        }

    }

    /**
     * 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 {
        /*
         * Close SQLiteOpenHelper so it will commit the created empty database
         * to internal storage.
         */
        close();

        /*
         * Open the database in the assets folder as the input stream.
         */
        InputStream myInput = myContext.getAssets().open(DB_NAME);

        /*
         * Open the empty db in interal storage as the output stream.
         */
        OutputStream myOutput = new FileOutputStream(DB_PATH);

        /*
         * Copy over the empty db in internal storage with the database in the
         * assets folder.
         */
        FileHelper.copyFile(myInput, myOutput);

        /*
         * Access the copied database so SQLiteHelper will cache it and mark it
         * as created.
         */
        getWritableDatabase().close();
    }

    /*
     * This is where the creation of tables and the initial population of the
     * tables should happen, if a database is being created from scratch instead
     * of being copied from the application package assets. Copying a database
     * from the application package assets to internal storage inside this
     * method will result in a corrupted database.
     * <P>
     * NOTE: This method is normally only called when a database has not already
     * been created. When the database has been copied, then this method is
     * called the first time a reference to the database is retrieved after the
     * database is copied since the database last cached by SQLiteOpenHelper is
     * different than the database in internal storage.
     */
    @Override
    public void onCreate(SQLiteDatabase db) {
        /*
         * Signal that a new database needs to be copied. The copy process must
         * be performed after the database in the cache has been closed causing
         * it to be committed to internal storage. Otherwise the database in
         * internal storage will not have the same creation timestamp as the one
         * in the cache causing the database in internal storage to be marked as
         * corrupted.
         */
        createDatabase = true;

        /*
         * This will create by reading a sql file and executing the commands in
         * it.
         */
            // try {
            // InputStream is = myContext.getResources().getAssets().open(
            // "create_database.sql");
            //
            // String[] statements = FileHelper.parseSqlFile(is);
            //
            // for (String statement : statements) {
            // db.execSQL(statement);
            // }
            // } catch (Exception ex) {
            // ex.printStackTrace();
            // }
    }

    /**
     * Called only if version number was changed and the database has already
     * been created. Copying a database from the application package assets to
     * the internal data system inside this method will result in a corrupted
     * database in the internal data system.
     */
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        /*
         * Signal that the database needs to be upgraded for the copy method of
         * creation. The copy process must be performed after the database has
         * been opened or the database will be corrupted.
         */
        upgradeDatabase = true;

        /*
         * Code to update the database via execution of sql statements goes
         * here.
         */

        /*
         * This will upgrade by reading a sql file and executing the commands in
         * it.
         */
        // try {
        // InputStream is = myContext.getResources().getAssets().open(
        // "upgrade_database.sql");
        //
        // String[] statements = FileHelper.parseSqlFile(is);
        //
        // for (String statement : statements) {
        // db.execSQL(statement);
        // }
        // } catch (Exception ex) {
        // ex.printStackTrace();
        // }
    }

    /**
     * Called everytime the database is opened by getReadableDatabase or
     * getWritableDatabase. This is called after onCreate or onUpgrade is
     * called.
     */
    @Override
    public void onOpen(SQLiteDatabase db) {
        super.onOpen(db);
    }

    /*
     * Add your public helper methods to access and get content from the
     * database. You could return cursors by doing
     * "return myDataBase.query(....)" so it'd be easy to you to create adapters
     * for your views.
     */

}

Voici la classe FileHelper qui contient des méthodes de copie de flux d'octets et d'analyse de fichiers SQL.

package Android.example;

import Java.io.BufferedReader;
import Java.io.File;
import Java.io.FileInputStream;
import Java.io.FileOutputStream;
import Java.io.FileReader;
import Java.io.IOException;
import Java.io.InputStream;
import Java.io.InputStreamReader;
import Java.io.OutputStream;
import Java.io.Reader;
import Java.nio.channels.FileChannel;

/**
 * @author Danny Remington - MacroSolve
 * 
 *         Helper class for common tasks using files.
 * 
 */
public class FileHelper {
    /**
     * Creates the specified <i><b>toFile</b></i> that is a byte for byte a copy
     * of <i><b>fromFile</b></i>. If <i><b>toFile</b></i> already existed, then
     * it will be replaced with a copy of <i><b>fromFile</b></i>. The name and
     * path of <i><b>toFile</b></i> will be that of <i><b>toFile</b></i>. Both
     * <i><b>fromFile</b></i> and <i><b>toFile</b></i> will be closed by this
     * operation.
     * 
     * @param fromFile
     *            - InputStream for the file to copy from.
     * @param toFile
     *            - InputStream for the file to copy to.
     */
    public static void copyFile(InputStream fromFile, OutputStream toFile) throws IOException {
        // transfer bytes from the inputfile to the outputfile
        byte[] buffer = new byte[1024];
        int length;

        try {
            while ((length = fromFile.read(buffer)) > 0) {
                toFile.write(buffer, 0, length);
            }
        }
        // Close the streams
        finally {
            try {
                if (toFile != null) {
                    try {
                        toFile.flush();
                    } finally {
                        toFile.close();
                    }
            }
            } finally {
                if (fromFile != null) {
                    fromFile.close();
                }
            }
        }
    }

    /**
     * Creates the specified <i><b>toFile</b></i> that is a byte for byte a copy
     * of <i><b>fromFile</b></i>. If <i><b>toFile</b></i> already existed, then
     * it will be replaced with a copy of <i><b>fromFile</b></i>. The name and
     * path of <i><b>toFile</b></i> will be that of <i><b>toFile</b></i>. Both
     * <i><b>fromFile</b></i> and <i><b>toFile</b></i> will be closed by this
     * operation.
     * 
     * @param fromFile
     *            - String specifying the path of the file to copy from.
     * @param toFile
     *            - String specifying the path of the file to copy to.
     */
    public static void copyFile(String fromFile, String toFile) throws IOException {
        copyFile(new FileInputStream(fromFile), new FileOutputStream(toFile));
    }

    /**
     * Creates the specified <i><b>toFile</b></i> that is a byte for byte a copy
     * of <i><b>fromFile</b></i>. If <i><b>toFile</b></i> already existed, then
     * it will be replaced with a copy of <i><b>fromFile</b></i>. The name and
     * path of <i><b>toFile</b></i> will be that of <i><b>toFile</b></i>. Both
     * <i><b>fromFile</b></i> and <i><b>toFile</b></i> will be closed by this
     * operation.
     * 
     * @param fromFile
     *            - File for the file to copy from.
     * @param toFile
     *            - File for the file to copy to.
     */
    public static void copyFile(File fromFile, File toFile) throws IOException {
        copyFile(new FileInputStream(fromFile), new FileOutputStream(toFile));
    }

    /**
     * Creates the specified <i><b>toFile</b></i> that is a byte for byte a copy
     * of <i><b>fromFile</b></i>. If <i><b>toFile</b></i> already existed, then
     * it will be replaced with a copy of <i><b>fromFile</b></i>. The name and
     * path of <i><b>toFile</b></i> will be that of <i><b>toFile</b></i>. Both
     * <i><b>fromFile</b></i> and <i><b>toFile</b></i> will be closed by this
     * operation.
     * 
     * @param fromFile
     *            - FileInputStream for the file to copy from.
     * @param toFile
     *            - FileInputStream for the file to copy to.
     */
    public static void copyFile(FileInputStream fromFile, FileOutputStream toFile) throws IOException {
        FileChannel fromChannel = fromFile.getChannel();
        FileChannel toChannel = toFile.getChannel();

        try {
            fromChannel.transferTo(0, fromChannel.size(), toChannel);
        } finally {
            try {
                if (fromChannel != null) {
                    fromChannel.close();
                }
            } finally {
                if (toChannel != null) {
                    toChannel.close();
                }
            }
        }
    }

    /**
     * Parses a file containing sql statements into a String array that contains
     * only the sql statements. Comments and white spaces in the file are not
     * parsed into the String array. Note the file must not contained malformed
     * comments and all sql statements must end with a semi-colon ";" in order
     * for the file to be parsed correctly. The sql statements in the String
     * array will not end with a semi-colon ";".
     * 
     * @param sqlFile
     *            - String containing the path for the file that contains sql
     *            statements.
     * 
     * @return String array containing the sql statements.
     */
    public static String[] parseSqlFile(String sqlFile) throws IOException {
        return parseSqlFile(new BufferedReader(new FileReader(sqlFile)));
    }

    /**
     * Parses a file containing sql statements into a String array that contains
     * only the sql statements. Comments and white spaces in the file are not
     * parsed into the String array. Note the file must not contained malformed
     * comments and all sql statements must end with a semi-colon ";" in order
     * for the file to be parsed correctly. The sql statements in the String
     * array will not end with a semi-colon ";".
     * 
     * @param sqlFile
     *            - InputStream for the file that contains sql statements.
     * 
     * @return String array containing the sql statements.
     */
    public static String[] parseSqlFile(InputStream sqlFile) throws IOException {
        return parseSqlFile(new BufferedReader(new InputStreamReader(sqlFile)));
    }

    /**
     * Parses a file containing sql statements into a String array that contains
     * only the sql statements. Comments and white spaces in the file are not
     * parsed into the String array. Note the file must not contained malformed
     * comments and all sql statements must end with a semi-colon ";" in order
     * for the file to be parsed correctly. The sql statements in the String
     * array will not end with a semi-colon ";".
     * 
     * @param sqlFile
     *            - Reader for the file that contains sql statements.
     * 
     * @return String array containing the sql statements.
     */
    public static String[] parseSqlFile(Reader sqlFile) throws IOException {
        return parseSqlFile(new BufferedReader(sqlFile));
    }

    /**
     * Parses a file containing sql statements into a String array that contains
     * only the sql statements. Comments and white spaces in the file are not
     * parsed into the String array. Note the file must not contained malformed
     * comments and all sql statements must end with a semi-colon ";" in order
     * for the file to be parsed correctly. The sql statements in the String
     * array will not end with a semi-colon ";".
     * 
     * @param sqlFile
     *            - BufferedReader for the file that contains sql statements.
     * 
     * @return String array containing the sql statements.
     */
    public static String[] parseSqlFile(BufferedReader sqlFile) throws IOException {
        String line;
        StringBuilder sql = new StringBuilder();
        String multiLineComment = null;

        while ((line = sqlFile.readLine()) != null) {
            line = line.trim();

            // Check for start of multi-line comment
            if (multiLineComment == null) {
                // Check for first multi-line comment type
                if (line.startsWith("/*")) {
                    if (!line.endsWith("}")) {
                        multiLineComment = "/*";
                    }
                // Check for second multi-line comment type
                } else if (line.startsWith("{")) {
                    if (!line.endsWith("}")) {
                        multiLineComment = "{";
                }
                // Append line if line is not empty or a single line comment
                } else if (!line.startsWith("--") && !line.equals("")) {
                    sql.append(line);
                } // Check for matching end comment
            } else if (multiLineComment.equals("/*")) {
                if (line.endsWith("*/")) {
                    multiLineComment = null;
                }
            // Check for matching end comment
            } else if (multiLineComment.equals("{")) {
                if (line.endsWith("}")) {
                    multiLineComment = null;
                }
            }

        }

        sqlFile.close();

        return sql.toString().split(";");
    }

}

Answer 3

La bibliothèque SQLiteAssetHelper rend cette tâche très simple.

Il est facile d’ajouter une dépendance de niveau (mais un fichier Jar est également disponible pour Ant/Eclipse). Vous pouvez le trouver avec la documentation à l’adresse suivante:
https://github.com/jgilfelt/Android-sqlite-asset-helper

Remarque: Ce projet n'est plus mis à jour comme indiqué sur le lien Github ci-dessus.

Comme expliqué dans la documentation:

1. Ajoutez la dépendance au fichier de construction de gradle de votre module:

   dependencies {
       compile 'com.readystatesoftware.sqliteasset:sqliteassethelper:+'
   }
   

2. Copiez la base de données dans le répertoire des actifs, dans un sous-répertoire appelé assets/databases. Par exemple:
   assets/databases/my_database.db

   (Vous pouvez éventuellement compresser la base de données dans un fichier Zip tel que assets/databases/my_database.Zip. Ce n'est pas nécessaire, car l'APK est déjà compressé dans son ensemble.)

3. Créez une classe, par exemple:

   public class MyDatabase extends SQLiteAssetHelper {
   
       private static final String DATABASE_NAME = "my_database.db";
       private static final int DATABASE_VERSION = 1;
   
       public MyDatabase(Context context) {
           super(context, DATABASE_NAME, null, DATABASE_VERSION);
       }
   }
   

Answer 4

Je suppose que la meilleure et la plus récente des méthodes utilisées jusqu’à présent utilise la classe SQLiteAssetHelper.

Ce tutoriel vous guide parfaitement à travers Importation et utilisation d'une base de données externe sous Android

La bibliothèque Android SQLiteAssetHelper vous permet de créer votre base de données SQLite sur votre ordinateur de bureau, de l'importer et de l'utiliser dans votre application Android. Créons une application simple pour démontrer l'application de cette bibliothèque.

Étape 1 : Créez une base de données quotes.db en utilisant votre application de base de données SQLite préférée (DB Browser for SQLite est un logiciel gratuit multiplateforme portable, qui peut être utilisé pour: créer et éditer des bases de données SQLite). Créez une table "guillemets" avec une colonne unique "guillemet". Insérez des citations aléatoires dans la table 'citations'.

Étape 2 : la base de données peut être importée dans le projet directement ou en tant que fichier compressé. Le fichier compressé est recommandé si votre base de données est trop volumineuse. Vous pouvez créer une compression Zip ou une compression GZ.

Le nom du fichier db compressé doit être quotes.db.Zip, si vous utilisez la compression Zip ou quotes.db.gz, si vous utilisez la compression GZ.

Étape 3 : créez une nouvelle application External Database Demo avec un nom de package com.javahelps.com.javahelps.externaldatabasedemo.

Étape 4 : Ouvrez le fichier build.gradle (Module: app) et ajoutez la dépendance suivante.

dependencies {
    compile 'com.readystatesoftware.sqliteasset:sqliteassethelper:+'
}

Une fois que vous avez enregistré le fichier build.gradle, cliquez sur le lien "Synchroniser maintenant" pour mettre à jour le projet. Vous pouvez synchroniser le build.gradle en cliquant avec le bouton droit de la souris sur le fichier build.gradle et en sélectionnant également l’option Synchronize build.gradle.

Étape 5 : Faites un clic droit sur le dossier de l'application et créez un nouveau dossier d'éléments.

Étape 6 : créez un nouveau dossier 'bases de données' dans le dossier des actifs.

Étape 7 : Copiez et collez le fichier quotes.db.Zip dans le dossier assets/databases.

Étape 8 : créez une nouvelle classe DatabaseOpenHelper

package com.javahelps.externaldatabasedemo;

import Android.content.Context;

import com.readystatesoftware.sqliteasset.SQLiteAssetHelper;

public class DatabaseOpenHelper extends SQLiteAssetHelper {
    private static final String DATABASE_NAME = "quotes.db";
    private static final int DATABASE_VERSION = 1;

    public DatabaseOpenHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }
}  Notice that rather than extending SQLiteOpenHelper, the DatabaseOpenHelper extends  SQLiteAssetHelper class.

Étape 9 : créez une nouvelle classe DatabaseAccess et entrez le code comme indiqué ci-dessous. Plus de détails sur cette classe sont disponibles dans Avancé Android Didacticiel de base de données.

package com.javahelps.externaldatabasedemo;

import Android.content.Context;
import Android.database.Cursor;
import Android.database.sqlite.SQLiteDatabase;
import Android.database.sqlite.SQLiteOpenHelper;

import Java.util.ArrayList;
import Java.util.List;

public class DatabaseAccess {
    private SQLiteOpenHelper openHelper;
    private SQLiteDatabase database;
    private static DatabaseAccess instance;

    /**
     * Private constructor to aboid object creation from outside classes.
     *
     * @param context
     */
    private DatabaseAccess(Context context) {
        this.openHelper = new DatabaseOpenHelper(context);
    }

    /**
     * Return a singleton instance of DatabaseAccess.
     *
     * @param context the Context
     * @return the instance of DabaseAccess
     */
    public static DatabaseAccess getInstance(Context context) {
        if (instance == null) {
            instance = new DatabaseAccess(context);
        }
        return instance;
    }

    /**
     * Open the database connection.
     */
    public void open() {
        this.database = openHelper.getWritableDatabase();
    }

    /**
     * Close the database connection.
     */
    public void close() {
        if (database != null) {
            this.database.close();
        }
    }

    /**
     * Read all quotes from the database.
     *
     * @return a List of quotes
     */
    public List<String> getQuotes() {
        List<String> list = new ArrayList<>();
        Cursor cursor = database.rawQuery("SELECT * FROM quotes", null);
        cursor.moveToFirst();
        while (!cursor.isAfterLast()) {
            list.add(cursor.getString(0));
            cursor.moveToNext();
        }
        cursor.close();
        return list;
    }
}  In this class only the `getQuotes` method is implemented to read the data from the database. You have the full freedom to insert,

mettre à jour et supprimer toutes les lignes de la base de données comme d'habitude. Pour plus de détails, suivez ce lien Avancé Android Base de données.

Toutes les configurations liées à la base de données sont terminées et nous devons maintenant créer un ListView pour afficher les guillemets.

Étape 10 : Ajoutez une ListView dans votre activity_main.xml.

<FrameLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
    xmlns:tools="http://schemas.Android.com/tools"
    Android:layout_width="match_parent"
    Android:layout_height="match_parent"
    Android:paddingBottom="@dimen/activity_vertical_margin"
    Android:paddingLeft="@dimen/activity_horizontal_margin"
    Android:paddingRight="@dimen/activity_horizontal_margin"
    Android:paddingTop="@dimen/activity_vertical_margin"
    tools:context=".MainActivity">

    <ListView
        Android:id="@+id/listView"
        Android:layout_width="match_parent"
        Android:layout_height="match_parent"
        Android:layout_gravity="center" />
</FrameLayout>  

Etape 11 : Recherchez l’objet de ListView dans la méthode onCreate de MainActivity et alimentez les guillemets qui sont lire à partir de la base de données.

package com.javahelps.externaldatabasedemo;

import Android.os.Bundle;
import Android.support.v7.app.ActionBarActivity;
import Android.widget.ArrayAdapter;
import Android.widget.ListView;

import Java.util.List;


public class MainActivity extends ActionBarActivity {
    private ListView listView;

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

        this.listView = (ListView) findViewById(R.id.listView);
        DatabaseAccess databaseAccess = DatabaseAccess.getInstance(this);
        databaseAccess.open();
        List<String> quotes = databaseAccess.getQuotes();
        databaseAccess.close();

        ArrayAdapter<String> adapter = new ArrayAdapter<String>(this, Android.R.layout.simple_list_item_1,
quotes);
        this.listView.setAdapter(adapter);
    }
}

Étape 12 : enregistrez toutes les modifications et exécutez l'application.

En plus de cet article, vous pouvez télécharger SQLiteAssetHelperhere

Answer 5

Ma solution n'utilise aucune bibliothèque tierce ni ne vous oblige à appeler des méthodes personnalisées sur la sous-classe SQLiteOpenHelper pour initialiser la base de données à la création. Il prend également en charge les mises à niveau de la base de données. Tout ce qui reste à faire est de sous-classe SQLiteOpenHelper.

Prérequis:

1. La base de données que vous souhaitez expédier avec l'application. Il devrait contenir une table 1x1 nommée Android_metadata avec un attribut locale ayant la valeur en_US en plus des tables propres à votre application.

Sous-classement SQLiteOpenHelper:

1. Sous-classe SQLiteOpenHelper.
2. Créez une méthode private dans la sous-classe SQLiteOpenHelper. Cette méthode contient la logique permettant de copier le contenu de la base de données à partir du fichier de la base de données dans le dossier 'assets' vers la base de données créée dans le contexte du package d'application.
3. Substitution onCreate, onUpgradeetonOpen méthodes de SQLiteOpenHelper.

Assez dit. Voici la sous-classe SQLiteOpenHelper:

public class PlanDetailsSQLiteOpenHelper extends SQLiteOpenHelper {
    private static final String TAG = "SQLiteOpenHelper";

    private final Context context;
    private static final int DATABASE_VERSION = 1;
    private static final String DATABASE_NAME = "my_custom_db";

    private boolean createDb = false, upgradeDb = false;

    public PlanDetailsSQLiteOpenHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
        this.context = context;
    }

    /**
     * Copy packaged database from assets folder to the database created in the
     * application package context.
     * 
     * @param db
     *            The target database in the application package context.
     */
    private void copyDatabaseFromAssets(SQLiteDatabase db) {
        Log.i(TAG, "copyDatabase");
        InputStream myInput = null;
        OutputStream myOutput = null;
        try {
            // Open db packaged as asset as the input stream
            myInput = context.getAssets().open("path/to/shipped/db/file");

            // Open the db in the application package context:
            myOutput = new FileOutputStream(db.getPath());

            // Transfer db file contents:
            byte[] buffer = new byte[1024];
            int length;
            while ((length = myInput.read(buffer)) > 0) {
                myOutput.write(buffer, 0, length);
            }
            myOutput.flush();

            // Set the version of the copied database to the current
            // version:
            SQLiteDatabase copiedDb = context.openOrCreateDatabase(
                DATABASE_NAME, 0, null);
            copiedDb.execSQL("PRAGMA user_version = " + DATABASE_VERSION);
            copiedDb.close();

        } catch (IOException e) {
            e.printStackTrace();
            throw new Error(TAG + " Error copying database");
        } finally {
            // Close the streams
            try {
                if (myOutput != null) {
                    myOutput.close();
                }
                if (myInput != null) {
                    myInput.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
                throw new Error(TAG + " Error closing streams");
            }
        }
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        Log.i(TAG, "onCreate db");
        createDb = true;
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        Log.i(TAG, "onUpgrade db");
        upgradeDb = true;
    }

    @Override
    public void onOpen(SQLiteDatabase db) {
        Log.i(TAG, "onOpen db");
        if (createDb) {// The db in the application package
            // context is being created.
            // So copy the contents from the db
            // file packaged in the assets
            // folder:
            createDb = false;
            copyDatabaseFromAssets(db);

        }
        if (upgradeDb) {// The db in the application package
            // context is being upgraded from a lower to a higher version.
            upgradeDb = false;
            // Your db upgrade logic here:
        }
    }
}

Enfin, pour obtenir une connexion à la base de données, appelez simplement getReadableDatabase() ou getWritableDatabase() dans la sous-classe SQLiteOpenHelper. Il se chargera de créer une base de données, en copiant le contenu de la base de données à partir du fichier spécifié dans les actifs. 'dossier, si la base de données n'existe pas.

En résumé, vous pouvez utiliser la sous-classe SQLiteOpenHelper pour accéder à la base de données fournie dans le dossier des ressources, comme vous le feriez pour une base de données initialisée à l'aide de requêtes SQL dans la méthode onCreate().

Answer 6

Envoi de l'application avec un fichier de base de données, dans Android Studio 3.0

Envoyer l'application avec un fichier de base de données est une bonne idée pour moi. L'avantage est que vous n'avez pas besoin de faire une initialisation complexe, ce qui prend parfois beaucoup de temps, si votre jeu de données est énorme.

Étape 1: Préparez le fichier de base de données

Ayez votre fichier de base de données prêt. Il peut s'agir d'un fichier .db ou d'un fichier .sqlite. Si vous utilisez un fichier .sqlite, il vous suffit de modifier les noms d’extension de fichier. Les étapes sont les mêmes.

Dans cet exemple, j'ai préparé un fichier appelé testDB.db. Il contient une table et des exemples de données comme ceci

Étape 2: Importez le fichier dans votre projet

Créez le dossier des ressources si vous n'en avez pas. Puis copiez et collez le fichier de base de données dans ce dossier

Étape 3: Copiez le fichier dans le dossier de données de l'application .

Vous devez copier le fichier de base de données dans le dossier de données de l'application pour pouvoir continuer à interagir avec celui-ci. Ceci est une action unique (initialisation) pour copier le fichier de base de données. Si vous appelez ce code plusieurs fois, le fichier de la base de données dans le dossier de données sera remplacé par celui du dossier assets. Ce processus de remplacement est utile lorsque vous souhaitez mettre à jour la base de données lors de la mise à jour de l'application.

Notez que lors de la mise à jour de l'application, ce fichier de base de données ne sera pas modifié dans le dossier de données de l'application. Seule la désinstallation le supprimera.

Le fichier de base de données doit être copié dans le dossier /databases. Ouvrez l'explorateur de fichiers du périphérique. Entrez data/data/<YourAppName>/ location. Ceci est le dossier de données par défaut de l'application mentionné ci-dessus. Et par défaut, le fichier de base de données sera placé dans un autre dossier appelé bases de données sous ce répertoire

À présent, le processus de copie des fichiers ressemble beaucoup à ce que Java est en train de faire. Utilisez le code suivant pour faire le copier-coller. C'est le code d'initiation. Il peut également être utilisé pour mettre à jour (en écrasant) le fichier de base de données à l'avenir.

//get context by calling "this" in activity or getActivity() in fragment
//call this if API level is lower than 17  String appDataPath = "/data/data/" + context.getPackageName() + "/databases/"
String appDataPath = context.getApplicationInfo().dataDir;

File dbFolder = new File(appDataPath + "/databases");//Make sure the /databases folder exists
dbFolder.mkdir();//This can be called multiple times.

File dbFilePath = new File(appDataPath + "/databases/testDB.db");

try {
    InputStream inputStream = context.getAssets().open("testDB.db");
    OutputStream outputStream = new FileOutputStream(dbFilePath);
    byte[] buffer = new byte[1024];
    int length;
    while ((length = inputStream.read(buffer))>0)
    {
        outputStream.write(buffer, 0, length);
    }
    outputStream.flush();
    outputStream.close();
    inputStream.close();
} catch (IOException e){
    //handle
}

Puis actualisez le dossier pour vérifier le processus de copie

Étape 4: Créer un utilitaire d'ouverture de base de données

Créez une sous-classe pour SQLiteOpenHelper, avec connect, close, chemin, etc. Je l'ai nommée DatabaseOpenHelper

import Android.content.Context;
import Android.database.SQLException;
import Android.database.sqlite.SQLiteDatabase;
import Android.database.sqlite.SQLiteOpenHelper;

public class DatabaseOpenHelper extends SQLiteOpenHelper {
    public static final String DB_NAME = "testDB.db";
    public static final String DB_SUB_PATH = "/databases/" + DB_NAME;
    private static String APP_DATA_PATH = "";
    private SQLiteDatabase dataBase;
    private final Context context;

    public DatabaseOpenHelper(Context context){
        super(context, DB_NAME, null, 1);
        APP_DATA_PATH = context.getApplicationInfo().dataDir;
        this.context = context;
    }

    public boolean openDataBase() throws SQLException{
        String mPath = APP_DATA_PATH + DB_SUB_PATH;
        //Note that this method assumes that the db file is already copied in place
        dataBase = SQLiteDatabase.openDatabase(mPath, null, SQLiteDatabase.OPEN_READWRITE);
        return dataBase != null;
    }

    @Override
    public synchronized void close(){
        if(dataBase != null) {dataBase.close();}
        super.close();
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
    }

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

Étape 5: Créez une classe de niveau supérieur pour interagir avec la base de données

Ce sera la classe qui lit et écrit votre fichier de base de données. Il existe également un exemple de requête pour imprimer la valeur dans la base de données.

import Android.content.Context;
import Android.database.Cursor;
import Android.database.SQLException;
import Android.database.sqlite.SQLiteDatabase;
import Android.util.Log;

public class Database {
    private final Context context;
    private SQLiteDatabase database;
    private DatabaseOpenHelper dbHelper;

    public Database(Context context){
        this.context = context;
        dbHelper = new DatabaseOpenHelper(context);
    }

    public Database open() throws SQLException
    {
        dbHelper.openDataBase();
        dbHelper.close();
        database = dbHelper.getReadableDatabase();
        return this;
    }

    public void close()
    {
        dbHelper.close();
    }

    public void test(){
        try{
            String query ="SELECT value FROM test1";
            Cursor cursor = database.rawQuery(query, null);
            if (cursor.moveToFirst()){
                do{
                    String value = cursor.getString(0);
                    Log.d("db", value);
                }while (cursor.moveToNext());
            }
            cursor.close();
        } catch (SQLException e) {
            //handle
        }
    }
}

Étape 6: test en cours d'exécution

Testez le code en exécutant les lignes de codes suivantes.

Database db = new Database(context);
db.open();
db.test();
db.close();

Appuyez sur le bouton d'exécution et applaudissez!

Answer 7

En novembre 2017, Google a publié le Room Persistence Library

De la documentation:

La bibliothèque de persistance de salle fournit une couche d'abstraction sur SQLite pour permettre un accès fluide à la base de données tout en exploitant toute la puissance de SQLite.

La bibliothèque vous aide à créer un cache des données de votre application sur un périphérique exécutant votre application. Ce cache, qui sert de source de vérité unique à votre application, permet aux utilisateurs de visualiser une copie cohérente des informations clés au sein de votre application, que les utilisateurs soient connectés à Internet ou non.

La base de données de la salle a un rappel lorsque la base de données est créée ou ouverte pour la première fois. Vous pouvez utiliser le rappel de création pour renseigner votre base de données.

Room.databaseBuilder(context.applicationContext,
        DataDatabase::class.Java, "Sample.db")
        // prepopulate the database after onCreate was called
        .addCallback(object : Callback() {
            override fun onCreate(db: SupportSQLiteDatabase) {
                super.onCreate(db)
                // moving to a new thread
                ioThread {
                    getInstance(context).dataDao()
                                        .insert(PREPOPULATE_DATA)
                }
            }
        })
        .build()

Code de cette blog post .

Answer 8

D'après ce que j'ai vu, vous devriez envoyer une base de données contenant déjà la configuration et les données des tables. Toutefois, si vous le souhaitez (et en fonction du type d'application que vous possédez), vous pouvez autoriser "l'option de mise à niveau de la base de données". Vous devez ensuite télécharger la dernière version de SQLite, obtenir les dernières instructions Insert/Create d’un fichier texte hébergé en ligne, les exécuter et transférer les données de l’ancienne base de données vers la nouvelle.

Answer 9

Enfin je l'ai fait !! J'ai utilisé ce lien aide Utilisation de votre propre base de données SQLite dans Android applications , mais j'ai dû le modifier un peu.

1. Si vous avez plusieurs paquetages, vous devriez mettre le nom du paquet principal ici:

   private static String DB_PATH = "data/data/masterPakageName/databases";

2. J'ai changé la méthode qui copie la base de données du dossier local au dossier de l'émulateur! Il y avait un problème quand ce dossier n'existait pas. Donc, tout d’abord, il devrait vérifier le chemin et, s’il n’y est pas, créer le dossier.

3. Dans le code précédent, la méthode copyDatabase n'était jamais appelée alors que la base de données n'existait pas et que la méthode checkDataBase provoquait une exception. J'ai donc changé un peu le code.

4. Si votre base de données n'a pas d'extension de fichier, n'utilisez pas le nom de fichier avec une.

cela fonctionne bien pour moi, j'espère que cela vous sera utile aussi

    package farhangsarasIntroduction;


import Java.io.File;
import Java.io.FileOutputStream;
import Java.io.IOException;
import Java.io.InputStream;
import Java.io.OutputStream;
import Java.util.ArrayList;
import Java.util.HashMap;

import Android.content.Context;
import Android.database.Cursor;

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.example.sample/databases";

    private static String DB_NAME = "farhangsaraDb";

    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() {

        boolean dbExist;
        try {

             dbExist = checkDataBase();


        } catch (SQLiteException e) {

            e.printStackTrace();
            throw new Error("database dose not exist");

        }

        if(dbExist){
        //do nothing - database already exist
        }else{

            try {

                copyDataBase();


            } catch (IOException e) {

                e.printStackTrace();
                throw new Error("Error copying database");

            }
    //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();


    }

    }

    /**
      * 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.
        throw new Error("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{



            //copyDataBase();
            //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;
            File databaseFile = new File( DB_PATH);
             // check if databases folder exists, if not create one and its subfolders
            if (!databaseFile.exists()){
                databaseFile.mkdir();
            }

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



    }



    @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) {

    }

     you to create adapters for your views.

}

Answer 10

Actuellement, il n'y a aucun moyen de créer préalablement une base de données SQLite à expédier avec votre apk. Le mieux que vous puissiez faire est d’enregistrer le code SQL approprié en tant que ressource et de l’exécuter à partir de votre application. Oui, cela entraîne une duplication des données (la même information existe sous forme de ressource et de base de données), mais il n'y a pas d'autre moyen pour le moment. Le seul facteur atténuant est que le fichier apk est compressé. Mon expérience est 908Ko compresse à moins de 268Ko.

Le fil de discussion ci-dessous contient la meilleure discussion/solution que j'ai trouvée avec un bon exemple de code.

http://groups.google.com/group/Android-developers/msg/9f455ae93a1cf152

J'ai stocké mon instruction CREATE en tant que ressource de chaîne à lire avec Context.getString () et je l'ai exécutée avec SQLiteDatabse.execSQL ().

J'ai stocké les données pour mes insertions dans res/raw/inserts.sql (j'ai créé le fichier SQL, plus de 7 000 lignes). En utilisant la technique du lien ci-dessus, je suis entré dans une boucle, j'ai lu le fichier ligne par ligne et j'ai concédé les données sur "INSERT INTO tbl VALUE", puis une autre requête SQLiteDatabase.execSQL (). Cela ne sert à rien d’économiser 7000 "INSERT INTO tbl VALUE" quand ils peuvent juste être concactés.

Cela prend environ vingt secondes sur l'émulateur, je ne sais pas combien de temps cela prendrait sur un vrai téléphone, mais cela ne se produit qu'une fois, lorsque l'utilisateur lance l'application pour la première fois.

Answer 11

Expédier la base de données à l'intérieur de l'apk puis le copier dans /data/data/... doublera la taille de la base de données (1 dans apk, 1 dans data/data/...) et augmentera la taille de l'apk (bien sûr). Donc, votre base de données ne devrait pas être trop grosse.

Answer 12

Android fournit déjà une approche de la gestion de base de données prenant en compte les versions. Cette approche a été mise à profit dans le cadre BARACUS pour les applications Android.

Il vous permet de gérer la base de données tout au long du cycle de vie d’une application, ce qui permet de mettre à jour la base de données sqlite de n’importe quelle version précédente vers la version actuelle.

En outre, il vous permet d'exécuter des sauvegardes à chaud et une récupération à chaud de SQLite.

Je ne suis pas sûr à 100%, mais une récupération à chaud pour un appareil spécifique peut vous permettre d'expédier une base de données préparée dans votre application. Mais je ne suis pas sûr du format binaire de la base de données, qui pourrait être spécifique à certains périphériques, fournisseurs ou générations de périphériques.

Comme il s’agit de la licence Apache 2, vous pouvez réutiliser n’importe quelle partie du code, que l’on trouve sur github

MODIFIER :

Si vous souhaitez uniquement envoyer des données, vous pouvez envisager d'instancier et de conserver des POJO au premier démarrage des applications. BARACUS a obtenu un support intégré pour cela (magasin de valeurs de clé intégré pour les informations de configuration, par exemple "APP_FIRST_RUN" plus un point d'accrochage after-context-bootstrap afin d'exécuter des opérations de post-lancement sur le contexte). Cela vous permet d'avoir des données couplées serrées livrées avec votre application; dans la plupart des cas, cela correspondait à mes cas d'utilisation.

Answer 13

Si les données requises ne sont pas trop volumineuses (des limites que je ne connais pas, cela dépendrait de beaucoup de choses), vous pouvez également télécharger les données (au format XML, JSON, etc.) depuis un site Web/une application Web. Après réception, exécutez les instructions SQL en utilisant les données reçues, en créant vos tables et en insérant les données.

Si votre application mobile contient beaucoup de données, il sera peut-être plus facile ultérieurement de mettre à jour les données dans les applications installées avec des données ou des modifications plus précises.

Answer 14

J'ai écrit un bibliothèque pour simplifier ce processus.

dataBase = new DataBase.Builder(context, "myDb").
//        setAssetsPath(). // default "databases"
//        setDatabaseErrorHandler().
//        setCursorFactory().
//        setUpgradeCallback()
//        setVersion(). // default 1
build();

Il créera une base de données à partir du fichier assets/databases/myDb.db. De plus, vous obtiendrez toutes ces fonctionnalités:

• Charger la base de données à partir d'un fichier
• Accès synchronisé à la base de données
• Utilisation de sqlite-Android par interrogation, Android distribution spécifique des dernières versions de SQLite.

Clonez-le de github .

Answer 15

J'utilise ORMLite et le code ci-dessous a fonctionné pour moi

public class DatabaseProvider extends OrmLiteSqliteOpenHelper {
    private static final String DatabaseName = "DatabaseName";
    private static final int DatabaseVersion = 1;
    private final Context ProvidedContext;

    public DatabaseProvider(Context context) {
        super(context, DatabaseName, null, DatabaseVersion);
        this.ProvidedContext= context;
        SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(context);
        boolean databaseCopied = preferences.getBoolean("DatabaseCopied", false);
        if (databaseCopied) {
            //Do Nothing
        } else {
            CopyDatabase();
            SharedPreferences.Editor editor = preferences.edit();
            editor.putBoolean("DatabaseCopied", true);
            editor.commit();
        }
    }

    private String DatabasePath() {
        return "/data/data/" + ProvidedContext.getPackageName() + "/databases/";
    }

    private void CopyDatabase() {
        try {
            CopyDatabaseInternal();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private File ExtractAssetsZip(String zipFileName) {
        InputStream inputStream;
        ZipInputStream zipInputStream;
        File tempFolder;
        do {
            tempFolder = null;
            tempFolder = new File(ProvidedContext.getCacheDir() + "/extracted-" + System.currentTimeMillis() + "/");
        } while (tempFolder.exists());

        tempFolder.mkdirs();

        try {
            String filename;
            inputStream = ProvidedContext.getAssets().open(zipFileName);
            zipInputStream = new ZipInputStream(new BufferedInputStream(inputStream));
            ZipEntry zipEntry;
            byte[] buffer = new byte[1024];
            int count;

            while ((zipEntry = zipInputStream.getNextEntry()) != null) {
                filename = zipEntry.getName();
                if (zipEntry.isDirectory()) {
                    File fmd = new File(tempFolder.getAbsolutePath() + "/" + filename);
                    fmd.mkdirs();
                    continue;
                }

                FileOutputStream fileOutputStream = new FileOutputStream(tempFolder.getAbsolutePath() + "/" + filename);
                while ((count = zipInputStream.read(buffer)) != -1) {
                    fileOutputStream.write(buffer, 0, count);
                }

                fileOutputStream.close();
                zipInputStream.closeEntry();
            }

            zipInputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }

        return tempFolder;
    }

    private void CopyDatabaseInternal() throws IOException {

        File extractedPath = ExtractAssetsZip(DatabaseName + ".Zip");
        String databaseFile = "";
        for (File innerFile : extractedPath.listFiles()) {
            databaseFile = innerFile.getAbsolutePath();
            break;
        }
        if (databaseFile == null || databaseFile.length() ==0 )
            throw new RuntimeException("databaseFile is empty");

        InputStream inputStream = new FileInputStream(databaseFile);

        String outFileName = DatabasePath() + DatabaseName;

        File destinationPath = new File(DatabasePath());
        if (!destinationPath.exists())
            destinationPath.mkdirs();

        File destinationFile = new File(outFileName);
        if (!destinationFile.exists())
            destinationFile.createNewFile();

        OutputStream myOutput = new FileOutputStream(outFileName);

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

        myOutput.flush();
        myOutput.close();
        inputStream.close();
    }

    @Override
    public void onCreate(SQLiteDatabase sqLiteDatabase, ConnectionSource connectionSource) {
    }

    @Override
    public void onUpgrade(SQLiteDatabase sqLiteDatabase, ConnectionSource connectionSource, int fromVersion, int toVersion) {

    }
}

Veuillez noter que le code extrait le fichier de base de données à partir d'un fichier Zip dans les actifs.

Answer 16

J'ai modifié la classe et les réponses à la question et ai écrit une classe qui permet de mettre à jour la base de données via DB_VERSION.

public class DatabaseHelper extends SQLiteOpenHelper {
    private static String DB_NAME = "info.db";
    private static String DB_PATH = "";
    private static final int DB_VERSION = 1;

    private SQLiteDatabase mDataBase;
    private final Context mContext;
    private boolean mNeedUpdate = false;

    public DatabaseHelper(Context context) {
        super(context, DB_NAME, null, DB_VERSION);
        if (Android.os.Build.VERSION.SDK_INT >= 17)
            DB_PATH = context.getApplicationInfo().dataDir + "/databases/";
        else
            DB_PATH = "/data/data/" + context.getPackageName() + "/databases/";
        this.mContext = context;

        copyDataBase();

        this.getReadableDatabase();
    }

    public void updateDataBase() throws IOException {
        if (mNeedUpdate) {
            File dbFile = new File(DB_PATH + DB_NAME);
            if (dbFile.exists())
                dbFile.delete();

            copyDataBase();

            mNeedUpdate = false;
        }
    }

    private boolean checkDataBase() {
        File dbFile = new File(DB_PATH + DB_NAME);
        return dbFile.exists();
    }

    private void copyDataBase() {
        if (!checkDataBase()) {
            this.getReadableDatabase();
            this.close();
            try {
                copyDBFile();
            } catch (IOException mIOException) {
                throw new Error("ErrorCopyingDataBase");
            }
        }
    }

    private void copyDBFile() throws IOException {
        InputStream mInput = mContext.getAssets().open(DB_NAME);
        //InputStream mInput = mContext.getResources().openRawResource(R.raw.info);
        OutputStream mOutput = new FileOutputStream(DB_PATH + DB_NAME);
        byte[] mBuffer = new byte[1024];
        int mLength;
        while ((mLength = mInput.read(mBuffer)) > 0)
            mOutput.write(mBuffer, 0, mLength);
        mOutput.flush();
        mOutput.close();
        mInput.close();
    }

    public boolean openDataBase() throws SQLException {
        mDataBase = SQLiteDatabase.openDatabase(DB_PATH + DB_NAME, null, SQLiteDatabase.CREATE_IF_NECESSARY);
        return mDataBase != null;
    }

    @Override
    public synchronized void close() {
        if (mDataBase != null)
            mDataBase.close();
        super.close();
    }

    @Override
    public void onCreate(SQLiteDatabase db) {

    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        if (newVersion > oldVersion)
            mNeedUpdate = true;
    }
}

Utiliser une classe.

Dans la classe d'activité, déclarez les variables.

private DatabaseHelper mDBHelper;
private SQLiteDatabase mDb;

Dans la méthode onCreate, écrivez le code suivant.

mDBHelper = new DatabaseHelper(this);

try {
    mDBHelper.updateDataBase();
} catch (IOException mIOException) {
    throw new Error("UnableToUpdateDatabase");
}

try {
    mDb = mDBHelper.getWritableDatabase();
} catch (SQLException mSQLException) {
    throw mSQLException;
}

Si vous ajoutez un fichier de base de données au dossier res/raw, utilisez la modification suivante de la classe.

public class DatabaseHelper extends SQLiteOpenHelper {
    private static String DB_NAME = "info.db";
    private static String DB_PATH = "";
    private static final int DB_VERSION = 1;

    private SQLiteDatabase mDataBase;
    private final Context mContext;
    private boolean mNeedUpdate = false;

    public DatabaseHelper(Context context) {
        super(context, DB_NAME, null, DB_VERSION);
        if (Android.os.Build.VERSION.SDK_INT >= 17)
            DB_PATH = context.getApplicationInfo().dataDir + "/databases/";
        else
            DB_PATH = "/data/data/" + context.getPackageName() + "/databases/";
        this.mContext = context;

        copyDataBase();

        this.getReadableDatabase();
    }

    public void updateDataBase() throws IOException {
        if (mNeedUpdate) {
            File dbFile = new File(DB_PATH + DB_NAME);
            if (dbFile.exists())
                dbFile.delete();

            copyDataBase();

            mNeedUpdate = false;
        }
    }

    private boolean checkDataBase() {
        File dbFile = new File(DB_PATH + DB_NAME);
        return dbFile.exists();
    }

    private void copyDataBase() {
        if (!checkDataBase()) {
            this.getReadableDatabase();
            this.close();
            try {
                copyDBFile();
            } catch (IOException mIOException) {
                throw new Error("ErrorCopyingDataBase");
            }
        }
    }

    private void copyDBFile() throws IOException {
        //InputStream mInput = mContext.getAssets().open(DB_NAME);
        InputStream mInput = mContext.getResources().openRawResource(R.raw.info);
        OutputStream mOutput = new FileOutputStream(DB_PATH + DB_NAME);
        byte[] mBuffer = new byte[1024];
        int mLength;
        while ((mLength = mInput.read(mBuffer)) > 0)
            mOutput.write(mBuffer, 0, mLength);
        mOutput.flush();
        mOutput.close();
        mInput.close();
    }

    public boolean openDataBase() throws SQLException {
        mDataBase = SQLiteDatabase.openDatabase(DB_PATH + DB_NAME, null, SQLiteDatabase.CREATE_IF_NECESSARY);
        return mDataBase != null;
    }

    @Override
    public synchronized void close() {
        if (mDataBase != null)
            mDataBase.close();
        super.close();
    }

    @Override
    public void onCreate(SQLiteDatabase db) {

    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        if (newVersion > oldVersion)
            mNeedUpdate = true;
    }
}

http://blog.harrix.org/article/6784