StateFlow and SharedFlow in Android Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Difference between StateFlow and SharedFlow

Which statement correctly describes the main difference between StateFlow and SharedFlow in Kotlin?

A SharedFlow always holds the latest value and replays it to new collectors, while StateFlow does not hold any value and only emits new values.

B StateFlow always holds the latest value and replays it to new collectors, while SharedFlow does not hold any value by default and can replay a configurable number of values.

C StateFlow and SharedFlow are identical; both always replay all emitted values to new collectors.

D StateFlow is used only for one-time events, while SharedFlow is used for state management.

💡 Hint

Think about which flow remembers the last value and which one can replay multiple values.

StateFlow always holds the latest value and emits it immediately to new collectors. SharedFlow does not hold a value by default but can be configured to replay a set number of past values.

❓ ui_behavior

intermediate

StateFlow UI update behavior

Given a StateFlow that emits numbers, what will happen in the UI if a collector subscribes after the StateFlow has emitted values 1, 2, and 3?

A The collector receives all previous values 1, 2, and 3 in order, then new values.

B The collector receives only the first emitted value 1 and ignores the rest.

C The collector receives no values until a new value is emitted after subscription.

D The collector immediately receives the latest value 3 and then any new values emitted after subscription.

💡 Hint

Remember what StateFlow holds and replays to new subscribers.

StateFlow always holds the latest value and emits it immediately to new collectors. It does not replay all past values, only the latest one.

❓ lifecycle

advanced

SharedFlow and lifecycle-aware collection

You have a SharedFlow that emits UI events like navigation commands. What is the best way to collect this SharedFlow in an Android Activity to avoid missing events when the Activity is recreated?

A Collect the SharedFlow in onCreate() using lifecycleScope.launchWhenStarted to ensure events are received only when the Activity is visible.

B Collect the SharedFlow in onDestroy() to catch all events before the Activity is destroyed.

C Collect the SharedFlow in onCreate() without lifecycleScope to avoid missing events during recreation.

D Collect the SharedFlow in onResume() without lifecycle awareness to get all events immediately.

💡 Hint

Think about lifecycle-aware collection and when UI events should be handled.

Using lifecycleScope.launchWhenStarted ensures the SharedFlow is collected only when the Activity is visible, preventing missed events and avoiding leaks.

📝 Syntax

advanced

Creating a StateFlow with initial value

Which Kotlin code snippet correctly creates a MutableStateFlow with an initial value of 0?

A val stateFlow = MutableStateFlow.create(0)

B val stateFlow = MutableStateFlow<Int>()

C val stateFlow = MutableStateFlow(0)

D val stateFlow = MutableStateFlow.value(0)

💡 Hint

Check the constructor usage for MutableStateFlow.

MutableStateFlow requires an initial value passed directly to its constructor.

🔧 Debug

expert

Why does this SharedFlow not emit to new subscribers?

Consider this SharedFlow declaration:

val sharedFlow = MutableSharedFlow()

New subscribers do not receive any previously emitted values. Why?

A Because MutableSharedFlow by default has replay = 0, so it does not replay past values to new subscribers.

B Because MutableSharedFlow requires an initial value to replay to new subscribers.

C Because SharedFlow only emits values when collected before emission.

D Because MutableSharedFlow buffers all values and drops new subscribers.

💡 Hint

Check the default replay parameter of MutableSharedFlow.

MutableSharedFlow by default has replay set to 0, so it does not replay any past values to new subscribers.

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