SharedFlow for event broadcasting in Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a MutableSharedFlow instance.

Kotlin

val eventFlow = MutableSharedFlow<[1]>()

Drag options to blanks, or click blank then click option'

ADouble

BInt

CString

DBoolean

Attempts:

3 left

💡 Hint

Common Mistakes

Using a type that does not match the event data.

Forgetting to specify the generic type.

We create a MutableSharedFlow to broadcast events of type String.

2fill in blank

medium

Complete the code to emit an event into the SharedFlow.

Kotlin

suspend fun sendEvent(event: String) {
    eventFlow.[1](event)
}

Drag options to blanks, or click blank then click option'

Acollect

Bemit

Claunch

Dsubscribe

Attempts:

3 left

💡 Hint

Common Mistakes

Using collect which is for receiving events.

Using launch which is for coroutines, not flows.

Use emit to send an event to the SharedFlow.

3fill in blank

hard

Fix the error in collecting events from the SharedFlow.

Kotlin

suspend fun observeEvents() {
    eventFlow.[1] { event ->
        println("Received: $event")
    }
}

Drag options to blanks, or click blank then click option'

Acollect

Bemit

Csend

Dsubscribe

Attempts:

3 left

💡 Hint

Common Mistakes

Using emit which is for sending events.

Using subscribe which is not a Kotlin Flow method.

Use collect to receive events from a SharedFlow.

4fill in blank

hard

Fill both blanks to create a SharedFlow with replay and buffer capacity.

Kotlin

val bufferedFlow = MutableSharedFlow<String>(replay = [1], extraBufferCapacity = [2])

Drag options to blanks, or click blank then click option'

A1

B0

C2

D5

Attempts:

3 left

💡 Hint

Common Mistakes

Setting replay or buffer to zero when some buffering is needed.

Confusing replay and buffer parameters.

Replay 1 event and buffer 2 extra events for smooth broadcasting.

5fill in blank

hard

Fill all three blanks to filter and map events in a SharedFlow.

Kotlin

val filteredFlow = eventFlow
    .filter { it.length [1] [2] }
    .map { it.[3]() }

Drag options to blanks, or click blank then click option'

A>

B3

Cuppercase

Dlowercase

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong comparison operator.

Using a non-existent string method.

Filter events longer than 3 characters and convert them to lowercase.

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