StateFlow for reactive state in Android Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

What happens when StateFlow value changes?

Consider a StateFlow holding an integer count. When the count updates, what will the UI displaying this count do?

Android Kotlin

val countFlow = MutableStateFlow(0)
// UI collects countFlow and shows count
countFlow.value = 5

A The UI automatically updates to show 5

B The UI shows 0 and never updates

C The UI crashes because StateFlow is immutable

D The UI updates only if manually refreshed

💡 Hint

StateFlow emits new values to collectors automatically.

StateFlow is designed to emit updates to its collectors whenever its value changes, so the UI observing it will update automatically.

❓ lifecycle

intermediate

StateFlow collection and lifecycle

In an Android app, what happens if you collect a StateFlow in a ViewModel but the UI lifecycle is destroyed?

Android Kotlin

val stateFlow = MutableStateFlow("Hello")
// UI collects stateFlow in lifecycleScope
// UI is destroyed

A StateFlow stops emitting values

B Collection continues and leaks memory

C App crashes due to lifecycle mismatch

D Collection stops automatically when UI lifecycle is destroyed

💡 Hint

Lifecycle-aware scopes stop coroutines when lifecycle ends.

Collecting StateFlow in lifecycleScope ensures collection stops when the UI lifecycle is destroyed, preventing leaks.

📝 Syntax

advanced

Correct syntax to expose StateFlow from ViewModel

Which option correctly exposes a read-only StateFlow from a ViewModel?

Android Kotlin

private val _state = MutableStateFlow(0)
// expose state

A val state = _state as StateFlow<Int>

B val state = _state.value

C val state: StateFlow<Int> get() = _state

D val state: MutableStateFlow<Int> = _state

💡 Hint

Expose StateFlow as an interface, not mutable type.

Option C exposes _state as a read-only StateFlow, hiding mutability from outside.

🔧 Debug

advanced

Why does UI not update when StateFlow value changes?

Given this code, why does the UI not update when _count.value changes? class MyViewModel : ViewModel() { private val _count = MutableStateFlow(0) val count: StateFlow = _count fun increment() { _count.value += 1 } } // UI collects count but never updates

A StateFlow requires emit() instead of value assignment

B UI is not collecting count in a coroutine

C _count.value += 1 does not update StateFlow value

D ViewModel is not initialized properly

💡 Hint

StateFlow emits only when collected in a coroutine.

If UI does not collect StateFlow in a coroutine, it won't receive updates and won't update UI.

🧠 Conceptual

expert

StateFlow vs SharedFlow for UI state

Which statement best explains why StateFlow is preferred over SharedFlow for holding UI state?

A StateFlow always holds the latest value and replays it to new collectors, SharedFlow does not by default

B SharedFlow is slower and cannot be collected in UI

C StateFlow supports multiple values at once, SharedFlow supports only one

D SharedFlow requires manual reset of values, StateFlow resets automatically

💡 Hint

Think about replay behavior and state retention.

StateFlow always keeps the latest value and emits it immediately to new collectors, making it ideal for UI state. SharedFlow requires configuration to replay values.