unified-ble-manager 4.0.0-alpha.0

package/ios/vendor/MultiplatformBleAdapter/RxBluetoothKit/CBCentralManagerDelegateWrapper.swift

@@ -0,0 +1,75 @@
+import Foundation
+import CoreBluetooth
+
+
+class CBCentralManagerDelegateWrapper: NSObject, CBCentralManagerDelegate {
+
+    let didUpdateState = PublishSubject<BluetoothState>()
+    let willRestoreState = ReplaySubject<[String: Any]>.create(bufferSize: 1)
+    let didDiscoverPeripheral = PublishSubject<(CBPeripheral, [String: Any], NSNumber)>()
+    let didConnectPeripheral = PublishSubject<CBPeripheral>()
+    let didFailToConnectPeripheral = PublishSubject<(CBPeripheral, Error?)>()
+    let didDisconnectPeripheral = PublishSubject<(CBPeripheral, Error?)>()
+    let didUpdateANCSAuthorizationForPeripheral = PublishSubject<(CBPeripheral)>()
+
+    func centralManagerDidUpdateState(_ central: CBCentralManager) {
+        guard let bleState = BluetoothState(rawValue: central.state.rawValue) else { return }
+        RxBluetoothKitLog.d("\(central.logDescription) didUpdateState(state: \(bleState.logDescription))")
+        didUpdateState.onNext(bleState)
+    }
+
+    func centralManager(_ central: CBCentralManager, willRestoreState dict: [String: Any]) {
+        RxBluetoothKitLog.d("\(central.logDescription) willRestoreState(restoredState: \(dict))")
+        willRestoreState.onNext(dict)
+    }
+
+    func centralManager(_ central: CBCentralManager,
+                        didDiscover peripheral: CBPeripheral,
+                        advertisementData: [String: Any],
+                        rssi: NSNumber) {
+        RxBluetoothKitLog.d("""
+            \(central.logDescription) didDiscover(peripheral: \(peripheral.logDescription),
+            rssi: \(rssi))
+            """)
+        didDiscoverPeripheral.onNext((peripheral, advertisementData, rssi))
+    }
+
+    func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
+        RxBluetoothKitLog.d("""
+            \(central.logDescription) didConnect(to: \(peripheral.logDescription))
+            """)
+        didConnectPeripheral.onNext(peripheral)
+    }
+
+    func centralManager(_ central: CBCentralManager,
+                        didFailToConnect peripheral: CBPeripheral,
+                        error: Error?) {
+        RxBluetoothKitLog.d("""
+            \(central.logDescription) didFailToConnect(to: \(peripheral.logDescription),
+            error: \(String(describing: error)))
+            """)
+        didFailToConnectPeripheral.onNext((peripheral, error))
+    }
+
+    func centralManager(_ central: CBCentralManager,
+                        didDisconnectPeripheral peripheral: CBPeripheral,
+                        error: Error?) {
+        RxBluetoothKitLog.d("""
+            \(central.logDescription) didDisconnect(from: \(peripheral.logDescription),
+            error: \(String(describing: error)))
+            """)
+        didDisconnectPeripheral.onNext((peripheral, error))
+    }
+
+    #if !os(macOS)
+    @available(iOS 13.0, watchOS 6.0, tvOS 13.0, *)
+    func centralManager(_ central: CBCentralManager,
+                        didUpdateANCSAuthorizationFor peripheral: CBPeripheral) {
+        RxBluetoothKitLog.d("""
+            \(central.logDescription) didUpdateANCSAuthorizationFor
+            (peripheral: \(peripheral.logDescription)
+            """)
+        didUpdateANCSAuthorizationForPeripheral.onNext(peripheral)
+    }
+    #endif
+}

package/ios/vendor/MultiplatformBleAdapter/RxBluetoothKit/CBPeripheralDelegateWrapper.swift

