Deprecate CoroutineWorker, enable the new Memory Model

README.md

@@ -1,3 +1,10 @@
+# This project is DEPRECATED
+
+With the release of Kotlin 1.7.20-Beta (https://blog.jetbrains.com/kotlin/2022/08/kotlin-1-7-20-beta/) and the new 
+Memory Model for Kotlin Native becoming the default, there's no longer a need for this library. Version 0.9.0 helps 
+transition over to the new memory model without having to make any changes related to CoroutineWorker code. The latest 
+version of CoroutineWorker uses the same implementation for all platforms.
+
 # CoroutineWorker
 
 [![Build Status](https://github.com/autodesk/coroutineworker/workflows/build/badge.svg)](https://github.com/autodesk/coroutineworker/actions?query=workflow%3Abuild)
@@ -18,7 +25,7 @@ kotlin {
     sourceSets {
         commonMain {
             dependencies {
-                implementation "com.autodesk:coroutineworker:0.8.3"
+                implementation "com.autodesk:coroutineworker:0.9.0"
             }
         }
     }

gradle.properties

@@ -1,4 +1,5 @@
-VERSION=0.8.3
+VERSION=0.9.0
 
 kotlin.mpp.enableCompatibilityMetadataVariant=true
-kotlin.mpp.stability.nowarn=true
+kotlin.mpp.stability.nowarn=true
+kotlin.native.binary.memoryModel=experimental

src/commonMain/kotlin/com/autodesk/coroutineworker/CoroutineWorker.kt

@@ -2,41 +2,38 @@ package com.autodesk.coroutineworker
 
 import kotlinx.coroutines.CoroutineScope
 import kotlin.coroutines.CoroutineContext
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.launch
 
-/**
- * Encapsulates performing background work. On JVM, this use coroutines outright.
- * In native, this uses Worker threads and manages its mutability/concurrency issues.
- */
-public expect class CoroutineWorker internal constructor() {
-
-    /** Cancels the underlying Job */
-    public fun cancel()
+public class CoroutineWorker : CoroutineScope {
+    private val job = Job()
 
     /**
-     * Cancel the underlying job/worker and waits for it
-     * to receive its cancellation message or complete
-     * */
-    public suspend fun cancelAndJoin()
+     * The context of this scope. See [CoroutineScope.coroutineContext]
+     */
+    override val coroutineContext: CoroutineContext = job
+
+    public fun cancel() {
+        job.cancel()
+    }
+
+    public suspend fun cancelAndJoin() {
+        job.cancelAndJoin()
+    }
 
     public companion object {
 
-        /**
-         * Enqueues the background work [block] to run and returns a reference to the worker, which can be cancelled
-         */
-        public fun execute(block: suspend CoroutineScope.() -> Unit): CoroutineWorker
-
-        /**
-         * Performs [block] in another [CoroutineContext] ([jvmContext]) and waits for it to complete.
-         * This is similar to [kotlinx.coroutines.withContext] with some caveats:
-         *
-         * - Native: we cannot use [kotlinx.coroutines.withContext] because
-         *           the global Dispatchers do not work properly. Therefore,
-         *           the context argument is ignored, and the block is always
-         *           run on some other Worker in the Worker pool. This is the
-         *           most similar to switching contexts on JVM.
-         *
-         * - JVM: This has the same behavior as calling [kotlinx.coroutines.withContext] in the JVM
-         */
-        public suspend fun <T> withContext(jvmContext: CoroutineContext, block: suspend CoroutineScope.() -> T): T
+        public fun execute(block: suspend CoroutineScope.() -> Unit): CoroutineWorker {
+            return CoroutineWorker().also {
+                it.launch(block = block)
+            }
+        }
+
+        public suspend fun <T> withContext(jvmContext: CoroutineContext, block: suspend CoroutineScope.() -> T): T {
+            return kotlinx.coroutines.withContext(jvmContext) {
+                block()
+            }
+        }
     }
 }

src/commonMain/kotlin/com/autodesk/coroutineworker/Utils.kt

@@ -1,11 +1,21 @@
 package com.autodesk.coroutineworker
+
+import kotlinx.coroutines.suspendCancellableCoroutine
+
 /**
- * Bridges a platform's callback-based async method to coroutines,
- * ensuring that the coroutine is resumed on a thread appropriate
- * for the platform.
- *
  * [startAsync] is called to start the work. It calls the passed [CompletionLambda]
  * when complete, and returns a [CancellationLambda] that can be called to cancel the
  * async work
  * */
-public expect suspend fun <T> threadSafeSuspendCallback(startAsync: (CompletionLambda<T>) -> CancellationLambda): T
+public suspend fun <T> threadSafeSuspendCallback(startAsync: (CompletionLambda<T>) -> CancellationLambda): T {
+    return suspendCancellableCoroutine { cont ->
+        val cancellable = startAsync {
+            if (cont.isActive) {
+                cont.resumeWith(it)
+            }
+        }
+        cont.invokeOnCancellation {
+            cancellable()
+        }
+    }
+}