How to Cancel Coroutines in Kotlin Android

Introduction:

In the ongoing execution of your application, it becomes essential to manage background coroutines effectively. Kotlin offers a convenient feature for terminating coroutine processes using the cancel method. The launch method employed to initiate a coroutine returns a Job object, which serves as a handle for canceling the associated coroutine at a later point in the program.

Use of Cancel function:

        val job = CoroutineScope(Dispatchers.IO).launch {
            repeat(1000){i ->
                println("Job: $i")
                delay(700L)
            }
        }
        delay(1500L)
        println("main: Hello from Main")
        job.cancel()
        job.join()
        println("main: This is my last message")
    

In the provided code snippet, the job.cancel() method is utilized to terminate the Coroutine process. Executing the above code will yield the following result:

        Job: 0
        Job: 1
        Job: 2
        main: Hello from Main
        main: This is my last message

In the given code snippet, it’s crucial to note that the job.cancel() method is intended for use within the Coroutine context. Attempting to employ this method outside of a Coroutine, for example, in a delay function, will result in an error. If the provided code is currently being used in the main function as illustrated below:

Full Code:

        fun main() = runBlocking{
            val job = CoroutineScope(Dispatchers.IO).launch {
                repeat(1000){i ->
                    println("Job: $i")
                    delay(700L)
                }
            }
            delay(1500L)
            println("main: Hello from Main")
            job.cancel()
            job.join()
            println("main: This is my last message")
        }

Conclusion:

In conclusion, managing coroutine execution in Kotlin Android applications involves utilizing the cancel method associated with the coroutine’s Job object. This method proves effective in terminating coroutine processes within their designated scopes. However, it is imperative to exercise caution and restrict the usage of cancel to the appropriate coroutine context. Attempting to employ it outside of a coroutine, for instance, in a non-coroutine function, may lead to errors. By understanding and applying these principles, developers can efficiently control and cancel coroutines to enhance the overall robustness and responsiveness of their Kotlin Android applications.

To learn more about Coroutines, Click Here