Kotlin Coroutines Deep Dive: Structured Concurrency in Practice

class SearchViewModel(
    private val searchRepo: SearchRepository
) : ViewModel() {

    private val _results = MutableStateFlow<List<Result>>(emptyList())
    val results: StateFlow<List<Result>> = _results.asStateFlow()

    // viewModelScope survives configuration changes
    fun search(query: String) {
        viewModelScope.launch {
            // Cancelled automatically when the ViewModel is cleared
            _results.value = searchRepo.search(query)
        }
    }
}

@Composable
fun SearchScreen(snackbarHostState: SnackbarHostState) {
    // Bound to this point of the composition
    val scope = rememberCoroutineScope()

    Button(
        onClick = {
            // Launch from an event, never from the composable body
            scope.launch {
                snackbarHostState.showSnackbar("Search complete")
            }
        }
    ) { Text("Search") }
}

// BAD: this loop ignores cancellation
suspend fun processLargeList(items: List<Item>) {
    for (item in items) {
        item.transform() // CPU work, no suspension point
    }
}

// GOOD: check for cancellation in tight loops
suspend fun processLargeList(items: List<Item>) = coroutineScope {
    for (item in items) {
        ensureActive() // Throws CancellationException if cancelled
        item.transform()
    }
}

// BAD: swallows cancellation along with real failures
try {
    repo.sync()
} catch (e: Exception) {
    showError(e)
}

// GOOD: catch what you can handle, let cancellation through
try {
    repo.sync()
} catch (e: IOException) {
    showError(e)
}

// PROBLEM: one failure cancels everything
viewModelScope.launch {
    launch { loadUserProfile() }  // If this throws...
    launch { loadUserPosts() }    // ...this is cancelled
    launch { loadUserSettings() } // ...and so is this
}

// SOLUTION 1: supervisorScope isolates the children
viewModelScope.launch {
    supervisorScope {
        launch {
            try { loadUserProfile() }
            catch (e: IOException) { handleProfileError(e) }
        }
        launch {
            try { loadUserPosts() }
            catch (e: IOException) { handlePostsError(e) }
        }
    }
}

// SOLUTION 2: launch each one directly in viewModelScope,
// which already has a SupervisorJob. The handler works here
// because each coroutine is a direct child of the supervisor.
val handler = CoroutineExceptionHandler { _, exception ->
    analytics.logError(exception)
}
viewModelScope.launch(handler) { loadUserProfile() }
viewModelScope.launch(handler) { loadUserPosts() }

// WRONG: detaches from viewModelScope and isolates nothing
viewModelScope.launch(handler + SupervisorJob()) {
    launch { loadUserProfile() }
    launch { loadUserPosts() }
}

@OptIn(FlowPreview::class, ExperimentalCoroutinesApi::class)
class SearchViewModel(
    private val repo: SearchRepository
) : ViewModel() {

    private val _query = MutableStateFlow("")

    val results: StateFlow<SearchState> = _query
        .debounce(300) // Wait 300 ms after the last keystroke
        .filter { it.length >= 2 }
        .flatMapLatest { query ->
            // The previous search is cancelled when a new query arrives
            flow {
                emit(SearchState.Loading)
                try {
                    emit(SearchState.Success(repo.search(query)))
                } catch (e: IOException) {
                    emit(SearchState.Error(e.message))
                }
            }
        }
        .stateIn(
            scope = viewModelScope,
            started = SharingStarted.WhileSubscribed(5000),
            initialValue = SearchState.Idle
        )

    fun onQueryChanged(query: String) {
        _query.value = query
    }
}

sealed interface SearchState {
    data object Idle : SearchState
    data object Loading : SearchState
    data class Success(val results: List<Result>) : SearchState
    data class Error(val message: String?) : SearchState
}

@OptIn(ExperimentalCoroutinesApi::class)
class SearchViewModelTest {

    @Before
    fun setup() {
        Dispatchers.setMain(UnconfinedTestDispatcher())
    }

    @After
    fun tearDown() {
        Dispatchers.resetMain()
    }

    @Test
    fun `search emits results`() = runTest {
        val fakeRepo = FakeSearchRepository(
            results = listOf(Result("Kotlin"))
        )
        val viewModel = SearchViewModel(fakeRepo)

        // Without a collector, WhileSubscribed never starts the flow
        backgroundScope.launch(UnconfinedTestDispatcher(testScheduler)) {
            viewModel.results.collect {}
        }

        viewModel.onQueryChanged("Kotlin")
        advanceUntilIdle() // Skips the 300 ms debounce

        val state = viewModel.results.value
        assertIs<SearchState.Success>(state)
        assertEquals(1, state.results.size)
    }
}