Agrupar um Realm - Kotlin SDK

Preencher um Realm de ativo com dados de semente

1. Crie um novo projeto temporário para criar e preencher um Realm de ativo com dados de semente. Esse projeto usa o mesmo esquema de objetos do Realm que seu aplicativo de produção.

2. Abra um domínio existente com os dados que deseja semear ou crie um novo domínio. Defina um nome específico para o domínio do seu ativo para que você possa consultá-lo pelo nome como a fonte de dados inicial do seu aplicativo.

3. Preencha o Realm do ativo com os dados iniciais que você deseja incluir em sua aplicação de produção.

   Você pode obter o caminho para o arquivo de domínio do ativo usando Realm.configuration.path.

// Open a local realm to use as the asset realm
val config = RealmConfiguration.Builder(schema = setOf(Item::class))
    .name("asset.realm")
    .build()
val assetRealm = Realm.open(config)
assetRealm.writeBlocking {
    // Add seed data to the asset realm
    copyToRealm(Item().apply {
        summary = "Write an awesome app"
        isComplete = false
    })
}
// Verify the data in the existing realm
// (this data should also be in the bundled realm we open later)
val originalItems: RealmResults<Item> = assetRealm.query<Item>().find()
for(item in originalItems) {
    Log.v("Item in the assetRealm: ${item.summary}")
}
// Get the path to the realm
Log.v("Realm location: ${config.path}")
assetRealm.close()

Agora que você tem um Realm, pode movê-lo para sua aplicação de produção e usá-lo lá.

Agrupe e abra o Arquivo de Realm em sua aplicação de produção

1. Salve a cópia do arquivo de Realm de ativo em seu aplicação de produção. Você deve colocar este arquivo de ativo no local apropriado para a plataforma do seu aplicativo. Para obter detalhes, consulte Localizações do Realm de Ativos por Plataforma.

2. Crie uma configuração que seu aplicativo de produção possa usar para abrir o Realm do ativo. Defina a propriedade initialRealmFile nesta configuração como o nome do seu Realm de ativos.

   Opcionalmente, você pode fornecer um sha256checkSum para o initialRealmFile para verificar a integridade do Arquivo de Realm ao abri-lo. Se você fornecer uma soma de verificação que não corresponde à soma de verificação calculada do arquivo de ativo quando você abrir o domínio de semente, Realm.open() falhará com um IllegalArgumentException.

3. Com essa configuração, você pode abrir o Realm de ativos agrupado. Ele contém os dados que estavam no Realm do ativo no momento em que você o copiou.

// The config should list the bundled asset realm as the initialRealmFile
val bundledRealmConfig = RealmConfiguration.Builder(schema = setOf(Item::class))
    .initialRealmFile("asset.realm")
    .build()
// After moving the bundled realm to the appropriate location for your app's platform,
// open and use the bundled realm as usual.
val bundledRealm = Realm.open(bundledRealmConfig)
val bundledItems: RealmResults<Item> = bundledRealm.query<Item>().find()
for(item in bundledItems) {
    Log.v("Item in the bundledRealm: ${item.summary}")
}
bundledRealm.close()

Preencher um Realm de ativo com dados de semente

1. Crie um novo projeto temporário para criar e preencher o Realm do ativo. Esse projeto usa o mesmo esquema de objetos do Realm que seu aplicativo de produção.

2. Abra o Realm sincronizado que você deseja utilizar como um Realm de ativo.

3. Preencha o Realm de ativo com os dados iniciais que você deseja incluir em seu aplicação de produção. Você deve aguardar que todas as alterações locais sejam sincronizadas com o servidor do Device Sync . Use uploadAllLocalChanges() e downloadAllServerChanges() para garantir que todos os processos de sincronização sejam concluídos.

