How to Handle Errors in Flow in Kotlin: Simple Guide

In Kotlin, you handle errors in Flow by using the catch operator to intercept exceptions and emit fallback values or handle them gracefully. You can also use retry to attempt the flow again after an error occurs.

Why This Happens

When a Flow emits an error, it stops emitting further values and throws an exception downstream. If you don't handle this error, your program may crash or stop processing data unexpectedly.

kotlin

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

fun main() = runBlocking {
    val flow = flow {
        emit(1)
        emit(2)
        throw RuntimeException("Oops, error in flow")
        emit(3)
    }

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

Output

1
2
Exception in thread "main" java.lang.RuntimeException: Oops, error in flow
	at MainKt$main$1.invokeSuspend(Main.kt:7)
	... (stack trace)

The Fix

Use the catch operator to catch exceptions inside the flow and handle them without crashing. You can emit fallback values or log the error. This keeps the flow running smoothly.

kotlin

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

fun main() = runBlocking {
    val flow = flow {
        emit(1)
        emit(2)
        throw RuntimeException("Oops, error in flow")
        emit(3)
    }.catch { e ->
        println("Caught error: ${e.message}")
        emit(-1) // fallback value
    }

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

Output

1
2
Caught error: Oops, error in flow
-1

Prevention

To avoid unhandled errors in flows, always use catch when collecting from flows that might throw exceptions. Consider using retry to automatically retry the flow on failure. Also, keep your flow logic simple and test error cases.

• Use catch to handle exceptions gracefully.
• Use retry to retry failed flows.
• Write unit tests for error scenarios.
• Keep side effects outside the flow builder.

Related Errors

Other common errors include:

• CancellationException: Happens when the coroutine collecting the flow is cancelled.
• IllegalStateException: Occurs if you try to collect a flow multiple times without proper sharing.
• TimeoutCancellationException: When a flow operation times out.

Use appropriate coroutine scopes and operators like shareIn or stateIn to manage flow lifecycle and avoid these errors.

Key Takeaways

Use the catch operator to handle errors inside Kotlin flows gracefully.

Emit fallback values or log errors inside catch to keep the flow running.

Use retry to automatically retry flows after failures.

Test your flows for error cases to prevent crashes.

Manage flow lifecycle properly to avoid cancellation and state errors.