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.