coroutines-patterns

Coroutines Patterns

Structured concurrency for Kotlin.

Coroutine Scopes

// ✅ ViewModel scope (auto-cancelled)
class HomeViewModel : ViewModel() {
    fun loadData() {
        viewModelScope.launch {
            // Cancelled when ViewModel cleared
        }
    }
}

// ✅ Lifecycle scope
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycleScope.launch {
            // Cancelled when lifecycle destroyed
        }
    }
}

// ❌ AVOID: GlobalScope
GlobalScope.launch { }  // Never cancelled, memory leaks

Dispatchers

// Main - UI operations
withContext(Dispatchers.Main) {
    textView.text = "Updated"
}

// IO - Network, disk
withContext(Dispatchers.IO) {
    api.fetchData()
    database.query()
}

// Default - CPU intensive
withContext(Dispatchers.Default) {
    list.sortedBy { it.score }
}

Flow Patterns

// StateFlow for UI state
private val _state = MutableStateFlow(HomeState())
val state: StateFlow<HomeState> = _state.asStateFlow()

// SharedFlow for events (replay=0: emissions with no active
// collector are dropped — extraBufferCapacity does NOT save them,
// it only buffers for slow existing subscribers; for must-deliver
// events use Channel(BUFFERED).receiveAsFlow() instead)
private val _events = MutableSharedFlow<Event>()
val events: SharedFlow<Event> = _events.asSharedFlow()

// Collect with lifecycle
@Composable
fun HomeScreen(viewModel: HomeViewModel) {
    val state by viewModel.state.collectAsStateWithLifecycle()
}

Flow Operators

flow
    .filter { it.isActive }
    .map { transform(it) }
    .distinctUntilChanged()
    .debounce(300)  // still @FlowPreview: needs @OptIn(FlowPreview::class)
    .catch { emit(fallback) }
    .collect { process(it) }

Error Handling

// Try-catch in coroutine (same _state: MutableStateFlow<HomeState> as above;
// don't name a state subtype `Error` — kotlin.Error is a default import and
// `Error(e.message)` silently resolves to the Throwable)
viewModelScope.launch {
    try {
        _state.value = HomeState(data = repository.fetchData())
    } catch (e: CancellationException) {
        throw e  // Never swallow cancellation
    } catch (e: Exception) {
        _state.value = HomeState(error = e.message)
    }
}

// supervisorScope - siblings don't cancel
supervisorScope {
    launch { task1() }  // Failure doesn't cancel task2
    launch { task2() }
}

// CoroutineExceptionHandler - last-resort logging for uncaught
// exceptions in launch. Only effective on root coroutines (or
// supervisorScope children); async surfaces failures via await().
val handler = CoroutineExceptionHandler { _, e -> log(e) }
scope.launch(handler) { risky() }