Inicio rápido - SDK de Kotlin

Define tu modelo de objeto

El modelo de datos de su aplicación define la estructura de los datos almacenados en Realm. Puede definirlo mediante clases Kotlin en el código de su aplicación con los Modelos de Objetos de Realm.

Para definir el modelo de datos de su aplicación, agregue una definición de clase al código de la misma. El siguiente ejemplo ilustra la creación de un modelo "Elemento" que representa los elementos de la lista de tareas pendientes en una aplicación de lista de tareas pendientes.

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 un reino

Usa RealmConfiguration.create() para abrir un reino con los parámetros predeterminados. Pasa tu configuración al constructor de la fábrica de reinos para generar una instancia de ese reino:

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

Para obtener más información sobre cómo controlar los detalles de la RealmConfiguration que desea abrir (por ejemplo, nombre, ubicación, versión del esquema), consulte Abrir y cerrar un Realm.

Crear, leer, actualizar y eliminar objetos

Una vez abierto, puede crear objetos dentro de un reino en un bloque de transacción de escritura.

Para crear un nuevo Item, cree una instancia de la clase Item y agréguela al reino en un bloque de transacción de escritura:

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

Puede recuperar una colección de todos los elementos de Todo en el reino con query.find():

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

También puede filtrar una colección para recuperar una colección de objetos más específica:

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

Encuentre más información sobre las consultas de cadenas Realm en Filtrar datos.

Para modificar un elemento de Todo, actualice sus propiedades en un bloque de transacción de escritura:

// 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, puedes eliminar un elemento Todo llamando a mutableRealm.delete() en un bloque de transacción de escritura:

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

Esté atento a los cambios

Puedes observar un reino, una colección o un objeto para detectar cambios con el observe .

En el siguiente ejemplo, escuchamos cambios en todos los 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
            }
        }
    }
}

Más tarde, cuando haya terminado de observar, cancele el trabajo para cancelar la corrutina:

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

Cerrar un reino

Para cerrar un dominio y todos los recursos subyacentes, llame a realm.close().El close() método se bloquea hasta que se completen todas las transacciones de escritura en el dominio.

realm.close()

Agregar sincronización de dispositivos (opcional)

Esta sección ilustra cómo autenticarse con un usuario anónimo y abrir un reino de sincronización flexible para comenzar a sincronizar datos 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)

Siguiente: Consulta las aplicaciones de plantilla y el tutorial

Consulta la aplicación de plantilla para experimentar con otra forma rápida de empezar a programar con el SDK de Kotlin de Realm. La plantilla del SDK de Kotlin, etiquetada android.kotlin.todo.flex como, es una aplicación prediseñada que integra Realm y Atlas Device Sync en una aplicación Android personalizable.

Alternativamente, si está interesado en una experiencia guiada, puede leer nuestro tutorial de Android con Kotlin SDK que amplía la aplicación de plantilla.