@@ -0,0 +1,163 @@
+import Foundation
+import CoreBluetooth
+
+class CBPeripheralDelegateWrapper: NSObject, CBPeripheralDelegate {
+
+    let peripheralDidUpdateName = PublishSubject<String?>()
+    let peripheralDidModifyServices = PublishSubject<([CBService])>()
+    let peripheralDidReadRSSI = PublishSubject<(Int, Error?)>()
+    let peripheralDidDiscoverServices = PublishSubject<([CBService]?, Error?)>()
+    let peripheralDidDiscoverIncludedServicesForService = PublishSubject<(CBService, Error?)>()
+    let peripheralDidDiscoverCharacteristicsForService = PublishSubject<(CBService, Error?)>()
+    let peripheralDidUpdateValueForCharacteristic = PublishSubject<(CBCharacteristic, Error?)>()
+    let peripheralDidWriteValueForCharacteristic = PublishSubject<(CBCharacteristic, Error?)>()
+    let peripheralDidUpdateNotificationStateForCharacteristic =
+        PublishSubject<(CBCharacteristic, Error?)>()
+    let peripheralDidDiscoverDescriptorsForCharacteristic =
+        PublishSubject<(CBCharacteristic, Error?)>()
+    let peripheralDidUpdateValueForDescriptor = PublishSubject<(CBDescriptor, Error?)>()
+    let peripheralDidWriteValueForDescriptor = PublishSubject<(CBDescriptor, Error?)>()
+    let peripheralIsReadyToSendWriteWithoutResponse = PublishSubject<Void>()
+    let peripheralDidOpenL2CAPChannel = PublishSubject<(Any?, Error?)>()
+
+    func peripheralDidUpdateName(_ peripheral: CBPeripheral) {
+        RxBluetoothKitLog.d("""
+            \(peripheral.logDescription) didUpdateName(name: \(String(describing: peripheral.name)))
+            """)
+        peripheralDidUpdateName.onNext(peripheral.name)
+    }
+
+    func peripheral(_ peripheral: CBPeripheral, didModifyServices invalidatedServices: [CBService]) {
+        RxBluetoothKitLog.d("""
+            \(peripheral.logDescription) didModifyServices(services:
+            [\(invalidatedServices.logDescription))]
+            """)
+        peripheralDidModifyServices.onNext(invalidatedServices)
+    }
+
+    func peripheral(_ peripheral: CBPeripheral, didReadRSSI rssi: NSNumber, error: Error?) {
+        RxBluetoothKitLog.d("""
+            \(peripheral.logDescription) didReadRSSI(rssi: \(rssi),
+            error: \(String(describing: error)))
+            """)
+        peripheralDidReadRSSI.onNext((rssi.intValue, error))
+    }
+
+    func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
+        RxBluetoothKitLog.d("""
+            \(peripheral.logDescription) didDiscoverServices(services
+            : \(String(describing: peripheral.services?.logDescription)),
+            error: \(String(describing: error)))
+            """)
+        peripheralDidDiscoverServices.onNext((peripheral.services, error))
+    }
+
+    func peripheral(_ peripheral: CBPeripheral,
+                    didDiscoverIncludedServicesFor service: CBService,
+                    error: Error?) {
+        RxBluetoothKitLog.d("""
+            \(peripheral.logDescription) didDiscoverIncludedServices(for:
+            \(service.logDescription), includedServices:
+            \(String(describing: service.includedServices?.logDescription)),
+            error: \(String(describing: error)))
+            """)
+        peripheralDidDiscoverIncludedServicesForService.onNext((service, error))
+    }
+
+    func peripheral(_ peripheral: CBPeripheral,
+                    didDiscoverCharacteristicsFor service: CBService,
+                    error: Error?) {
+        RxBluetoothKitLog.d("""
+            \(peripheral.logDescription) didDiscoverCharacteristicsFor(for:
+            \(service.logDescription), characteristics:
+            \(String(describing: service.characteristics?.logDescription)),
+            error: \(String(describing: error)))
+            """)
+        peripheralDidDiscoverCharacteristicsForService.onNext((service, error))
+    }
+
+    func peripheral(_ peripheral: CBPeripheral,
+                    didUpdateValueFor characteristic: CBCharacteristic,
+                    error: Error?) {
+        RxBluetoothKitLog.d("""
+            \(peripheral.logDescription) didUpdateValueFor(for:\(characteristic.logDescription),
+            value: \(String(describing: characteristic.value?.logDescription)),
+            error: \(String(describing: error)))
+            """)
+        peripheralDidUpdateValueForCharacteristic
+            .onNext((characteristic, error))
+    }
+
+    func peripheral(_ peripheral: CBPeripheral,
+                    didWriteValueFor characteristic: CBCharacteristic,
+                    error: Error?) {
+        RxBluetoothKitLog.d("""
+            \(peripheral.logDescription) didWriteValueFor(for:\(characteristic.logDescription),
+            value: \(String(describing: characteristic.value?.logDescription)),
+            error: \(String(describing: error)))
+            """)
+        peripheralDidWriteValueForCharacteristic
+            .onNext((characteristic, error))
+    }
+
+    func peripheral(_ peripheral: CBPeripheral,
+                    didUpdateNotificationStateFor characteristic: CBCharacteristic,
+                    error: Error?) {
+        RxBluetoothKitLog.d("""
+            \(peripheral.logDescription) didUpdateNotificationStateFor(
+            for:\(characteristic.logDescription), isNotifying: \(characteristic.isNotifying),
+            error: \(String(describing: error)))
+            """)
+        peripheralDidUpdateNotificationStateForCharacteristic
+            .onNext((characteristic, error))
+    }
+
+    func peripheral(_ peripheral: CBPeripheral,
+                    didDiscoverDescriptorsFor characteristic: CBCharacteristic,
+                    error: Error?) {
+        RxBluetoothKitLog.d("""
+            \(peripheral.logDescription) didDiscoverDescriptorsFor
+            (for:\(characteristic.logDescription), descriptors:
+            \(String(describing: characteristic.descriptors?.logDescription)),
+            error: \(String(describing: error)))
+            """)
+        peripheralDidDiscoverDescriptorsForCharacteristic
+            .onNext((characteristic, error))
+    }
+
+    func peripheral(_ peripheral: CBPeripheral,
+                    didUpdateValueFor descriptor: CBDescriptor,
+                    error: Error?) {
+        RxBluetoothKitLog.d("""
+            \(peripheral.logDescription) didUpdateValueFor(for:\(descriptor.logDescription),
+            value: \(String(describing: descriptor.value)), error: \(String(describing: error)))
+            """)
+        peripheralDidUpdateValueForDescriptor.onNext((descriptor, error))
+    }
+
+    func peripheral(_ peripheral: CBPeripheral,
+                    didWriteValueFor descriptor: CBDescriptor,
+                    error: Error?) {
+        RxBluetoothKitLog.d("""
+            \(peripheral.logDescription) didWriteValueFor(for:\(descriptor.logDescription),
+            error: \(String(describing: error)))
+            """)
+        peripheralDidWriteValueForDescriptor.onNext((descriptor, error))
+    }
+
+    func peripheralIsReady(toSendWriteWithoutResponse peripheral: CBPeripheral) {
+        RxBluetoothKitLog.d("""
+            \(peripheral.logDescription) peripheralIsReady(toSendWriteWithoutResponse)
+            """)
+        peripheralIsReadyToSendWriteWithoutResponse.onNext(())
+    }
+
+    @available(OSX 10.13, iOS 11, *)
+    func peripheral(_ peripheral: CBPeripheral, didOpen channel: CBL2CAPChannel?, error: Error?) {
+        RxBluetoothKitLog.d("""
+            \(peripheral.logDescription) didOpenL2CAPChannel(for:\(peripheral.logDescription),
+            error: \(String(describing: error)))
+            """)
+        peripheralDidOpenL2CAPChannel.onNext((channel, error))
+    }
+}

