Kotlin coroutines for async operations

Alex Chen Jan 2026

2 tabs

package com.example.myapp.data

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
import retrofit2.http.GET
import retrofit2.http.POST
import retrofit2.http.Body

interface ApiService {
    @GET("posts")
    suspend fun getPosts(): List<Post>

    @POST("posts")
    suspend fun createPost(@Body post: Post): Post
}

class PostRepository(
    private val apiService: ApiService,
    private val postDao: PostDao
) {
    private val _postsFlow = MutableStateFlow<List<Post>>(emptyList())
    val postsFlow: StateFlow<List<Post>> = _postsFlow.asStateFlow()

    suspend fun fetchPosts(): Result<List<Post>> = withContext(Dispatchers.IO) {
        try {
            val posts = apiService.getPosts()
            postDao.insertAll(posts)
            _postsFlow.value = posts
            Result.success(posts)
        } catch (e: Exception) {
            // Fallback to cached data
            val cachedPosts = postDao.getAllPosts()
            _postsFlow.value = cachedPosts
            Result.failure(e)
        }
    }

    suspend fun createPost(post: Post): Result<Post> = withContext(Dispatchers.IO) {
        try {
            val created = apiService.createPost(post)
            postDao.insert(created)
            Result.success(created)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }

    fun observePosts(): Flow<List<Post>> = postDao.observePosts()
        .flowOn(Dispatchers.IO)
        .map { posts ->
            posts.sortedByDescending { it.createdAt }
        }

    suspend fun syncPosts() = coroutineScope {
        val local = async { postDao.getAllPosts() }
        val remote = async { apiService.getPosts() }

        val localPosts = local.await()
        val remotePosts = remote.await()

        // Merge and deduplicate
        val merged = (localPosts + remotePosts)
            .distinctBy { it.id }
            .sortedByDescending { it.createdAt }

        postDao.deleteAll()
        postDao.insertAll(merged)
        _postsFlow.value = merged
    }
}

package com.example.myapp.ui

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.launch

class PostViewModel(
    private val repository: PostRepository
) : ViewModel() {

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

    init {
        loadPosts()
        observePosts()
    }

    private fun observePosts() {
        viewModelScope.launch {
            repository.observePosts()
                .catch { e ->
                    _uiState.update { it.copy(error = e.message) }
                }
                .collect { posts ->
                    _uiState.update { it.copy(posts = posts, isLoading = false) }
                }
        }
    }

    fun loadPosts() {
        viewModelScope.launch {
            _uiState.update { it.copy(isLoading = true, error = null) }

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

    fun createPost(title: String, body: String) {
        viewModelScope.launch {
            val post = Post(
                id = 0,
                title = title,
                body = body,
                author = "Current User",
                createdAt = System.currentTimeMillis()
            )

            repository.createPost(post)
                .onSuccess {
                    loadPosts()
                }
                .onFailure { e ->
                    _uiState.update { it.copy(error = e.message) }
                }
        }
    }
}

data class PostsUiState(
    val posts: List<Post> = emptyList(),
    val isLoading: Boolean = false,
    val error: String? = null
)

2 files · kotlin Explain with highlit

Kotlin coroutines provide structured concurrency for asynchronous programming. I use suspend functions to mark async code, and launch or async to start coroutines. viewModelScope and lifecycleScope tie coroutines to component lifecycles, cancelling automatically. Dispatchers control execution context—Dispatchers.IO for network/disk, Dispatchers.Main for UI updates, Dispatchers.Default for CPU work. withContext switches dispatchers. async/await enables parallel execution with awaitAll(). Flow provides reactive streams with operators like map, filter, and collect. StateFlow and SharedFlow share state across coroutines. Error handling uses try/catch or CoroutineExceptionHandler. Coroutines replace callbacks and RxJava with cleaner, sequential code.