unified-ble-manager 4.0.0-alpha.0

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

@@ -0,0 +1,218 @@
+import Foundation
+import CoreBluetooth
+
+/**
+ RxBluetoothKit specific logging class which gives access to its settings.
+ */
+public class RxBluetoothKitLog: ReactiveCompatible {
+
+    fileprivate static var currentLogLevel: LogLevel = .none
+
+    fileprivate static let subject = PublishSubject<String>()
+
+    private init() {
+    }
+
+    /// Log levels for internal logging mechanism.
+    public enum LogLevel: UInt8 {
+        /// Logging is disabled
+        case none = 255
+        /// All logs are monitored.
+        case verbose = 0
+        /// Only debug logs and of higher importance are logged.
+        case debug = 1
+        /// Only info logs and of higher importance are logged.
+        case info = 2
+        /// Only warning logs and of higher importance are logged.
+        case warning = 3
+        /// Only error logs and of higher importance are logged.
+        case error = 4
+    }
+
+    /**
+     * Set new log level.
+     * - Parameter logLevel: New log level to be applied.
+     */
+    public static func setLogLevel(_ logLevel: LogLevel) {
+        currentLogLevel = logLevel
+    }
+
+    /**
+     * Get current log level.
+     * - Returns: Currently set log level.
+     */
+    public static func getLogLevel() -> LogLevel {
+        return currentLogLevel
+    }
+
+    fileprivate static func tag(with logLevel: LogLevel) -> String {
+        let prefix: String
+
+        switch logLevel {
+        case .none:
+            prefix = "[RxBLEKit|NONE|"
+        case .verbose:
+            prefix = "[RxBLEKit|VERB|"
+        case .debug:
+            prefix = "[RxBLEKit|DEBG|"
+        case .info:
+            prefix = "[RxBLEKit|INFO|"
+        case .warning:
+            prefix = "[RxBLEKit|WARN|"
+        case .error:
+            prefix = "[RxBLEKit|ERRO|"
+        }
+        let time = Date().timeIntervalSinceReferenceDate
+        return prefix + String(format: "%02.0f:%02.0f:%02.0f.%03.f]:",
+                               floor(time / 3600.0).truncatingRemainder(dividingBy: 24),
+                               floor(time / 60.0).truncatingRemainder(dividingBy: 60),
+                               floor(time).truncatingRemainder(dividingBy: 60),
+                               floor(time * 1000).truncatingRemainder(dividingBy: 1000))
+    }
+
+    fileprivate static func log(with logLevel: LogLevel, message: @autoclosure () -> String) {
+        if currentLogLevel <= logLevel {
+            let string = "\(tag(with: logLevel)) \(message())"
+            subject.onNext(string)
+            print(string)
+        }
+    }
+
+    static func v(_ message: @autoclosure () -> String) {
+        log(with: .verbose, message: message())
+    }
+
+    static func d(_ message: @autoclosure () -> String) {
+        log(with: .debug, message: message())
+    }
+
+    static func i(_ message: @autoclosure () -> String) {
+        log(with: .info, message: message())
+    }
+
+    static func w(_ message: @autoclosure () -> String) {
+        log(with: .warning, message: message())
+    }
+
+    static func e(_ message: @autoclosure () -> String) {
+        log(with: .error, message: message())
+    }
+}
+
+extension RxBluetoothKitLog.LogLevel: Comparable {
+    public static func < (lhs: RxBluetoothKitLog.LogLevel, rhs: RxBluetoothKitLog.LogLevel) -> Bool {
+        return lhs.rawValue < rhs.rawValue
+    }
+
+    public static func <= (lhs: RxBluetoothKitLog.LogLevel, rhs: RxBluetoothKitLog.LogLevel) -> Bool {
+        return lhs.rawValue <= rhs.rawValue
+    }
+
+    public static func > (lhs: RxBluetoothKitLog.LogLevel, rhs: RxBluetoothKitLog.LogLevel) -> Bool {
+        return lhs.rawValue > rhs.rawValue
+    }
+
+    public static func >= (lhs: RxBluetoothKitLog.LogLevel, rhs: RxBluetoothKitLog.LogLevel) -> Bool {
+        return lhs.rawValue >= rhs.rawValue
+    }
+
+    public static func == (lhs: RxBluetoothKitLog.LogLevel, rhs: RxBluetoothKitLog.LogLevel) -> Bool {
+        return lhs.rawValue == rhs.rawValue
+    }
+}
+
+protocol Loggable {
+    var logDescription: String { get }
+}
+
+extension Data: Loggable {
+    var logDescription: String {
+        return map { String(format: "%02x", $0) }.joined()
+    }
+}
+
+extension BluetoothState: Loggable {
+    var logDescription: String {
+        switch self {
+        case .unknown: return "unknown"
+        case .resetting: return "resetting"
+        case .unsupported: return "unsupported"
+        case .unauthorized: return "unauthorized"
+        case .poweredOff: return "poweredOff"
+        case .poweredOn: return "poweredOn"
+        }
+    }
+}
+
+extension CBCharacteristicWriteType: Loggable {
+    var logDescription: String {
+        switch self {
+        case .withResponse: return "withResponse"
+        case .withoutResponse: return "withoutResponse"
+        }
+    }
+}
+
+extension UUID: Loggable {
+    var logDescription: String {
+        return uuidString
+    }
+}
+
+extension CBUUID: Loggable {
+    @objc var logDescription: String {
+        return uuidString
+    }
+}
+
+extension CBCentralManager: Loggable {
+    @objc var logDescription: String {
+        return "CentralManager(\(UInt(bitPattern: ObjectIdentifier(self))))"
+    }
+}
+
+extension CBPeripheral: Loggable {
+    @objc var logDescription: String {
+        return "Peripheral(uuid: \(value(forKey: "identifier") as! NSUUID as UUID), name: \(String(describing: name)))"
+    }
+}
+
+extension CBCharacteristic: Loggable {
+    @objc var logDescription: String {
+        return "Characteristic(uuid: \(uuid), id: \((UInt(bitPattern: ObjectIdentifier(self)))))"
+    }
+}
+
+extension CBService: Loggable {
+    @objc var logDescription: String {
+        return "Service(uuid: \(uuid), id: \((UInt(bitPattern: ObjectIdentifier(self)))))"
+    }
+}
+
+extension CBDescriptor: Loggable {
+    @objc var logDescription: String {
+        return "Descriptor(uuid: \(uuid), id: \((UInt(bitPattern: ObjectIdentifier(self)))))"
+    }
+}
+
+extension Array where Element: Loggable {
+    var logDescription: String {
+        return "[\(map { $0.logDescription }.joined(separator: ", "))]"
+    }
+}
+
+extension Reactive where Base == RxBluetoothKitLog {
+    /**
+     * This is continuous value, which emits before a log is printed to standard output.
+     *
+     * - it never fails
+     * - it delivers events on `MainScheduler.instance`
+     * - `share(scope: .whileConnected)` sharing strategy
+     */
+    public var log: Observable<String> {
+        return RxBluetoothKitLog.subject.asObserver()
+            .observeOn(MainScheduler.instance)
+            .catchErrorJustReturn("")
+            .share(scope: .whileConnected)
+    }
+}

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

