Kotlin Coroutines & Flow

Priority: P1 (HIGH)

Standard for safe, structured asynchronous programming.

Implementation Guidelines

• •Structured Concurrency: Always launch coroutines within a CoroutineScope (e.g., viewModelScope, lifecycleScope). Never use GlobalScope.
• •Dispatchers: Inject DispatcherProvider or CoroutineDispatcher to simplify testing. Do not hardcode Dispatchers.IO in classes.
• •Suspend Functions: Mark blocking/long-running operations as suspend. They should be "main-safe" (handle their own context switching).
• •Flow: Prefer StateFlow (state holder) and SharedFlow (events) over LiveData.
• •Collection: Use collectLatest for restartable upstream updates. Use flowWithLifecycle in UI.
• •Error Handling: Use CoroutineExceptionHandler for top-level launch, try/catch for code blocks within coroutines.

Anti-Patterns

• •GlobalScope: Leaks memory and breaks structure.
• •Blocking Calls: Never use Thread.sleep or blocking I/O in coroutines. Use delay or proper suspend functions.
• •Async/Await Abuse: Don't use async unless you need parallel execution. Use linear code in launch.
• •Mutable State in Flow: Don't expose MutableStateFlow publicly. Cast to StateFlow.

Code

For detailed ViewModel + StateFlow and Parallel Async examples: references/advanced-patterns.md

// Structured Scope + Main-safe Suspend
viewModelScope.launch {
    val data = withContext(Dispatchers.IO) { repo.fetch() }
    _state.value = UiState.Success(data)
}

Related Topics

best-practices | language | android