Exception handling in coroutines in Android Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of exception handling in Kotlin coroutines?

Exception handling in Kotlin coroutines helps manage errors that occur during asynchronous tasks, preventing app crashes and allowing graceful recovery.

beginner

Which coroutine builder automatically propagates exceptions to its parent coroutine?

The launch builder propagates exceptions to its parent coroutine, which can then handle or cancel the child coroutine.

beginner

How does try-catch work inside a coroutine?

You can use try-catch blocks inside a coroutine to catch exceptions thrown by suspend functions or other code, just like in regular synchronous code.

intermediate

What is the role of CoroutineExceptionHandler?

CoroutineExceptionHandler is a special context element that catches uncaught exceptions in coroutines launched with launch, allowing centralized error handling.

intermediate

Why should exceptions in async coroutines be handled differently?

Exceptions in async coroutines are deferred until await() is called, so you must handle exceptions when awaiting the result, not when launching.

Which coroutine builder requires you to handle exceptions when calling await()?

A async

B launch

C runBlocking

D withContext

async defers exceptions until await() is called, so you handle exceptions there.

What happens if an exception is not caught inside a launch coroutine?

A It is propagated to the parent coroutine

B It crashes the app immediately

C It is ignored silently

D It is logged but does not affect the app

Exceptions in launch coroutines propagate to their parent, which can handle or cancel them.

Which of these is a correct way to catch exceptions inside a coroutine?

A Using <code>catch</code> method on the coroutine builder

B Using <code>try-catch</code> inside the coroutine block

C Using <code>finally</code> outside the coroutine

D Exceptions cannot be caught in coroutines

You can use try-catch blocks inside coroutines to catch exceptions.

What is the purpose of CoroutineExceptionHandler?

A To cancel coroutines automatically

B To delay coroutine execution

C To handle uncaught exceptions in <code>launch</code> coroutines

D To convert exceptions to logs only

CoroutineExceptionHandler catches uncaught exceptions in launch coroutines.

Where should you handle exceptions when using async?

A When launching the coroutine

B Before starting the coroutine

C Exceptions are handled automatically

D When calling <code>await()</code>

Exceptions in async coroutines are thrown when await() is called.

Explain how exception handling differs between launch and async coroutines in Kotlin.

Think about when exceptions are thrown and caught in each builder.

Describe how to use CoroutineExceptionHandler to handle errors in a coroutine.

It is a context element that catches uncaught exceptions.

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