SharedFlow for events in Android Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

What happens when multiple collectors subscribe to a SharedFlow?

Consider a SharedFlow that emits integer events. If two collectors start collecting from this SharedFlow, what will they receive?

Android Kotlin

val sharedFlow = MutableSharedFlow<Int>()

// Collector 1
sharedFlow.onEach { println("Collector 1 received: $it") }.launchIn(scope)

// Collector 2
sharedFlow.onEach { println("Collector 2 received: $it") }.launchIn(scope)

sharedFlow.emit(5)

A Only the first collector receives the event 5.

B Both collectors receive the event 5.

C Only the second collector receives the event 5.

D Neither collector receives the event 5.

💡 Hint

SharedFlow is designed to broadcast events to all active collectors.

A SharedFlow emits events to all collectors that are actively collecting. So when you emit 5, both collectors receive it.

❓ lifecycle

intermediate

How does SharedFlow behave when collectors start after emission?

If a MutableSharedFlow is created with default settings and an event is emitted before any collector starts, what happens when a collector starts collecting later?

Android Kotlin

val sharedFlow = MutableSharedFlow<Int>()

sharedFlow.emit(10)

// Collector starts after emit
sharedFlow.onEach { println("Received: $it") }.launchIn(scope)

A The collector receives a default value 0.

B The code throws an exception.

C The collector does not receive the event 10.

D The collector receives the event 10.

💡 Hint

Default SharedFlow does not replay events to late collectors.

By default, MutableSharedFlow does not replay past events to new collectors. So if the event was emitted before collecting started, the collector misses it.

📝 Syntax

advanced

What is the correct way to create a SharedFlow that replays the last event?

You want a SharedFlow that replays the last emitted event to new collectors. Which code snippet correctly creates such a SharedFlow?

A val sharedFlow = MutableSharedFlow<Int>(replay = 1)

B val sharedFlow = MutableSharedFlow<Int>(bufferSize = 1)

C val sharedFlow = MutableSharedFlow<Int>(cache = 1)

D val sharedFlow = MutableSharedFlow<Int>(replayCount = 1)

💡 Hint

The parameter to control replay is named 'replay'.

The replay parameter sets how many past events are replayed to new collectors. The correct parameter name is replay.

🔧 Debug

advanced

Why does this SharedFlow emit block suspend indefinitely?

Given this code, why does the call to emit suspend forever?

Android Kotlin

val sharedFlow = MutableSharedFlow<Int>(replay = 0, extraBufferCapacity = 0)

// No collectors started
sharedFlow.emit(1) // Suspends here

A Because emit requires at least one collector to be started before calling.

B Because replay is zero, emit cannot send events.

C Because extraBufferCapacity is zero, emit throws an exception.

D Because there is no buffer and no active collectors, emit suspends waiting for a collector.

💡 Hint

Emit suspends if there is no buffer and no collector to receive the event.

When replay and extraBufferCapacity are zero, emit suspends until a collector is ready to receive the event.

🧠 Conceptual

expert

How to ensure events are not lost when no collectors are active?

You want to use a SharedFlow to send UI events that must not be lost even if no collector is active at the moment of emission. Which configuration ensures this behavior?

A Create MutableSharedFlow with replay = 1 and extraBufferCapacity = 1.

B Create MutableSharedFlow with replay = 0 and extraBufferCapacity = 1.

C Create MutableSharedFlow with replay = 1 and extraBufferCapacity = 0.

D Create MutableSharedFlow with replay = 0 and extraBufferCapacity = 0.

💡 Hint

Replay buffers past events; extraBufferCapacity buffers new events when no collector is ready.

Setting replay = 1 keeps the last event for new collectors. Setting extraBufferCapacity = 1 allows buffering one event when no collector is active, preventing suspension or loss.