Flow basics in Android Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ ui_behavior

intermediate

What is the output of this Flow collection?

Consider this Kotlin Flow code that emits numbers and collects them. What will be printed?

Android Kotlin

import kotlinx.coroutines.flow.*
import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
  val flow = flow {
    emit(1)
    emit(2)
    emit(3)
  }
  flow.collect { value ->
    println(value)
  }
}

A 1\n2\n3

B 3\n2\n1

C 1 2 3 on one line

D No output, code does not compile

💡 Hint

Remember that Flow emits values in the order they are emitted inside the flow builder.

The flow emits values 1, 2, and 3 sequentially. The collect function prints each value on its own line.

🧠 Conceptual

intermediate

What does the 'flowOn' operator do in Kotlin Flow?

Choose the correct description of the 'flowOn' operator in Kotlin Flow.

A Cancels the flow immediately

B Changes the context where the flow is collected

C Changes the context where the flow is emitted

D Buffers the flow emissions

💡 Hint

Think about where the code inside the flow builder runs.

'flowOn' changes the coroutine context where the upstream flow is executed (emission happens). Collection context remains unchanged.

❓ lifecycle

advanced

What happens if you collect a Flow multiple times?

Given a cold Flow in Kotlin, what is the behavior when you collect it multiple times?

A The flow starts emitting from the beginning each time it is collected

B The flow emits only once and shares the result with all collectors

C The flow caches the first emission and replays it to new collectors

D The flow throws an exception on the second collection

💡 Hint

Cold flows start fresh for each collector.

Cold flows start their emission anew for each collector. They do not share emissions unless converted to hot flows.

📝 Syntax

advanced

What error does this Flow code produce?

Analyze this Kotlin Flow code snippet. What error will it cause?

Android Kotlin

import kotlinx.coroutines.flow.*
import kotlinx.coroutines.runBlocking

fun main() = runBlocking {
  val flow = flow {
    emit(1)
    emit(2)
    emit(3)
  }
  flow.collect { value ->
    if (value == 2) throw Exception("Error at 2")
    println(value)
  }
}

A No error, prints 1 2 3

B Exception with message 'Error at 2' is thrown during collection

C Compilation error due to throw inside collect

D Runtime error: NullPointerException

💡 Hint

Throwing inside collect will propagate the exception.

The exception is thrown when value equals 2 during collection, stopping the flow and propagating the error.

❓ navigation

expert

How to cancel a Flow collection properly in Android?

In an Android app using Kotlin Flow, which approach correctly cancels the flow collection when the lifecycle owner is destroyed?

A Use runBlocking { flow.collect { ... } } in the main thread

B Use GlobalScope.launch { flow.collect { ... } } without cancellation

C Collect flow without any coroutine scope

D Use lifecycleScope.launch { flow.collect { ... } } and rely on lifecycleScope cancellation

💡 Hint

Think about lifecycle-aware coroutine scopes in Android.

Using lifecycleScope.launch ties the coroutine to the lifecycle owner, automatically cancelling collection on destruction.

Practice

1. What is the primary purpose of a Flow in Kotlin?

easy

A. To represent a stream of data that can emit multiple values over time

B. To store a single immutable value

C. To create a user interface layout

D. To handle exceptions synchronously

Solution

1. Step 1: Understand what Flow represents

   A Flow is designed to emit multiple values asynchronously over time, like a stream of data.

2. Step 2: Compare options with Flow's purpose

   Only To represent a stream of data that can emit multiple values over time correctly describes Flow as a stream of data emitting multiple values over time.

3. Final Answer:

   To represent a stream of data that can emit multiple values over time -> Option A

4. Quick Check:

   Flow = stream of data [OK]

Hint: Flow emits multiple values over time, not just one [OK]

Common Mistakes:

• Confusing Flow with a single value container like LiveData
• Thinking Flow is for UI layout
• Assuming Flow handles exceptions synchronously

2. Which of the following is the correct way to create a Flow that emits numbers 1 to 3?

easy

A. val flow = flow { emit(1); emit(2); emit(3) }

B. val flow = flowOf(1, 2, 3)

C. All of the above

D. val flow = listOf(1, 2, 3).asFlow()

Solution

1. Step 1: Review Flow creation methods

   Kotlin provides multiple ways to create flows: using flow builder with emit, flowOf, and converting collections with asFlow().

2. Step 2: Check each option

   val flow = flow { emit(1); emit(2); emit(3) } uses flow builder with emit calls, B uses flowOf, and C converts a list to flow. All are valid ways.

3. Final Answer:

   All of the above -> Option C

4. Quick Check:

   Multiple ways to create Flow = D [OK]

Hint: Remember flow, flowOf, and asFlow() all create flows [OK]

Common Mistakes:

• Thinking only flow builder with emit works
• Confusing flowOf with a list
• Not knowing asFlow() converts collections

3. What will be printed by this code?

val flow = flow {
  emit(10)
  emit(20)
}

runBlocking {
  flow.collect { value -> println(value) }
}

medium

A. No output

B. 20 10

C. Only 10

D. 10 20

Solution

1. Step 1: Understand flow emission order

   The flow emits 10 first, then 20 in order.

2. Step 2: Collect prints emitted values in order

   Collect receives values in the same order they are emitted, so prints 10 then 20.

3. Final Answer:

   10 20 -> Option D

4. Quick Check:

   Flow emits in order = 10 20 [OK]

Hint: Flow emits values in order unless otherwise specified [OK]

Common Mistakes:

• Assuming values print in reverse order
• Expecting only first value to print
• Forgetting to run collect inside coroutine

4. Identify the error in this code snippet:

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

flow.collect { println(it) }

medium

A. Missing coroutine scope to call collect

B. emit() cannot be called inside flow builder

C. collect should be replaced with collectLatest

D. No error, code is correct

Solution

1. Step 1: Check how collect is called

   collect is a suspend function and must be called inside a coroutine or suspend function.

2. Step 2: Analyze code context

   Here, collect is called directly without coroutine scope like runBlocking or launch, causing error.

3. Final Answer:

   Missing coroutine scope to call collect -> Option A

4. Quick Check:

   collect needs coroutine scope [OK]

Hint: Always call collect inside coroutine scope [OK]

Common Mistakes:

• Calling collect outside coroutine
• Thinking emit() is invalid inside flow
• Confusing collect with collectLatest necessity

5. You want to create a Flow that emits numbers 1 to 5 but only collect even numbers. Which code correctly achieves this?

hard

A. val flow = flow {
for (i in 1..5) emit(i)
}

runBlocking {
flow.collect { if (it % 2 == 0) println(it) }
}

B. All of the above

C. val flow = flow {
for (i in 1..5) if (i % 2 == 0) emit(i)
}

runBlocking {
flow.collect { println(it) }
}

D. val flow = flowOf(1, 2, 3, 4, 5)

runBlocking {
flow.filter { it % 2 == 0 }.collect { println(it) }
}

Solution

1. Step 1: Analyze each code snippet

   val flow = flow { for (i in 1..5) emit(i) } runBlocking { flow.collect { if (it % 2 == 0) println(it) } } emits all numbers and filters during collect; C emits only even numbers directly; D uses filter operator before collect.

2. Step 2: Confirm all produce only even numbers on collect

   All options print only even numbers 2 and 4 when collected.

3. Final Answer:

   All of the above -> Option B

4. Quick Check:

   Multiple ways to filter Flow = B [OK]

Hint: Filter before or during collect both work [OK]

Common Mistakes:

• Thinking filter must be before collect only
• Not realizing emit can be conditional
• Forgetting to run collect inside coroutine