@@ -0,0 +1,41 @@
+import Foundation
+import CoreBluetooth
+
+public protocol ManagerType: AnyObject {
+    associatedtype Manager 
+
+    /// Implementation of CBManager
+    var manager: Manager { get }
+    /// Current state of `CentralManager` instance described by `BluetoothState` which is equivalent to
+    /// [CBManagerState](https://developer.apple.com/documentation/corebluetooth/cbmanagerstate).
+    var state: BluetoothState { get }
+
+    /// Continuous state of `CBManager` instance described by `BluetoothState` which is equivalent to  [CBManagerState](https://developer.apple.com/documentation/corebluetooth/cbmanagerstate).
+    /// - returns: Observable that emits `next` event whenever state changes.
+    ///
+    /// It's **infinite** stream, so `.complete` is never called.
+    func observeState() -> Observable<BluetoothState>
+
+    /// Continuous state of `CBManager` instance described by `BluetoothState` which is equivalent to  [CBManagerState](https://developer.apple.com/documentation/corebluetooth/cbmanagerstate).
+    /// - returns: Observable that emits `next` event starting with current state and whenever state changes.
+    ///
+    /// It's **infinite** stream, so `.complete` is never called.
+    func observeStateWithInitialValue() -> Observable<BluetoothState>
+}
+
+public extension ManagerType {
+    /// Ensure that `state` is and will be the only state of `CentralManager` during subscription.
+    /// Otherwise error is emitted.
+    /// - parameter state: `BluetoothState` which should be present during subscription.
+    /// - parameter observable: Observable into which potential errors should be merged.
+    /// - returns: New observable which merges errors with source observable.
+    func ensure<T>(_ state: BluetoothState, observable: Observable<T>) -> Observable<T> {
+        return .deferred { [weak self] in
+            guard let strongSelf = self else { throw BluetoothError.destroyed }
+            let statesObservable = strongSelf.observeStateWithInitialValue()
+                .filter { $0 != state && BluetoothError(state: $0) != nil }
+                .map { state -> T in throw BluetoothError(state: state)! }
+            return .absorb(statesObservable, observable)
+        }
+    }
+}

