Flow context preservation in Kotlin - Step-by-Step Execution

Concept Flow - Flow context preservation

Start Flow

↓

Emit values

↓

Flow collects values

↓

Preserve Coroutine Context

↓

Process values with context

↓

Flow completes

This flow shows how a Kotlin Flow emits values, collects them, and preserves the coroutine context during processing.

Execution Sample

Kotlin

val flow = flow {
  emit(1)
  emit(2)
}

flow.collect { value ->
  println("Collected $value")
}

This code creates a flow that emits two values and collects them, printing each collected value.

Execution Table

Step	Action	Coroutine Context	Value Emitted	Value Collected	Output
1	Start flow builder	Main	None	None	None
2	Emit value 1	Main	1	None	None
3	Collect value 1	Main	1	1	Collected 1
4	Emit value 2	Main	2	None	None
5	Collect value 2	Main	2	2	Collected 2
6	Flow completes	Main	None	2	Collected 2

💡 Flow completes after emitting and collecting all values preserving the coroutine context.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	Final
value	None	1	1	2	2	2
coroutineContext	Main	Main	Main	Main	Main	Main

Key Moments - 2 Insights

Why does the coroutine context remain 'Main' during emission and collection?

Because the flow preserves the coroutine context from the collector side, as shown in execution_table steps 2 to 5, the context stays 'Main' throughout.

What happens if the flow emits values but the collector is on a different context?

The flow switches to the collector's coroutine context when collecting values, preserving context consistency as seen in the flow's design.

Visual Quiz - 3 Questions

Look at the execution table, what is the value collected at step 3?

A None

B 1

C 2

D 0

💡 Hint

Check the 'Value Collected' column at step 3 in the execution_table.

At which step does the flow emit the value 2?

A Step 4

B Step 2

C Step 3

D Step 5

💡 Hint

Look at the 'Value Emitted' column in the execution_table.

If the coroutine context changed to 'IO' during collection, what would change in the execution table?

A The 'Value Emitted' would change to 'IO'.

B The 'Output' would be empty.

C The 'Coroutine Context' column would show 'IO' during collection steps.

D The flow would emit no values.

💡 Hint

Focus on the 'Coroutine Context' column in the execution_table during collection steps.

Concept Snapshot

Kotlin Flow preserves coroutine context during emission and collection.
Flow emits values asynchronously.
Collector processes values in its coroutine context.
Context preservation ensures consistent execution environment.
Use flow { emit(...) } and collect { } to handle streams safely.

Full Transcript

This example shows a Kotlin Flow emitting two values and collecting them while preserving the coroutine context. The flow starts in the 'Main' context, emits values 1 and 2, and the collector receives these values also in the 'Main' context. The coroutine context remains consistent throughout emission and collection, ensuring safe and predictable asynchronous processing. The execution table traces each step, showing the emitted and collected values and the context state. Key moments clarify why context preservation matters and what happens if contexts differ. The visual quiz tests understanding of values and context at each step.

Practice

1. What does flowOn do in Kotlin Flow context preservation?

easy

A. It converts a flow into a list.

B. It cancels the flow immediately.

C. It collects the flow on the main thread only.

D. It changes the coroutine context where the flow is executed.

Solution

1. Step 1: Understand flowOn purpose

   flowOn switches the coroutine context for upstream flow operations.

2. Step 2: Identify effect on execution

   It changes the thread or dispatcher where the flow runs, preserving context safely.

3. Final Answer:

   It changes the coroutine context where the flow is executed. -> Option D

4. Quick Check:

   flowOn = changes coroutine context [OK]

Hint: Remember flowOn switches thread context upstream [OK]

Common Mistakes:

• Thinking flowOn cancels the flow
• Assuming flowOn collects on main thread only
• Confusing flowOn with terminal operators

2. Which of the following is the correct syntax to switch the flow context to Dispatchers.IO?

easy

A. flow.flowOn(Dispatchers.Main)

B. flow.collectOn(Dispatchers.IO)

C. flow.flowOn(Dispatchers.IO)

D. flow.switchContext(Dispatchers.IO)

Solution

1. Step 1: Recall correct function name

   The function to switch context in flow is flowOn.

