/ /

/ /

SDK de dispositivos Atlas

SDK de Java

Archivos del reino

Agrupar un archivo Realm - SDK de Java

Los SDK de dispositivos Atlas están obsoletos. Consulte Página de desuso para más detalles.

Nota

Paquete de reinos sincronizados

La versión 10.9.0 del SDK introdujo la posibilidad de agrupar dominios sincronizados. Antes de la versión 10.9.0, solo se podían agrupar dominios locales.

Realm permite agrupar archivos de realm. Al agrupar un archivo de realm, se incluye una base de datos y todos sus datos en la descarga de la aplicación.

Esto permite a los usuarios iniciar aplicaciones por primera vez con un conjunto de datos iniciales. En el caso de los dominios sincronizados, la agrupación puede evitar una descarga inicial prolongada la primera vez que un usuario abre la aplicación. En su lugar, los usuarios solo deben descargar los cambios sincronizados realizados desde que se generó el archivo agrupado.

Importante

Agrupación de reinos sincronizados

Si su aplicación backend utiliza Sincronización flexible: los usuarios podrían experimentar un reinicio del cliente la primera vez que abren el archivo de dominio incluido. Esto puede ocurrir cuando el tiempo máximo sin conexión del cliente está habilitado (esta opción está habilitada por defecto). Si el archivo de dominio incluido se generó más de los días especificados en la configuración de tiempo máximo sin conexión del cliente antes de que el usuario sincronice por primera vez, el cliente se reiniciará.

Las aplicaciones que reinician el cliente descargan el estado completo del dominio desde el backend de la aplicación. Esto anula las ventajas de agrupar un archivo de dominio. Para evitar reinicios del cliente y conservar las ventajas de agrupar archivos de dominio:

Evite utilizar un tiempo máximo sin conexión del cliente en aplicaciones que agrupan un reino sincronizado.
Si su aplicación utiliza un tiempo máximo de desconexión del cliente, asegúrese de que la descarga de la aplicación siempre incluya un archivo de dominio sincronizado recientemente. Genere un nuevo archivo con cada versión de la aplicación y asegúrese de que ninguna versión permanezca actualizada durante más días que el tiempo máximo de desconexión del cliente.

Overview

Para crear y agrupar un archivo de reino con su aplicación:

Crea un archivo de reino que contenga los datos que deseas agrupar.
Agrupe el archivo de reino en la /<app name>/src/main/assets carpeta de su aplicación de producción.
En su aplicación de producción, abra el dominio desde el archivo de recursos incluido. Para dominios sincronizados, debe proporcionar la clave de partición.

Nota

Solo sincronización del mismo tipo

Este método solo permite copiar una configuración de sincronización basada en particiones para otro usuario de sincronización basada en particiones, o una configuración de sincronización flexible para otro usuario de sincronización flexible. No se puede usar este método para convertir entre un dominio de sincronización basada en particiones y uno de sincronización flexible, ni viceversa.

Crear un archivo de reino para agrupar

Cree una aplicación de reino temporal que comparta el modelo de datos de su aplicación.
Abra un dominio y agregue los datos que desea agrupar. Si usa un dominio sincronizado, espere a que se sincronice por completo.

Utiliza el método writeCopyTo() para copiar el realm a un nuevo archivo:

