Replace Semaphore with Mutex in Connection (#490)

Author: twyatt

core/src/appleMain/kotlin/Connection.kt

@@ -8,8 +8,8 @@ import kotlinx.coroutines.Deferred
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.async
 import kotlinx.coroutines.cancel
-import kotlinx.coroutines.sync.Semaphore
-import kotlinx.coroutines.sync.withPermit
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import kotlin.coroutines.CoroutineContext
 
 internal class Connection(
@@ -23,14 +23,12 @@ internal class Connection(
 
     private val logger = Logger(logging, tag = "Kable/Connection", identifier = identifier)
 
-    // Using Semaphore as Mutex never relinquished lock when multiple concurrent `withLock`s are executed.
-    val semaphore = Semaphore(1)
-
     private var deferredResponse: Deferred<PeripheralDelegate.Response>? = null
+    val guard = Mutex()
 
     suspend inline fun <T> execute(
         action: () -> Unit,
-    ): T = semaphore.withPermit {
+    ): T = guard.withLock {
         deferredResponse?.let {
             if (it.isActive) {
                 // Discard response as we've performed another `execute` without the previous finishing. This happens if

core/src/appleMain/kotlin/Peripheral.kt

@@ -43,7 +43,7 @@ import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.onSubscription
 import kotlinx.coroutines.flow.updateAndGet
 import kotlinx.coroutines.job
-import kotlinx.coroutines.sync.withPermit
+import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
 import platform.CoreBluetooth.CBCharacteristicWriteWithResponse
 import platform.CoreBluetooth.CBCharacteristicWriteWithoutResponse
@@ -283,7 +283,7 @@ internal class CBPeripheralCoreBluetoothPeripheral(
             WithResponse -> connection.execute<DidWriteValueForCharacteristic> {
                 centralManager.write(cbPeripheral, data, platformCharacteristic, CBCharacteristicWriteWithResponse)
             }
-            WithoutResponse -> connection.semaphore.withPermit {
+            WithoutResponse -> connection.guard.withLock {
                 if (!canSendWriteWithoutResponse.updateAndGet { cbPeripheral.canSendWriteWithoutResponse }) {
                     canSendWriteWithoutResponse.first { it }
                 }
@@ -308,7 +308,7 @@ internal class CBPeripheralCoreBluetoothPeripheral(
 
         val platformCharacteristic = discoveredServices.obtain(characteristic, Read)
 
-        val event = connection.semaphore.withPermit {
+        val event = connection.guard.withLock {
             observers
                 .characteristicChanges
                 .onSubscription { centralManager.read(cbPeripheral, platformCharacteristic) }