SharedFlow for event broadcasting in Kotlin - Step-by-Step Execution

Concept Flow - SharedFlow for event broadcasting

Create SharedFlow

↓

Emit Event

↓

SharedFlow holds event

↓

Subscribers collect event

↓

Subscribers react to event

↓

Wait for next event or complete

SharedFlow lets multiple parts listen to events. When an event is sent, all listeners get it.

Execution Sample

Kotlin

val events = MutableSharedFlow<String>(replay = 1)

// Emit event
launch { events.emit("Hello") }

// Collect event
launch { events.collect { println(it) } }

This code creates a SharedFlow, sends a "Hello" event, and prints it when collected.

Execution Table

Step	Action	SharedFlow State	Subscribers	Output
1	Create MutableSharedFlow	Empty	None
2	Launch emitter coroutine	Empty	None
3	Emit "Hello"	Contains "Hello"	None
4	Launch collector coroutine	Contains "Hello"	Collector started
5	Collector receives "Hello"	Contains "Hello"	Collector active	Print: Hello
6	Wait for next event	Contains "Hello"	Collector active

💡 No more events emitted, collector waits for new events

Variable Tracker

Variable	Start	After Step 3	After Step 5	Final
events	Empty SharedFlow	Contains "Hello"	Contains "Hello"	Contains "Hello"
Subscribers	None	None	Collector active	Collector active

Key Moments - 2 Insights

Why does the collector receive the event even though it started after the event was emitted?

Because SharedFlow can replay events to new subscribers if replay is set. Here, the event was still in the buffer when the collector started (see step 4 and 5 in execution_table).

What happens if no subscriber is active when an event is emitted?

The event stays in SharedFlow if replay > 0, so future subscribers can get it. Otherwise, emit suspends until subscriber starts. In this example, the event was held until the collector started (step 3 to 5).

Visual Quiz - 3 Questions

Look at the execution_table, what is the SharedFlow state right after emitting "Hello"?

A Contains "Hello"

B Empty

C Contains "Hello" and collector active

D Collector active only

💡 Hint

Check step 3 in the execution_table under SharedFlow State

At which step does the collector print the event?

A Step 3

B Step 4

C Step 5

D Step 6

💡 Hint

Look at the Output column in execution_table

If the SharedFlow had replay = 0, what would happen when the collector starts after the event is emitted?

A Collector receives the event anyway

B Collector misses the event

C Event is duplicated

D Program crashes

💡 Hint

With replay=0, emit() suspends until collector joins; see key_moments

Concept Snapshot

SharedFlow broadcasts events to many listeners.
Create with MutableSharedFlow.
Emit events with emit().
Subscribers collect events with collect().
Replay controls if new subscribers get past events.
Useful for one-to-many event communication.

Full Transcript

SharedFlow is a Kotlin tool to send events to many listeners. First, you create a MutableSharedFlow. Then, you emit events into it. These events stay in the flow depending on replay settings. When subscribers start collecting, they receive events currently in the flow. In the example, an event "Hello" is emitted before the collector starts. Because the event is still in the flow, the collector receives and prints it. If replay was zero, the collector would miss past events. SharedFlow is great for broadcasting events like button clicks or messages to multiple parts of your app.

Practice

1. What is the main purpose of SharedFlow in Kotlin?

easy

A. To broadcast events to multiple listeners simultaneously

B. To store data permanently in a database

C. To perform heavy computations asynchronously

D. To create a single-threaded event queue

Solution

1. Step 1: Understand SharedFlow's role

   SharedFlow is designed to send events to many listeners at once, like a radio broadcast.

2. Step 2: Compare with other options

   It does not store data permanently, perform heavy computations, or create single-threaded queues.

3. Final Answer:

   To broadcast events to multiple listeners simultaneously -> Option A

4. Quick Check:

   SharedFlow = Broadcast events [OK]

Hint: SharedFlow is like a radio sending to many listeners [OK]

Common Mistakes:

• Confusing SharedFlow with data storage
• Thinking SharedFlow handles computations
• Assuming SharedFlow is single-threaded queue

2. Which of the following is the correct way to create a SharedFlow with replay of 2 events?

