Master Kotlin Coroutines for Async Programming

This skill guides asynchronous Kotlin programming with coroutines, covering structured concurrency, Flow transformations, exception handling, and testing strategies. Structured concurrency means always launching coroutines within a defined CoroutineScope, using coroutineScope to group concurrent tasks that should fail together (an async/await pair loading a user and settings in parallel for a dashboard) or supervisorScope when one task's failure shouldn't cancel the others - shown with a parallel-fetch example where task1's exception is caught inline so task2 still completes even though it's a sibling under supervisorScope. Exception handling uses CoroutineExceptionHandler at the top-level scope for catch-all logging, while granular handling inside suspending functions relies on ordinary try-catch, illustrated with a viewModelScope.launch(handler) block catching an IOException specifically. For reactive streams, StateFlow holds state that needs to be retained and replayed to new collectors, while SharedFlow is for one-off events; a cold flow example debounces search queries and uses flatMapLatest plus flowOn(Dispatchers.IO) to move work off the main thread, contrasted with a hot StateFlow exposed via asStateFlow().

Use this when implementing asynchronous operations in Kotlin, designing reactive data streams with Flow, debugging coroutine cancellation or exception behavior, or writing unit tests for suspending functions or Flows.

Do not use GlobalScope - it breaks structured concurrency and can leak coroutines that outlive their intended lifetime. Do not catch CancellationException unless you immediately rethrow it, since swallowing it silently breaks coroutine cancellation propagation. As with the skill's own stated limitations, use it only when the task matches this scope, and treat the output as guidance rather than a substitute for environment-specific validation or expert review.

Input is an asynchronous Kotlin task - a parallel data load, a reactive stream, an exception-handling requirement, or a coroutine unit test. Output is Kotlin code using the appropriate scope (coroutineScope vs supervisorScope), the appropriate Flow type (StateFlow vs SharedFlow), and correct exception handling for that context, following the stated best practices: use Dispatchers.IO for blocking I/O, cancel scopes when no longer needed (e.g. in ViewModel.onCleared), and use TestScope with runTest for unit testing.

Built on Kotlin's coroutines library (CoroutineScope, async/await, Flow, StateFlow, SharedFlow) and its coroutine test library (TestScope, runTest, TestDispatcher) for controlling virtual time in tests.

Kotlin developers implementing async operations, reactive data streams, or coroutine unit tests who need correct scope selection, exception propagation, and testable virtual-time control.

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
}