Exception handling in coroutines in Android Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to catch exceptions inside a coroutine using try-catch.

Android Kotlin

launch {
  try {
    // some suspend function call
  } catch (e: [1]) {
    println("Error caught")
  }
}

Drag options to blanks, or click blank then click option'

AException

BError

CCancellationException

DThrowable

Attempts:

3 left

💡 Hint

Common Mistakes

Using Error instead of Exception

Catching CancellationException which is usually rethrown

In Kotlin coroutines, Exception is commonly caught to handle errors.

2fill in blank

medium

Complete the code to handle exceptions globally in a CoroutineScope using a handler.

Android Kotlin

val handler = CoroutineExceptionHandler { _, [1] ->
  println("Caught: $[1]")
}

CoroutineScope(Dispatchers.Main + handler).launch {
  // coroutine code
}

Drag options to blanks, or click blank then click option'

Aerror

Bthrowable

Cexception

De

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'throwable' instead of 'exception'

Using 'error' which is not the parameter name

The CoroutineExceptionHandler lambda receives the CoroutineContext and the exception object.

3fill in blank

hard

Fix the error in the code to properly handle cancellation exceptions separately.

Android Kotlin

try {
  withContext(Dispatchers.IO) {
    // some suspend call
  }
} catch (e: [1]) {
  println("Cancelled")
} catch (e: Exception) {
  println("Other error")
}

Drag options to blanks, or click blank then click option'

AError

BCancellationException

CThrowable

DException

Attempts:

3 left

💡 Hint

Common Mistakes

Catching Exception first and missing cancellation

Catching Throwable which is too broad

CancellationException must be caught separately to handle coroutine cancellations properly.

4fill in blank

hard

Fill both blanks to create a supervisor scope that handles child coroutine failures independently.

Android Kotlin

supervisorScope {
  val job = launch [1] {
    throw RuntimeException("Fail")
  }
  job [2] {
    println("Child failed")
  }
}

Drag options to blanks, or click blank then click option'

ASupervisorJob()

Bjoin()

CinvokeOnCompletion

Dcancel()

Attempts:

3 left

💡 Hint

Common Mistakes

Using cancel instead of invokeOnCompletion

Using join which waits but does not handle completion callbacks

Using SupervisorJob() allows child coroutines to fail independently. invokeOnCompletion registers a callback on job completion.

5fill in blank

hard

Fill all three blanks to create a coroutine with a handler that logs exceptions and rethrows cancellation.

Android Kotlin

val handler = CoroutineExceptionHandler { _, e ->
  if (e is [1]) throw e
  else println("Error: $e")
}

CoroutineScope(Dispatchers.Default + handler).launch {
  try {
    // some suspend call
  } catch (e: [2]) {
    println("Caught: $e")
  }
}

fun main() {
  val job = CoroutineScope(Dispatchers.Default + handler).launch {
    throw [3]("Oops")
  }
}

Drag options to blanks, or click blank then click option'

ACancellationException

BException

CRuntimeException

DError

Attempts:

3 left

💡 Hint

Common Mistakes

Catching CancellationException in try-catch instead of rethrowing

Throwing Error which is not recommended

CancellationException is rethrown to not swallow cancellations. Exception is caught in try-catch. RuntimeException is thrown in main coroutine.

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