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

Início rápido - Swift SDK

Nesta página

  • Importar Realm
  • Definir seu modelo de objeto
  • Abrir um Realm
  • Criar, ler, atualizar e excluir objetos
  • Fique atento às mudanças
  • Adicionar Device Sync (opcional)
  • Pré-requisitos
  • Inicialize o aplicativo
  • Autenticar um usuário
  • Abrir um Realm

Este Início Rápido demonstra como usar o Realm com o Realm Swift SDK. Antes de começar, certifique-se de ter instalado o Swift SDK.

Dica

Veja também:

Se o seu aplicativo usa SwiftUI, confira o Início Rápido do SwiftUI.

Importar Realm

Perto da parte superior de qualquer arquivo Swift que use o Realm, adicione a seguinte declaração de importação:

import RealmSwift

Definir seu modelo de objeto

Para um domínio somente local, você pode definir seu modelo de objeto diretamente no código. Neste início rápido, você pode remover o ownerId, a menos que queira adicionar o Device Sync opcional.

class Todo: Object {
   @Persisted(primaryKey: true) var _id: ObjectId
   @Persisted var name: String = ""
   @Persisted var status: String = ""
   @Persisted var ownerId: String
   convenience init(name: String, ownerId: String) {
       self.init()
       self.name = name
       self.ownerId = ownerId
   }
}

Abrir um Realm

Em um realm somente local, a opção mais simples para abrir um realm é usar o realm padrão sem nenhum parâmetro de configuração:

// Open the local-only default realm
let realm = try! Realm()

Você também pode especificar um parâmetro Realm.Configuration para abrir um Realm em uma URL de arquivo específica , na memória ou com um subconjunto de classes.

Para mais informações, consulte: Configurar e Abrir um Realm.

Criar, ler, atualizar e excluir objetos

Depois de abrir um realm, você pode modificá-lo e seus objetos em um bloco de transação de gravação .

Para criar um novo objeto de Todo, instancie a classe de Todo e adicione-a ao domínio em um bloco de gravação:

let todo = Todo(name: "Do laundry", ownerId: user.id)
try! realm.write {
    realm.add(todo)
}

Você pode recuperar uma coleção ao vivo de todos no domínio:

// Get all todos in the realm
let todos = realm.objects(Todo.self)

Você também pode filtrar essa coleção usando onde:

let todosInProgress = todos.where {
    $0.status == "InProgress"
}
print("A list of all todos in progress: \(todosInProgress)")

Para modificar uma tarefa, atualize suas propriedades em um bloco de transação de gravação:

// All modifications to a realm must happen in a write block.
let todoToUpdate = todos[0]
try! realm.write {
    todoToUpdate.status = "InProgress"
}

Por fim, você pode excluir uma tarefa:

// All modifications to a realm must happen in a write block.
let todoToDelete = todos[0]
try! realm.write {
    // Delete the Todo.
    realm.delete(todoToDelete)
}

Fique atento às mudanças

Você pode assistir a um domínio, coleção ou objeto para alterações com o método observe.

// Retain notificationToken as long as you want to observe
let notificationToken = todos.observe { (changes) in
    switch changes {
    case .initial: break
        // Results are now populated and can be accessed without blocking the UI
    case .update(_, let deletions, let insertions, let modifications):
        // Query results have changed.
        print("Deleted indices: ", deletions)
        print("Inserted indices: ", insertions)
        print("Modified modifications: ", modifications)
    case .error(let error):
        // An error occurred while opening the Realm file on the background worker thread
        fatalError("\(error)")
    }
}

Certifique-se de reter o token de notificação retornado por observe enquanto quiser continuar observando. Quando terminar de observar, invalide o token para liberar os recursos:

// Invalidate notification tokens when done observing
notificationToken.invalidate()

Adicionar Device Sync (opcional)

Se você deseja sincronizar dados do Realm entre dispositivos, você pode configurar um aplicativo do Atlas App Services e habilitar a Device Sync. Para obter mais informações sobre o que você pode fazer com o App Services, consulte: App Services - Swift SDK.

Pré-requisitos

Antes de sincronizar os dados do Realm, você deve:

Inicialize o aplicativo

Para usar as funcionalidades do App Services, como autenticação e sincronização, acesse o App Services App usando seu ID do aplicativo. O ID do aplicativo está disponível na UI do App Services.

let app = App(id: APP_ID) // Replace APP_ID with your Atlas App ID

Autenticar um usuário

Neste início rápido, você usa a autenticação anônima para fazer login de usuários sem exigir que eles forneçam nenhuma informação de identificação. Depois de autenticar o usuário, você poderá abrir um domínio para esse usuário.

do {
    let user = try await app.login(credentials: Credentials.anonymous)
    print("Successfully logged in user: \(user)")
    await openSyncedRealm(user: user)
} catch {
    print("Error logging in: \(error.localizedDescription)")
}

O Realm Swift SDK oferece muitas maneiras adicionais de autenticar, registrar e vincular usuários.Swift Para outros provedores de autenticação, consulte: Autenticar usuários - Swift SDK

Abrir um Realm

Depois de ativar a Device Sync e autenticar um usuário, você pode criar um objeto Configuration e abrir o domínio. Em seguida, você pode adicionar uma assinatura do Flexible Sync que determina quais dados o domínio pode ler e gravar.

Uma vez que você tenha um realm com uma assinatura, este exemplo passa o realm e o usuário para outra função na qual você pode usar o realm.

Dica

Se a sua aplicação acessar Realm em um contexto do async/await, marque o código com @MainActor para evitar falhas relacionadas a threading.

// Opening a realm and accessing it must be done from the same thread.
// Marking this function as `@MainActor` avoids threading-related issues.
@MainActor
func openSyncedRealm(user: User) async {
    do {
        var config = user.flexibleSyncConfiguration()
        // Pass object types to the Flexible Sync configuration
        // as a temporary workaround for not being able to add a
        // complete schema for a Flexible Sync app.
        config.objectTypes = [Todo.self]
        let realm = try await Realm(configuration: config, downloadBeforeOpen: .always)
        // You must add at least one subscription to read and write from a Flexible Sync realm
        let subscriptions = realm.subscriptions
        try await subscriptions.update {
            subscriptions.append(
                QuerySubscription<Todo> {
                    $0.ownerId == user.id
                })
        }
        await useRealm(realm: realm, user: user)
    } catch {
        print("Error opening realm: \(error.localizedDescription)")
    }
}

A sintaxe para ler, gravar e observar alterações em um domínio sincronizado é idêntica à sintaxe para domínios não sincronizados acima. Enquanto você trabalha com dados locais, um thread faz a integração, envia e baixa conjuntos de alterações no background.

Cada transação de escrita para um conjunto de assinaturas tem um custo de desempenho. Se você precisar fazer várias atualizações em um objeto do Realm durante uma sessão, considere manter objetos editados na memória até que todas as alterações sejam concluídas. Isso melhora o desempenho da sincronização, gravando apenas o objeto completo e atualizado em seu domínio, em vez de cada alteração.

Próximo

Bem-vindo aos Docs do Atlas Device SDK