/ /

/ /

SDK de Dispositivo Atlas

Java SDK

Sync Data

Configurar un Realm sincronizado - Java SDK

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

Nota

Las nuevas aplicaciones SDK de Java no pueden usar RealmAny

Nuevo Servicios de aplicaciones Las aplicaciones no podrán sincronizar modelos de datos con propiedades de tipo RealmAny.

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.
Initialize the app
Enable Sync in your application by adding the following to the top level of your application-level build.gradle file:
```
realm { syncEnabled = true }
```
Authenticate a user in your client project.

Realms sincronizados

Synced realms use Atlas Device Sync to store data both on the client device and in your synced data source. Opening a synced realm works exactly like opening a local realm, except you use SyncConfiguration to customize the settings for synced realms.

Synced Realm Configuration

Para configurar la configuración de un realm, crea una SyncConfiguration con un SyncConfiguration.Builder.

Para abrir un reino sincronizado, llame a getInstanceAsync() y pase un objeto SyncConfiguration.

Cuando su aplicación use Sincronización Flexible, llame al método del generador de configuración de sincronización initialSubscriptions() con una instancia de SyncConfiguration.InitialFlexibleSyncSubscriptions() para abrir un dominio sincronizado. En el configure() método, cree una instancia UnmanagedSubscription de con un nombre y una consulta mediante Subscription.create(). Pase su nueva suscripción al add() método del parámetro MutableSubscriptionSet para agregarla a sus suscripciones:

// instantiate a Realm App connection
String appID = YOUR_APP_ID; // replace this with your App ID
App app = new App(new AppConfiguration.Builder(appID)
        .build());
// authenticate a user
Credentials credentials = Credentials.anonymous();
app.loginAsync(credentials, it -> {
    if (it.isSuccess()) {
        User user = it.get();
        // add an initial subscription to the sync configuration
        SyncConfiguration config = new SyncConfiguration.Builder(app.currentUser())
                .initialSubscriptions(new SyncConfiguration.InitialFlexibleSyncSubscriptions() {
                    @Override
                    public void configure(Realm realm, MutableSubscriptionSet subscriptions) {
                        subscriptions.add(Subscription.create("subscriptionName",
                                realm.where(Frog.class)
                                    .equalTo("species", "spring peeper")));
                    }
                })
                .build();
        // instantiate a realm instance with the flexible sync configuration
        Realm.getInstanceAsync(config, new Realm.Callback() {
            @Override
            public void onSuccess(Realm realm) {
                Log.v("EXAMPLE", "Successfully opened a realm.");
            }
        });
    } else {
        Log.e("EXAMPLE", "Failed to log in: " + it.getError().getErrorMessage());
    }
});

// instantiate a Realm App connection
val appID: String = YOUR_APP_ID // replace this with your App ID
val app = App(
    AppConfiguration.Builder(appID)
        .build()
)
// authenticate a user
val credentials = Credentials.anonymous()
app.loginAsync(
    credentials
) { it: App.Result<User?> ->
    if (it.isSuccess) {
        val user = it.get()
        // add an initial subscription to the sync configuration
        val config = SyncConfiguration.Builder(app.currentUser())
            .initialSubscriptions { realm, subscriptions ->
                subscriptions.add(
                    Subscription.create(
                        "subscriptionName",
                        realm.where(Frog::class.java)
                            .equalTo("species", "spring peeper")
                    )
                )
            }
            .build()
        // instantiate a realm instance with the flexible sync configuration
        Realm.getInstanceAsync(config, object : Realm.Callback() {
            override fun onSuccess(realm: Realm) {
                Log.v("EXAMPLE", "Successfully opened a realm.")
            }
        })
    } else {
        Log.e(
            "EXAMPLE",
            "Failed to log in: " + it.error.errorMessage
        )
    }
}

Tip

For more information about subscriptions, see Subscribe to Queryable Fields.

Importante

Synchronous Reads and Writes on the UI Thread

By default, you can only read or write to a realm in your application's UI thread using asynchronous transactions. That is, you can only use Realm methods whose name ends with the word Async in the main thread of your Android application unless you explicitly allow the use of synchronous methods.

Esta restricción existe en beneficio de los usuarios de tu aplicación: realizar operaciones de lectura y escritura en el hilo de la Interfaz de Usuario puede generar interacciones lentas o no respondidas en la Interfaz de Usuario, por lo que generalmente es mejor gestionar estas operaciones de manera asíncrona o en un hilo en segundo plano. Sin embargo, si tu aplicación requiere el uso de lecturas o escrituras de realm síncronas en el hilo de la IU, puedes permitir explícitamente el uso de métodos síncronos con las siguientes opciones SyncConfiguration:

SyncConfiguration config = new SyncConfiguration.Builder(app.currentUser())
        .allowQueriesOnUiThread(true)
        .allowWritesOnUiThread(true)
        .initialSubscriptions(new SyncConfiguration.InitialFlexibleSyncSubscriptions() {
            @Override
            public void configure(Realm realm, MutableSubscriptionSet subscriptions) {
                subscriptions.add(Subscription.create("springPeepers",
                        realm.where(Frog.class)
                            .equalTo("species", "spring peeper")));
            }
        })
        .build();
Realm.getInstanceAsync(config, new Realm.Callback() {
    @Override
    public void onSuccess(Realm realm) {
        Log.v( 
            "EXAMPLE",
            "Successfully opened a realm with reads and writes allowed on the UI thread.");
    }
});

val config = SyncConfiguration.Builder(app.currentUser())
    .allowQueriesOnUiThread(true)
    .allowWritesOnUiThread(true)
    .initialSubscriptions { realm, subscriptions ->
        subscriptions.add(
            Subscription.create(
                "subscriptionName",
                realm.where(Frog::class.java)
                    .equalTo("species", "springPeepers")
            )
        )
    }
    .build()
Realm.getInstanceAsync(config, object : Realm.Callback() {
    override fun onSuccess(realm: Realm) {
        Log.v(
            "EXAMPLE",
            "Successfully opened a realm with reads and writes allowed on the UI thread."
        )
    }
})

Open a Synced Realm While Offline

Puede abrir un realm sincronizado sin conexión utilizando la misma sintaxis exacta que utiliza para abrir un realm sincronizado en línea. No todos los SDKs siguen este patrón, por lo que los desarrolladores multiplataforma deben consultar la documentación de cada SDK para obtener más información.

Close a Realm

Es importante recordar llamar al método close() al terminar con una instancia de reino para liberar recursos. No cerrar los reinos puede generar un error.OutOfMemoryError

realm.close();

realm.close()

Volver

Sync Data

Administrar suscripciones de sincronización flexible