Why StateFlow and SharedFlow in Android Kotlin? - Purpose & Use Cases

The Big Idea

Discover how StateFlow and SharedFlow make your app's data updates smooth and bug-free!

The Scenario

Imagine you are building an app where multiple parts need to know when data changes, like a shopping cart updating the item count in different screens.

Without a proper way to share these updates, you might try to manually pass data around or use callbacks everywhere.

The Problem

Manually passing data or using callbacks can get messy fast. It's easy to miss updates, cause bugs, or write repetitive code.

Also, managing the timing of updates and ensuring all parts get the latest info is tricky and error-prone.

The Solution

StateFlow and SharedFlow provide a clean, reactive way to share data updates across your app.

StateFlow holds the latest value and emits it to new subscribers automatically, perfect for UI state.

SharedFlow broadcasts events to multiple subscribers without holding a value, great for one-time events.

Before vs After

✗ Before

fun updateCart() {
  cartCount++
  notifyAllScreens(cartCount)
}

✓ After

val cartState = MutableStateFlow(0)
fun addItem() {
  cartState.value = cartState.value + 1
}

What It Enables

It enables smooth, reliable communication of data changes across your app without tangled code or missed updates.

Real Life Example

When a user adds an item to their cart, StateFlow instantly updates the cart icon count on every screen without extra code.

Key Takeaways

Manual data sharing is slow and error-prone.

StateFlow and SharedFlow simplify reactive data updates.

They help keep your app UI in sync effortlessly.

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