String appID = YOUR_APP_ID; // replace this with your App ID
App app = new App(appID);
Credentials anonymousCredentials = Credentials.anonymous();
app.loginAsync(anonymousCredentials, it -> {
    if (it.isSuccess()) {
        Log.v("EXAMPLE", "Successfully authenticated anonymously.");
        String PARTITION = "PARTITION_YOU_WANT_TO_BUNDLE";
        // you can only create realm copies on a background thread with a looper.
        // HandlerThread provides a Looper-equipped thread.
        HandlerThread handlerThread = new HandlerThread("CopyARealmHandler");
        handlerThread.start();
        Handler handler = new Handler(handlerThread.getLooper());
        handler.post(new Thread(new Runnable() { @Override public void run() {
            SyncConfiguration config = new SyncConfiguration.Builder(app.currentUser(), PARTITION)
                    // wait for the realm to download all data from the backend before opening
                    .waitForInitialRemoteData()
                    .build();
            Realm realm = Realm.getInstance(config);
            Log.v("EXAMPLE", "Successfully opened a realm.");
            // write a copy of the realm you can manually copy to your production application assets
            File outputDir = activity.getApplicationContext().getCacheDir();
            File outputFile = new File(outputDir.getPath() + "/" +  PARTITION + "_bundled.realm");
            // ensure all local changes have synced to the backend
            try {
                app.getSync().getSession(config).uploadAllLocalChanges(10000, TimeUnit.MILLISECONDS);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // cannot write to file if it already exists. Delete the file if already there
            outputFile.delete();
            realm.writeCopyTo(outputFile);
            // search for this log line to find the location of the realm copy
            Log.i("EXAMPLE", "Wrote copy of realm to " + outputFile.getAbsolutePath());
            // always close a realm when you're done using it
            realm.close();
        }}));
    } else {
        Log.e("EXAMPLE", "Failed to authenticate: " + it.getError().toString());
    }
});

val appID: String = YOUR_APP_ID // replace this with your App ID
val app = App(appID)
val anonymousCredentials = Credentials.anonymous()
app.loginAsync(anonymousCredentials) { it: App.Result<User?> ->
    if (it.isSuccess) {
        Log.v("EXAMPLE", "Successfully authenticated anonymously.")
        val PARTITION = "PARTITION_YOU_WANT_TO_BUNDLE"
        // you can only create realm copies on a background thread with a looper.
        // HandlerThread provides a Looper-equipped thread.
        val handlerThread = HandlerThread("CopyARealmHandler")
        handlerThread.start()
        val handler = Handler(handlerThread.looper)
        handler.post(Thread {
            val config = SyncConfiguration.Builder(app.currentUser(), PARTITION)
                // wait for the realm to download all data from the backend before opening
                .waitForInitialRemoteData()
                .build()
            val realm : Realm = Realm.getInstance(config);
            Log.v("EXAMPLE", "Successfully opened a realm.")
            // write a copy of the realm you can manually copy to your production application assets
            val outputDir = activity!!.applicationContext.cacheDir
            val outputFile =
                File(outputDir.path + "/" + PARTITION + "_bundled.realm")
            // ensure all local changes have synced to the backend
            try {
                app.sync.getSession(config)
                    .uploadAllLocalChanges(10000, TimeUnit.MILLISECONDS)
            } catch (e: InterruptedException) {
                e.printStackTrace()
            }
            // cannot write to file if it already exists. Delete the file if already there
            outputFile.delete()
            realm.writeCopyTo(outputFile)
            // search for this log line to find the location of the realm copy
            Log.i("EXAMPLE", "Wrote copy of realm to " + outputFile.absolutePath)
            // always close a realm when you're done using it
            realm.close()
        })
    } else {
        Log.e("EXAMPLE", "Failed to authenticate: ${it.error}")
    }
}

writeCopyTo() Compacta automáticamente tu reino al tamaño más pequeño posible antes de copiarlo.

Tip

Diferencias entre los dominios sincronizados y los dominios solo locales

El ejemplo anterior usa SyncConfiguration para configurar un dominio sincronizado. Para crear una copia de un dominio local, configure su dominio con RealmConfiguration.

Agrupar un archivo de reino en su aplicación de producción

Ahora que tiene una copia del reino que contiene los datos iniciales, inclúyalo en su aplicación de producción.

Busque en los registros de su aplicación para encontrar la ubicación de la copia del archivo de reino que acaba de crear.
Usando el widget "Explorador de archivos del dispositivo" en la parte inferior derecha de la ventana de Android Studio, navega hasta el archivo.
Haz clic derecho en el archivo y selecciona "Guardar como". Navega a la carpeta /<app name>/src/main/assets de tu aplicación de producción. Guarda allí una copia del archivo realm.

Tip

Carpetas de activos

Si su aplicación aún no contiene una carpeta de activos, puede crear una haciendo clic derecho en la carpeta de aplicación de nivel superior (<app name>) en Android Studio y seleccionando New > Folder > Assets Folder en el menú.

Abrir un reino desde un archivo de reino incluido

Ahora que tiene una copia del dominio incluida en su aplicación de producción, necesita agregar código para usarla. Use el método assetFile() al configurar su dominio para abrirlo desde el archivo incluido:

String appID = YOUR_APP_ID; // replace this with your App ID
App app = new App(appID);
Credentials anonymousCredentials = Credentials.anonymous();
app.loginAsync(anonymousCredentials, it -> {
    if (it.isSuccess()) {
        Log.v("EXAMPLE", "Successfully authenticated anonymously.");
        // asset file name should correspond to the name of the bundled file
        SyncConfiguration config = new SyncConfiguration.Builder(
                    app.currentUser(),
                    "PARTITION_YOU_WANT_TO_BUNDLE")
                .assetFile("example_bundled.realm")
                .build();
        Realm realm = Realm.getInstance(config);
        Log.v("EXAMPLE", "Successfully opened bundled realm.");
        // read and write to the bundled realm as normal
        realm.executeTransactionAsync(transactionRealm -> {
            Frog frog = new Frog(new ObjectId(),
                    "Asimov",
                    4,
                    "red eyed tree frog",
                    "Spike");
            transactionRealm.insert(frog);
            expectation.fulfill();
        });
    } else {
        Log.e("EXAMPLE", "Failed to authenticate: " + it.getError().toString());
    }
});

val appID: String = YOUR_APP_ID // replace this with your App ID
val app = App(appID)
val anonymousCredentials = Credentials.anonymous()
app.loginAsync(anonymousCredentials) { it: App.Result<User?> ->
    if (it.isSuccess) {
        Log.v("EXAMPLE", "Successfully authenticated anonymously.")
        // asset file name should correspond to the name of the bundled file
        val config = SyncConfiguration.Builder(
                app.currentUser(),
                "PARTITION_YOU_WANT_TO_BUNDLE")
            .assetFile("example_bundled.realm")
            .build()
        val realm: Realm = Realm.getInstance(config)
        Log.v("EXAMPLE", "Successfully opened bundled realm.")
        // read and write to the bundled realm as normal
        realm.executeTransactionAsync { transactionRealm: Realm ->
            val frog = Frog(
                ObjectId(),
                "Asimov",
                4,
                "red eyed tree frog",
                "Spike"
            )
            transactionRealm.insert(frog)
            expectation.fulfill()
        }
    } else {
        Log.e("EXAMPLE", "Failed to authenticate: ${it.error}")
    }
}

Tip

Diferencias entre los dominios sincronizados y los dominios solo locales

El ejemplo anterior usa SyncConfiguration para configurar un dominio sincronizado. Para crear una copia de un dominio local, configure su dominio con RealmConfiguration.

Volver

Abrir y cerrar un reino

Cifrar un reino