val app = App.create(yourFlexAppId)
// Login with user that has the server-side permissions to
// read and write the data you want in the asset realm
val user = app.login(credentials)
// Create a SyncConfiguration to open a synced realm to use as the asset realm
val assetRealmConfig = SyncConfiguration.Builder(user, setOf(Item::class))
    .name("asset.realm")
    // Add a subscription that matches the data being added
    // and your app's backend permissions
    .initialSubscriptions{ realm ->
        add(
            realm.query<Item>("isComplete == $0", false), "Incomplete Items")
    }
    .build()
val assetRealm = Realm.open(assetRealmConfig)
assetRealm.subscriptions.waitForSynchronization(10.seconds)
assertEquals(SubscriptionSetState.COMPLETE, assetRealm.subscriptions.state)
assetRealm.writeBlocking {
    // Add seed data to the synced realm
    copyToRealm(Item().apply {
        summary = "Make sure the app has the data it needs"
        isComplete = false
    })
}
// Verify the data in the existing realm
// (this data should also be in the bundled realm we open later)
val assetItems: RealmResults<Item> = assetRealm.query<Item>().find()
for(item in assetItems) {
    Log.v("Item in the assetRealm: ${item.summary}")
}
// IMPORTANT: Sync all changes with server before copying the synced realm
assetRealm.syncSession.uploadAllLocalChanges(30.seconds)
assetRealm.syncSession.downloadAllServerChanges(30.seconds)

Criar uma cópia do Realm do ativo

Você deve criar uma cópia do Realm do ativo a partir do projeto temporário que você pode agrupar com sua aplicação de produção.

1. Crie uma SyncConfiguration que seu aplicativo pode usar para abrir uma cópia do Realm de ativos. Defina a propriedade initialRealmFile nesta configuração como o nome do seu Realm de ativos.

   Opcionalmente, você pode fornecer um sha256checkSum para o initialRealmFile para verificar a integridade do Arquivo de Realm ao abri-lo. Se você fornecer uma soma de verificação que não corresponde à soma de verificação calculada do domínio de semente quando você abri-lo, o Realm.open() falhará com um IllegalArgumentException.

   // Create a SyncConfiguration for the bundled copy.
   // The initialRealmFile value is the `name` property of the asset realm you're bundling.
   val copyConfig = SyncConfiguration.Builder(user, setOf(Item::class))
       .initialRealmFile("asset.realm")
       .build()

2. Crie uma nova versão do domínio sincronizado usando writeCopyTo() . Você deve usar writeCopyTo() para agrupar um domínio sincronizado. Este método remove metadados que associam o domínio ao usuário, o que permite que outros usuários abram o arquivo de domínio também.

   Obtenha o caminho para o arquivo de domínio copiado usando Realm.configuration.path.

   // Copy the synced realm with writeCopyTo()
   assetRealm.writeCopyTo(copyConfig)
   // Get the path to the copy you just created.
   // You must move this file into the appropriate location for your app's platform.
   Log.v("Bundled realm location: ${copyConfig.path}")
   assetRealm.close()

Agora que você tem uma cópia do Realm, pode movê-lo para sua aplicação de produção e usá-lo lá.

Agrupar e abrir um Arquivo de Realm sincronizado em sua aplicação de produção

1. Salve a cópia do arquivo de Realm de ativo em seu aplicação de produção. Você deve colocar este arquivo de ativo no local apropriado para a plataforma do seu aplicativo. Para obter detalhes, consulte Localizações do Realm de Ativos por Plataforma.

2. Agora que você tem uma cópia do Realm de ativos fornecido com seu aplicativo, você pode abri-lo usando a configuração de Realm copiada que você criou. Ele contém os dados que estavam no Realm do ativo no momento em que você o copiou.

// After moving the bundled realm to the appropriate location for your app's platform,
// open and use the bundled realm as usual.
val copiedRealm = Realm.open(copyConfig)
// This should contain the same Items as in the asset realm
val copiedItems: RealmResults<Item> = copiedRealm.query<Item>().find()
for(item in copiedItems) {
    Log.v("Item in the copiedRealm: ${item.summary}")
}
copiedRealm.close()