Menu Docs
Página inicial do Docs
/
MongoDB Atlas
/
Atlas Device SDKs
/
SDK Kotlin
/
Sincronizar dados do dispositivo

Configurar e abrir um domínio sincronizado - Realm Kotlin SDK

Nesta página

  • Pré-requisitos
  • Abrir um realm sincronizado
  • Configurar um realm sincronizado
  • Baixe as alterações antes de abrir
  • Baixe as alterações condicionalmente antes de abrir
  • Abrir um Realm Offline Sincronizado

Esta página descreve como abrir um reconhecimento de data center sincronizado e as várias opções de configuração disponíveis.

Pré-requisitos

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

  1. Ative a sincronização na interface do usuário do Atlas App Services .

  2. Instale a distribuição de sincronização do Kotlin SDK para Android ou do Kotlin Multiplatform.

  3. Autenticar um usuário em seu projeto de cliente.

Abrir um realm sincronizado

Para abrir um Realm de Flexible Sync , passe um usuário e um conjunto de esquemas de Objeto de Realm para SyncConfiguration.Builder(). Em seguida, crie um conjunto de assinaturas iniciais com o método de construtor initialSubscriptions() . Por fim, passe a configuração para Realm.open() para abrir uma instância do Realm:

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

Para obter mais informações sobre como inicializar o Realm com assinaturas iniciais e gerenciar suas assinaturas de Realm sincronizadas, consulte managed assinaturas de sincronização.

Configurar um realm sincronizado

Para ajustar definições de configuração específicas, use as opções fornecidas por 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()
}

Novo na versão 1,13,0: Opções de configuração de tempo limite de sincronização adicionadas

No Kotlin v1.13.0, você pode substituir vários tempos limite padrão usados para operações de sincronização. Você pode definir esses tempos limite na configuração do cliente App e eles se aplicam a todas as sessões de sincronização no aplicativo. Para saber como, consulte Configurar tempos limite de sincronização.

Baixe as alterações antes de abrir

Ao abrir um Realm sincronizado com o Kotlin SDK, você pode usar o .waitForInitialRemoteData() função para baixar o changeset do seu aplicativo antes de abrir o Realm. Essa configuração bloqueia a abertura do Realm até que todos os dados tenham sido baixados. Se um dispositivo estiver off-line, isso bloqueará a abertura do Realm. Como o download inicial de dados pode ser uma operação demorada, abra um Realm usando essa configuração em um thread em background.

Esta função aceita um tempo limite de duração. Quando o download excede uma duração de tempo limite, o Realm lança uma 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()

Baixe as alterações condicionalmente antes de abrir

Se houver uma condição que determine se seu aplicativo deve baixar os dados do servidor antes de abrir o domínio, você poderá usá-la com SyncSession.downloadAllServerChanges() para baixar condicionalmente as alterações antes de abrir o domínio. A chamada desse método bloqueia até que todas as alterações remotas conhecidas tenham sido baixadas e aplicadas ao Realm, ou até que um tempo limite especificado seja atingido. Você deve chamar esse método somente a partir de um thread que não seja da UI.

Esta função aceita uma duração de tempo limite.

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()

Abrir um Realm Offline Sincronizado

Quando seu aplicativo Realm autentica um usuário, armazena em cache as credenciais do usuário. Você pode verificar as credenciais de usuário existentes para ignorar o fluxo de login e acessar o usuário em cache. Use isto para abrir um realm offline.

Observação

O login inicial exige uma conexão de rede

Quando um usuário se inscreve em seu aplicativo ou faz login pela primeira vez com uma conta existente em um cliente, o cliente deve ter uma conexão de rede. A verificação de credenciais de usuário em cache permite que você abra um domínio offline, mas somente se o usuário já tiver feito login enquanto estiver online.

Você só pode abrir um Realm sincronizado offline se não exigir que seu aplicativo cliente baixe as alterações antes de abrir o 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()

Voltar

Adicionar sincronização a um aplicativo

Próximo

Gerir subscrições