Kotlin Coroutines Expert

Visão Geral

Um guia para dominar a programação assíncrona com Kotlin Coroutines. Abrange tópicos avançados como concorrência estruturada, Flow transformações, tratamento de exceções e estratégias de teste.

Quando Usar Esta Habilidade

• Use ao implementar operações assíncronas em Kotlin.
• Use ao projetar fluxos de dados reativos com Flow.
• Use ao depurar cancelamentos ou exceções de coroutines.
• Use ao escrever testes unitários para funções de suspensão ou Flows.

Guia Passo a Passo

1. Concorrência Estruturada

Sempre inicie coroutines dentro de um CoroutineScope definido. Use coroutineScope ou supervisorScope para agrupar tarefas concorrentes.

suspend fun loadDashboardData(): DashboardData = coroutineScope {
    val userDeferred = async { userRepo.getUser() }
    val settingsDeferred = async { settingsRepo.getSettings() }

    DashboardData(
        user = userDeferred.await(),
        settings = settingsDeferred.await()
    )
}

2. Tratamento de Exceções

Use CoroutineExceptionHandler para escopos de nível superior, mas confie em try-catch dentro de funções de suspensão para controle granular.

val handler = CoroutineExceptionHandler { _, exception ->
    println("Caught $exception")
}

viewModelScope.launch(handler) {
    try {
        riskyOperation()
    } catch (e: IOException) {
        // Handle network error specifically
    }
}

3. Fluxos Reativos com Flow

Use StateFlow para estado que precisa ser retido e SharedFlow para eventos.

// Cold Flow (Lazy)
val searchResults: Flow<List<Item>> = searchQuery
    .debounce(300)
    .flatMapLatest { query -> searchRepo.search(query) }
    .flowOn(Dispatchers.IO)

// Hot Flow (State)
val uiState: StateFlow<UiState> = _uiState.asStateFlow()

Exemplos

Exemplo 1: Execução Paralela com Tratamento de Erros

suspend fun fetchDataWithErrorHandling() = supervisorScope {
    val task1 = async {
        try { api.fetchA() } catch (e: CancellationException) { throw e } catch (e: IOException) { null }
    }
    val task2 = async { api.fetchB() }

    // A child failure does not directly cancel its siblings.
    // But an uncaught exception from await escapes the supervisor block and cancels it.
    val result1 = task1.await()
    val result2 = task2.await() // May throw
}

Melhores Práticas

• ✅ Faça: Use Dispatchers.IO para operações de I/O bloqueantes.
• ✅ Faça: Cancele escopos quando eles não forem mais necessários (por exemplo, ViewModel.onCleared).
• ✅ Faça: Use TestScope e runTest para testes unitários de coroutines.
• ❌ Não Faça: Use GlobalScope. Isso quebra a concorrência estruturada e pode levar a vazamentos.
• ❌ Não Faça: Capture CancellationException a menos que você o relance.

Solução de Problemas

Problema: O teste de coroutine fica pendurado ou falha de forma imprevisível. Solução: Certifique-se de estar usando runTest e injetando TestDispatcher em suas classes para que você possa controlar o tempo virtual.

Limitações

• Use esta habilidade apenas quando a tarefa corresponder claramente ao escopo descrito acima.
• Não trate a saída como um substituto para validação específica do ambiente, testes ou revisão de especialistas.
• Pare e peça esclarecimentos se os inputs necessários, permissões, limites de segurança ou critérios de sucesso estiverem faltando.

Exemplos são fragmentos: forneça imports, interfaces de repositório, dependências de ciclo de vida do Android e a versão das coroutines instalada. Trate cada falha aguardada deliberadamente e relance o cancelamento. As escolhas de replay/buffer SharedFlow determinam a entrega enquanto nenhum coletor está ativo; não é uma fila de eventos garantida. StateFlow conflaciona mudanças de estado. Teste o cancelamento e coletores lentos/ausentes, não apenas caminhos felizes. Comportamento oficial de exceção.