package/ios/vendor/MultiplatformBleAdapter/RxBluetoothKit/Characteristic.swift

@@ -0,0 +1,121 @@
+import Foundation
+import CoreBluetooth
+
+// swiftlint:disable line_length
+
+/// Characteristic is a class implementing ReactiveX which wraps CoreBluetooth functions related to interaction with [CBCharacteristic](https://developer.apple.com/library/ios/documentation/CoreBluetooth/Reference/CBCharacteristic_Class/)
+public class Characteristic {
+    let characteristic: RxCharacteristicType
+    /// Service which contains this characteristic
+    public let service: Service
+
+    /// Current value of characteristic. If value is not present - it's `nil`.
+    public var value: Data? {
+        return characteristic.value
+    }
+
+    /// Unique identifier of an object.
+    public var objectId: UInt {
+        return characteristic.objectId
+    }
+
+    /// The Bluetooth UUID of the `Characteristic` instance.
+    public var uuid: CBUUID {
+        return characteristic.uuid
+    }
+
+    /// Flag which is set to true if characteristic is currently notifying
+    public var isNotifying: Bool {
+        return characteristic.isNotifying
+    }
+
+    /// Properties of characteristic. For more info about this refer to [CBCharacteristicProperties](https://developer.apple.com/library/ios/documentation/CoreBluetooth/Reference/CBCharacteristic_Class/#//apple_ref/c/tdef/CBCharacteristicProperties)
+    public var properties: CBCharacteristicProperties {
+        return characteristic.properties
+    }
+
+    /// Value of this property is an array of `Descriptor` objects. They provide more detailed information about characteristics value.
+    public var descriptors: [Descriptor]? {
+        return characteristic.descriptors?.map { Descriptor(descriptor: $0, characteristic: self) }
+    }
+
+    init(characteristic: RxCharacteristicType, service: Service) {
+        self.characteristic = characteristic
+        self.service = service
+    }
+
+    /// Function that triggers descriptors discovery for characteristic.
+    /// - returns: Observable that emits `Next` with array of `Descriptor` instances, once they're discovered.
+    /// Immediately after that `.Complete` is emitted.
+    public func discoverDescriptors() -> Observable<[Descriptor]> {
+        return service.peripheral.discoverDescriptors(for: self)
+    }
+
+    /// Function that allow to monitor writes that happened for characteristic.
+    /// - Returns: Observable that emits `Next` with `Characteristic` instance every time when write has happened.
+    /// It's **infinite** stream, so `.Complete` is never called.
+    public func monitorWrite() -> Observable<Characteristic> {
+        return service.peripheral.monitorWrite(for: self)
+    }
+
+    /// Function that triggers write of data to characteristic. Write is called after subscribtion to `Observable` is made.
+    /// Behavior of this function strongly depends on [CBCharacteristicWriteType](https://developer.apple.com/library/ios/documentation/CoreBluetooth/Reference/CBPeripheral_Class/#//apple_ref/swift/enum/c:@E@CBCharacteristicWriteType), so be sure to check this out before usage of the method.
+    /// - parameter forCharacteristic: `Descriptor` instance to write value to.
+    /// - parameter type: Type of write operation. Possible values: `.WithResponse`, `.WithoutResponse`
+    /// - returns: Observable that emition depends on `CBCharacteristicWriteType` passed to the function call.
+    /// Behavior is following:
+    ///
+    /// - `WithResponse` -  Observable emits `Next` with `Characteristic` instance write was confirmed without any errors.
+    /// Immediately after that `Complete` is called. If any problem has happened, errors are emitted.
+    /// - `WithoutResponse` - Observable emits `Next` with `Characteristic` instance once write was called.
+    /// Immediately after that `.Complete` is called. Result of this call is not checked, so as a user you are not sure
+    /// if everything completed successfully. Errors are not emitted
+    public func writeValue(_ data: Data, type: CBCharacteristicWriteType) -> Observable<Characteristic> {
+        return service.peripheral.writeValue(data, for: self, type: type)
+    }
+
+    /// Function that allow to monitor value updates for `Characteristic` instance.
+    /// - Returns: Observable that emits `Next` with `Characteristic` instance every time when value has changed.
+    /// It's **infinite** stream, so `.Complete` is never called.
+    public func monitorValueUpdate() -> Observable<Characteristic> {
+        return service.peripheral.monitorValueUpdate(for: self)
+    }
+
+    /// Function that triggers read of current value of the `Characteristic` instance.
+    /// Read is called after subscription to `Observable` is made.
+    /// - Returns: Observable which emits `Next` with given characteristic when value is ready to read. Immediately after that
+    /// `.Complete` is emitted.
+    public func readValue() -> Observable<Characteristic> {
+        return service.peripheral.readValue(for: self)
+    }
+
+    /// Function that triggers set of notification state of the `Characteristic`.
+    /// This change is called after subscribtion to `Observable` is made.
+    /// - warning: This method is not responsible for emitting values every time that `Characteristic` value is changed.
+    /// For this, refer to other method: `monitorValueUpdateForCharacteristic(_)`. These two are often called together.
+    /// - parameter enabled: New value of notifications state. Specify `true` if you're interested in getting values
+    /// - returns: Observable which emits `Next` with Characteristic that state was changed. Immediately after `.Complete` is emitted
+    public func setNotifyValue(_ enabled: Bool) -> Observable<Characteristic> {
+        return service.peripheral.setNotifyValue(enabled, for: self)
+    }
+
+    /// Function that triggers set of notification state of the `Characteristic`, and monitor for any incoming updates.
+    /// Notification is set after subscribtion to `Observable` is made.
+    /// - returns: Observable which emits `Next`, when characteristic value is updated.
+    /// This is **infinite** stream of values.
+
+    public func setNotificationAndMonitorUpdates() -> Observable<Characteristic> {
+        return service.peripheral.setNotificationAndMonitorUpdates(for: self)
+    }
+}
+
+extension Characteristic: Equatable {}
+
+/// Compare two characteristics. Characteristics are the same when their UUIDs are the same.
+///
+/// - parameter lhs: First characteristic to compare
+/// - parameter rhs: Second characteristic to compare
+/// - returns: True if both characteristics are the same.
+public func == (lhs: Characteristic, rhs: Characteristic) -> Bool {
+    return lhs.characteristic == rhs.characteristic
+}

