/ /

/ /

SDK de dispositivos Atlas

SDK de Java

Sincronizar datos

Configurar un dominio sincronizado - SDK de Java

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

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

Antes de poder acceder a un reino sincronizado desde el cliente, debe:

Habilitar la sincronización en la interfaz de usuario de App Services.
Inicializar la aplicación
Habilite la sincronización en su aplicación agregando lo siguiente al nivel superior de su archivo de nivel de aplicación build.gradle:
```
realm { syncEnabled = true }
```
Autenticar un usuario en su proyecto cliente.

Realms sincronizados

Los dominios sincronizados utilizan Atlas Device Sync para almacenar datos tanto en el dispositivo cliente como en la fuente de datos sincronizada. Abrir un dominio sincronizado funciona igual que abrir un dominio local, excepto que SyncConfiguration se usa para personalizar la configuración de los dominios sincronizados.

Configuración de reino sincronizado

Para configurar los ajustes de un reino, cree 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

Para obtener más información sobre las suscripciones, consulte Suscribirse a campos consultables.

Importante

Lecturas y escrituras sincrónicas en el hilo de interfaz de usuario

De forma predeterminada, solo se puede leer o escribir en un dominio en el hilo de interfaz de usuario de la aplicación mediante transacciones asíncronas. Es decir, solo se pueden usar Realm métodos cuyo nombre termine con la palabra Async en el hilo principal de la aplicación Android, a menos que se permita explícitamente el uso de métodos síncronos.

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."
        )
    }
})

Abrir un reino sincronizado sin conexión

Puedes abrir un reino sincronizado sin conexión con la misma sintaxis que para abrir un reino sincronizado con conexión. No todos los SDK siguen este patrón, por lo que los desarrolladores multiplataforma deben consultar la documentación de cada SDK para obtener más información.

Cerrar un reino

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

Sincronizar datos

Administrar suscripciones de sincronización flexible