Configurar um Realm sincronizado - Java SDK

Nesta página

Pré-requisitos

Domínios sincronizados
Configuração de Realm sincronizada
Abrir um Realm sincronizado enquanto estiver offline
Fechar um Realm

Os Atlas Device SDKs estão obsoletos. Consulte apágina de descontinuação do para detalhes.

Observação

Novas aplicações Java SDK não podem usar RealmAny

Os novos aplicativos App Services não poderão sincronizar modelos de dados com propriedades do tipo RealmAny.

Pré-requisitos

Antes de acessar um Realm sincronizado do cliente, você deve:

Ative a sincronização na interface do usuário do Atlas App Services .
Inicialize o aplicativo
Habilite a sincronização em seu aplicativo adicionando o seguinte ao nível superior do seu arquivo build.gradle no nível do aplicativo:
```
realm { syncEnabled = true }
```
Autenticar um usuário em seu projeto de cliente.

Domínios sincronizados

Os domínios sincronizados usam o Atlas Device Sync para armazenar dados no dispositivo cliente e na sua fonte de dados sincronizada. A abertura de um domínio sincronizado funciona exatamente como a abertura de um domínio local, exceto que você usa SyncConfiguration para personalizar as configurações dos domínios sincronizados.

Configuração de Realm sincronizada

Para definir as configurações de um realm, crie uma SyncConfiguration com um SyncConfiguration.Builder.

Para abrir um domínio sincronizado, chame getInstanceAsync(), passando um objeto SyncConfiguration .

Quando seu aplicativo usar o Flexible Sync, chame o método construtor de configuração de sincronização initialSubscriptions() com uma instância de SyncConfiguration.InitialFlexibleSyncSubscriptions() para abrir um domínio sincronizado. No método configure() , instancie um UnmanagedSubscription com um nome e uma query usando Subscription.create(). Passe sua nova assinatura para o método add() do parâmetro MutableSubscriptionSet para adicioná-la às suas assinaturas:

// 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
        )
    }
}

Dica

Veja também:

Para obter mais informações sobre assinaturas, consulte Inscrever-se em campos de query.

Importante

Leituras e gravações síncronas na thread da interface do usuário

Por padrão, você só pode ler ou escrever em um realm no thread da UI do aplicativo usando transações assíncronas. Ou seja, você só pode usar métodos Realm cujo nome termina com a palavra Async no thread principal do seu aplicativo Android, a menos que você permita explicitamente o uso de métodos síncronos.

Essa restrição existe para o benefício dos usuários do aplicativo: executar operações de leitura e escrita no thread da interface do usuário pode levar a interações de interface do usuário não responsivas ou lentas, portanto, geralmente é melhor lidar com essas operações de forma assíncrona ou em um thread de fundo. No entanto, se o seu aplicativo exigir o uso de leituras ou gravações síncronas de realm no thread da interface do usuário, você poderá permitir explicitamente o uso de métodos síncronos com as seguintes opções 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 um Realm sincronizado enquanto estiver offline

Você pode abrir um Realm quando estiver offline com exatamente a mesma sintaxe que você usa para abrir um Realm enquanto estiver online. Nem todos os SDKs seguem esse padrão, portanto, os desenvolvedores de plataformas cruzadas devem consultar a documentação de cada SDK para saber mais.

Fechar um Realm

É importante lembrar de chamar o método close () quando terminar com uma instância de realm para liberar recursos. Negligenciar o fechamento de realms pode levar a um OutOfMemoryError.

realm.close();

realm.close()

Voltar

Sincronizar dados

Gerenciar assinaturas de sincronização flexível