Understanding LiveData, StateFlow, SharedFlow, and Flow in Android

23 May 2023 - 3 mins read time
Tags: Kotlin LiveData StateFlow SharedFlow Flow

Source: Nagaraj Alagusundaram

LiveData

LiveData is your Android data stream sidekick. It holds data and lets components like activities or fragments observe this data, automatically updating them as it changes. LiveData also respects the lifecycle of app components, updating only those in an active state.

val liveData: MutableLiveData<String> = MutableLiveData()
liveData.value = "Hey, I'm LiveData!"

// To observe LiveData
liveData.observe(this, Observer { value ->
    // Update UI with the value
})

StateFlow

Think of StateFlow as your app’s data broadcast channel. This Kotlin coroutine library feature allows a single piece of data to be observed by multiple components. When the data changes, all observers get notified - enabling asynchronous and efficient state changes.

val stateFlow: MutableStateFlow<String> = MutableStateFlow("Hey, I'm StateFlow!")

// To consume StateFlow
lifecycleScope.launchWhenStarted {
    stateFlow.collect { value ->
        // Do something with the value
    }
}

SharedFlow

SharedFlow is the team player of data streams, similar to a group chat where everyone receives the same information. Part of the Kotlin coroutines library, SharedFlow emits values to multiple collectors, facilitating inter-app communication.

val sharedFlow: MutableSharedFlow<String> = MutableSharedFlow()
sharedFlow.emit("Hey, I'm SharedFlow!")

// To consume SharedFlow
lifecycleScope.launchWhenStarted {
    sharedFlow.collect { value ->
        // Do something with the value
    }
}

Flow

Flow, also a part of the Kotlin coroutines library, is your data pipeline, delivering a sequence of values over time. This reactive streams-based API ensures asynchronous and non-blocking data processing, with features like data stream composition, backpressure handling, and seamless integration with other coroutine APIs.

val flow: Flow<Int> = flow {
    for (i in 1..3) {
        delay(100)
        emit(i)
    }
}

// To consume Flow
lifecycleScope.launchWhenStarted {
    flow.collect { value ->
        // Do something with the value
    }
}

Final Thoughts

Choosing the right tool for your needs is crucial. LiveData is your go-to when working with Android app and needing lifecycle-awareness. StateFlow suits when your project requires a mutable state holder that continuously updates in a coroutine setup and it requires an initial state to be passed in to the constructor. SharedFlow is your choice for sharing data across multiple collectors simultaneously, which means new collectors will immediately get the current state as soon as they start collecting. . Finally, Flow is your flexible friend for when you need a composable data stream processing mechanism, for example you can use a flow to receive live updates from a database.

Understanding these tools will help you navigate Android’s data handling landscape with ease. Happy coding!