Exception handling in coroutines in Android Kotlin - Build, Publish & Deploy

Build & Publish - Exception handling in coroutines

Performance Impact

Using exception handling in coroutines adds minimal overhead if used properly. Catching exceptions prevents app crashes and allows graceful recovery, improving user experience. However, excessive try-catch blocks inside tight loops can slightly reduce frame rates below 60fps. Proper coroutine cancellation on exceptions helps save memory and battery by stopping unnecessary work.

Optimization Tips

• Use CoroutineExceptionHandler for centralized error handling to avoid repeated try-catch blocks.
• Handle exceptions at the highest coroutine scope possible to reduce redundant catches.
• Cancel coroutines promptly on errors to free resources and maintain smooth UI updates.
• Avoid blocking calls inside coroutines; use suspend functions to keep UI responsive.

App Size and Startup Time

Exception handling in coroutines uses Kotlin standard library features already included in most Android apps, so it adds negligible size to the app bundle. It does not affect startup time significantly. Proper error handling can prevent crashes that would otherwise cause app restarts, indirectly improving perceived startup performance.

iOS vs Android Differences

On Android, Kotlin coroutines are the standard for asynchronous code and support structured concurrency with built-in exception handling. iOS apps typically use Swift concurrency with async/await and try/catch for error handling. Android requires explicit coroutine exception handlers and cancellation, while Swift concurrency integrates error propagation more natively. Understanding platform-specific concurrency models is key when writing cross-platform apps.

Store Review Guidelines

• Google Play: Apps must not crash due to unhandled exceptions; proper coroutine exception handling helps meet this requirement.
• Apple App Store: While this is Android-specific, iOS apps must also handle errors gracefully to avoid crashes and rejections.
• Both stores require apps to maintain good performance and stability, which proper exception handling supports.

Self-Check Question

Your app takes 5 seconds to load this screen and sometimes crashes. What's likely wrong?

• Uncaught exceptions in coroutines causing app crashes.
• Missing or improper use of CoroutineExceptionHandler leading to unhandled errors.
• Long-running coroutine work without cancellation on errors, causing delays.

Key Result

Proper exception handling in Kotlin coroutines prevents crashes and resource leaks, ensuring smooth 60fps UI and stable app behavior with minimal impact on app size or startup time.

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