package/ios/vendor/MultiplatformBleAdapter/RxBluetoothKit/Descriptor.swift

@@ -0,0 +1,74 @@
+import Foundation
+import CoreBluetooth
+
+/// Descriptor is a class implementing ReactiveX which wraps CoreBluetooth functions related to interaction with
+/// [CBDescriptor](https://developer.apple.com/library/ios/documentation/CoreBluetooth/Reference/CBDescriptor_Class/)
+/// Descriptors provide more information about a characteristic’s value.
+public class Descriptor {
+
+    let descriptor: RxDescriptorType
+
+    /// Characteristic to which this descriptor belongs.
+    public let characteristic: Characteristic
+
+    /// Unique identifier of an object.
+    public var objectId: UInt {
+        return descriptor.objectId
+    }
+
+    /// The Bluetooth UUID of the `Descriptor` instance.
+    public var uuid: CBUUID {
+        return descriptor.uuid
+    }
+
+    /// The value of the descriptor. It can be written and read through functions on `Descriptor` instance.
+    public var value: Any? {
+        return descriptor.value
+    }
+
+    init(descriptor: RxDescriptorType, characteristic: Characteristic) {
+        self.descriptor = descriptor
+        self.characteristic = characteristic
+    }
+
+    /// Function that allow to monitor writes that happened for descriptor.
+    /// - Returns: Observable that emits `Next` with `Descriptor` instance every time when write has happened.
+    /// It's **infinite** stream, so `.Complete` is never called.
+    public func monitorWrite() -> Observable<Descriptor> {
+        return characteristic.service.peripheral.monitorWrite(for: self)
+    }
+
+    ///  Function that triggers write of data to descriptor. Write is called after subscribtion to `Observable` is made.
+    ///  - Parameter data: `NSData` that'll be written to `Descriptor` instance
+    ///  - Returns: Observable that emits `Next` with `Descriptor` instance, once value is written successfully.
+    ///  Immediately after that `.Complete` is emitted.
+    public func writeValue(_ data: Data) -> Observable<Descriptor> {
+        return characteristic.service.peripheral.writeValue(data, for: self)
+    }
+
+    /// Function that allow to monitor value updates for `Descriptor` instance.
+    /// - Returns: Observable that emits `Next` with `Descriptor` instance every time when value has changed.
+    /// It's **infinite** stream, so `.Complete` is never called.
+    public func monitorValueUpdate() -> Observable<Descriptor> {
+        return characteristic.service.peripheral.monitorValueUpdate(for: self)
+    }
+
+    /// Function that triggers read of current value of the `Descriptor` instance.
+    /// Read is called after subscription to `Observable` is made.
+    /// - Returns: Observable which emits `Next` with given descriptor when value is ready to read.
+    /// Immediately after that `.Complete` is emitted.
+    public func readValue() -> Observable<Descriptor> {
+        return characteristic.service.peripheral.readValue(for: self)
+    }
+}
+
+extension Descriptor: Equatable {}
+
+/// Compare two descriptors. Descriptors are the same when their UUIDs are the same.
+///
+/// - parameter lhs: First descriptor to compare
+/// - parameter rhs: Second descriptor to compare
+/// - returns: True if both descriptor are the same.
+public func == (lhs: Descriptor, rhs: Descriptor) -> Bool {
+    return lhs.descriptor == rhs.descriptor
+}