package/ios/vendor/MultiplatformBleAdapter/RxBluetoothKit/Observable+Absorb.swift

@@ -0,0 +1,25 @@
+extension ObservableType {
+    /// Absorbes all of events from a and b observables into result observable.
+
+    /// - parameter a: First observable
+    /// - parameter b: Second observable
+    /// - returns: New observable which emits all of events from a and b observables.
+    /// If error or complete is received on any of the observables, it's propagates immediately to result observable
+    static func absorb(_ a: Observable<Element>, _ b: Observable<Element>) -> Observable<Element> {
+        return .create { observer in
+            let disposable = CompositeDisposable()
+            let innerObserver: AnyObserver<Element> = AnyObserver { event in
+                observer.on(event)
+                if event.isStopEvent {
+                    disposable.dispose()
+                }
+            }
+            _ = disposable.insert(a.subscribe(innerObserver))
+            if !disposable.isDisposed {
+                _ = disposable.insert(b.subscribe(innerObserver))
+            }
+
+            return disposable
+        }
+    }
+}

package/ios/vendor/MultiplatformBleAdapter/RxBluetoothKit/Observable+QueueSubscribeOn.swift

@@ -0,0 +1,125 @@
+import Foundation
+
+/// Queue which is used for queueing subscriptions for queueSubscribeOn operator.
+class SerializedSubscriptionQueue {
+    let lock = NSLock()
+
+    /// First element on queue is curently subscribed and not completed
+    /// observable. All others are queued for subscription when the first
+    /// one is finished.
+    var queue: [DelayedObservableType] = []
+
+    /// Queue subscription. If observable is inserted
+    /// into empty queue it's subscribed immediately. Otherwise
+    /// it waits for completion from other observables.
+    func queueSubscription(observable: DelayedObservableType) {
+        lock.lock(); defer { lock.unlock() }
+        let execute = queue.isEmpty
+        queue.append(observable)
+        if execute {
+            // Observable is scheduled immidiately
+            queue.first?.delayedSubscribe()
+        }
+    }
+
+    func unsubscribe(observable: DelayedObservableType) {
+        lock.lock(); defer { lock.unlock() }
+        // Find index of observable which should be unsubscribed
+        // and remove it from queue
+        if let index = queue.index(where: { $0 === observable }) {
+            queue.remove(at: index)
+            // If first item was unsubscribed, subscribe on next one
+            // if available
+            if index == 0 {
+                queue.first?.delayedSubscribe()
+            }
+        }
+    }
+}
+
+protocol DelayedObservableType: class {
+    func delayedSubscribe()
+}
+
+class QueueSubscribeOn<Element>: Cancelable, ObservableType, ObserverType, DelayedObservableType {
+    typealias E = Element
+
+    let source: Observable<Element>
+    let queue: SerializedSubscriptionQueue
+    var observer: AnyObserver<Element>?
+
+    let serialDisposable = SerialDisposable()
+    var _isDisposed: Int32 = 0
+    var isDisposed: Bool {
+        return _isDisposed == 1
+    }
+
+    var disposed: Bool {
+        return _isDisposed == 1
+    }
+
+    init(source: Observable<Element>, queue: SerializedSubscriptionQueue) {
+        self.source = source
+        self.queue = queue
+    }
+
+    /// All event needs to be passed to original observer
+    /// if subscription was not disposed. If stream is completed
+    /// cleanup should occur.
+    func on(_ event: Event<Element>) {
+        guard !isDisposed else { return }
+        observer?.on(event)
+        if event.isStopEvent {
+            dispose()
+        }
+    }
+
+    /// Part of producer implementation. We need to make sure that we can optimize
+    /// scheduling of a work (taken from RxSwift source code)
+    func subscribe<O: ObserverType>(_ observer: O) -> Disposable where O.Element == Element {
+        if !CurrentThreadScheduler.isScheduleRequired {
+            return run(observer: observer)
+        }
+        return CurrentThreadScheduler.instance.schedule(()) { _ in
+            self.run(observer: observer)
+        }
+    }
+
+    /// After original subscription we need to place it on queue for delayed execution if required.
+    func run<O: ObserverType>(observer: O) -> Disposable where O.Element == Element {
+        self.observer = observer.asObserver()
+        queue.queueSubscription(observable: self)
+        return self
+    }
+
+    /// Delayed subscription must be called after original subscription so that observer
+    /// will be stored by that time.
+    func delayedSubscribe() {
+        serialDisposable.disposable = self.source.subscribe(self)
+    }
+
+    /// When this observable is disposed we need to remove it from queue to let other
+    /// observables to be able to subscribe.
+    func dispose() {
+        if OSAtomicCompareAndSwap32(0, 1, &_isDisposed) {
+            self.queue.unsubscribe(observable: self)
+            self.serialDisposable.dispose()
+        }
+    }
+}
+
+extension ObservableType {
+
+    // swiftlint:disable missing_docs
+    /// Store subscription in queue on which it will be executed sequentially. Subscribe method is called
+    /// only when there are no registered subscription on queue or last running observable completed its stream
+    /// or was disposed before that event.
+    /// - parameter queue: Queue on which scheduled subscriptions will be executed in sequentially.
+    /// - returns: The source which will be subscribe when queue is empty or previous
+    /// observable was completed or disposed.
+    func queueSubscribe(on queue: SerializedSubscriptionQueue) -> Observable<Element> {
+        return QueueSubscribeOn(source: asObservable(), queue: queue).asObservable()
+    }
+
+    // swiftlint:enable missing_docs
+}

