Flow context preservation in Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a simple flow emitting numbers 1 to 3.

Kotlin

val numbersFlow = flow {
    for (i in 1..3) {
        emit([1])
    }
}

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

Ai

B3

Cflow

Dcollect

Attempts:

3 left

💡 Hint

Common Mistakes

Using a fixed number like 3 instead of the loop variable.

Trying to emit the flow itself instead of a value.

The emit function sends each value from the flow. Here, i is the current number in the loop.

2fill in blank

medium

Complete the code to collect values from the flow and print them.

Kotlin

runBlocking {
    numbersFlow.[1] { value ->
        println(value)
    }
}

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

Aemit

BflowOn

Claunch

Dcollect

Attempts:

3 left

💡 Hint

Common Mistakes

Using emit instead of collect.

Trying to launch the flow instead of collecting.

The collect function gathers the emitted values from the flow and lets you process them.

3fill in blank

hard

Fix the error in the code to switch the flow context to Dispatchers.IO.

Kotlin

val ioFlow = numbersFlow.[1](Dispatchers.IO)

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

AflowOn

Bcollect

Claunch

Demit

Attempts:

3 left

💡 Hint

Common Mistakes

Using collect or emit which do not change context.

Trying to launch the flow instead of switching context.

The flowOn operator changes the context where the flow runs, here to Dispatchers.IO.

4fill in blank

hard

Fill both blanks to create a flow that emits squares of numbers only if they are even.

Kotlin

val evenSquares = flow {
    for (x in 1..5) {
        if (x [1] 2 == 0) {
            emit(x [2] x)
        }
    }
}

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

A%

B*

C+

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using addition or subtraction instead of multiplication for square.

Using wrong operator for checking even numbers.

The modulo operator % checks if a number is even. The multiplication operator * calculates the square.

5fill in blank

hard

Fill all three blanks to create a flow that emits uppercase strings only if their length is greater than 3.

Kotlin

val words = listOf("cat", "lion", "tiger", "dog")
val filteredFlow = flow {
    for (word in words) {
        if (word.[1] > 3) {
            emit(word.[2]())
        }
    }
}.[3](Dispatchers.Default)

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

Alength

BtoUpperCase

CflowOn

DtoLowerCase

Attempts:

3 left

💡 Hint

Common Mistakes

Using toLowerCase() instead of toUpperCase().

Forgetting to switch the flow context with flowOn.

Using parentheses incorrectly on properties.

length gets the string length, toUpperCase() converts to uppercase, and flowOn changes the flow context.

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