🔵 🔵 Coroutines & Kotlin Flows

Coroutines are lightweight concurrency primitives — suspendable computations that can be paused and resumed without blocking a thread. They're built on top of continuation-passing style (CPS) transforms at the compiler level.

• 1 thread can run thousands of coroutines.
• No new threads created for suspend function calls.
• The compiler transforms suspend functions into state machines.

A function marked with suspend can be paused and resumed. It can only be called from a coroutine or another suspend function. Under the hood, the compiler adds a Continuation parameter to manage the state machine.

suspend fun fetchUser(): User {
    return withContext(Dispatchers.IO) {
        api.getUser() // network call, doesn't block thread
    }
}

Structured concurrency guarantees that coroutines launched in a scope are bound to that scope's lifetime:

• When a scope is cancelled, all its children are cancelled.
• A parent won't complete until all its children complete.
• Exceptions propagate upward through the hierarchy.

viewModelScope.launch {
    val a = async { fetchA() }
    val b = async { fetchB() }
    process(a.await(), b.await())
} // Both a and b cancelled if viewModel is cleared

• viewModelScope: Tied to ViewModel. Cancelled when ViewModel is cleared. Best for data loading.
• lifecycleScope: Tied to Activity/Fragment lifecycle. Use for UI-bound work.
• GlobalScope: App-lifetime scope. Avoid — leaks memory, breaks structured concurrency.

// Option 1: try-catch inside coroutine
launch {
    try { riskyCall() }
    catch (e: Exception) { handleError(e) }
}
 
// Option 2: CoroutineExceptionHandler (for launch only)
val handler = CoroutineExceptionHandler { _, throwable ->
    Log.e("Error", throwable.message ?: "")
}
launch(handler) { riskyCall() }

async exceptions are NOT caught by CoroutineExceptionHandler — they surface on .await().

• Job: Failure in one child cancels all siblings.
• SupervisorJob: Each child fails independently; siblings are not cancelled.

val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
scope.launch { failingTask() }   // doesn't cancel other children
scope.launch { otherTask() }     // continues running

ViewModelScope uses SupervisorJob internally.

Flow is a cold, asynchronous stream of values built on coroutines. "Cold" means the stream doesn't start until it's collected.

fun getNumbers(): Flow<Int> = flow {
    for (i in 1..5) {
        delay(100)
        emit(i)
    }
}
 
viewModelScope.launch {
    getNumbers().collect { println(it) }
}

flow
    .filter { it > 2 }
    .map { it * 10 }
    .debounce(300L)        // wait 300ms of silence before emitting
    .collectLatest { value ->
        // cancels previous block if new value arrives
        expensiveOperation(value)
    }

• debounce: Useful for search-as-you-type. Waits for a pause before emitting.
• throttleFirst: Emits first item in a time window.
• collectLatest: Cancels in-progress collection if new value arrives.

• Cold: Each collector gets its own independent stream. Starts fresh on each collect call.
• Hot: Stream runs regardless of collectors. Multiple collectors share the same emissions.

StateFlow and SharedFlow are hot. flow {} builder creates cold flows.

• buffer(): Collector runs concurrently with emitter in a separate coroutine.
• conflate(): Drop intermediate values, always process latest.
• collectLatest {}: Cancel previous collection when new value arrives.

heavyFlow()
    .buffer(capacity = 64)
    .collect { process(it) }