Copie de Base de données à partir du dossier des actifs dans les déracinés de l'appareil

Je suis en train de copier DB à partir d'un dossier des actifs à l'appareil. Ce code fonctionne bien sur Émulateur et Dispositif enracinée. Je veux juste savoir est-il de créer de problème sur les déracinés de l'appareil ou il travaillera même.

private void StoreDatabase() {
    File DbFile = new File(
            "data/data/packagename/DBname.sqlite");
    if (DbFile.exists()) {
        System.out.println("file already exist ,No need to Create");
    } else {
        try {
            DbFile.createNewFile();
            System.out.println("File Created successfully");
            InputStream is = this.getAssets().open("DBname.sqlite");
            FileOutputStream fos = new FileOutputStream(DbFile);
            byte[] buffer = new byte[1024];
            int length = 0;
            while ((length = is.read(buffer)) > 0) {
                fos.write(buffer, 0, length);
            }
            System.out.println("File succesfully placed on sdcard");
            //Close the streams
            fos.flush();
            fos.close();
            is.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

Oui, votre extrait de code fonctionne parfaitement sur non racinées dispositifs de trop 🙂

OriginalL'auteur Krishnakant Dalal | 2012-05-24

Cela fonctionne pour vous dans tous les appareils et l'émulateur, pas besoin de root.

/**
 * 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(String dbname) throws IOException {
    //Open your local db as the input stream
    InputStream myInput = myContext.getAssets().open(dbname);
    //Path to the just created empty db
    File outFileName = myContext.getDatabasePath(dbname);
    //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();
}

Mon code est aussi bien fonctionner, je veux juste savoir est-il de créer de problème sur les déracinés de l'appareil ?
Non, pour sûr. code ci-dessus fonctionne bien et le vôtre aussi.
JAMAIS coder en dur des CHEMINS. Le outFileName valeur sera mauvais sur Android nombreux environnements, tels que les comptes secondaires. Utilisation getDatabasePath() pour en déduire le chemin d'accès d'un fichier de base de données.
Merci @CommonsWare . Je vais le changer à String outFileName = getDatabasePath() + dbname;
Si ce n'est pas myContext.getDatabasePath(dbname)? Aussi getDatabasePath(dbName) renvoie un fichier objet n'est pas une Chaîne.

OriginalL'auteur abbas.aniefa

    /**
 * Copy database file from assets folder inside the apk to the system database path.
 * @param context Context
 * @param databaseName Database file name inside assets folder
 * @param overwrite True to rewrite on the database if exists
 * @return True if the database have copied successfully or if the database already exists without overwrite, false otherwise.
 */
private boolean copyDatabaseFromAssets(Context context, String databaseName , boolean overwrite)  {

    File outputFile = context.getDatabasePath(databaseName);
    if (outputFile.exists() && !overwrite) {
        return true;
    }

    outputFile = context.getDatabasePath(databaseName + ".temp");
    outputFile.getParentFile().mkdirs();

    try {
        InputStream inputStream = context.getAssets().open(databaseName);
        OutputStream outputStream = new FileOutputStream(outputFile);


        //transfer bytes from the input stream into the output stream
        byte[] buffer = new byte[1024];
        int length;
        while ((length = inputStream.read(buffer)) > 0) {
            outputStream.write(buffer, 0, length);
        }

        //Close the streams
        outputStream.flush();
        outputStream.close();
        inputStream.close();

        outputFile.renameTo(context.getDatabasePath(databaseName));

    } catch (IOException e) {
        if (outputFile.exists()) {
            outputFile.delete();
        }
        return false;
    }

    return true;
}

J'ai donné un +1 parce que la combinaison de getDatabasePath() la méthode de l'objet de contexte et outputFile.getParentFile().mkdirs() de votre code résolu mon problème dans lequel la base de données de la copie n'était pas quand j'ai utilisé l'codée en dur le chemin du répertoire que d'autres exemples montrent.
après des heures de travail, VOTRE code viens de résoudre mon problème...

OriginalL'auteur Mahmoud Shahoud

Je ne suis pas sûr, mais cela fonctionne sur tous les appareils que j'ai testé. J'ai volé cette méthode (à partir de quelque part ici), et générique pour à la fois la sauvegarde et la restauration:

public static void movedb(File srcdb, File destdb)
{
    try 
    {
        if (Environment.getExternalStorageDirectory().canWrite()) 
        {                 
            if (srcdb.exists()) 
            {
                FileChannel src = new FileInputStream(srcdb).getChannel();
                FileChannel dst = new FileOutputStream(destdb).getChannel();
                dst.transferFrom(src, 0, src.size());
                src.close();
                dst.close();                    
            }
            else
            {
                //ERROR: "Database file references are incorrect"                    
            }
        }
        else
        {
           //ERROR: "Cannot write to file"
        }
    }
    catch (Exception e) 
    {
        //ERROR: e.getMessage()
    }
}

Puis je viens de le sauvegarder en appelant le:

movedb(this, getDatabasePath(getDbName()), new File(Environment.getExternalStorageDirectory(), getDatabaseBackupPath()));

Où getDatabasePath() et getDatabaseBackupPath() sont juste des valeurs de chaîne

Mon code est aussi bien fonctionner, je veux juste savoir est-il de créer de problème sur les déracinés de l'appareil ?

OriginalL'auteur Quintin Balsdon

private void copyDataBase(Context context) throws IOException {

    //Log.i(TAG, "Opening Asset...");
    //Open your local db as the input stream
    InputStream myInput = context.getAssets().open(DBHelper.DATABASE_NAME);

   //Log.i(TAG, "Getting db path...");
    //Path to the just created empty db
    File dbFile = getDatabasePath(DBHelper.DATABASE_NAME);

    if (!dbFile.exists()) {
        SQLiteDatabase checkDB = context.openOrCreateDatabase(DBHelper.DATABASE_NAME, context.MODE_PRIVATE, null);
        if (checkDB != null) {
            checkDB.close();
        }
    }

    //Log.i(TAG, "Getting output stream...");
    //Open the empty db as the output stream
    OutputStream myOutput = new FileOutputStream(dbFile);

  // Log.i(TAG, "Writing data...");
    //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();
}

OriginalL'auteur Vinay Mandadapu

Cela fonctionne pour Kotlin.

assets.open("sqlite_db_in_assets.db")
      .copyTo(getDatabasePath("sqlite_db_in_device.db").outputStream())

OriginalL'auteur arjunaskykok

Vous devez vous connecter pour publier un commentaire.