Exception handling in coroutines in Android Kotlin

Introduction

Sometimes, things go wrong when your app does work in the background. Exception handling in coroutines helps you catch and manage these errors so your app doesn't crash.

When you want to safely run background tasks like fetching data from the internet.

When you need to handle errors without stopping the whole app.

When you want to show a friendly message if something fails during a background job.

When you want to log errors happening inside coroutines for debugging.

When you want to clean up resources if a coroutine fails.

Syntax

Android Kotlin

try {
    // coroutine code that might throw an exception
} catch (e: Exception) {
    // handle the exception here
}

Use try-catch inside coroutines to catch exceptions.

You can also use CoroutineExceptionHandler to handle exceptions globally.

Examples

This example shows catching an exception inside a coroutine launched with launch.

Android Kotlin

launch {
    try {
        val result = fetchData()
        println("Data: $result")
    } catch (e: Exception) {
        println("Error: ${e.message}")
    }
}

This example shows using CoroutineExceptionHandler to catch exceptions globally in a coroutine.

Android Kotlin

val handler = CoroutineExceptionHandler { _, exception ->
    println("Caught $exception")
}

GlobalScope.launch(handler) {
    throw RuntimeException("Oops!")
}

Sample App

This program starts a coroutine that throws an exception after a delay. The CoroutineExceptionHandler catches the exception and prints a message. The program then prints that the coroutine finished.

Android Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    val handler = CoroutineExceptionHandler { _, exception ->
        println("Caught exception: ${exception.message}")
    }

    val job = launch(handler) {
        println("Starting coroutine")
        delay(500)
        throw IllegalArgumentException("Something went wrong")
    }

    job.join()
    println("Coroutine finished")
}

Important Notes

Exceptions in launch coroutines must be handled to avoid app crashes.

Exceptions in async coroutines are thrown when you call await().

Use CoroutineExceptionHandler for centralized error handling in coroutines.

Summary

Use try-catch blocks inside coroutines to catch exceptions.

CoroutineExceptionHandler helps handle exceptions globally.

Handling exceptions keeps your app stable and user-friendly.

Practice

1. What is the primary purpose of using try-catch blocks inside Kotlin coroutines?

easy

A. To pause the coroutine execution

B. To start a new coroutine

C. To catch and handle exceptions that occur during coroutine execution

D. To cancel the coroutine immediately

Solution

1. Step 1: Understand coroutine error handling

   Coroutines can throw exceptions during their execution which need to be handled to avoid app crashes.

2. Step 2: Role of try-catch in coroutines

   Using try-catch inside a coroutine allows catching exceptions locally and handling them gracefully.

3. Final Answer:

   To catch and handle exceptions that occur during coroutine execution -> Option C

4. Quick Check:

   try-catch in coroutine = catch exceptions [OK]

Hint: try-catch inside coroutine catches errors locally [OK]

Common Mistakes:

• Thinking try-catch starts or cancels coroutines
• Confusing try-catch with coroutine builders
• Assuming try-catch pauses coroutine

2. Which of the following is the correct syntax to define a CoroutineExceptionHandler in Kotlin?

easy

A. val handler = CoroutineExceptionHandler(context, exception) -> println(exception)

B. val handler = CoroutineExceptionHandler { context, exception -> println(exception) }

C. val handler = CoroutineExceptionHandler(context) { exception -> println(exception) }

D. val handler = CoroutineExceptionHandler { exception -> println(exception) }

Solution

1. Step 1: Recall CoroutineExceptionHandler syntax

   The handler takes a lambda with two parameters: CoroutineContext and Throwable.

2. Step 2: Match correct lambda parameters

   val handler = CoroutineExceptionHandler { context, exception -> println(exception) } correctly uses (context, exception) parameters and prints the exception.

3. Final Answer:

   val handler = CoroutineExceptionHandler { context, exception -> println(exception) } -> Option B

4. Quick Check:

   CoroutineExceptionHandler syntax = val handler = CoroutineExceptionHandler { context, exception -> println(exception) } [OK]

Hint: CoroutineExceptionHandler lambda needs context and exception [OK]

Common Mistakes:

• Omitting context parameter in lambda
• Using wrong lambda parameter order
• Incorrect parentheses placement

3. What will be the output of this Kotlin coroutine code snippet?

val handler = CoroutineExceptionHandler { _, exception -> println("Caught: ${exception.message}") }

GlobalScope.launch(handler) {
  throw IllegalArgumentException("Invalid argument")
}
Thread.sleep(100)

medium

A. Caught: Invalid argument

B. No output, exception crashes app

C. Caught: null

D. Compilation error due to handler

Solution

1. Step 1: Understand CoroutineExceptionHandler usage

   The handler catches uncaught exceptions in the coroutine and prints the message.

2. Step 2: Analyze the thrown exception

   The coroutine throws IllegalArgumentException with message "Invalid argument", which the handler prints.

3. Final Answer:

   Caught: Invalid argument -> Option A

4. Quick Check:

   Exception caught and printed = Caught: Invalid argument [OK]

Hint: ExceptionHandler prints exception message on uncaught errors [OK]

Common Mistakes:

• Assuming exception crashes app without handler
• Expecting null message output
• Confusing compile error with runtime behavior

4. Identify the error in this coroutine exception handling code:

val handler = CoroutineExceptionHandler { context, exception ->
  println("Error: ${exception.message}")
}

GlobalScope.launch {
  throw RuntimeException("Failure")
}

medium

A. GlobalScope.launch requires a try-catch block inside

B. CoroutineExceptionHandler lambda has wrong parameters

C. RuntimeException cannot be caught by CoroutineExceptionHandler

D. Handler is not attached to the coroutine, so exception is uncaught

Solution

1. Step 1: Check handler usage

   The handler is defined but not passed to the coroutine builder, so it is unused.

2. Step 2: Effect of missing handler attachment

   Without attaching handler to launch, exceptions are not caught by it and crash the app.

3. Final Answer:

   Handler is not attached to the coroutine, so exception is uncaught -> Option D

4. Quick Check:

   Handler must be passed to launch = Handler is not attached to the coroutine, so exception is uncaught [OK]

Hint: Attach handler to launch to catch exceptions [OK]

Common Mistakes:

• Defining handler but forgetting to pass it to launch
• Thinking all exceptions are caught automatically
• Misunderstanding CoroutineExceptionHandler parameters

5. You want to handle exceptions globally for all coroutines in your app using CoroutineExceptionHandler. Which approach correctly applies this handler to multiple coroutines launched in different scopes?

hard

A. Create a single CoroutineExceptionHandler instance and pass it to each coroutine builder's context

B. Use try-catch inside each coroutine instead of CoroutineExceptionHandler

C. Attach CoroutineExceptionHandler only to the first coroutine launched

D. Use a global try-catch block outside all coroutine launches

Solution

1. Step 1: Understand global exception handling

   CoroutineExceptionHandler can be reused by passing the same instance to multiple coroutine builders.

2. Step 2: Evaluate options for applying handler globally

   Passing the handler to each coroutine context ensures all coroutines use the same global handler.

3. Final Answer:

   Create a single CoroutineExceptionHandler instance and pass it to each coroutine builder's context -> Option A

4. Quick Check:

   Reuse handler by passing to each coroutine = Create a single CoroutineExceptionHandler instance and pass it to each coroutine builder's context [OK]

Hint: Pass one handler instance to all coroutine contexts [OK]

Common Mistakes:

• Using try-catch only inside coroutines misses global handling
• Attaching handler to only one coroutine limits scope
• Trying to catch exceptions outside coroutine scope