Flow context preservation in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is Flow context preservation in Kotlin?

It means that when a Flow emits values, it keeps the coroutine context (like dispatcher) consistent across its operations, ensuring predictable execution.

beginner

Why is context preservation important in Kotlin Flows?

Because it ensures that all operators in the Flow run on the expected thread or dispatcher, avoiding unexpected thread switches and bugs.

intermediate

How does flowOn affect Flow context preservation?

flowOn changes the coroutine context upstream of where it is applied, allowing you to control where emissions happen without affecting downstream collectors.

intermediate

What happens if you use withContext inside a Flow builder?

Using withContext inside a Flow builder can break context preservation because it switches context inside the emission block, which is discouraged.

intermediate

How can you ensure a Flow preserves its context when collecting?

Collect the Flow in the desired coroutine context or dispatcher, and use flowOn to control upstream context without switching downstream context.

What does flowOn do in Kotlin Flows?

A Changes the context of downstream collectors

B Starts a new coroutine

C Cancels the flow

D Changes the context of upstream flow emissions

flowOn changes the coroutine context for the upstream flow emissions only.

Which operator can break Flow context preservation if used inside a Flow builder?

A withContext

B map

C filter

D collect

withContext switches coroutine context inside the builder and can break context preservation.

Why should you avoid using withContext inside a Flow builder?

A It causes compilation errors

B It slows down the flow

C It breaks context preservation and can cause unexpected behavior

D It cancels the flow

Using withContext inside a Flow builder breaks context preservation and can cause bugs.

How do you keep the downstream collector on the main thread while running emissions on IO dispatcher?

A Use <code>launch(Dispatchers.IO)</code>

B Use <code>flowOn(Dispatchers.IO)</code>

C Use <code>collect(Dispatchers.IO)</code>

D Use <code>withContext(Dispatchers.Main)</code> inside the flow

flowOn(Dispatchers.IO) runs upstream emissions on IO but keeps downstream collection context unchanged.

What ensures that a Flow runs on the expected thread or dispatcher?

A Context preservation

B Using <code>delay()</code>

C Calling <code>cancel()</code>

D Using <code>launch</code> inside the flow

Context preservation keeps the Flow running on the expected coroutine context.

Explain what Flow context preservation means and why it matters in Kotlin coroutines.

Think about how Flow operators run on threads.

Describe how flowOn helps control the execution context of a Flow.

Consider where emissions happen vs where collection happens.