Flow exception handling in Kotlin - Mini Project: Build & Apply

Flow exception handling

📖 Scenario: You are building a simple Kotlin program that uses a Flow to emit numbers. Sometimes, the flow might throw an exception. You want to handle this exception gracefully and provide a fallback value.

🎯 Goal: Create a Kotlin Flow that emits numbers from 1 to 5 but throws an exception at number 3. Then, handle the exception using catch to emit a fallback value of 0. Finally, collect and print all emitted values.

📋 What You'll Learn

Create a Flow that emits numbers 1 to 5

Throw an exception when the number 3 is emitted

Use catch to handle the exception and emit 0 as fallback

Collect the flow and print each emitted value

💡 Why This Matters

🌍 Real World

Flows are used in Kotlin to handle streams of data asynchronously, such as user inputs, network responses, or sensor data. Handling exceptions in flows ensures your app can recover gracefully from errors.

💼 Career

Understanding Flow exception handling is important for Kotlin developers working on Android apps or backend services that require reactive programming and robust error management.

1

Create a Flow that emits numbers 1 to 5

Create a Flow called numberFlow that emits the numbers 1, 2, 3, 4, and 5 using flow { } and emit().

Kotlin

# Create a Flow called numberFlow that emits 1 to 5
// Your code here

Hint

Use flow { } to create the flow and emit() to send each number.

2

Throw an exception when emitting number 3

Modify the numberFlow so that it throws an Exception("Error at 3") when trying to emit the number 3. Emit numbers 1 and 2 normally before the exception.

Kotlin

import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow

val numberFlow: Flow = flow {
    emit(1)
    emit(2)
    // Throw exception when number is 3
    // Your code here
    emit(4)
    emit(5)
}

Hint

Use throw Exception("Error at 3") right after emitting 2.

3

Handle the exception with catch and emit fallback

Use the catch operator on numberFlow to catch the exception and emit 0 as a fallback value.

Kotlin

import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.catch

val numberFlow: Flow = flow {
    emit(1)
    emit(2)
    throw Exception("Error at 3")
    emit(4)
    emit(5)
}.catch { e ->
    // Emit 0 as fallback when exception occurs
    // Your code here
}

Hint

Use .catch { e -> emit(0) } after the flow to handle exceptions.

4

Collect and print all emitted values

Collect the numberFlow using collect inside a runBlocking block and print each emitted value with println().

Kotlin

import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.flow.collect

fun main() = runBlocking {
    // Collect numberFlow and print each value
    // Your code here
}

Hint

Use runBlocking to run the coroutine and numberFlow.collect { value -> println(value) } to print each emitted value.

Practice

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

easy

A. To start collecting the flow

B. To handle exceptions that occur during the flow emission

C. To transform emitted values into another type

D. To cancel the flow collection

Solution

1. Step 1: Understand the role of catch in Flow

   The catch operator is designed to intercept exceptions that happen during the emission of values in a Flow.

2. Step 2: Differentiate from other operators

   Operators like map transform values, collect starts the flow, and cancel stops it. Only catch handles errors.

3. Final Answer:

   To handle exceptions that occur during the flow emission -> Option B

4. Quick Check:

   Flow error handling = catch [OK]

Hint: Remember: catch is for errors inside Flow [OK]

Common Mistakes:

• Confusing catch with map or collect
• Thinking catch cancels the flow
• Assuming catch transforms values

2. Which of the following is the correct syntax to catch exceptions in a Kotlin Flow?

easy

A. flow.catch { e -> emit(fallbackValue) }

B. flow.try { e -> emit(fallbackValue) }

C. flow.handle { e -> emit(fallbackValue) }

D. flow.error { e -> emit(fallbackValue) }

Solution

1. Step 1: Recall the correct operator name

   The operator to handle exceptions in Kotlin Flow is catch, not try, handle, or error.

2. Step 2: Verify the lambda syntax

   The lambda receives the exception e and can emit fallback values inside it, matching the syntax flow.catch { e -> emit(fallbackValue) }.

