/ /

/ /

SDK de Dispositivo Atlas

Kotlin SDK

Sync Device Data

Configure & Open a Synced Realm - Kotlin SDK

Los SDK de dispositivos Atlas están obsoletos. Consulte deprecation page for details.

Esta página describe cómo abrir una base de datos sincronizada y las diversas opciones de configuración disponibles.

Requisitos previos

Para poder acceder a un realm sincronizado desde el cliente se debe:

Habilitar la sincronización en la interfaz de usuario de App Services.
Install the sync distribution of the Kotlin SDK for Android or Kotlin Multiplatform.
Authenticate a user in your client project.

Open a Synced Realm

Para abrir un dominio de sincronización flexible, pase un usuario y un conjunto de esquemas de objetos de dominio a SyncConfiguration.Builder(). A continuación, cree un conjunto de suscripciones iniciales con el initialSubscriptions() Método constructor. Finalmente, pasa la configuración a Realm.open() para abrir una instancia del reino:

val app = App.create(YOUR_APP_ID)
// use constants for query names so you can edit or remove them later
val NAME_QUERY = "NAME_QUERY"
runBlocking {
    val user = app.login(Credentials.anonymous())
    val config = SyncConfiguration.Builder(user, setOf(Toad::class))
        .initialSubscriptions { realm ->
            add(
                realm.query<Toad>(
                    "name == $0",
                    "name value"
                ),
                "subscription name"
            )
        }
        .build()
    val realm = Realm.open(config)
    Log.v("Successfully opened realm: ${realm.configuration.name}")
    realm.close()
}

For more information on bootstrapping the realm with initial subscriptions and managing your synced realm subscriptions, refer to Manage Sync Subscriptions.

Configurar un Realm sincronizado

To adjust specific configuration settings, use the options provided by SyncConfiguration.Builder:

val app = App.create(YOUR_APP_ID)
runBlocking {
    val user = app.login(Credentials.anonymous())
    val config = SyncConfiguration.Builder(user, setOf(Toad::class))
        .maxNumberOfActiveVersions(10)
        .name("realm name")
        .initialSubscriptions { realm ->
            add(
                realm.query<Toad>(
                    "name == $0",
                    "name value"
                ),
                "subscription name"
            )
        }
        .build()
    val realm = Realm.open(config)
    Log.v("Successfully opened realm: ${realm.configuration}")
    realm.close()
}

Novedad en la versión 1.13.0: Opciones de configuración de tiempo de espera de sincronización añadidas

En Kotlin v1.13.0, puedes sobrescribir varios tiempos de espera por defecto para las operaciones de sincronización. Puedes configurar estos tiempos de espera en la configuración del cliente App, y se aplican a todas las sesiones de sincronización en la aplicación. Para aprender cómo, consulta Configurar los tiempos de espera de la sincronización.

Descargar cambios antes de abrir

Cuando abres un realm sincronizado con el Kotlin SDK, puedes usar la función .waitForInitialRemoteData() para descargar el conjunto de cambios desde tu aplicación antes de abrir el realm. Establecer esto bloquea la apertura del realm hasta que se hayan descargado todos los datos. Si un dispositivo está fuera de línea, esto bloquea la apertura del realm. Debido a que la descarga inicial de datos podría ser una operación prolongada, se debe abrir un realm usando este ajuste en un hilo en segundo plano.

Esta función acepta una duración de tiempo de espera Cuando la descarga excede un tiempo de espera determinado, Realm lanza una excepción DownloadingRealmTimeoutException.

val user = app.login(Credentials.emailPassword(email, password))
val config = SyncConfiguration.Builder(user, setOf(Toad::class))
    .waitForInitialRemoteData(60.seconds)
    .initialSubscriptions { realm ->
        add(
            realm.query<Toad>(
                "name == $0",
                "Jeremiah"
            ),
            "toads_named_jeremiah"
        )
    }
    .build()
val realm = Realm.open(config)
Log.v("Successfully opened realm: ${realm.configuration}")
// Query the realm we opened after waiting for data to download, and see that it contains data
val downloadedToads: RealmResults<Toad> = realm.query<Toad>().find()
Log.v("After downloading initial data, downloadedToads.size is ${downloadedToads.size}")
realm.close()

Conditionally Download Changes Before Opening

If there is a condition that determines whether your app should download server data before opening the realm, you can use that with SyncSession.downloadAllServerChanges() to conditionally download changes before opening the realm. Calling this method blocks until all known remote changes have been downloaded and applied to the Realm, or until a specified timeout is hit. You should call this method only from a non-UI thread.

Esta función acepta una duración de tiempo de espera.

val user = app.login(Credentials.emailPassword(email, password))
val config = SyncConfiguration.Builder(user, setOf(Toad::class))
    .initialSubscriptions { realm ->
        add(
            realm.query<Toad>(
                "name == $0",
                "Lollihops"
            ),
            "toads_named_lollihops"
        )
    }
    .build()
val realm = Realm.open(config)
// Conditionally download data before using the realm based on some business logic
if (downloadData) {
    realm.syncSession.downloadAllServerChanges(30.seconds)
}
// Query the realm we opened after waiting for data to download, and see that it contains data
val downloadedToads: RealmResults<Toad> = realm.query<Toad>().find()
Log.v("After conditionally downloading data, downloadedToads.size is ${downloadedToads.size}")
realm.close()

Open a Synced Realm Offline

Cuando tu aplicación Realm autentica a un usuario, almacena en caché las credenciales del usuario. Puedes comprobar si existen credenciales de usuario para omitir el flujo de inicio de sesión y acceder al usuario almacenado en caché. Usa esto para abrir un realm sin conexión.

Nota

El inicio de sesión inicial requiere una conexión de red

Cuando un usuario se registra en tu aplicación o inicia sesión por primera vez con una cuenta existente en un cliente, este debe tener conexión de red. Comprobar las credenciales de usuario en caché permite abrir un reino sin conexión, pero solo si el usuario ha iniciado sesión previamente con conexión.

Solo puedes abrir un realm sincronizado sin conexión si no requieres que tu aplicación cliente descargue los cambios antes de abrir el realm.

// You can only open a synced realm offline if there is a cached user credential. If
// there is no app.currentUser, you must log them in, which requires a network connection.
if (app.currentUser == null) {
    app.login(Credentials.emailPassword(email, password))
}
// If the app.currentUser isn't null, you can use the cached credential to open the synced
// realm even if the user is offline.
val user = app.currentUser!!
val realm = Realm.open(config)
// Query the realm we opened, and see that it contains data
val offlineToads: RealmResults<Toad> = realm.query<Toad>().find()
Log.v("After opening a realm offline, offlineToads.size is ${offlineToads.size}")
realm.close()

Volver

Add Sync to an App

Gestionar suscripciones