coroutineScope
Creates a CoroutineScope and calls the specified suspend block with this scope. The provided scope inherits its coroutineContext from the outer scope, but overrides the context's Job.
This function is designed for concurrent decomposition of work. When any child coroutine in this scope fails, this scope fails and all the rest of the children are cancelled (for a different behavior see supervisorScope). This function returns as soon as the given block and all its children coroutines are completed. A usage example of a scope looks like this:
suspend fun showSomeData() = coroutineScope {
val data = async(Dispatchers.IO) { // <- extension on current scope
... load some UI data for the Main thread ...
}
withContext(Dispatchers.Main) {
doSomeWork()
val result = data.await()
display(result)
}
}
The scope in this example has the following semantics:
showSomeData
returns as soon as the data is loaded and displayed in the UI.If
doSomeWork
throws an exception, then theasync
task is cancelled andshowSomeData
rethrows that exception.If the outer scope of
showSomeData
is cancelled, both startedasync
andwithContext
blocks are cancelled.If the
async
block fails,withContext
will be cancelled.
The method may throw a CancellationException if the current job was cancelled externally or may throw a corresponding unhandled Throwable if there is any unhandled exception in this scope (for example, from a crashed coroutine that was started with launch in this scope).