3. Final Answer:

   flow.catch { e -> emit(fallbackValue) } -> Option A

4. Quick Check:

   Correct catch syntax = flow.catch { e -> ... } [OK]

Hint: Use catch, not try, for Flow exceptions [OK]

Common Mistakes:

• Using try instead of catch
• Wrong operator names like handle or error
• Incorrect lambda parameter usage

3. What will be the output of the following Kotlin code?

import kotlinx.coroutines.flow.*
suspend fun main() {
    flow {
        emit(1)
        throw RuntimeException("Error!")
    }
    .catch { emit(99) }
    .collect { println(it) }
}

medium

A. 1
Error!

B. Only 99

C. Error! Exception thrown

D. 1
99

Solution

1. Step 1: Analyze the flow emissions and exception

   The flow emits 1, then throws a RuntimeException. The catch operator catches this exception and emits 99 as a fallback.

2. Step 2: Understand the collection output

   The collector prints each emitted value. So it prints 1 first, then after catching the exception, it prints 99.

3. Final Answer:

   1 99 -> Option D

4. Quick Check:

   Emit before error + catch fallback = 1 and 99 [OK]

Hint: catch emits fallback after error, original emits stay [OK]

Common Mistakes:

• Expecting exception message to print
• Thinking flow stops without catch
• Ignoring emitted values before error

4. Identify the error in this Kotlin Flow exception handling code:

flow {
    emit(10)
    throw IllegalStateException("Oops")
}.catch { e ->
    println("Caught: $e")
}.collect {
    println(it)
}

medium

A. Missing emit inside catch to provide fallback value

B. catch block should be after collect

C. collect should be inside catch block

D. No error, code is correct

Solution

1. Step 1: Review catch usage

   The catch block prints the exception but does not emit any fallback value, so the flow ends after the exception.

2. Step 2: Understand flow continuation

   Without emitting a fallback value inside catch, the collector won't receive any value after the error, which might not be intended.

3. Final Answer:

   Missing emit inside catch to provide fallback value -> Option A

4. Quick Check:

   catch without emit = no fallback value [OK]

Hint: Emit fallback inside catch to continue flow after error [OK]

Common Mistakes:

• Placing catch after collect
• Trying to collect inside catch
• Not emitting fallback value in catch

5. You want to create a Kotlin Flow that emits numbers 1 to 3, but if an exception occurs, it should emit -1 and then complete. Which code snippet correctly implements this behavior?

hard

A. flow {
for (i in 1..3) emit(i)
}.catch { emit(-1) }

B. flow {
for (i in 1..3) {
if (i == 4) throw Exception()
emit(i)
}
}.catch { emit(-1) }

C. flow {
for (i in 1..3) {
if (i == 2) throw Exception()
emit(i)
}
}.catch { emit(-1) }

D. flow {
for (i in 1..3) emit(i)
}.catch { throw Exception() }

Solution

1. Step 1: Identify where exception occurs

   flow { for (i in 1..3) { if (i == 2) throw Exception() emit(i) } }.catch { emit(-1) } throws an exception at i == 2, triggering the catch block to emit -1 as fallback.

2. Step 2: Confirm fallback emission and completion

   The catch block emits -1, then the flow completes. Codes without throwing an exception during the emission loop do not trigger catch. Code that rethrows the exception in catch does not emit fallback.

3. Final Answer:

   flow { for (i in 1..3) { if (i == 2) throw Exception() emit(i) } }.catch { emit(-1) } -> Option C

4. Quick Check:

   Throw inside flow + catch emit fallback = flow { for (i in 1..3) { if (i == 2) throw Exception() emit(i) } }.catch { emit(-1) } [OK]

Hint: Throw inside flow, catch emits fallback -1 [OK]

Common Mistakes:

• Not throwing exception inside emission loop
• Rethrowing exception in catch instead of emitting fallback
• Throwing exception outside emission range