2. Step 2: Identify correct dispatcher

   To switch to IO thread, use Dispatchers.IO inside flowOn.

3. Final Answer:

   flow.flowOn(Dispatchers.IO) -> Option C

4. Quick Check:

   Correct syntax = flowOn(Dispatchers.IO) [OK]

Hint: Use flowOn with Dispatchers.IO to switch context [OK]

Common Mistakes:

• Using collectOn or switchContext which don't exist
• Passing wrong dispatcher like Dispatchers.Main
• Misplacing flowOn after collect

3. What will be the output of this Kotlin code snippet?

val flow = flow {
  println("Emitting on: ${Thread.currentThread().name}")
  emit(1)
}.flowOn(Dispatchers.IO)

runBlocking {
  flow.collect {
    println("Collected $it on: ${Thread.currentThread().name}")
  }
}

medium

A. Emitting on: DefaultDispatcher-worker-1
Collected 1 on: main

B. Emitting on: main
Collected 1 on: DefaultDispatcher-worker-1

C. Emitting on: main
Collected 1 on: main

D. Emitting on: DefaultDispatcher-worker-1
Collected 1 on: DefaultDispatcher-worker-1

Solution

1. Step 1: Identify where emission runs

   flowOn(Dispatchers.IO) moves emission to IO dispatcher thread, e.g., DefaultDispatcher-worker-1.

2. Step 2: Identify where collection runs

   collect runs in runBlocking context, which is main thread.

3. Final Answer:

   Emitting on: DefaultDispatcher-worker-1 Collected 1 on: main -> Option A

4. Quick Check:

   Emission thread = IO, Collection thread = main [OK]

Hint: Emission runs on flowOn thread, collection on caller thread [OK]

Common Mistakes:

• Assuming emission runs on main thread
• Assuming collection runs on IO thread
• Ignoring flowOn effect on emission

4. Identify the error in this Kotlin flow code:

val flow = flow {
  emit(1)
}.flowOn(Dispatchers.IO)

runBlocking {
  flow.flowOn(Dispatchers.Default).collect {
    println(it)
  }
}

medium

A. Multiple flowOn calls cause context override; only the last applies upstream.

B. flowOn cannot be used with runBlocking.

C. emit must be called inside collect block.

D. Dispatchers.Default is not a valid dispatcher.

Solution

1. Step 1: Understand flowOn chaining behavior

   Multiple flowOn calls override upstream context; only the nearest upstream applies.

2. Step 2: Identify effect on this code

   The second flowOn(Dispatchers.Default) overrides the first flowOn(Dispatchers.IO), so emission runs on Default, not IO.

3. Final Answer:

   Multiple flowOn calls cause context override; only the last applies upstream. -> Option A

4. Quick Check:

   Multiple flowOn = last one wins [OK]

Hint: Only one flowOn affects upstream; last one wins [OK]

Common Mistakes:

• Thinking flowOn can be used multiple times independently
• Believing emit must be inside collect
• Assuming Dispatchers.Default is invalid

5. You want to perform a CPU-intensive calculation inside a flow without blocking the main thread, then update UI on the main thread. Which is the best way to preserve flow context?

hard

A. Perform calculation inside collect block on main thread.

B. Use flowOn(Dispatchers.Default) for calculation, then collect on main thread.

C. Use flowOn(Dispatchers.Main) for calculation, then collect on IO thread.

D. Use flowOn(Dispatchers.IO) for calculation, then collect on Default dispatcher.

Solution

1. Step 1: Identify dispatcher for CPU-intensive work

   CPU-intensive tasks should run on Dispatchers.Default to avoid blocking main thread.

2. Step 2: Preserve UI update on main thread

   Collecting on main thread allows safe UI updates after calculation.

3. Final Answer:

   Use flowOn(Dispatchers.Default) for calculation, then collect on main thread. -> Option B

4. Quick Check:

   CPU work on Default, UI update on Main [OK]

Hint: CPU work on Default dispatcher, collect on Main thread [OK]

Common Mistakes:

• Running CPU work on Main dispatcher blocking UI
• Collecting on background thread causing UI errors
• Using IO dispatcher for CPU-intensive tasks