package/ios/vendor/MultiplatformBleAdapter/RxBluetoothKit/Peripheral+Convenience.swift

@@ -0,0 +1,213 @@
+import Foundation
+import CoreBluetooth
+
+// swiftlint:disable line_length
+
+extension Peripheral {
+
+    /// Function used to receive service with given identifier. It's taken from cache if it's available,
+    /// or directly by `discoverServices` call
+    /// - Parameter identifier: Unique identifier of Service
+    /// - Returns: Observation which emits `Next` event, when specified service has been found.
+    /// Immediately after that `.Complete` is emitted.
+    public func service(with identifier: ServiceIdentifier) -> Observable<Service> {
+        return .deferred { [weak self] in
+            guard let strongSelf = self else { throw BluetoothError.destroyed }
+            if let services = strongSelf.services,
+                let service = services.first(where: { $0.uuid == identifier.uuid }) {
+                return .just(service)
+            } else {
+                return strongSelf.discoverServices([identifier.uuid])
+                    .flatMap { Observable.from($0) }
+            }
+        }
+    }
+
+    /// Function used to receive characteristic with given identifier. If it's available it's taken from cache.
+    /// Otherwise - directly by `discoverCharacteristics` call
+    /// - Parameter identifier: Unique identifier of Characteristic, that has information
+    /// about service which characteristic belongs to.
+    /// - Returns: Observation which emits `Next` event, when specified characteristic has been found.
+    /// Immediately after that `.Complete` is emitted.
+    public func characteristic(with identifier: CharacteristicIdentifier) -> Observable<Characteristic> {
+        return .deferred { [weak self] in
+            guard let strongSelf = self else { throw BluetoothError.destroyed }
+            return strongSelf.service(with: identifier.service)
+                .flatMap { service -> Observable<Characteristic> in
+                    if let characteristics = service.characteristics, let characteristic = characteristics.first(where: {
+                        $0.uuid == identifier.uuid
+                    }) {
+                        return .just(characteristic)
+                    }
+                    return service.discoverCharacteristics([identifier.uuid])
+                        .flatMap { Observable.from($0) }
+                }
+        }
+    }
+
+    /// Function used to receive descriptor with given identifier. If it's available it's taken from cache.
+    /// Otherwise - directly by `discoverDescriptor` call
+    /// - Parameter identifier: Unique identifier of Descriptor, that has information
+    /// about characteristic which descriptor belongs to.
+    /// - Returns: Observation which emits `Next` event, when specified descriptor has been found.
+    /// Immediately after that `.Complete` is emitted.
+    public func descriptor(with identifier: DescriptorIdentifier) -> Observable<Descriptor> {
+        return .deferred { [weak self] in
+            guard let strongSelf = self else { throw BluetoothError.destroyed }
+            return strongSelf.characteristic(with: identifier.characteristic)
+                .flatMap { characteristic -> Observable<Descriptor> in
+                    if let descriptors = characteristic.descriptors,
+                        let descriptor = descriptors.first(where: { $0.uuid == identifier.uuid }) {
+                        return .just(descriptor)
+                    }
+                    return characteristic.discoverDescriptors()
+                        .flatMap { Observable.from($0) }
+                        .filter { $0.uuid == identifier.uuid }
+                        .take(1)
+                }
+        }
+    }
+
+    /// Function that allow to monitor writes that happened for characteristic.
+    /// - Parameter identifier: Identifier of characteristic of which value writes should be monitored.
+    /// - 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(for identifier: CharacteristicIdentifier)
+        -> Observable<Characteristic> {
+        return characteristic(with: identifier)
+            .flatMap { [weak self] in
+                self?.monitorWrite(for: $0) ?? .error(BluetoothError.destroyed)
+            }
+    }
+
+    /// 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 data: Data that'll be written  written to `Characteristic` instance
+    /// - parameter forCharacteristicWithIdentifier: unique identifier of service, which also holds information about service characteristic belongs to.
+    /// `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, for identifier: CharacteristicIdentifier,
+                           type: CBCharacteristicWriteType) -> Observable<Characteristic> {
+        return characteristic(with: identifier)
+            .flatMap { [weak self] in
+                self?.writeValue(data, for: $0, type: type) ?? .error(BluetoothError.destroyed)
+            }
+    }
+
+    /// Function that allow to monitor value updates for `Characteristic` instance.
+    /// - Parameter identifier: unique identifier of service, which also holds information about service that characteristic belongs to.
+    /// - 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(for identifier: CharacteristicIdentifier) -> Observable<Characteristic> {
+        return characteristic(with: identifier)
+            .flatMap { [weak self] in
+                self?.monitorValueUpdate(for: $0) ?? .error(BluetoothError.destroyed)
+            }
+    }
+
+    /// Function that triggers read of current value of the `Characteristic` instance.
+    /// Read is called after subscription to `Observable` is made.
+    /// - Parameter identifier: unique identifier of service, which also holds information about service that characteristic belongs to.
+    /// - Returns: Observable which emits `Next` with given characteristic when value is ready to read. Immediately after that
+    /// `.Complete` is emitted.
+    public func readValue(for identifier: CharacteristicIdentifier) -> Observable<Characteristic> {
+        return characteristic(with: identifier)
+            .flatMap { [weak self] in
+                self?.readValue(for: $0) ?? .error(BluetoothError.destroyed)
+            }
+    }
+
+    /// 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
+    /// - parameter identifier: unique identifier of service, which also holds information about service that characteristic belongs to.
+    /// - returns: Observable which emits `Next` with Characteristic that state was changed. Immediately after `.Complete` is emitted
+    public func setNotifyValue(_ enabled: Bool, for identifier: CharacteristicIdentifier)
+        -> Observable<Characteristic> {
+        return characteristic(with: identifier)
+            .flatMap { [weak self] in
+                self?.setNotifyValue(enabled, for: $0) ?? .error(BluetoothError.destroyed)
+            }
+    }
+
+    /// 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.
+    /// - parameter identifier: unique identifier of service, which also holds information about service that characteristic belongs to.
+    /// - returns: Observable which emits `Next`, when characteristic value is updated.
+    /// This is **infinite** stream of values.
+    public func setNotificationAndMonitorUpdates(for identifier: CharacteristicIdentifier)
+        -> Observable<Characteristic> {
+        return characteristic(with: identifier)
+            .flatMap { [weak self] in
+                self?.setNotificationAndMonitorUpdates(for: $0) ?? .error(BluetoothError.destroyed)
+            }
+    }
+
+    /// Function that triggers descriptors discovery for characteristic
+    /// - Parameter characteristic: `Characteristic` instance for which descriptors should be discovered.
+    /// - parameter identifier: unique identifier of descriptor, which also holds information about characteristic that descriptor belongs to.
+    /// - Returns: Observable that emits `Next` with array of `Descriptor` instances, once they're discovered.
+    /// Immediately after that `.Complete` is emitted.
+    public func discoverDescriptors(for identifier: CharacteristicIdentifier) ->
+        Observable<[Descriptor]> {
+        return characteristic(with: identifier)
+            .flatMap { [weak self] in
+                self?.discoverDescriptors(for: $0) ?? .error(BluetoothError.destroyed)
+            }
+    }
+
+    /// Function that allow to monitor writes that happened for descriptor.
+    /// - parameter identifier: unique identifier of descriptor, which also holds information about characteristic that descriptor belongs to.
+    /// - 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(for identifier: DescriptorIdentifier) -> Observable<Descriptor> {
+        return descriptor(with: identifier)
+            .flatMap { [weak self] in
+                self?.monitorWrite(for: $0) ?? .error(BluetoothError.destroyed)
+            }
+    }
+
+    /// Function that triggers write of data to descriptor. Write is called after subscribtion to `Observable` is made.
+    /// - Parameter data: `Data` that'll be written to `Descriptor` instance
+    /// - parameter identifier: unique identifier of descriptor, which also holds information about characteristic that descriptor belongs to.
+    /// - Returns: Observable that emits `Next` with `Descriptor` instance, once value is written successfully.
+    /// Immediately after that `.Complete` is emitted.
+    public func writeValue(_ data: Data, for identifier: DescriptorIdentifier)
+        -> Observable<Descriptor> {
+        return descriptor(with: identifier)
+            .flatMap { [weak self] in
+                self?.writeValue(data, for: $0) ?? .error(BluetoothError.destroyed)
+            }
+    }
+
+    /// Function that allow to monitor value updates for `Descriptor` instance.
+    /// - parameter identifier: unique identifier of descriptor, which also holds information about characteristic that descriptor belongs to.
+    /// - 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(for identifier: DescriptorIdentifier) -> Observable<Descriptor> {
+        return descriptor(with: identifier)
+            .flatMap { [weak self] in
+                self?.monitorValueUpdate(for: $0) ?? .error(BluetoothError.destroyed)
+            }
+    }
+
+    /// Function that triggers read of current value of the `Descriptor` instance.
+    /// Read is called after subscription to `Observable` is made.
+    /// - Parameter descriptor: `Descriptor` to read value from
+    /// - Returns: Observable which emits `Next` with given descriptor when value is ready to read. Immediately after that `.Complete` is emitted.
+    public func readValue(for identifier: DescriptorIdentifier) -> Observable<Descriptor> {
+        return descriptor(with: identifier)
+            .flatMap { [weak self] in
+                self?.readValue(for: $0) ?? .error(BluetoothError.destroyed)
+            }
+    }
+}