Início rápido - SDK do Kotlin

Definir seu modelo de objeto

O modelo de dados do aplicativo define a estrutura de dados armazenados no Realm. Você pode definir o modelo de dados do seu aplicativo por meio de classes Kotlin no código do aplicativo com Realm Object Models.

Para definir o modelo de dados do aplicativo, adicione uma definição de classe ao código do aplicativo. O exemplo abaixo ilustra a criação de um modelo 'Item' que representa itens Todo em um aplicativo de lista Todo.

class Item() : RealmObject {
    @PrimaryKey
    var _id: ObjectId = ObjectId()
    var isComplete: Boolean = false
    var summary: String = ""
    var owner_id: String = ""
    constructor(ownerId: String = "") : this() {
        owner_id = ownerId
    }
}

Abrir um Realm

Use RealmConfiguration.create() para abrir um realm utilizando parâmetros padrão. Passe sua configuração para o construtor de fábrica do realm para gerar uma instância desse realm:

val config = RealmConfiguration.create(schema = setOf(Item::class))
val realm: Realm = Realm.open(config)

Para obter mais informações sobre como controlar as especificidades do RealmConfiguration que você gostaria de abrir (por exemplo. nome, localização, versão do esquema), consulte Abrir e fechar um idioma.

Criar, ler, atualizar e excluir objetos

Depois de aberto, você pode criar objetos dentro de um domínio em um bloco de transação de gravação.

Para criar uma nova Item, instancie uma instância da classe Item e adicione-a ao domínio em um bloco de transação de gravação:

realm.writeBlocking {
    copyToRealm(Item().apply {
        summary = "Do the laundry"
        isComplete = false
    })
}

Você pode recuperar uma coleção de todos os itens do Todo no realm com query.find():

// all items in the realm
val items: RealmResults<Item> = realm.query<Item>().find()

Você também pode filtrar uma coleção para recuperar uma coleção mais específica de objetos:

// items in the realm whose name begins with the letter 'D'
val itemsThatBeginWIthD: RealmResults<Item> =
    realm.query<Item>("summary BEGINSWITH $0", "D")
        .find()
//  todo items that have not been completed yet
val incompleteItems: RealmResults<Item> =
    realm.query<Item>("isComplete == false")
        .find()

Encontre mais informações sobre queries de string Realm em Filtrardados.

Para modificar um item Todo, atualize suas propriedades em um bloco de transação de escrita:

// change the first item with open status to complete to show that the todo item has been done
realm.writeBlocking {
    findLatest(incompleteItems[0])?.isComplete = true
}

Finalmente, você pode excluir um item Todo chamando mutableRealm.delete() em um bloco de transação de gravação:

// delete the first item in the realm
realm.writeBlocking {
    val writeTransactionItems = query<Item>().find()
    delete(writeTransactionItems.first())
}

Fique atento às mudanças

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

No exemplo a seguir, escutamos alterações em todos os objetos Item .

// flow.collect() is blocking -- run it in a background context
val job = CoroutineScope(Dispatchers.Default).launch {
    // create a Flow from the Item collection, then add a listener to the Flow
    val itemsFlow = items.asFlow()
    itemsFlow.collect { changes: ResultsChange<Item> ->
        when (changes) {
            // UpdatedResults means this change represents an update/insert/delete operation
            is UpdatedResults -> {
                changes.insertions // indexes of inserted objects
                changes.insertionRanges // ranges of inserted objects
                changes.changes // indexes of modified objects
                changes.changeRanges // ranges of modified objects
                changes.deletions // indexes of deleted objects
                changes.deletionRanges // ranges of deleted objects
                changes.list // the full collection of objects
            }
            else -> {
                // types other than UpdatedResults are not changes -- ignore them
            }
        }
    }
}

Mais tarde, quando terminar de observar, cancele o trabalho para cancelar o coroutine:

job.cancel() // cancel the coroutine containing the listener

Fechar um Realm

Para fechar um realm e todos os recursos subjacentes, chame realm.close(). O método close() bloqueia até que todas as transações de gravação no domínio tenham sido concluídas.

realm.close()

Adicionar Device Sync (opcional)

Esta seção ilustra como autenticar com um usuário anônimo e abrir um domínio de Flexible Sync para começar a sincronizar dados entre dispositivos.

val app = App.create(YOUR_APP_ID)

val credentials = Credentials.anonymous()
val user = app.login(credentials)

// create a SyncConfiguration
val config = SyncConfiguration.Builder(
    user,
    setOf(Item::class)
) // the SyncConfiguration defaults to Flexible Sync, if a Partition is not specified
    .initialSubscriptions { realm ->
        add(
            realm.query<Item>(
                "owner_id == $0", // owner_id == the logged in user
                user.id
            ),
            "User's Items"
        )
    }
    .build()
val realm = Realm.open(config)

Próximo: Confira os aplicativos de modelo e o tutorial

Confira o template app para experimentar outra maneira rápida de começar a programar com o Realm Kotlin SDK. O modelo Kotlin SDK, denominado android.kotlin.todo.flex, é um aplicativo predefinido que integra o Realm e o Atlas Device Sync em um aplicativo Android personalizável.

Como alternativa, se você estiver interessado em uma experiência guiada, leia nosso tutorial do Kotlin SDK, que expande o aplicativo modelo.