StateFlow and SharedFlow in Android Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is StateFlow in Kotlin?

StateFlow is a state-holder observable flow that emits the current and new state updates to its collectors. It always has a current value and is designed to hold and manage UI state in a reactive way.

beginner

How does SharedFlow differ from StateFlow?

SharedFlow is a hot flow that can emit values to multiple collectors but does not hold a current value by default. It is useful for events or broadcasts where you want to share emissions without state retention.

intermediate

What happens when you collect from a StateFlow?

When you collect from a StateFlow, you immediately receive the current value and then any subsequent updates. This makes it perfect for UI components that need the latest state right away.

intermediate

Can SharedFlow replay past emissions to new collectors?

Yes, SharedFlow can be configured with a replay cache size to replay a certain number of past emissions to new collectors. This is useful for sharing recent events with late subscribers.

advanced

Why would you use StateFlow over LiveData in Android?

StateFlow is Kotlin-native, supports coroutines, and offers better control over state updates and emissions. It integrates well with modern Kotlin code and provides a consistent reactive stream for UI state.

Which flow always holds a current value and emits it immediately to new collectors?

A Flow

B StateFlow

C SharedFlow

D Channel

StateFlow always holds a current value and emits it immediately to new collectors.

What is a key feature of SharedFlow that StateFlow does not have by default?

A Is cold and lazy

B Holds a current value

C Can replay past emissions

D Supports only one collector

SharedFlow can be configured to replay past emissions to new collectors, unlike StateFlow which always holds only the latest value.

Which of these is best suited for representing UI state that changes over time?

A StateFlow

B SharedFlow

C Channel

D BroadcastReceiver

StateFlow is designed to hold and emit UI state changes over time.

If you want to send one-time events like navigation commands, which flow is more appropriate?

A SharedFlow

B StateFlow

C LiveData

D Flow

SharedFlow is better for one-time events because it does not hold a state but can emit events to multiple collectors.

How do you update the value inside a StateFlow?

A By calling emit()

B By subscribing to it

C By calling collect()

D By setting its value property

StateFlow's value can be updated by setting its value property directly.

Explain the main differences between StateFlow and SharedFlow and when to use each.

Think about holding state versus broadcasting events.

Describe how you would use StateFlow in an Android app to manage UI state reactively.

Consider ViewModel and UI communication.

Practice

1. What is the main difference between StateFlow and SharedFlow in Kotlin?

easy

A. Both StateFlow and SharedFlow hold the latest value.

B. StateFlow holds the latest value, SharedFlow does not hold any value.

C. SharedFlow holds the latest value, StateFlow does not hold any value.

D. Neither StateFlow nor SharedFlow hold any value.

Solution

1. Step 1: Understand StateFlow behavior

   StateFlow always holds the latest emitted value and replays it to new collectors.

2. Step 2: Understand SharedFlow behavior

   SharedFlow emits events but does not hold or replay the latest value by default.

3. Final Answer:

   StateFlow holds the latest value, SharedFlow does not hold any value. -> Option B

4. Quick Check:

   StateFlow holds state, SharedFlow emits events [OK]

Hint: Remember: StateFlow = state holder, SharedFlow = event emitter [OK]

Common Mistakes:

• Thinking SharedFlow holds the latest value like StateFlow
• Confusing event emission with state holding
• Assuming both behave the same way

2. Which of the following is the correct way to create a StateFlow with an initial value of 0?

easy

A. val stateFlow = StateFlow<Int>()

B. val stateFlow = MutableSharedFlow(0)

C. val stateFlow = MutableStateFlow(0)

D. val stateFlow = SharedFlow(0)

Solution

1. Step 1: Identify correct constructor for StateFlow

   MutableStateFlow requires an initial value and is created with MutableStateFlow(initialValue).

2. Step 2: Check other options

   MutableSharedFlow does not take an initial value; StateFlow is an interface and cannot be instantiated directly.

3. Final Answer:

   val stateFlow = MutableStateFlow(0) -> Option C

4. Quick Check:

   MutableStateFlow needs initial value [OK]

Hint: StateFlow needs initial value via MutableStateFlow constructor [OK]

Common Mistakes:

• Trying to instantiate StateFlow interface directly
• Using SharedFlow constructor for StateFlow
• Passing initial value to MutableSharedFlow

3. Given the code below, what will be printed?

val stateFlow = MutableStateFlow(10)

stateFlow.value = 20

println(stateFlow.value)

medium

A. Compilation error

B. 10

C. null

D. 20

Solution

1. Step 1: Understand MutableStateFlow value assignment

   Assigning stateFlow.value = 20 updates the current value held by the StateFlow.

2. Step 2: Print the current value

   println(stateFlow.value) prints the latest value, which is 20.

3. Final Answer:

   20 -> Option D

4. Quick Check:

   StateFlow.value reflects latest assigned value [OK]

Hint: StateFlow.value always shows latest assigned value [OK]

Common Mistakes:

• Thinking initial value 10 will print instead of updated 20
• Confusing StateFlow with SharedFlow behavior
• Expecting null or error due to reassignment

4. What is wrong with this code snippet using SharedFlow?

val sharedFlow = MutableSharedFlow<Int>()

sharedFlow.value = 5

medium

A. SharedFlow does not have a value property to assign.

B. You must initialize SharedFlow with an initial value.

C. You cannot create a MutableSharedFlow without parameters.

D. The code is correct and will compile.

Solution

1. Step 1: Check SharedFlow properties

   SharedFlow does not hold state and has no value property to assign.

2. Step 2: Understand how to emit values

   Values are emitted using emit() or tryEmit() functions, not by assigning value.

3. Final Answer:

   SharedFlow does not have a value property to assign. -> Option A

4. Quick Check:

   SharedFlow emits events, no value property [OK]

Hint: Use emit() to send values in SharedFlow, not value assignment [OK]

Common Mistakes:

• Trying to assign value property on SharedFlow
• Confusing SharedFlow with StateFlow
• Assuming SharedFlow holds state like StateFlow

5. You want to create a SharedFlow that replays the last 3 emitted values to new collectors. Which configuration is correct?

hard

A. val sharedFlow = MutableSharedFlow<Int>(replay = 3)

B. val sharedFlow = MutableSharedFlow<Int>(replay = 0)

C. val sharedFlow = MutableStateFlow<Int>(3)

D. val sharedFlow = MutableSharedFlow<Int>(bufferSize = 3)

Solution

1. Step 1: Understand replay parameter in SharedFlow

   The replay parameter defines how many past values are replayed to new collectors.

2. Step 2: Check options for replaying last 3 values

   Setting replay = 3 in MutableSharedFlow correctly configures this behavior.

3. Final Answer:

   val sharedFlow = MutableSharedFlow<Int>(replay = 3) -> Option A

4. Quick Check:

   Replay count sets how many past events are replayed [OK]

Hint: Use replay parameter to replay past events in SharedFlow [OK]

Common Mistakes:

• Confusing bufferSize with replay
• Using StateFlow instead of SharedFlow for replay
• Setting replay to 0 expecting replay behavior