easy

A. val flow = SharedFlow<Int>(replayCount = 2)

B. val flow = MutableSharedFlow<Int>(replay = 2)

C. val flow = MutableSharedFlow<Int>(buffer = 2)

D. val flow = SharedFlow<Int>(bufferSize = 2)

Solution

1. Step 1: Recall SharedFlow creation syntax

   MutableSharedFlow constructor uses parameter replay to set how many past events to keep.

2. Step 2: Check options for correct parameter

   Only val flow = MutableSharedFlow<Int>(replay = 2) uses replay = 2 correctly. Others use wrong parameter names or types.

3. Final Answer:

   val flow = MutableSharedFlow<Int>(replay = 2) -> Option B

4. Quick Check:

   Use replay parameter to set past events [OK]

Hint: Use replay parameter in MutableSharedFlow constructor [OK]

Common Mistakes:

• Using SharedFlow instead of MutableSharedFlow for creation
• Wrong parameter names like bufferSize or replayCount
• Confusing replay with buffer

3. What will be the output of this Kotlin code snippet?

val flow = MutableSharedFlow<Int>(replay = 1)

suspend fun main() {
    flow.emit(10)
    flow.emit(20)

    flow.collect { value ->
        println(value)
    }
}

medium

A. 10
20

B. 10

C. 20

D. No output

Solution

1. Step 1: Understand replay behavior

   With replay = 1, only the last emitted value is kept for new collectors.

2. Step 2: Analyze emitted values and collection

   Values 10 and 20 are emitted, but only 20 is replayed to the collector.

3. Final Answer:

   20 -> Option C

4. Quick Check:

   Replay 1 means last event only [OK]

Hint: Replay 1 means only last emitted event is received [OK]

Common Mistakes:

• Expecting all emitted values to be replayed
• Confusing replay with buffer size
• Thinking collector receives events emitted before subscription

4. Identify the error in this Kotlin code using SharedFlow:

val flow = MutableSharedFlow<Int>()
suspend fun main() {
    flow.collect { println(it) }
    flow.emit(5)
}

medium

A. collect should be launched in a separate coroutine

B. emit must be called before collect

C. Calling emit after collect blocks the coroutine

D. MutableSharedFlow requires a replay parameter

Solution

1. Step 1: Understand collect and emit behavior

   collect is a suspending function that waits for events and blocks until cancelled.

2. Step 2: Analyze code flow

   Since collect is called first and blocks, emit is never reached. emit must be called concurrently.

3. Final Answer:

   collect should be launched in a separate coroutine -> Option A

4. Quick Check:

   collect blocks; emit needs separate coroutine [OK]

Hint: Run collect and emit in separate coroutines [OK]

Common Mistakes:

• Calling emit after collect in same coroutine
• Assuming emit runs before collect automatically
• Thinking replay parameter is mandatory

5. You want to broadcast user click events to multiple UI components using SharedFlow. Which approach correctly ensures all components receive the latest 3 clicks even if they subscribe late?

hard

A. Use a simple List to store clicks and pass it to components on subscription

B. Use a MutableStateFlow to hold the last click and components read its value

C. Create a Channel with capacity 3 and send clicks; components receive from it

D. Create a MutableSharedFlow with replay = 3 and emit clicks; components collect from it

Solution

1. Step 1: Identify replay requirement

   Replay of 3 means new subscribers get last 3 events automatically.

2. Step 2: Match with SharedFlow usage

   MutableSharedFlow with replay = 3 fits perfectly for broadcasting recent events to multiple listeners.

3. Step 3: Evaluate other options

   MutableStateFlow holds only one value, Channel does not replay past events, List is manual and not reactive.

4. Final Answer:

   Create a MutableSharedFlow with replay = 3 and emit clicks; components collect from it -> Option D

5. Quick Check:

   Replay 3 in SharedFlow broadcasts last 3 events [OK]

Hint: Use MutableSharedFlow with replay for recent event replay [OK]

Common Mistakes:

• Using StateFlow which holds only one value
• Using Channel which doesn't replay past events
• Manually managing event lists instead of reactive streams