Enables multi-threaded coroutine usage in shared code, facilitating background tasks, asynchronous work, and callback-based operations. Prefers frozen state for object handling across threads.
To use in your multiplatform project, update your common dependencies in your gradle configuration:
kotlin {
sourceSets {
commonMain {
dependencies {
implementation "com.autodesk:coroutineworker:0.8.3"
}
}
}
}
CoroutineWorker uses gradle module metadata. We recommend adding the following to your settings.gradle to take advantage of that (not necessary for Gradle 6+):
enableFeaturePreview('GRADLE_METADATA')
CoroutineWorker helps support multi-threaded coroutine usage in common code that works in Kotlin/Native and on JVM until kotlinx.coroutines has full support for native, multi-threaded coroutines.
Use execute to start background work from common code:
val worker = CoroutineWorker.execute {
// - In here, `this` is a `CoroutineScope`
// - Run suspend functions, call launch, etc.
// - This code runs in a thread pool
}
// Tells the worker to cancel (uses standard coroutine cancellation)
worker.cancel()
// Tells the worker to cancel; it suspends until cancellation is finished
worker.cancelAndJoin()
From a coroutine context (i.e. somewhere you can call a suspend fun), use withContext to kick off work to another thread. It will non-blocking/suspend wait for the cross-thread work to complete:
suspend fun doWork() {
val result = CoroutineWorker.withContext {
// This is similar to execute, but it returns
// the result of the work at the end of this lambda
1
}
print(result) // prints 1
}
This is like using withContext on JVM to switch coroutine contexts. You can also properly pass a dispatcher, which will be used on JVM: withContext(Dispatchers.IO) { … }. The idea here is that this will be easy to migrate when we do get multi-threaded coroutine support in Kotlin/Native.
Use threadSafeSuspendCallback to bridge callback-style async work into your code as a suspend fun:
suspend fun performNetworkFetch() {
val result = threadSafeSuspendCallback { completion ->
// example: fetch network data that isn't coroutine-compatible
fetchNetworkData { networkResult ->
// notify that async work is complete
completion(networkResult)
}
}
// result is now available here
}
In the sample directory, there is a sample project that demonstrates adding CoroutineWorker to an iOS + JVM library. We just used the sample library from IntelliJ's template for a "Mobile Shared Library." In the sample is a function called performWork (common code) that takes a completion lambda and demonstrates CoroutineWorker.execute. In tests, we use K/N concurrency helpers from kotlinx.atomicfu to demonstrate capturing a result across threads in K/N and executing this function.
Object detachment (i.e. transferring object ownership from one thread to another) is relatively difficult to achieve (outside of simple scenarios) compared to working with objects that are frozen and immutable. Because of this, CoroutineWorker prefers taking the frozen, immutable route:
withContext is also frozen.this.ensureNeverFrozen() on objects that you don't expect to ever be frozen.In the JVM world, you typically write code like this for managing IO-bound work with coroutines:
withContext(Dispatchers.IO) {
// IO writes
}
Similar behavior is supported in CoroutineWorker for Kotlin/Native via the IODispatcher. To use it in common code, make an expect val Dispatchers.IO: CoroutineDispatcher that returns IODispatcher for Kotlin/Native and Dispatchers.IO for JVM, and pass that to CoroutineWorker.withContext when performing IO-bound worker.
Surfaced from shared tags and platforms — no rankings paid for.