Kotlin Coroutines Expert

# Kotlin Coroutines Expert

Overview

A guide to mastering asynchronous programming with Kotlin Coroutines. Covers advanced topics like structured concurrency, `Flow` transformations, exception handling, and testing strategies.

When to Use This Skill

- Use when implementing asynchronous operations in Kotlin.

- Use when designing reactive data streams with `Flow`.

- Use when debugging coroutine cancellations or exceptions.

- Use when writing unit tests for suspending functions or Flows.

Step-by-Step Guide

1. Structured Concurrency

Always launch coroutines within a defined `CoroutineScope`. Use `coroutineScope` or `supervisorScope` to group concurrent tasks.

suspend fun loadDashboardData(): DashboardData = coroutineScope {
    val userDeferred = async { userRepo.getUser() }
    val settingsDeferred = async { settingsRepo.getSettings() }
    
    DashboardData(
        user = userDeferred.await(),
        settings = settingsDeferred.await()
    )
}

2. Exception Handling

Use `CoroutineExceptionHandler` for top-level scopes, but rely on `try-catch` within suspending functions for granular control.

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

viewModelScope.launch(handler) {
    try {
        riskyOperation()
    } catch (e: IOException) {
        // Handle network error specifically
    }
}

3. Reactive Streams with Flow

Use `StateFlow` for state that needs to be retained, and `SharedFlow` for events.

// Cold Flow (Lazy)
val searchResults: Flow<List<Item>> = searchQuery
    .debounce(300)
    .flatMapLatest { query -> searchRepo.search(query) }
    .flowOn(Dispatchers.IO)

// Hot Flow (State)
val uiState: StateFlow<UiState> = _uiState.asStateFlow()

Examples

Example 1: Parallel Execution with Error Handling

suspend fun fetchDataWithErrorHandling() = supervisorScope {
    val task1 = async { 
        try { api.fetchA() } catch (e: Exception) { null } 
    }
    val task2 = async { api.fetchB() }
    
    // If task2 fails, task1 is NOT cancelled because of supervisorScope
    val result1 = task1.await()
    val result2 = task2.await() // May throw
}

Best Practices

- ✅ **Do:** Use `Dispatchers.IO` for blocking I/O operations.

- ✅ **Do:** Cancel scopes when they are no longer needed (e.g., `ViewModel.onCleared`).

- ✅ **Do:** Use `TestScope` and `runTest` for unit testing coroutines.

- ❌ **Don't:** Use `GlobalScope`. It breaks structured concurrency and can lead to leaks.

- ❌ **Don't:** Catch `CancellationException` unless you rethrow it.

Troubleshooting

**Problem:** Coroutine test hangs or fails unpredictably.

**Solution:** Ensure you are using `runTest` and injecting `TestDispatcher` into your classes so you can control virtual time.