android-kotlin-coroutines

Android Kotlin Coroutines

Expert guidance for Android development using Kotlin Coroutines and Flow for asynchronous programming with structured concurrency.

When to Use This Skill

Invoke this skill when:

• Implementing asynchronous operations in Android
• Managing concurrent operations with structured concurrency
• Using Flow for reactive data streams (StateFlow, SharedFlow, callbackFlow)
• Integrating coroutines with Retrofit, Room, or WorkManager
• Handling cancellation and error propagation
• Writing coroutine-based unit tests
• User explicitly mentions "coroutines", "async", "Flow", "suspend", or related patterns

Core Principles

1. Structured Concurrency — Coroutines bound to lifecycle prevent leaks
2. Suspend over Callbacks — Transform callback APIs to suspend functions
3. Main-Safety — Suspend functions safe to call from main thread
4. Flow for Streams — Use Flow for multiple values over time

Quick Reference

Essential Dependencies

// build.gradle.kts (app)
dependencies {
    // Coroutines core
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.8.0")

    // Lifecycle-aware scopes
    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.7.0")
    implementation("androidx.lifecycle:lifecycle-viewmodel-ktx:2.7.0")

    // Flow integration with Compose
    implementation("androidx.lifecycle:lifecycle-runtime-compose:2.7.0")

    // Testing
    testImplementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.8.0")
    testImplementation("app.cash.turbine:turbine:1.0.0")
}

Coroutine Scopes in Android

ViewModel Scope

@HiltViewModel
class UserViewModel @Inject constructor(
    private val repository: UserRepository
) : ViewModel() {

    private val _uiState = MutableStateFlow(UserUiState())
    val uiState: StateFlow<UserUiState> = _uiState.asStateFlow()

    init {
        loadUser()
    }

    private fun loadUser() {
        // Automatically cancelled when ViewModel is cleared
        viewModelScope.launch {
            _uiState.update { it.copy(isLoading = true) }

            repository.getUser()
                .onSuccess { user ->
                    _uiState.update { it.copy(user = user, isLoading = false) }
                }
                .onFailure { error ->
                    _uiState.update { it.copy(error = error.message, isLoading = false) }
                }
        }
    }

    fun refresh() {
        viewModelScope.launch {
            repository.sync()
        }
    }
}