Reaccionar a los cambios - SDK de Kotlin

// Listen for changes on whole collection
val characters = realm.query(Character::class)
// flow.collect() is blocking -- run it in a background context
val job = CoroutineScope(Dispatchers.Default).launch {
    // create a Flow from that collection, then add a listener to the Flow
    val charactersFlow = characters.asFlow()
    val subscription = charactersFlow.collect { changes: ResultsChange<Character> ->
        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
            }
        }
    }
}
// Listen for changes on RealmResults
val hobbits = realm.query(Character::class, "species == 'Hobbit'")
val hobbitJob = CoroutineScope(Dispatchers.Default).launch {
    val hobbitsFlow = hobbits.asFlow()
    val hobbitsSubscription = hobbitsFlow.collect { changes: ResultsChange<Character> ->
        // ... all the same data as above
    }
}

// query for the specific object you intend to listen to
val frodo = realm.query(Character::class, "name == 'Frodo'").first()
// flow.collect() is blocking -- run it in a background context
val job = CoroutineScope(Dispatchers.Default).launch {
    val frodoFlow = frodo.asFlow()
    frodoFlow.collect { changes: SingleQueryChange<Character> ->
        when (changes) {
            is UpdatedObject -> {
                changes.changedFields // the changed properties
                changes.obj // the object in its newest state
                changes.isFieldChanged("name") // check if a specific field changed in value
            }
            is DeletedObject -> {
                // if the object has been deleted
                changes.obj // returns null for deleted objects -- always reflects newest state
            }
            is InitialObject -> {
                // Initial event observed on a RealmObject or EmbeddedRealmObject flow.
                // It contains a reference to the starting object state.
                changes.obj
            }
            is PendingObject -> {
                // Describes the initial state where a query result does not contain any elements.
                changes.obj
            }
        }
    }
}

// query for the specific object you intend to listen to
val fellowshipOfTheRing = realm.query(Fellowship::class, "name == 'Fellowship of the Ring'").first().find()!!
val members = fellowshipOfTheRing.members
// flow.collect() is blocking -- run it in a background context
val job = CoroutineScope(Dispatchers.Default).launch {
    val membersFlow = members.asFlow()
    membersFlow.collect { changes: ListChange<Character> ->
        when (changes) {
            is UpdatedList -> {
                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
            }
            is DeletedList -> {
                // if the list was deleted
            }
            is InitialList -> {
                // Initial event observed on a RealmList flow. It contains a reference
                // to the starting list state.
                changes.list
            }
        }
    }
}

runBlocking {
    // Query for the specific object you intend to listen to.
    val frodoQuery = realm.query(Character::class, "name == 'Frodo'").first()
    val observer = async {
        val frodoFlow = frodoQuery.asFlow(listOf("age"))
        frodoFlow.collect { changes: SingleQueryChange<Character> ->
            // Change listener stuff in here.
        }
    }
    // Changing a property whose key path you're not observing does not trigger a notification.
    realm.writeBlocking {
        findLatest(frodoObject)!!.species = "Ring Bearer"
    }
    // Changing a property whose key path you are observing triggers a notification.
    realm.writeBlocking {
        findLatest(frodoObject)!!.age = 52
    }
    // For this example, we send the object change to a Channel where we can verify the
    // changes we expect. In your application code, you might use the notification to
    // update the UI or take some other action based on your business logic.
    channel.receiveOrFail().let { objChange ->
        assertIs<UpdatedObject<*>>(objChange)
        assertEquals(1, objChange.changedFields.size)
        // Because we are observing only the `age` property, the change to
        // the `species` property does not trigger a notification.
        // The first notification we receive is a change to the `age` property.
        assertEquals("age", objChange.changedFields.first())
    }
    observer.cancel()
    channel.close()
}

// query for the specific object you intend to listen to
val fellowshipOfTheRing = realm.query(Fellowship::class, "name == 'Fellowship of the Ring'").first().find()!!
val members = fellowshipOfTheRing.members
// flow.collect() is blocking -- run it in a background context
val job = CoroutineScope(Dispatchers.Default).launch {
    val membersFlow = members.asFlow()
    membersFlow.collect { changes: ListChange<Character> ->
        // change listener stuff in here
    }
}
job.cancel() // cancel the coroutine containing the listener