SharedFlow for event broadcasting in Kotlin

Introduction

SharedFlow lets many parts of your app listen to the same events at the same time. It helps send messages that everyone can hear.

You want to send a message to many listeners at once, like a chat message.

You need to broadcast updates, such as a new notification, to multiple screens.

You want to share user actions, like button clicks, with different parts of your app.

You want to handle events that happen only once but need to be seen by many.

You want to avoid missing events even if some listeners start late.

Syntax

Kotlin

val sharedFlow = MutableSharedFlow<Type>(replay = 0)

// To send an event
sharedFlow.emit(value)

// To listen for events
sharedFlow.collect { value ->
    // handle value
}

MutableSharedFlow is used to create a flow you can send events to.

The replay parameter controls how many past events new listeners get.

Examples

This example creates a SharedFlow of strings with no replay. Listeners get only new events.

Kotlin

val sharedFlow = MutableSharedFlow<String>(replay = 0)

// Emit an event
sharedFlow.emit("Hello")

// Collect events
sharedFlow.collect { message ->
    println("Received: $message")
}

Here, replay is 2, so new listeners get the last two events immediately.

Kotlin

val sharedFlow = MutableSharedFlow<Int>(replay = 2)

// Emit some numbers
sharedFlow.emit(1)
sharedFlow.emit(2)
sharedFlow.emit(3)

// New collector will receive last 2 events: 2 and 3

Sample Program

This program shows two listeners receiving events from a SharedFlow. The second listener starts after some events were emitted but still receives the last event because replay is 1.

Kotlin

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

fun main() = runBlocking {
    val sharedFlow = MutableSharedFlow<String>(replay = 1)

    // First listener
    launch {
        sharedFlow.collect { value ->
            println("Listener 1 received: $value")
        }
    }

    // Emit events
    sharedFlow.emit("Event 1")
    sharedFlow.emit("Event 2")

    delay(100) // Wait a bit

    // Second listener starts late
    launch {
        sharedFlow.collect { value ->
            println("Listener 2 received: $value")
        }
    }

    sharedFlow.emit("Event 3")

    delay(100) // Wait to see output
}

Important Notes

SharedFlow is hot, meaning it keeps running even if no one listens.

Use replay carefully to avoid memory issues with many events.

Collecting from SharedFlow should be done in a coroutine.

Summary

SharedFlow lets you send events to many listeners at once.

Listeners can get past events if replay is set.

It is useful for broadcasting messages or user actions in apps.

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