Kotlin Coroutines Flow catch 机制

Question

In my sample I'm calling.network operation and emitting success case but on error eg 404 app crashes wihout emitting exception. Surrendering with try catch prevent crashes but I want to pass error till the ui layer like success case.

  suspend fun execute(
    params: Params,
):
        Flow<Result<Type>> = withContext(Dispatchers.IO) {
    flow {
        emit(Result.success(run(params)))
    }.catch {
        emit(Result.failure(it))
    }

}

Answer 1

If you want to use flows you can use the catch method of flows. As you said you can use try-catch but it would break the structured concurrency since it would catch the cancellation exception as well or it would avoid the cancellation exception to be thrown. One thing that you can do is to use an Exception handler at the point where you launch the root coroutine that calls the suspend function.

val coroutineExceptionHandler = CoroutineExceptionHandler { _, exception -> 
    // handle it
}

scope.launch(handler) { // root coroutine
    execute(params)
    somethingThatShouldBeExecutedOnlyIfPreviousCallDoesNotThrow()
}

This solution is good for both flows and non-flow coroutines.

In the solution with the runCatching you will have to manually check the result of the first execute to avoid the second one to run. One interesting thread is here .

Answer 2

There is a helpful function runCatching for creating a Result easily, but the problem in coroutines is that you don't want to be swallowing CancellationExceptions. So below, I'm using runCatchingCancellable from my answer here .

This shouldn't be a Flow since it returns a single item.

If run is a not a blocking function (it shouldn't be if you are using Retrofit with suspend functions), your code can simply be:

suspend fun execute(params: Params): Result<Type> = runCatchingCancellable {
    run(params)
}

If it is a blocking function you can use:

suspend fun execute(params: Params): Result<Type> = runCatchingCancellable {
    withContext(Dispatchers.IO) {
        run(params)
    }
}

If you were going to return a Flow (which you shouldn't for a returning a single item,!), then you shouldn't make this a suspend function, and you should catch the error inside the flow builder lambda:

fun execute(params: Params): Flow<Result<Type>> = flow {
    emit(runCatchingCancellable {
        run(params)
    })
}

// or if run is blocking (it shouldn't be):

fun execute(params: Params): Flow<Result<Type>> = flow {
    emit(runCatchingCancellable {
        withContext(Dispatchers.IO) { run(params) }
    })
}