Merge pull request #257 from Polidea/feature/peripheral_manager

Support for CBPeripheralManager

Author: pouljohn1

.swiftlint.yml

@@ -15,9 +15,12 @@ excluded:
   - Carthage
   - ExampleApp
   - Tests
+  - .build
 
 
-line_length: 120
+line_length: 
+  warning: 120
+  ignores_comments: true
 # they can set both implicitly with an array
 type_body_length:
   - 300 # warning

HOW_TO_RELEASE.md

@@ -4,7 +4,7 @@
 - add new change log to `Changelog.md`
 - change `RxBluetoothKit.podspec` with new library version
 - generate new doc by running script `./scripts/generate-docs.sh x.x.x`
-- push new commit with that changes
+- create new Pull Request with that changes and merge it
 - create new release on github
 - create archive by running `carthage build --no-skip-current && carthage archive RxBluetoothKit`
 - add those archive to github release that was created before

README.md

@@ -23,13 +23,14 @@ Follow [Polidea's Blog](https://www.polidea.com/blog/RxBluetoothKit_The_most_sim
 
 ## Features
 - [x] CBCentralManger RxSwift support
+- [x] CBPeripheralManger RxSwift support
 - [x] CBPeripheral RxSwift support
 - [x] Scan sharing
 - [x] Scan queueing
 - [x] Bluetooth error bubbling
 
 ## Sample
-In Example folder you can find application we've provided to you. It's a great place to dig in, once you want to see everything in action. App provides most of the common usages of RxBluetoothKit.
+In ExampleApp folder you can find application we've provided to you. It's a great place to dig in, once you want to see everything in action. App provides most of the common usages of RxBluetoothKit.
 
 ## Installation
 
@@ -60,6 +61,7 @@ Library is built on top of Apple's CoreBluetooth.
 It has multiple components, that should be familiar to you:
 
 - CentralManager
+- PeripheralManager
 - ScannedPeripheral
 - Peripheral
 - Service

RxBluetoothKit.xcodeproj/project.pbxproj

@@ -9,6 +9,9 @@ public enum BluetoothError: Error {
     case destroyed
     // Emitted when `CentralManager.scanForPeripherals` called and there is already ongoing scan
     case scanInProgress
+    // Emitted when `PeripheralManager.startAdvertising` called and there is already ongoing advertisement
+    case advertisingInProgress
+    case advertisingStartFailed(Error)
     // States
     case bluetoothUnsupported
     case bluetoothUnauthorized
@@ -25,6 +28,7 @@ public enum BluetoothError: Error {
     // Services
     case servicesDiscoveryFailed(Peripheral, Error?)
     case includedServicesDiscoveryFailed(Peripheral, Error?)
+    case addingServiceFailed(CBService, Error?)
     // Characteristics
     case characteristicsDiscoveryFailed(Service, Error?)
     case characteristicWriteFailed(Characteristic, Error?)
@@ -35,8 +39,9 @@ public enum BluetoothError: Error {
     case descriptorsDiscoveryFailed(Characteristic, Error?)
     case descriptorWriteFailed(Descriptor, Error?)
     case descriptorReadFailed(Descriptor, Error?)
-    //L2CAP
+    // L2CAP
     case openingL2CAPChannelFailed(Peripheral, Error?)
+    case publishingL2CAPChannelFailed(CBL2CAPPSM, Error?)
 }
 
 extension BluetoothError: CustomStringConvertible {
@@ -54,6 +59,13 @@ extension BluetoothError: CustomStringConvertible {
             Tried to scan for peripheral when there is already ongoing scan.
             You can have only 1 ongoing scanning, please check documentation of CentralManager for more details
             """
+        case .advertisingInProgress:
+            return """
+            Tried to advertise when there is already advertising ongoing.
+            You can have only 1 ongoing advertising, please check documentation of PeripheralManager for more details
+            """
+        case let .advertisingStartFailed(err):
+            return "Start advertising error occured: \(err.localizedDescription)"
         case .bluetoothUnsupported:
             return "Bluetooth is unsupported"
         case .bluetoothUnauthorized:
@@ -82,6 +94,8 @@ extension BluetoothError: CustomStringConvertible {
             return "Services discovery error has occured: \(err?.localizedDescription ?? "-")"
         case let .includedServicesDiscoveryFailed(_, err):
             return "Included services discovery error has occured: \(err?.localizedDescription ?? "-")"
+        case let .addingServiceFailed(_, err):
+            return "Adding PeripheralManager service error has occured: \(err?.localizedDescription ?? "-")"
         // Characteristics
         case let .characteristicsDiscoveryFailed(_, err):
             return "Characteristics discovery error has occured: \(err?.localizedDescription ?? "-")"
@@ -102,6 +116,8 @@ extension BluetoothError: CustomStringConvertible {
             return "Descriptor read error has occured: \(err?.localizedDescription ?? "-")"
         case let .openingL2CAPChannelFailed(_, err):
             return "Opening L2CAP channel error has occured: \(err?.localizedDescription ?? "-")"
+        case let .publishingL2CAPChannelFailed(_, err):
+            return "Publishing L2CAP channel error has occured: \(err?.localizedDescription ?? "-")"
         }
     }
 }
@@ -132,6 +148,8 @@ extension BluetoothError: Equatable {}
 public func == (lhs: BluetoothError, rhs: BluetoothError) -> Bool {
     switch (lhs, rhs) {
     case (.scanInProgress, .scanInProgress): return true
+    case (.advertisingInProgress, .advertisingInProgress): return true
+    case (.advertisingStartFailed, .advertisingStartFailed): return true
     // States
     case (.bluetoothUnsupported, .bluetoothUnsupported): return true
     case (.bluetoothUnauthorized, .bluetoothUnauthorized): return true
@@ -141,6 +159,7 @@ public func == (lhs: BluetoothError, rhs: BluetoothError) -> Bool {
     // Services
     case let (.servicesDiscoveryFailed(l, _), .servicesDiscoveryFailed(r, _)): return l == r
     case let (.includedServicesDiscoveryFailed(l, _), .includedServicesDiscoveryFailed(r, _)): return l == r
+    case let (.addingServiceFailed(l, _), .addingServiceFailed(r, _)): return l == r
     // Peripherals
     case let (.peripheralIsAlreadyObservingConnection(l), .peripheralIsAlreadyObservingConnection(r)): return l == r
     case let (.peripheralIsConnectingOrAlreadyConnected(l), .peripheralIsConnectingOrAlreadyConnected(r)): return l == r
@@ -161,6 +180,7 @@ public func == (lhs: BluetoothError, rhs: BluetoothError) -> Bool {
     case let (.descriptorReadFailed(l, _), .descriptorReadFailed(r, _)): return l == r
     // L2CAP
     case let (.openingL2CAPChannelFailed(l, _), .openingL2CAPChannelFailed(r, _)): return l == r
+    case let (.publishingL2CAPChannelFailed(l, _), .publishingL2CAPChannelFailed(r, _)): return l == r
     default: return false
     }
 }

Source/BluetoothError.swift

@@ -0,0 +1,9 @@
+import Foundation
+import CoreBluetooth
+
+extension CBCentral {
+    /// There is still no identifier property for macOS, that's why we need to retrieve it by value method
+    var uuidIdentifier: UUID {
+        return value(forKey: "identifier") as! NSUUID as UUID
+    }
+}

Source/CBCentral+Uuid.swift

@@ -0,0 +1,108 @@
+import Foundation
+import CoreBluetooth
+import RxSwift
+
+class CBPeripheralManagerDelegateWrapper: NSObject, CBPeripheralManagerDelegate {
+
+    let didUpdateState = PublishSubject<BluetoothState>()
+    let isReady = PublishSubject<Void>()
+    let didStartAdvertising = PublishSubject<Error?>()
+    let didReceiveRead = PublishSubject<CBATTRequest>()
+    let willRestoreState = ReplaySubject<[String: Any]>.create(bufferSize: 1)
+    let didAddService = PublishSubject<(CBService, Error?)>()
+    let didReceiveWrite = PublishSubject<[CBATTRequest]>()
+    let didSubscribeTo = PublishSubject<(CBCentral, CBCharacteristic)>()
+    let didUnsubscribeFrom = PublishSubject<(CBCentral, CBCharacteristic)>()
+    let didPublishL2CAPChannel = PublishSubject<(CBL2CAPPSM, Error?)>()
+    let didUnpublishL2CAPChannel = PublishSubject<(CBL2CAPPSM, Error?)>()
+    private var _didOpenChannel: Any?
+    @available(iOS 11.0, macOS 10.13, tvOS 11.0, watchOS 4.0, *)
+    var didOpenChannel: PublishSubject<(CBL2CAPChannel?, Error?)> {
+        if _didOpenChannel == nil {
+            _didOpenChannel = PublishSubject<(CBL2CAPChannel?, Error?)>()
+        }
+        return _didOpenChannel as! PublishSubject<(CBL2CAPChannel?, Error?)>
+    }
+
+    func peripheralManagerDidUpdateState(_ peripheral: CBPeripheralManager) {
+        guard let bleState = BluetoothState(rawValue: peripheral.state.rawValue) else { return }
+        RxBluetoothKitLog.d("\(peripheral.logDescription) didUpdateState(state: \(bleState.logDescription))")
+        didUpdateState.onNext(bleState)
+    }
+
+    func peripheralManagerIsReady(toUpdateSubscribers peripheral: CBPeripheralManager) {
+        RxBluetoothKitLog.d("\(peripheral.logDescription) isReady()")
+        isReady.onNext(())
+    }
+
+    func peripheralManagerDidStartAdvertising(_ peripheral: CBPeripheralManager, error: Error?) {
+        RxBluetoothKitLog.d("\(peripheral.logDescription) didStartAdvertising(error: \(String(describing: error)))")
+        didStartAdvertising.onNext(error)
+    }
+
+    func peripheralManager(_ peripheral: CBPeripheralManager, didReceiveRead request: CBATTRequest) {
+        RxBluetoothKitLog.d("\(peripheral.logDescription) didReceiveRead(request: \(request.logDescription))")
+        didReceiveRead.onNext(request)
+    }
+
+    func peripheralManager(_ peripheral: CBPeripheralManager, willRestoreState dict: [String: Any]) {
+        RxBluetoothKitLog.d("\(peripheral.logDescription) willRestoreState(dict: \(dict))")
+        willRestoreState.onNext(dict)
+    }
+
+    func peripheralManager(_ peripheral: CBPeripheralManager, didAdd service: CBService, error: Error?) {
+        RxBluetoothKitLog.d("""
+            \(peripheral.logDescription)
+            didAdd(service: \(service.logDescription), error: \(String(describing: error))
+            """)
+        didAddService.onNext((service, error))
+    }
+
+    func peripheralManager(_ peripheral: CBPeripheralManager, didReceiveWrite requests: [CBATTRequest]) {
+        let requestsLog = requests.reduce("[", { $0 + $1.logDescription + "," }).dropLast().appending("]")
+        RxBluetoothKitLog.d("\(peripheral.logDescription) didReceiveWrite(requests: \(requestsLog))")
+        didReceiveWrite.onNext(requests)
+    }
+
+    func peripheralManager(_ peripheral: CBPeripheralManager, central: CBCentral,
+                           didSubscribeTo characteristic: CBCharacteristic) {
+        RxBluetoothKitLog.d("""
+            \(peripheral.logDescription)
+            didSubscribeTo(central: \(central.logDescription), characteristic: \(characteristic.logDescription))
+            """)
+        didSubscribeTo.onNext((central, characteristic))
+    }
+
+    func peripheralManager(_ peripheral: CBPeripheralManager,
+                           central: CBCentral,
+                           didUnsubscribeFrom characteristic: CBCharacteristic) {
+        RxBluetoothKitLog.d("""
+            \(peripheral.logDescription)
+            didUnsubscribeFrom(central: \(central.logDescription), characteristic: \(characteristic.logDescription))
+            """)
+        didUnsubscribeFrom.onNext((central, characteristic))
+    }
+
+    func peripheralManager(_ peripheral: CBPeripheralManager, didPublishL2CAPChannel PSM: CBL2CAPPSM, error: Error?) {
+        RxBluetoothKitLog.d("""
+            \(peripheral.logDescription) didPublishL2CAPChannel(PSM: \(PSM), error: \(String(describing: error))
+            """)
+        didPublishL2CAPChannel.onNext((PSM, error))
+    }
+
+    func peripheralManager(_ peripheral: CBPeripheralManager, didUnpublishL2CAPChannel PSM: CBL2CAPPSM, error: Error?) {
+        RxBluetoothKitLog.d("""
+            \(peripheral.logDescription) didUnpublishL2CAPChannel(PSM: \(PSM), error: \(String(describing: error))
+            """)
+        didUnpublishL2CAPChannel.onNext((PSM, error))
+    }
+
+    @available(iOS 11.0, macOS 10.13, tvOS 11.0, watchOS 4.0, *)
+    func peripheralManager(_ peripheral: CBPeripheralManager, didOpen channel: CBL2CAPChannel?, error: Error?) {
+        RxBluetoothKitLog.d("""
+            \(peripheral.logDescription)
+            didOpen(channel: \(channel?.logDescription ?? "nil"), error: \(String(describing: error))
+            """)
+        didOpenChannel.onNext((channel, error))
+    }
+}

Source/CBPeripheralManagerDelegateWrapper.swift

@@ -2,14 +2,25 @@ import Foundation
 import RxSwift
 import CoreBluetooth
 
-/// Closure that receives `RestoredState` as a parameter
+@available(*, deprecated: 5.1.0, renamed: "OnWillRestoreCentralManagerState")
 public typealias OnWillRestoreState = (RestoredState) -> Void
+/// Closure that receives `RestoredState` as a parameter
+public typealias OnWillRestoreCentralManagerState = (CentralManagerRestoredState) -> Void
 
 extension CentralManager {
 
     // MARK: State restoration
 
-    // swiftlint:disable line_length
+    /// Deprecated, use CentralManager.init(queue:options:onWillRestoreCentralManagerState:) instead
+    @available(*, deprecated: 5.1.0, renamed: "CentralManager.init(queue:options:onWillRestoreCentralManagerState:)")
+    public convenience init(queue: DispatchQueue = .main,
+                            options: [String: AnyObject]? = nil,
+                            onWillRestoreState: OnWillRestoreState? = nil) {
+        self.init(queue: queue, options: options)
+        if let onWillRestoreState = onWillRestoreState {
+            listenOnWillRestoreState(onWillRestoreState)
+        }
+    }
 
     /// Creates new `CentralManager` instance, which supports bluetooth state restoration.
     /// - warning: If you pass background queue to the method make sure to observe results on main thread
@@ -18,20 +29,18 @@ extension CentralManager {
     /// and all operations and events are executed and received on main thread.
     /// - parameter options: An optional dictionary containing initialization options for a central manager.
     /// For more info about it please refer to [Central Manager initialization options](https://developer.apple.com/library/ios/documentation/CoreBluetooth/Reference/CBCentralManager_Class/index.html)
-    /// - parameter onWillRestoreState: Closure called when state has been restored.
+    /// - parameter onWillRestoreCentralManagerState: Closure called when state has been restored.
     ///
-    /// - seealso: `RestoredState`
+    /// - seealso: `OnWillRestoreCentralManagerState`
     public convenience init(queue: DispatchQueue = .main,
                             options: [String: AnyObject]? = nil,
-                            onWillRestoreState: OnWillRestoreState? = nil) {
+                            onWillRestoreCentralManagerState: OnWillRestoreCentralManagerState? = nil) {
         self.init(queue: queue, options: options)
-        if let onWillRestoreState = onWillRestoreState {
-            listenOnWillRestoreState(onWillRestoreState)
+        if let onWillRestoreCentralManagerState = onWillRestoreCentralManagerState {
+            listenOnWillRestoreState(onWillRestoreCentralManagerState)
         }
     }
 
-    // swiftlint:enable line_length
-
     /// Creates new `CentralManager`
     /// - parameter centralManager: Central instance which is used to perform all of the necessary operations
     /// - parameter delegateWrapper: Wrapper on CoreBluetooth's central manager callbacks.
@@ -43,28 +52,38 @@ extension CentralManager {
         delegateWrapper: CBCentralManagerDelegateWrapper,
         peripheralProvider: PeripheralProvider,
         connector: Connector,
-        onWillRestoreState: @escaping OnWillRestoreState
-    ) {
+        onWillRestoreCentralManagerState: @escaping OnWillRestoreCentralManagerState
+        ) {
         self.init(
             centralManager: centralManager,
             delegateWrapper: delegateWrapper,
             peripheralProvider: peripheralProvider,
             connector: connector
         )
-        listenOnWillRestoreState(onWillRestoreState)
+        listenOnWillRestoreState(onWillRestoreCentralManagerState)
+    }
+
+    func listenOnWillRestoreState(_ handler: @escaping OnWillRestoreState) {
+        _ = restoreStateObservable
+            .map { RestoredState(centralManagerRestoredState: $0) }
+            .subscribe(onNext: { handler($0) })
     }
 
     /// Emits `RestoredState` instance, when state of `CentralManager` has been restored,
     /// Should only be called once in the lifetime of the app
     /// - returns: Observable which emits next events state has been restored
-    func listenOnWillRestoreState(_ handler: @escaping OnWillRestoreState) {
-        _ = delegateWrapper
+    func listenOnWillRestoreState(_ handler: @escaping OnWillRestoreCentralManagerState) {
+        _ = restoreStateObservable
+            .subscribe(onNext: { handler($0) })
+    }
+
+    var restoreStateObservable: Observable<CentralManagerRestoredState> {
+        return delegateWrapper
             .willRestoreState
             .take(1)
-            .flatMap { [weak self] dict -> Observable<RestoredState> in
+            .flatMap { [weak self] dict -> Observable<CentralManagerRestoredState> in
                 guard let strongSelf = self else { throw BluetoothError.destroyed }
-                return .just(RestoredState(restoredStateDictionary: dict, centralManager: strongSelf))
+                return .just(CentralManagerRestoredState(restoredStateDictionary: dict, centralManager: strongSelf))
             }
-            .subscribe(onNext: { handler($0) })
     }
 }