Menu Docs
Página inicial do Docs
/ /
Atlas Device SDKs
/ /

Configurar e abrir um Realm - SwiftUI

Nesta página

  • Abra um Realm com uma configuração
  • Abrir um realm sincronizado
  • Faça o download das alterações antes de abrir um domínio sincronizado
  • Abrir um Realm Offline Sincronizado

O Swift SDK fornece wrappers de propriedade para abrir um domínio de forma compatível com o SwiftUI.

Você pode:

  • Abra implicitamente um realm com um defaultConfiguration ou especifique uma configuração diferente. Isso funciona para domínios não sincronizados e sincronizados.

  • Sempre baixe as alterações antes de abrir um domínio sincronizado, que expira quando o usuário está offline.

  • Abra um domínio sincronizado mesmo quando um usuário estiver offline. O domínio pode não ter os dados mais recentes.

Quando utiliza @ObservedRealmObject ou @ObservedResults, estes wrappers de propriedade abrem implicitamente um domínio e recuperam os objetos ou resultados especificados.

// Implicitly use the default realm's objects(Dog.self)
@ObservedResults(Dog.self) var dogs

Observação

O invólucro de propriedades @ObservedResults deve ser usado em uma visualização SwiftUI. Se você quiser observar os resultados em um modelo de exibição, registre um ouvinte de alterações.

Quando você não especifica uma configuração, esses wrappers de propriedade usam o defaultConfiguration. Você pode definir a defaultConfiguration globalmente, e os wrappers de propriedade na aplicação podem usar essa configuração quando abrem implicitamente um realm.

Você pode fornecer configurações alternativas que os wrappers de propriedade usam para abrir implicitamente o domínio. Talvez você queira fazer isso ao usar várias configurações em seu aplicativo, como nos casos em que você tem uma SyncConfiguration e uma Configuration local. Para fazer isso, crie configurações explícitas. Em seguida, use a injeção de ambiente para passar as respectivas configurações para as visualizações que precisam delas. Passar uma configuração para uma visualização em que os wrappers de propriedade abrem um domínio usa a configuração passada em vez do defaultConfiguration.

Novidades na versão 10,12,0.

Esses wrappers de propriedade SwiftUI abrem domínios sincronizados e preenchem visualizações. A principal diferença entre esses wrappers de propriedade é se o usuário deve estar online:

  • Para baixar atualizações do seu aplicativo Atlas App Services antes de abrir um domínio, use o wrapper de propriedade @AsyncOpen . Isso exige que o usuário tenha uma conexão de rede.

  • Para abrir um domínio sincronizado independentemente de o usuário ter uma conexão de rede, use o wrapper de propriedade @AutoOpen . Esse wrapper de propriedade permite que os desenvolvedores criem recursos offline em seus aplicativos.

Dica

Migrar para a Flexible Sync

Você pode migrar automaticamente seu Atlas App Services Device Sync Mode da Partition-Based Sync para a Flexible Sync. Isso permite que você aproveite as assinaturas e permissões do Flexible Sync mais expressivas e granulares para gerenciar quais dados sincronizados seus usuários podem ler e escrever. Para obter mais informações, consulte Migrar da Partition-Based Sync para a Flexible Sync.

Use o wrapper de propriedade @AsyncOpen para aplicativos que exigem informações atualizadas do servidor, como aplicativos de jogos com tabelas de classificação ao vivo que o usuário pode jogar em vários dispositivos. Isso garante que o usuário nunca use o aplicativo com dados obsoletos.

Novidades na versão 10.27.0.

Realm Swift SDK versão 10.27.0 adiciona versões Flexible Sync dos wrappers de propriedades para abrir o Realm com o SwiftUI. Você pode adicionar queries de assinatura no .onAppear depois de abrir o domínio.

@AsyncOpen(appId: flexibleSyncAppId, timeout: 4000) var asyncOpen

Novidades na versão 10.28.0.

Você pode criar uma flexibleSyncConfiguration() com o parâmetro initialSubscriptions . Você pode usar este parâmetro para assinar queries do Flexible Sync na configuração. Se isso for executado mais de uma vez - por exemplo, se estiver em uma visualização que é recarregada regularmente - verifique se a assinatura já existe antes de adicioná-la. Adicionar a mesma assinatura novamente exibe um erro.

// Create a `flexibleSyncConfiguration` with `initialSubscriptions`.
// We'll inject this configuration as an environment value to use when opening the realm
// in the next view, and the realm will open with these initial subscriptions.
let config = user.flexibleSyncConfiguration(initialSubscriptions: { subs in
let peopleSubscriptionExists = subs.first(named: "people")
let dogSubscriptionExists = subs.first(named: "dogs")
// Check whether the subscription already exists. Adding it more
// than once causes an error.
if (peopleSubscriptionExists != nil) && (dogSubscriptionExists != nil) {
// Existing subscriptions found - do nothing
return
} else {
// Add queries for any objects you want to use in the app
// Linked objects do not automatically get queried, so you
// must explicitly query for all linked objects you want to include.
subs.append(QuerySubscription<Person>(name: "people"))
subs.append(QuerySubscription<Dog>(name: "dogs"))
}
})