package/ios/vendor/MultiplatformBleAdapter/RxBluetoothKit/DeviceIdentifiers.swift

@@ -0,0 +1,51 @@
+import CoreBluetooth
+
+/// ServiceIdentifier protocol specifies how information about services of device should look like.
+/// Sample implementation could look like:
+///
+/// ```
+/// enum DeviceService: String, ServiceIdentifier {
+///     case deviceInformation = "180A"
+///     var uuid: CBUUID {
+///         return CBUUID(string: self.rawValue)
+///     }
+/// }
+/// ```
+/// After implementing this and other protocol `CharacteristicIdentifier, you could call methods even easier
+/// thanks to convenience methods in library. This methods do all of the heavy lifting like discovering services, taking
+/// them from cache etc. for you. We really recommend you to use it.
+public protocol ServiceIdentifier {
+    /// Unique identifier of a service.
+    var uuid: CBUUID { get }
+}
+
+/// Characteristic protocol specifies how information about characteristics of device should look like.
+/// Sample implementation could look like:
+/// ```
+/// enum DeviceCharacteristic: String, CharacteristicIdentifier {
+///     case manufacturerName = "2A29"
+///     var uuid: CBUUID {
+///         return CBUUID(string: self.rawValue)
+///     }
+///     var service: ServiceIdentifier {
+///         switch self {
+///         case .ManufacturerName:
+///             return XXXService.DeviceInformation
+///         }
+///     }
+/// }
+/// ```
+public protocol CharacteristicIdentifier {
+    /// Unique identifier of a characteristic.
+    var uuid: CBUUID { get }
+    /// `ServiceIdentifier` instance that this characteristic belongs to.
+    var service: ServiceIdentifier { get }
+}
+
+/// DescriptorIdentifier protocol specifies how information about descriptors of device should look like.
+public protocol DescriptorIdentifier {
+    /// Unique identifier of a descriptor.
+    var uuid: CBUUID { get }
+    /// `CharacteristicIdentifier` instance that this descriptor belongs to.
+    var characteristic: CharacteristicIdentifier { get }
+}