SharedFlow for event broadcasting in Kotlin - Mini Project: Build & Apply

SharedFlow for event broadcasting

📖 Scenario: You are building a simple event broadcaster in Kotlin using SharedFlow. This will allow multiple parts of your program to listen for and react to events like messages being sent.

🎯 Goal: Create a SharedFlow to broadcast string messages. Set up a simple event sender and a listener that prints received messages.

📋 What You'll Learn

Create a MutableSharedFlow of type String called eventFlow

Create a replay configuration with value 0 for eventFlow

Create a suspend function sendEvent that emits a message to eventFlow

Create a coroutine that collects from eventFlow and prints received messages

Send two messages using sendEvent and observe the output

💡 Why This Matters

🌍 Real World

SharedFlow is useful in apps where multiple parts need to react to events like user actions, notifications, or data updates.

💼 Career

Understanding SharedFlow helps you build responsive Kotlin applications with clean event handling, a skill valued in Android and backend development.

1

Create a MutableSharedFlow for events

Create a MutableSharedFlow of type String called eventFlow with replay = 0.

Kotlin

import kotlinx.coroutines.flow.MutableSharedFlow

import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
    // Create eventFlow here
}

Hint

Use MutableSharedFlow<String>(replay = 0) to create eventFlow.

2

Create a suspend function to send events

Create a suspend function called sendEvent that takes a String parameter message and emits it to eventFlow.

Kotlin

import kotlinx.coroutines.flow.MutableSharedFlow

import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
    val eventFlow = MutableSharedFlow(replay = 0)

    // Create suspend function sendEvent here
}

Hint

Define sendEvent as a suspend function that calls eventFlow.emit(message).

3

Collect events and print them

Inside main, launch a coroutine that collects from eventFlow and prints each received message with println("Received: $message").

Kotlin

import kotlinx.coroutines.flow.MutableSharedFlow

import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.launch

suspend fun sendEvent(eventFlow: MutableSharedFlow, message: String) {
    eventFlow.emit(message)
}

fun main() = runBlocking {
    val eventFlow = MutableSharedFlow(replay = 0)

    // Launch coroutine to collect and print events
}

Hint

Use launch to start a coroutine that calls eventFlow.collect and prints messages.

4

Send events and observe output

Inside main, call sendEvent(eventFlow, "Hello") and sendEvent(eventFlow, "World") to send two messages. Then add a small delay of 100 milliseconds to allow collection before main ends.

Kotlin

import kotlinx.coroutines.flow.MutableSharedFlow

import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.launch
import kotlinx.coroutines.delay

suspend fun sendEvent(eventFlow: MutableSharedFlow, message: String) {
    eventFlow.emit(message)
}

fun main() = runBlocking {
    val eventFlow = MutableSharedFlow(replay = 0)

    launch {
        eventFlow.collect { message ->
            println("Received: $message")
        }
    }

    // Send two events and delay
}

Hint

Call sendEvent twice with messages "Hello" and "World" and add delay(100) to see output.

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