Como implementaria uma coroutine não cancelável?

Para implementar uma coroutine não cancelável, pode-se usar o contexto NonCancellable.

import kotlinx.coroutines.*

suspend fun performNonCancellableOperation() {
    coroutineScope {
        launch {
            // Esta coroutine pode ser cancelada
            delay(1000)
            println("Esta coroutine foi executada")
        }

        withContext(NonCancellable) {
            // Esta coroutine não será cancelada, mesmo que seu escopo pai seja cancelado
            try {
                delay(2000) // Simulação de uma operação prolongada
                println("Operação não cancelável concluída")
            } catch (e: CancellationException) {
                // A coroutine ainda pode receber CancellationException
                // em certos casos (por exemplo, ao fechar a aplicação),
                // mas ela não será cancelada reativamente à cancelamento do pai.
                println("Operação não cancelável foi cancelada: ${e.message}")
            } finally {
                // Este bloco será executado mesmo em caso de cancelamento
                println("Operação não cancelável finalizada (finally)")
            }
        }
    }
}

O uso de NonCancellable é útil para realizar operações finais, como salvar dados ou liberar recursos, quando a coroutine foi cancelada.

É importante lembrar que NonCancellable torna a coroutine insensível à cancelamento do contexto, mas ela ainda pode ser cancelada ao fechar a máquina virtual ou em outros casos extremos. Além disso, se dentro de withContext(NonCancellable) for chamada uma função suspensa que verifica a cancelamento (por exemplo, delay), ela pode lançar uma CancellationException. Portanto, recomenda-se usar try-catch-finally para lidar com essas situações.