Kotlin-first event and result observation for Android and Compose Multiplatform.

The project is split into three public modules:

• event-observer for DataResult, ResponseLiveData, ResponseFlow, and the supporting utilities
• event-observer-compose for ComposableDataResult and the Compose-facing observation DSL
• event-observer-state for serializable SavedStateHandle state, repository operations and projections

• Kotlin 2.4.10
• Gradle wrapper 9.7.1
• JDK 21 via the Gradle toolchain
• Android minSdk 23 and compileSdk 37
• Compose Multiplatform 1.12.0 with iOS ARM targets
• Use the project wrapper instead of a local Gradle install

The library centers on DataResult<T> and a small set of wrappers that keep loading, success, error, and list-state handling consistent across Android and Compose layers.

Use event-observer when you want:

• DataResult helpers and status handling
• ResponseLiveData, MutableResponseLiveData, and SwapResponseLiveData
• ResponseFlow, ResponseStateFlow, and ResponseSharedFlow
• chaining, mapping, and merge helpers for reactive state

Use event-observer-compose when you want:

• ComposableDataResult for declarative state rendering
• collectAsComposableState() for Flow<DataResult<T>> and LiveData<DataResult<T>>
• Compose observables such as OnData, OnError, OnShowLoading, OnEmpty, OnNotEmpty, OnSingle, and OnMany
• a Compose-first API on top of event-observer

Use event-observer-state when you want:

• shared Repository-to-ViewModel state backed by SavedStateHandle
• objects, lists and maps, with or without DataResult
• refresh, filters, continuous streams and derived UI state

Pick the module that matches your layer:

dependencies {
    implementation("io.github.matheus-corregiari:event-observer:<version>")
}

dependencies {
    implementation("io.github.matheus-corregiari:event-observer-compose:<version>")
}

event-observer-compose builds on top of event-observer, so use both only when you need Compose rendering on top of the base result model.

For saved state in shared code:

kotlin {
    sourceSets.commonMain.dependencies {
        implementation("io.github.matheus-corregiari:event-observer-state:<version>")
    }
}

Apply the Kotlin serialization plugin in the module declaring your @Serializable models. The state artifact includes the base result API; add the Compose artifact for its rendering DSL.

event-observer

• base result model and status helpers
• LiveData and Flow wrappers
• transformations, chaining, and merge helpers

event-observer-compose

• Compose observation DSL
• ComposableDataResult
• Compose rendering hooks for loading, data, error, and collection states

Use only event-observer when your UI layer is not Compose. Add event-observer-compose when the final observation point lives inside Jetpack Compose Multiplatform.

The fastest path is to start with DataResult and render it where you need it.

val result = dataResultSuccess("Hello")

result.unwrap {
    data { value -> println(value) }
    error { throwable -> println(throwable.message) }
    loading { isLoading -> println("loading=$isLoading") }
}

For Compose, convert the upstream state into a ComposableDataResult and render the blocks you care about.

myFlow.composable
    .OnShowLoading { CircularProgressIndicator() }
    .OnData { value -> Text(value.toString()) }
    .OnError { error -> Text(error.message ?: "Unknown error") }
    .Unwrap()

For saved state, declare a shared ViewModel and start a new operation on refresh:

import androidx.lifecycle.SavedStateHandle
import androidx.lifecycle.ViewModel
import br.com.arch.toolkit.eventObserver.state.saveResponseState
import br.com.arch.toolkit.result.DataResult
import kotlinx.coroutines.flow.Flow
import kotlinx.serialization.Serializable

@Serializable
data class User(val name: String)

class UsersViewModel(handle: SavedStateHandle) : ViewModel() {
    val users by handle.saveResponseState<List<User>>()
    val count = users.select { it?.size ?: 0 }

    fun refresh(source: () -> Flow<DataResult<List<User>>>) = users.load { source() }
}

Observe users.flow() from the View. Its last payload survives completed requests and is restored through the handle's owner. See the state guide for filters, plain values, mapping and platform restoration limits.

Public docs live in docs/:

• Home
• Getting Started
• event-observer
• event-observer-compose
• event-observer-state
• State migration
• State performance and responsiveness
• Core Concepts
• Recipes
• Changelog
• Contributing
• API Reference

The published MkDocs site is built from the same content and mirrors these pages.

• event-observer is Android-facing and integrates with LiveData.
• event-observer-compose builds on top of event-observer, Flow, and Compose state.
• The API is designed to stay predictable in shared KMP-oriented architecture layers.

Read CONTRIBUTING.md before sending changes.

Copyright 2025 Matheus Corregiari

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

See event-observer-state for one-shot requests, refresh, filters, continuous streams and transformations. Existing Toolkit consumers should follow the migration guide.