Em seguida, passe a configuração para a visualização que contém os wrappers de propriedade como um objeto de ambiente.

OpenFlexibleSyncRealmView()
.environment(\.realmConfiguration, config)

Para obter um exemplo completo, consulte o Início Rápido da SwiftUI.

Para abrir um realm com a Sincronização Baseada em Partição, adicione um partitionValue ao wrapper de propriedade:

@AsyncOpen(appId: YOUR_APP_SERVICES_APP_ID_HERE, partitionValue: "", timeout: 4000) var asyncOpen

Este invólucro de propriedade SwiftUI inicia Realm.asyncOpen() para o usuário atual. O wrapper da propriedade publica estados, representados pelo enum AsyncOpenState, que você pode usar para atualizar a visualização.

Exemplo

Este exemplo ilustra uma maneira de usar @AsyncOpen para abrir um realm em uma visualização. Primeiro, verifique se há um usuário ou faça login. Em seguida, tente abrir o domínio, ativando o AsyncOpenState para exibir uma visualização apropriada. Quando o realm for aberto com sucesso, injete-o como um valor de ambiente para preencher a visualização.

/// This view opens a synced realm.
struct OpenFlexibleSyncRealmView: View {
// We've injected a `flexibleSyncConfiguration` as an environment value,
// so `@AsyncOpen` here opens a realm using that configuration.
@AsyncOpen(appId: flexibleSyncAppId, timeout: 4000) var asyncOpen
var body: some View {
switch asyncOpen {
// Starting the Realm.asyncOpen process.
// Show a progress view.
case .connecting:
ProgressView()
// Waiting for a user to be logged in before executing
// Realm.asyncOpen.
case .waitingForUser:
ProgressView("Waiting for user to log in...")
// The realm has been opened and is ready for use.
// Show the content view.
case .open(let realm):
// Do something with the realm
UseRealmView(realm: realm)
// The realm is currently being downloaded from the server.
// Show a progress view.
case .progress(let progress):
ProgressView(progress)
// Opening the Realm failed.
// Show an error view.
case .error(let error):
ErrorView(error: error)
}
}
}
/// This view opens a synced realm.
struct OpenPartitionBasedSyncRealm: View {
// @AsyncOpen attempts to connect to the server and download remote changes
// before the realm opens. If there is no network connection,
// AsyncOpen cannot load changes and the realm does not open.
// We can use an empty string as the partitionValue here because we're
// injecting the user.id as an environment value from the LoginView.
@AsyncOpen(appId: YOUR_APP_SERVICES_APP_ID_HERE, partitionValue: "", timeout: 4000) var asyncOpen
var body: some View {
switch asyncOpen {
// Starting the Realm.asyncOpen process.
// Show a progress view.
case .connecting:
ProgressView()
// Waiting for a user to be logged in before executing
// Realm.asyncOpen.
case .waitingForUser:
ProgressView("Waiting for user to log in...")
// The realm has been opened and is ready for use.
// Show the content view.
case .open(let realm):
// Do something with the realm
UseRealmView(realm: realm)
// The realm is currently being downloaded from the server.
// Show a progress view.
case .progress(let progress):
ProgressView(progress)
// Opening the Realm failed.
// Show an error view.
case .error(let error):
ErrorView(error: error)
}
}
}

Como @AsyncOpen, o @AutoOpen tenta baixar as atualizações antes de abrir o domínio. No entanto, se uma conexão de rede não estiver disponível, esse método abrirá um domínio com dados no dispositivo.

Use esse wrapper de propriedade para aplicativos em que não seja um problema para o usuário trabalhar com dados potencialmente obsoletos, como aplicativos de anotações em que os usuários devem poder trabalhar com dados no dispositivo

@AutoOpen(appId: "app_id") var autoOpen
@AutoOpen(appId: "app_id", partitionValue: <partition_value>) var autoOpen

Este invólucro de propriedades da SwiftUI tenta baixar as atualizações antes de abrir um domínio para o usuário atual. Se não houver conexão com a Internet, esse wrapper de propriedade retornará a versão mais atualizada do arquivo de realm local para a configuração appId fornecida e a Flexible Sync ou a Partition-Based Sync.

O wrapper da propriedade publica estados, representados pelo enum AsyncOpenState, que você pode usar para atualizar a visualização. Para obter um exemplo completo, consulte os exemplos de código @AsyncOpen acima.

Voltar

Alterar um modelo de objeto

Próximo

Reagir às alterações