Kotlin Coroutines: From Basics to Advanced Patterns

Coroutines have revolutionized asynchronous programming in Kotlin. Let's dive deep into how they work.

What are Coroutines?

Coroutines are lightweight threads that allow you to write asynchronous code in a sequential manner.

Basic Usage

viewModelScope.launch {
    val user = userRepository.getUser() // Suspends, doesn't block
    updateUI(user)
}

Structured Concurrency

Always use structured concurrency to prevent leaks:

suspend fun loadUserData(userId: String) = coroutineScope {
    val profile = async { loadProfile(userId) }
    val posts = async { loadPosts(userId) }
    
    UserData(
        profile = profile.await(),
        posts = posts.await()
    )
}

Flow for Reactive Streams

class MessageRepository {
    fun observeMessages(): Flow<List<Message>> = flow {
        while (true) {
            val messages = fetchMessages()
            emit(messages)
            delay(5000) // Poll every 5 seconds
        }
    }
}

// In ViewModel
init {
    messageRepository.observeMessages()
        .onEach { messages ->
            _uiState.value = UiState.Success(messages)
        }
        .launchIn(viewModelScope)
}

Error Handling

viewModelScope.launch {
    try {
        val result = apiCall()
        handleSuccess(result)
    } catch (e: Exception) {
        handleError(e)
    }
}

Best Practices

1. Use viewModelScope for ViewModel coroutines
2. Use lifecycleScope for UI-related coroutines
3. Always handle cancellation
4. Prefer Flow over LiveData for reactive streams

Coroutines make async code readable and maintainable. Master them, and you'll write better Android apps!