Remove co.touchlab:stately-iso-collections dependency (#437)

Author: twyatt

core/build.gradle.kts

@@ -38,7 +38,6 @@ kotlin {
                 api(libs.kotlinx.coroutines.core)
                 api(libs.uuid)
                 implementation(libs.tuulbox.collections)
-                implementation(libs.stately.collections)
             }
         }
 

core/src/commonMain/kotlin/Observation.kt

@@ -14,7 +14,6 @@ internal class Observation(
     private val characteristic: Characteristic,
     logging: Logging,
     identifier: String,
-    private val subscribers: MutableList<OnSubscriptionAction> = mutableListOf(),
 ) {
 
     interface Handler {
@@ -24,6 +23,7 @@ internal class Observation(
 
     private val logger = Logger(logging, tag = "Kable/Observation", identifier)
 
+    private val subscribers = mutableListOf<OnSubscriptionAction>()
     private val mutex = Mutex()
 
     private val _didStartObservation = atomic(false)
@@ -34,12 +34,9 @@ internal class Observation(
     private val isConnected: Boolean
         get() = state.value.isAtLeast<Observes>()
 
-    private val hasSubscribers: Boolean
-        get() = subscribers.isNotEmpty()
-
     suspend fun onSubscription(action: OnSubscriptionAction) = mutex.withLock {
         subscribers += action
-        val shouldStartObservation = !didStartObservation && hasSubscribers && isConnected
+        val shouldStartObservation = !didStartObservation && subscribers.isNotEmpty() && isConnected
         if (shouldStartObservation) {
             suppressConnectionExceptions {
                 startObservation()
@@ -50,13 +47,13 @@ internal class Observation(
 
     suspend fun onCompletion(action: OnSubscriptionAction) = mutex.withLock {
         subscribers -= action
-        val shouldStopObservation = didStartObservation && !hasSubscribers && isConnected
+        val shouldStopObservation = didStartObservation && subscribers.isEmpty() && isConnected
         if (shouldStopObservation) stopObservation()
     }
 
     suspend fun onConnected() = mutex.withLock {
         if (isConnected) {
-            if (hasSubscribers) {
+            if (subscribers.isNotEmpty()) {
                 suppressConnectionExceptions {
                     startObservation()
                     subscribers.forEach { it() }

core/src/commonMain/kotlin/Observers.kt

@@ -1,10 +1,10 @@
 package com.juul.kable
 
-import co.touchlab.stately.collections.IsoMutableList
-import co.touchlab.stately.isolate.IsolateState
 import com.juul.kable.ObservationEvent.CharacteristicChange
 import com.juul.kable.ObservationEvent.Error
 import com.juul.kable.logs.Logging
+import kotlinx.atomicfu.locks.SynchronizedObject
+import kotlinx.atomicfu.locks.synchronized
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.filter
@@ -44,7 +44,9 @@ internal class Observers<T>(
 ) {
 
     val characteristicChanges = MutableSharedFlow<ObservationEvent<T>>(extraBufferCapacity = Int.MAX_VALUE)
-    private val observations = Observations()
+
+    private val observations = mutableMapOf<Characteristic, Observation>()
+    private val lock = SynchronizedObject()
 
     fun acquire(
         characteristic: Characteristic,
@@ -54,12 +56,10 @@ internal class Observers<T>(
         val handler = peripheral.observationHandler()
         val identifier = peripheral.identifier
 
-        // `IsoMutableList` created outside of `getOrPut`, because it would deadlock on Native if created in
-        // `Observation` constructor.
-        val subscribers = IsoMutableList<OnSubscriptionAction>()
-
-        val observation = observations.getOrPut(characteristic) {
-            Observation(state, handler, characteristic, logging, identifier.toString(), subscribers)
+        val observation = synchronized(lock) {
+            observations.getOrPut(characteristic) {
+                Observation(state, handler, characteristic, logging, identifier.toString())
+            }
         }
 
         return characteristicChanges
@@ -91,7 +91,9 @@ internal class Observers<T>(
     }
 
     suspend fun onConnected() {
-        observations.entries.forEach { (_, observation) ->
+        synchronized(lock) {
+            observations.entries
+        }.forEach { (_, observation) ->
             // Pipe failures to `characteristicChanges` while honoring in-flight connection cancellations.
             try {
                 observation.onConnected()
@@ -103,23 +105,3 @@ internal class Observers<T>(
         }
     }
 }
-
-private class Observations : IsolateState<MutableMap<Characteristic, Observation>>(
-    producer = { mutableMapOf() },
-) {
-
-    val entries: List<Pair<Characteristic, Observation>>
-        get() = access { observations ->
-            // `map` used as a means to copy entries, to prevent freeze exceptions on Native.
-            observations.entries.map { (characteristic, observation) ->
-                characteristic to observation
-            }
-        }
-
-    fun getOrPut(
-        characteristic: Characteristic,
-        defaultValue: () -> Observation,
-    ): Observation = access { observations ->
-        observations.getOrPut(characteristic, defaultValue)
-    }
-}

gradle/libs.versions.toml

@@ -13,7 +13,6 @@ atomicfu = { module = "org.jetbrains.kotlinx:atomicfu-jvm", version.ref = "atomi
 kotlinx-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-android", version.ref = "coroutines" }
 kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "coroutines" }
 kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "coroutines" }
-stately-collections = { module = "co.touchlab:stately-iso-collections", version = "1.2.3" }
 tuulbox-logging = { module = "com.juul.tuulbox:logging", version.ref = "tuulbox" }
 tuulbox-collections = { module = "com.juul.tuulbox:collections", version.ref = "tuulbox" }
 uuid = { module = "com.benasher44:uuid", version = "0.7.0" }