[Feature] Partial strict concurrency support (#56)

manolofdez · web-flow · commit 71ef5b070ce7 · 2024-08-04T17:00:57.000-04:00
* Add unchecked sendable to required types

* Remove unchecked from most sendables.

* Fix Peripheral

* Go after central manager

* Update the docs

* Combine doesn't need preconcurrency anymore

* Remove comment
diff --git a/README.md b/README.md
@@ -45,7 +45,7 @@ try await centralManager.connect(peripheral, options: nil)
 The central manager publishes several events. You can subscribe to them by using the `eventPublisher`.
 
 ```swift
-centralManager.eventPublisher
+await centralManager.eventPublisher
     .sink {
         switch $0 {
         case .didConnectPeripheral(let peripheral):
@@ -92,7 +92,7 @@ To get notified when a characteristic's value is updated, we provide a publisher
 
 ```swift
 let characteristicUUID = CBUUID()
-peripheral.characteristicValueUpdatedPublisher
+await peripheral.characteristicValueUpdatedPublisher
     .filter { $0.uuid == characteristicUUID }
     .map { try? $0.parsedValue() as String? } // replace `String?` with your type
     .sink { value in
@@ -129,7 +129,7 @@ fetchTask.cancel()
 There might also be cases were you want to stop awaiting for all responses. For example, when bluetooth has been powered off. This can be done like so:
 
 ```swift
-centralManager.eventPublisher
+await centralManager.eventPublisher
     .sink {
         switch $0 {
         case .didUpdateState(let state):
diff --git a/Sources/CentralManager/CentralManager.swift b/Sources/CentralManager/CentralManager.swift
@@ -1,12 +1,12 @@
 //  Copyright (c) 2021 Manuel Fernandez-Peix Perez. All rights reserved.
 
 import Foundation
-import CoreBluetooth
+@preconcurrency import CoreBluetooth
 import Combine
 import os.log
 
 /// An object that scans for, discovers, connects to, and manages peripherals using concurrency.
-public class CentralManager {
+public final class CentralManager: Sendable {
     
     private typealias Utils = CentralManagerUtils
     
@@ -27,12 +27,16 @@ public class CentralManager {
     }
     
     public var isScanning: Bool {
-        self.context.isScanning
+        get async {
+            await self.context.isScanning
+        }
     }
     
-    public lazy var eventPublisher: AnyPublisher<CentralManagerEvent, Never> = {
-        self.context.eventSubject.eraseToAnyPublisher()
-    }()
+    public var eventPublisher: AnyPublisher<CentralManagerEvent, Never> {
+        get async {
+            await self.context.eventSubject.eraseToAnyPublisher()
+        }
+    }
     
     private let cbCentralManager: CBCentralManager
     private let context: CentralManagerContext
@@ -58,7 +62,7 @@ public class CentralManager {
             try await self.context.waitUntilReadyExecutor.enqueue { [weak self] in
                 // Note we need to check again here in case the Bluetooth state was updated after we last
                 // checked but before the work was enqueued. Otherwise we could wait indefinitely.
-                guard let self = self, let isBluetoothReadyResult = Utils.isBluetoothReady(self.bluetoothState) else {
+                guard let self = self, let isBluetoothReadyResult = Utils.isBluetoothReady(self.cbCentralManager.state) else {
                     return
                 }
                 Task {
@@ -79,7 +83,7 @@ public class CentralManager {
     /// Scans for peripherals that are advertising services.
     public func scanForPeripherals(
         withServices serviceUUIDs: [CBUUID]?,
-        options: [String : Any]? = nil
+        options: [String : any Sendable]? = nil
     ) async throws -> AsyncStream<ScanData> {
         try await withCheckedThrowingContinuation { continuation in
             Task {
@@ -123,7 +127,7 @@ public class CentralManager {
     }
     
     /// Establishes a local connection to a peripheral.
-    public func connect(_ peripheral: Peripheral, options: [String : Any]? = nil) async throws {
+    public func connect(_ peripheral: Peripheral, options: [String : any Sendable]? = nil) async throws {
         guard await !self.context.connectToPeripheralExecutor.hasWorkForKey(peripheral.identifier) else {
             Self.logger.error("Unable to connect to \(peripheral.identifier) because a connection attempt is already in progress")
 
@@ -181,7 +185,7 @@ public class CentralManager {
     /// Cancels all pending operations, stops scanning and awaiting for any responses.
     /// - Note: Operation for Peripherals will not be cancelled. To do that, call `cancelAllOperations()` on the `Peripheral`.
     public func cancelAllOperations() async throws {
-        if isScanning {
+        if await isScanning {
             await self.stopScan()
         }
         try await self.context.flush(error: BluetoothError.operationCancelled)
@@ -237,9 +241,7 @@ extension CentralManager.DelegateWrapper: CBCentralManagerDelegate {
     
     func centralManagerDidUpdateState(_ central: CBCentralManager) {
         Task {
-            defer {
-                self.context.eventSubject.send(.didUpdateState(state: central.state))
-            }
+            await self.context.eventSubject.send(.didUpdateState(state: central.state))
             
             guard let isBluetoothReadyResult = Utils.isBluetoothReady(central.state) else { return }
 
@@ -248,7 +250,9 @@ extension CentralManager.DelegateWrapper: CBCentralManagerDelegate {
     }
     
     func centralManager(_ central: CBCentralManager, willRestoreState dict: [String : Any]) {
-        self.context.eventSubject.send(.willRestoreState(state: dict))
+        Task {
+            await self.context.eventSubject.send(.willRestoreState(state: dict))
+        }
     }
     
     func centralManager(
@@ -265,7 +269,8 @@ extension CentralManager.DelegateWrapper: CBCentralManagerDelegate {
 
         Task {
             guard let continuation = await self.context.scanForPeripheralsContext.continuation else {
-                Self.logger.info("Ignoring peripheral '\(scanData.peripheral.name ?? "unknown", privacy: .private)' because the central manager is not scanning")
+                let peripherlName = scanData.peripheral.name ?? "unknown"
+                Self.logger.info("Ignoring peripheral '\(peripherlName, privacy: .private)' because the central manager is not scanning")
                 return
             }
             continuation.yield(scanData)
@@ -286,7 +291,7 @@ extension CentralManager.DelegateWrapper: CBCentralManagerDelegate {
                 Self.logger.info("Received onDidConnect without a continuation")
             }
             
-            self.context.eventSubject.send(
+            await self.context.eventSubject.send(
                 .didConnectPeripheral(peripheral: Peripheral(peripheral))
             )
         }
@@ -309,12 +314,14 @@ extension CentralManager.DelegateWrapper: CBCentralManagerDelegate {
             break
         }
 
-        self.context.eventSubject.send(
-            .connectionEventDidOccur(
-                connectionEvent: event,
-                peripheral: peripheral
+        Task {
+            await self.context.eventSubject.send(
+                .connectionEventDidOccur(
+                    connectionEvent: event,
+                    peripheral: peripheral
+                )
             )
-        )
+        }
     }
     #endif
 
@@ -356,7 +363,7 @@ extension CentralManager.DelegateWrapper: CBCentralManagerDelegate {
                 Self.logger.info("Disconnected from \(peripheral.identifier) without a continuation")
             }
             
-            self.context.eventSubject.send(
+            await self.context.eventSubject.send(
                 .didDisconnectPeripheral(peripheral: Peripheral(peripheral), isReconnecting: isReconnecting, error: error)
             )
         }
@@ -378,7 +385,7 @@ extension CentralManager.DelegateWrapper: CBCentralManagerDelegate {
                 Self.logger.info("Disconnected from \(peripheral.identifier) without a continuation")
             }
             
-            self.context.eventSubject.send(
+            await self.context.eventSubject.send(
                 .didDisconnectPeripheral(peripheral: Peripheral(peripheral), isReconnecting: false, error: error)
             )
         }
diff --git a/Sources/CentralManager/CentralManagerContext.swift b/Sources/CentralManager/CentralManagerContext.swift
@@ -5,7 +5,7 @@ import CoreBluetooth
 import Combine
 
 /// Contains the objects necessary to track a Central Manager's commands.
-class CentralManagerContext {
+actor CentralManagerContext {
     actor ScanForPeripheralsContext {
         let onContinuationChanged: (_ isScanning: Bool) -> Void
         
@@ -25,7 +25,9 @@ class CentralManagerContext {
     private(set) var isScanning = false
     
     private(set) lazy var scanForPeripheralsContext = ScanForPeripheralsContext { [weak self] isScanning in
-        self?.isScanning = isScanning
+        Task { [weak self] in
+            await self?.updateIsScanning(isScanning)
+        }
     }
     
     private(set) lazy var eventSubject = PassthroughSubject<CentralManagerEvent, Never>()
@@ -61,4 +63,8 @@ class CentralManagerContext {
             try await flushableExecutor.flush(error: error)
         }
     }
+    
+    private func updateIsScanning(_ isScanning: Bool) {
+        self.isScanning = isScanning
+    }
 }
diff --git a/Sources/CentralManager/ScanData.swift b/Sources/CentralManager/ScanData.swift
@@ -4,10 +4,10 @@ import Foundation
 import CoreBluetooth
 
 /// Represents a single value gathered when scanning for peripheral.
-public struct ScanData {
+public struct ScanData: Sendable {
     public let peripheral: Peripheral
     /// A dictionary containing any advertisement and scan response data.
-    public let advertisementData: [String : Any]
+    public let advertisementData: [String : any Sendable]
     /// The current RSSI of the peripheral, in dBm. A value of 127 is reserved and indicates the RSSI
     /// was not available.
     public let rssi: NSNumber
diff --git a/Sources/Peripheral/Characteristic.swift b/Sources/Peripheral/Characteristic.swift
@@ -1,11 +1,11 @@
 //  Copyright (c) 2021 Manuel Fernandez-Peix Perez. All rights reserved.
 
 import Foundation
-import CoreBluetooth
+@preconcurrency import CoreBluetooth
 
 /// A characteristic of a remote peripheral’s service.
 /// - This class acts as a wrapper around `CBCharacteristic`.
-public struct Characteristic {
+public struct Characteristic: Sendable {
     public let cbCharacteristic: CBCharacteristic
     
     public init(_ cbCharacteristic: CBCharacteristic) {
diff --git a/Sources/Peripheral/Peripheral.swift b/Sources/Peripheral/Peripheral.swift
@@ -1,22 +1,24 @@
 //  Copyright (c) 2021 Manuel Fernandez-Peix Perez. All rights reserved.
 
 import Foundation
-import CoreBluetooth
+@preconcurrency import CoreBluetooth
 import Combine
 import os.log
 
 /// A remote peripheral device.
 /// - This class acts as a wrapper around `CBPeripheral`.
-public class Peripheral {
+public final class Peripheral: Sendable {
         
     private static var logger: Logger {
         Logging.logger(for: "peripheral")
     }
     
     /// Publishes characteristics that are notifying of value changes.
-    public lazy var characteristicValueUpdatedPublisher: AnyPublisher<Characteristic, Never> = {
-        self.context.characteristicValueUpdatedSubject.eraseToAnyPublisher()
-    }()
+    public var characteristicValueUpdatedPublisher: AnyPublisher<Characteristic, Never> {
+        get async {
+            await self.context.characteristicValueUpdatedSubject.eraseToAnyPublisher()
+        }
+    }
     
     /// The UUID associated with the peripheral.
     public var identifier: UUID {
diff --git a/Sources/Peripheral/PeripheralContext.swift b/Sources/Peripheral/PeripheralContext.swift
@@ -5,7 +5,7 @@ import CoreBluetooth
 import Combine
 
 /// Contains the objects necessary to track a Peripheral's commands.
-class PeripheralContext {
+actor PeripheralContext {
     private(set) lazy var characteristicValueUpdatedSubject = PassthroughSubject<Characteristic, Never>()
     private(set) lazy var invalidatedServicesSubject = PassthroughSubject<[Service], Never>()
     
diff --git a/Sources/Peripheral/PeripheralDelegate.swift b/Sources/Peripheral/PeripheralDelegate.swift
@@ -4,7 +4,7 @@ import Foundation
 import CoreBluetooth
 import os.log
 
-class PeripheralDelegate: NSObject {
+final class PeripheralDelegate: NSObject, Sendable {
     
     private static var logger: Logger {
         Logging.logger(for: "peripheralDelegate")
@@ -65,13 +65,11 @@ extension PeripheralDelegate: CBPeripheralDelegate {
     }
     
     func peripheral(_ cbPeripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
-        
-        if characteristic.isNotifying {
-           // characteristic.value is Data() and it will get trampled if allowed to run async.
-           self.context.characteristicValueUpdatedSubject.send( Characteristic(characteristic) )
-        }
-           
         Task {
+            if characteristic.isNotifying {
+               await self.context.characteristicValueUpdatedSubject.send(Characteristic(characteristic))
+            }
+
             do {
                 let result = CallbackUtils.result(for: (), error: error)
                 try await self.context.readCharacteristicValueExecutor.setWorkCompletedForKey(
@@ -169,6 +167,8 @@ extension PeripheralDelegate: CBPeripheralDelegate {
     }
     
     func peripheral(_ peripheral: CBPeripheral, didModifyServices invalidatedServices: [CBService]) {
-        self.context.invalidatedServicesSubject.send(invalidatedServices.map { Service($0) })
+        Task {
+            await self.context.invalidatedServicesSubject.send(invalidatedServices.map { Service($0) })
+        }
     }
 }
diff --git a/Sources/Peripheral/Service.swift b/Sources/Peripheral/Service.swift
@@ -1,11 +1,11 @@
 //  Copyright (c) 2021 Manuel Fernandez-Peix Perez. All rights reserved.
 
 import Foundation
-import CoreBluetooth
+@preconcurrency import CoreBluetooth
 
 /// A collection of data and associated behaviors that accomplish a function or feature of a device.
 /// - This class acts as a wrapper around `CBService`.
-public struct Service {
+public struct Service: Sendable {
     let cbService: CBService
     
     /// The Bluetooth-specific UUID of the service.
diff --git a/Sources/Utils/Extensions/CBUUID+Sendable.swift b/Sources/Utils/Extensions/CBUUID+Sendable.swift
@@ -0,0 +1,6 @@
+// Copyright (c) 2024 Manuel Fernandez. All rights reserved.
+
+import Foundation
+import CoreBluetooth
+
+extension CBUUID: @unchecked Sendable {}

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ import CoreBluetooth`
`5`	`5`	`import Combine`
`6`	`6`
`7`	`7`	`/// Contains the objects necessary to track a Central Manager's commands.`
`8`		`-class CentralManagerContext {`
	`8`	`+actor CentralManagerContext {`
`9`	`9`	`actor ScanForPeripheralsContext {`
`10`	`10`	`let onContinuationChanged: (_ isScanning: Bool) -> Void`
`11`	`11`
`@@ -25,7 +25,9 @@ class CentralManagerContext {`
`25`	`25`	`private(set) var isScanning = false`
`26`	`26`
`27`	`27`	`private(set) lazy var scanForPeripheralsContext = ScanForPeripheralsContext { [weak self] isScanning in`
`28`		`- self?.isScanning = isScanning`
	`28`	`+ Task { [weak self] in`
	`29`	`+ await self?.updateIsScanning(isScanning)`
	`30`	`+ }`
`29`	`31`	`}`
`30`	`32`
`31`	`33`	`private(set) lazy var eventSubject = PassthroughSubject<CentralManagerEvent, Never>()`
`@@ -61,4 +63,8 @@ class CentralManagerContext {`
`61`	`63`	`try await flushableExecutor.flush(error: error)`
`62`	`64`	`}`
`63`	`65`	`}`
	`66`	`+`
	`67`	`+ private func updateIsScanning(_ isScanning: Bool) {`
	`68`	`+ self.isScanning = isScanning`
	`69`	`+ }`
`64`	`70`	`}`