[BUGFIX] Fix: Write without response may get stuck if sending a large amount of data one by one.

Author: bo2themax

Sources/Peripheral/Peripheral.swift

@@ -55,6 +55,14 @@ public final class Peripheral: Sendable {
         #endif
     }
 
+    public var canSendWriteWithoutResponse: Bool {
+        cbPeripheral.canSendWriteWithoutResponse
+    }
+    
+    public var isReadyToSendWriteWithoutResponse: AnyPublisher<Void, Never> {
+        context.isReadyToSendWriteWithoutResponse.eraseToAnyPublisher()
+    }
+    
     public let cbPeripheral: CBPeripheral
 
     private var context: PeripheralContext {
@@ -151,16 +159,25 @@ public final class Peripheral: Sendable {
 
     /// Writes the value of a characteristic.
     public func writeValue(_ data: Data, for characteristic: Characteristic, type: CBCharacteristicWriteType) async throws {
-        try await self.context.writeCharacteristicValueExecutor.enqueue(withKey: characteristic.uuid) { [weak self] in
-            guard let self = self else { return }
-            
-            self.cbPeripheral.writeValue(data, for: characteristic.cbCharacteristic, type: type)
-            
-            guard type == .withoutResponse else {
+        switch type {
+        case .withResponse:
+            try await self.context.writeCharacteristicValueExecutor.enqueue(withKey: characteristic.uuid) { [weak self] in
+                guard let self = self else { return }
+
+                self.cbPeripheral.writeValue(data, for: characteristic.cbCharacteristic, type: type)
+            }
+        case .withoutResponse:
+            if self.cbPeripheral.canSendWriteWithoutResponse {
+                self.cbPeripheral.writeValue(data, for: characteristic.cbCharacteristic, type: type)
                 return
             }
-            
-            self.cbPeripheralDelegate.peripheral(self.cbPeripheral, didWriteValueFor: characteristic.cbCharacteristic, error: nil)
+            try await self.context.writeWithoutResponseCharacteristicValueExecutor.enqueue { [weak self] in
+                guard let self = self else { return }
+
+                self.cbPeripheral.writeValue(data, for: characteristic.cbCharacteristic, type: type)
+            }
+        @unknown default:
+            preconditionFailure("Unhandled CBCharacteristicWriteType: \(type)")
         }
     }
 

Sources/Peripheral/PeripheralContext.swift

@@ -8,7 +8,9 @@ import Combine
 actor PeripheralContext {
     nonisolated let characteristicValueUpdatedSubject = PassthroughSubject<CharacteristicValueUpdateEventData, Never>()
     nonisolated let invalidatedServicesSubject = PassthroughSubject<[Service], Never>()
-    
+    nonisolated let isReadyToSendWriteWithoutResponse = PassthroughSubject<Void, Never>()
+    let serialExecutor = SerialExecutor()
+
     private(set) lazy var readRSSIExecutor = {
         let executor = AsyncSerialExecutor<NSNumber>()
         Task {
@@ -46,7 +48,13 @@ actor PeripheralContext {
         flushableExecutors.append(executor)
         return executor
     }()
-    
+
+    private(set) lazy var writeWithoutResponseCharacteristicValueExecutor = {
+        let executor = AsyncSerialExecutor<Void>()
+        flushableExecutors.append(executor)
+        return executor
+    }()
+
     private(set) lazy var setNotifyValueExecutor = {
         let executor = AsyncExecutorMap<CBUUID, Void>()
         flushableExecutors.append(executor)

Sources/Peripheral/PeripheralDelegate.swift

@@ -97,6 +97,19 @@ extension PeripheralDelegate: CBPeripheralDelegate {
         }
     }
 
+    func peripheralIsReady(toSendWriteWithoutResponse peripheral: CBPeripheral) {
+        Self.logger.info("\(#function), \(peripheral)")
+        context.serialExecutor.enqueue { [weak self] in
+            guard let self else { return }
+            do {
+                try await context.writeWithoutResponseCharacteristicValueExecutor.setWorkCompletedWithResult(.success(()))
+            } catch {
+                Self.logger.warning("Received peripheralIsReadyToSendWriteWithoutResponse without a continuation: \(error)")
+            }
+        }
+        context.isReadyToSendWriteWithoutResponse.send()
+    }
+    
     func peripheral(
         _ cbPeripheral: CBPeripheral,
         didUpdateNotificationStateFor characteristic: CBCharacteristic,