Provide a way to cancel a running coroutine immediately

When using blocking IO or computations the coroutine won’t be cancelled until the operation is complete meaning finally and invokeOnCompletion blocks can be called long after the parent job is cancelled.

Here’s an example:

class MyPresenter {
  fun loadStuff() {
    scope.launch {
      view.showProgress()
      try {
        performNetworkRequest()
      } catch(e: Exception) {
        view.hideProgress()
      }
    }
  }
}

The example above might crash if the performNetworkRequest isn’t cancelled before the view is detached from the presenter.

Currently the only way around this is to either use suspendCancellableCoroutine and perform a context switch to suspend the coroutine or to use invokeOnCompletion(onCancelling = true) (which is marked internal).

Perhaps a special context could be added to indicate that the result of an operation should be ignored when cancelling.

[zach-klippenstein]

On the JVM, there’s no generic way to force cancellation for any blocking operation. Some APIs have the ability to cancel, others you can work around with thread interruptions. But it’s up to the integration with your particular blocking API to handle actually cancelling the blocking operation. If you’re using Retrofit’s coroutine integration, network requests will automatically be cancelled when the coroutine is cancelled.

Even if you can’t actually cancel the operation, as long as the network request suspends the current coroutine (which it will if it changes context), the cancellation exception should be getting thrown from that function when it finishes at least. Catch and rethrow CancellationException, or check if e is CancellationException, before updating view state again. In general, swallowing CancellationExceptions (or generic Exceptions) is usually not a great idea unless you’re really sure that’s what you want to do.

[ansman]

I created this function now that would fix this. Thanks for the suggestion.

suspend inline fun <R> withCancellableContext(
    context: CoroutineContext,
    crossinline block: CoroutineScope.() -> R
): R {
    val job = GlobalScope.async(context) {
        runCatching(block)
    }
    val result = try {
        job.await()
    } catch (e: CancellationException) {
        job.cancel()
        throw e
    }
    return result.getOrThrow()
}