react-native-ble-nitro 1.0.0-beta.15 → 1.0.0-beta.17

package/ios/BleNitroBleManager.swift

@@ -1,6 +1,6 @@
 ///
 /// BleNitroBleManager.swift
-/// React Native BLE Nitro - iOS Implementation
+/// React Native BLE Nitro - iOS Implementation (Minimal Stub)
 /// Copyright © 2025 Zyke (https://zyke.co)
 ///
 
@@ -9,571 +9,145 @@ import CoreBluetooth
 import NitroModules
 
 /**
- * Core BLE Manager implementation using CoreBluetooth
- * Implements the HybridBleManagerSpec protocol generated by Nitro
+ * Minimal BLE Manager implementation stub for iOS
+ * TODO: Implement full CoreBluetooth integration
  */
-public class BleNitroBleManager: NSObject, HybridBleManagerSpec, CBCentralManagerDelegate {
-    
-    // MARK: - Properties
-    private var centralManager: CBCentralManager!
-    private var logLevel: BleLogLevel = .none
-    private var isScanning = false
-    private var scanListener: ((_ error: NativeBleError?, _ scannedDevice: NativeDevice?) -> Void)?
-    private var stateChangeListener: ((_ newState: State) -> Void)?
-    private var connectedDevices: [String: CBPeripheral] = [:]
-    private var discoveredDevices: [String: CBPeripheral] = [:]
-    private var deviceDisconnectListeners: [String: ((_ error: NativeBleError?, _ device: NativeDevice?) -> Void)] = [:]
-    private var characteristicMonitors: [String: ((_ error: NativeBleError?, _ characteristic: NativeCharacteristic?) -> Void)] = [:]
-    private var pendingOperations: [String: Any] = [:]
-    
-    // State restoration
-    private var restoreIdentifier: String?
-    private var isInitialized = false
-    private var restoredState: BleRestoredState?
-    
-    // MARK: - Initialization
-    public override init() {
-        super.init()
-        // Initialize with default options - will be reconfigured in initialize() method
-        self.centralManager = CBCentralManager(delegate: self, queue: nil)
-    }
-    
-    private func reinitializeCentralManager() {
-        // Create CBCentralManager with state restoration if identifier is provided
-        var options: [String: Any] = [:]
-        if let restoreId = restoreIdentifier {
-            options[CBCentralManagerOptionRestoreIdentifierKey] = restoreId
-        }
-        
-        self.centralManager = CBCentralManager(delegate: self, queue: nil, options: options.isEmpty ? nil : options)
-    }
+public class BleNitroBleManager: HybridBleManagerSpec {
     
     public var memorySize: Int {
         return MemorySize.MemorySize_estimate(self)
     }
     
-    // MARK: - HybridBleManagerSpec Implementation
+    // MARK: - HybridBleManagerSpec Implementation (Stubs)
     
     public func destroy() throws -> Promise<Void> {
-        return Promise.async { resolve, reject in
-            self.stopDeviceScan()
-            self.centralManager.delegate = nil
-            self.connectedDevices.removeAll()
-            self.discoveredDevices.removeAll()
-            self.deviceDisconnectListeners.removeAll()
-            self.characteristicMonitors.removeAll()
-            self.pendingOperations.removeAll()
-            resolve(())
-        }
+        return Promise.resolve(withResult: ())
     }
     
     public func initialize(options: BleManagerNitroOptions) throws -> Promise<Void> {
-        return Promise.resolve(withBlock: {
-            if let restoreId = options.restoreStateIdentifier {
-                // Store the restore identifier
-                self.restoreIdentifier = restoreId
-                
-                // Reinitialize the central manager with state restoration
-                self.reinitializeCentralManager()
-                
-                print("BleNitro: Initialized with restore state identifier: \(restoreId)")
-            }
-            
-            self.isInitialized = true
-            print("BleNitro: BLE Manager initialized")
-        })
+        print("BleNitro: iOS implementation not yet complete")
+        return Promise.resolve(withResult: ())
     }
     
     public func getRestoredState() throws -> Promise<BleRestoredState?> {
-        return Promise.resolve(withBlock: {
-            return self.restoredState
-        })
+        return Promise.resolve(withResult: nil)
     }
     
     public func setLogLevel(logLevel: BleLogLevel) throws -> Promise<BleLogLevel> {
-        return Promise.resolve(withBlock: {
-            self.logLevel = logLevel
-            return logLevel
-        })
+        return Promise.resolve(withResult: logLevel)
     }
     
     public func logLevel() throws -> Promise<BleLogLevel> {
-        return Promise.resolve(self.logLevel)
+        return Promise.resolve(withResult: .none)
     }
     
     public func cancelTransaction(transactionId: String) throws -> Promise<Void> {
-        return Promise.async { resolve, reject in
-            self.pendingOperations.removeValue(forKey: transactionId)
-            resolve(())
-        }
+        return Promise.resolve(withResult: ())
     }
     
     public func enable(transactionId: String?) throws -> Promise<Void> {
-        return Promise.async { resolve, reject in
-            // CoreBluetooth manages Bluetooth state automatically
-            // We can't programmatically enable Bluetooth on iOS
-            if self.centralManager.state == .poweredOn {
-                resolve(())
-            } else {
-                let error = self.createBleError(.BluetoothPoweredOff, message: "Bluetooth is not powered on")
-                reject(error)
-            }
-        }
+        return Promise.reject(error: BleError.notImplemented("enable not implemented on iOS yet"))
     }
     
     public func disable(transactionId: String?) throws -> Promise<Void> {
-        return Promise.async { resolve, reject in
-            // CoreBluetooth doesn't allow programmatic disabling on iOS
-            let error = self.createBleError(.BluetoothUnsupported, message: "Cannot programmatically disable Bluetooth on iOS")
-            reject(error)
-        }
+        return Promise.reject(error: BleError.notImplemented("disable not implemented on iOS yet"))
     }
     
     public func state() throws -> Promise<State> {
-        return Promise.resolve(self.mapCBManagerState(self.centralManager.state))
-    }
-    
-    public func onStateChange(listener: @escaping (_ newState: State) -> Void, emitCurrentState: Bool?) throws -> Subscription {
-        self.stateChangeListener = listener
-        
-        if emitCurrentState == true {
-            listener(self.mapCBManagerState(self.centralManager.state))
-        }
-        
-        return Subscription(remove: {
-            self.stateChangeListener = nil
-        })
-    }
-    
-    public func startDeviceScan(uuids: [String]?, options: ScanOptions?, listener: @escaping (_ error: NativeBleError?, _ scannedDevice: NativeDevice?) -> Void) throws -> Promise<Void> {
-        return Promise.async { resolve, reject in
-            guard self.centralManager.state == .poweredOn else {
-                let error = self.createBleError(.BluetoothPoweredOff, message: "Bluetooth is not powered on")
-                reject(error)
-                return
-            }
-            
-            self.scanListener = listener
-            self.isScanning = true
-            
-            var serviceUUIDs: [CBUUID]? = nil
-            if let uuids = uuids {
-                serviceUUIDs = uuids.compactMap { CBUUID(string: $0) }
-            }
-            
-            var scanOptions: [String: Any] = [:]
-            if let options = options {
-                if options.allowDuplicates == true {
-                    scanOptions[CBCentralManagerScanOptionAllowDuplicatesKey] = true
-                }
-            }
-            
-            self.centralManager.scanForPeripherals(withServices: serviceUUIDs, options: scanOptions)
-            resolve(())
-        }
+        return Promise.resolve(withResult: .unknown)
+    }
+    
+    public func onStateChange(listener: @escaping (State) -> Void, emitCurrentState: Bool?) throws -> Subscription {
+        return Subscription(remove: {})
+    }
+    
+    public func startDeviceScan(uuids: [String]?, options: ScanOptions?, listener: @escaping (NativeBleError?, NativeDevice?) -> Void) throws -> Promise<Void> {
+        return Promise.reject(error: BleError.notImplemented("startDeviceScan not implemented on iOS yet"))
     }
     
     public func stopDeviceScan() throws -> Promise<Void> {
-        return Promise.resolve(withBlock: {
-            if self.isScanning {
-                self.centralManager.stopScan()
-                self.isScanning = false
-                self.scanListener = nil
-            }
-        })
+        return Promise.resolve(withResult: ())
     }
     
     public func requestConnectionPriorityForDevice(deviceIdentifier: String, connectionPriority: ConnectionPriority, transactionId: String?) throws -> Promise<NativeDevice> {
-        return Promise.async { resolve, reject in
-            // iOS doesn't have direct connection priority control like Android
-            // Return the device as-is since this is mostly an Android feature
-            if let peripheral = self.connectedDevices[deviceIdentifier] {
-                let device = self.createNativeDevice(from: peripheral)
-                resolve(device)
-            } else {
-                let error = self.createBleError(.DeviceNotFound, message: "Device not found: \(deviceIdentifier)")
-                reject(error)
-            }
-        }
+        return Promise.reject(error: BleError.notImplemented("requestConnectionPriorityForDevice not implemented on iOS yet"))
     }
     
     public func readRSSIForDevice(deviceIdentifier: String, transactionId: String?) throws -> Promise<NativeDevice> {
-        return Promise.async { resolve, reject in
-            guard let peripheral = self.connectedDevices[deviceIdentifier] else {
-                let error = self.createBleError(.DeviceNotFound, message: "Device not found: \(deviceIdentifier)")
-                reject(error)
-                return
-            }
-            
-            if let transactionId = transactionId {
-                self.pendingOperations[transactionId] = resolve
-            }
-            
-            peripheral.readRSSI()
-        }
+        return Promise.reject(error: BleError.notImplemented("readRSSIForDevice not implemented on iOS yet"))
     }
     
     public func requestMTUForDevice(deviceIdentifier: String, mtu: Double, transactionId: String?) throws -> Promise<NativeDevice> {
-        return Promise.async { resolve, reject in
-            // iOS automatically negotiates MTU, we can't explicitly set it
-            if let peripheral = self.connectedDevices[deviceIdentifier] {
-                let device = self.createNativeDevice(from: peripheral)
-                resolve(device)
-            } else {
-                let error = self.createBleError(.DeviceNotFound, message: "Device not found: \(deviceIdentifier)")
-                reject(error)
-            }
-        }
+        return Promise.reject(error: BleError.notImplemented("requestMTUForDevice not implemented on iOS yet"))
     }
     
     public func devices(deviceIdentifiers: [String]) throws -> Promise<[NativeDevice]> {
-        return Promise.resolve(withBlock: {
-            return deviceIdentifiers.compactMap { identifier in
-                if let peripheral = self.discoveredDevices[identifier] ?? self.connectedDevices[identifier] {
-                    return self.createNativeDevice(from: peripheral)
-                }
-                return nil
-            }
-        })
+        return Promise.resolve(withResult: [])
     }
     
     public func connectedDevices(serviceUUIDs: [String]) throws -> Promise<[NativeDevice]> {
-        return Promise.resolve(withBlock: {
-            let serviceUUIDs = serviceUUIDs.compactMap { CBUUID(string: $0) }
-            let peripherals = self.centralManager.retrieveConnectedPeripherals(withServices: serviceUUIDs)
-            return peripherals.map { self.createNativeDevice(from: $0) }
-        })
+        return Promise.resolve(withResult: [])
     }
     
     public func connectToDevice(deviceIdentifier: String, options: ConnectionOptions?) throws -> Promise<NativeDevice> {
-        return Promise.async { resolve, reject in
-            guard let peripheral = self.discoveredDevices[deviceIdentifier] else {
-                let error = self.createBleError(.DeviceNotFound, message: "Device not found: \(deviceIdentifier)")
-                reject(error)
-                return
-            }
-            
-            var connectOptions: [String: Any] = [:]
-            if let options = options {
-                connectOptions[CBConnectPeripheralOptionNotifyOnConnectionKey] = true
-                connectOptions[CBConnectPeripheralOptionNotifyOnDisconnectionKey] = true
-                connectOptions[CBConnectPeripheralOptionNotifyOnNotificationKey] = true
-            }
-            
-            self.pendingOperations[deviceIdentifier] = resolve
-            self.centralManager.connect(peripheral, options: connectOptions)
-        }
+        return Promise.reject(error: BleError.notImplemented("connectToDevice not implemented on iOS yet"))
     }
     
     public func cancelDeviceConnection(deviceIdentifier: String) throws -> Promise<NativeDevice> {
-        return Promise.async { resolve, reject in
-            guard let peripheral = self.connectedDevices[deviceIdentifier] else {
-                let error = self.createBleError(.DeviceNotFound, message: "Device not found: \(deviceIdentifier)")
-                reject(error)
-                return
-            }
-            
-            self.pendingOperations[deviceIdentifier] = resolve
-            self.centralManager.cancelPeripheralConnection(peripheral)
-        }
-    }
-    
-    public func onDeviceDisconnected(deviceIdentifier: String, listener: @escaping (_ error: NativeBleError?, _ device: NativeDevice?) -> Void) throws -> Subscription {
-        self.deviceDisconnectListeners[deviceIdentifier] = listener
-        
-        return Subscription(remove: {
-            self.deviceDisconnectListeners.removeValue(forKey: deviceIdentifier)
-        })
+        return Promise.reject(error: BleError.notImplemented("cancelDeviceConnection not implemented on iOS yet"))
     }
     
-    public func isDeviceConnected(deviceIdentifier: String) throws -> Promise<Bool> {
-        return Promise.resolve(withBlock: {
-            return self.connectedDevices[deviceIdentifier] != nil
-        })
+    public func onDeviceDisconnected(deviceIdentifier: String, listener: @escaping (NativeBleError?, NativeDevice?) -> Void) throws -> Subscription {
+        return Subscription(remove: {})
     }
     
-    // Additional methods for service/characteristic operations would follow...
-    // For brevity, showing the core pattern. The full implementation would include
-    // all the remaining methods from the HybridBleManagerSpec protocol.
+    public func isDeviceConnected(deviceIdentifier: String) throws -> Promise<Bool> {
+        return Promise.resolve(withResult: false)
+    }
     
     public func discoverAllServicesAndCharacteristicsForDevice(deviceIdentifier: String, transactionId: String?) throws -> Promise<NativeDevice> {
-        return Promise.async { resolve, reject in
-            guard let peripheral = self.connectedDevices[deviceIdentifier] else {
-                let error = self.createBleError(.DeviceNotFound, message: "Device not found: \(deviceIdentifier)")
-                reject(error)
-                return
-            }
-            
-            if let transactionId = transactionId {
-                self.pendingOperations[transactionId] = resolve
-            }
-            
-            peripheral.discoverServices(nil)
-        }
+        return Promise.reject(error: BleError.notImplemented("discoverAllServicesAndCharacteristicsForDevice not implemented on iOS yet"))
     }
     
     public func servicesForDevice(deviceIdentifier: String) throws -> Promise<[NativeService]> {
-        return Promise.resolve(withBlock: {
-            guard let peripheral = self.connectedDevices[deviceIdentifier],
-                  let services = peripheral.services else {
-                return []
-            }
-            
-            return services.enumerated().map { index, service in
-                return NativeService(
-                    id: Double(index),
-                    uuid: service.uuid.uuidString,
-                    deviceID: deviceIdentifier,
-                    isPrimary: service.isPrimary
-                )
-            }
-        })
-    }
-    
-    // MARK: - CBCentralManagerDelegate
-    
-    public func centralManagerDidUpdateState(_ central: CBCentralManager) {
-        let state = mapCBManagerState(central.state)
-        stateChangeListener?(state)
-        print("BleNitro: Central manager state changed to: \(central.state.rawValue)")
-    }
-    
-    public func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String: Any], rssi RSSI: NSNumber) {
-        let deviceId = peripheral.identifier.uuidString
-        discoveredDevices[deviceId] = peripheral
-        
-        let device = createNativeDevice(from: peripheral, advertisementData: advertisementData, rssi: RSSI)
-        scanListener?(nil, device)
-    }
-    
-    public func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
-        let deviceId = peripheral.identifier.uuidString
-        connectedDevices[deviceId] = peripheral
-        peripheral.delegate = self
-        
-        if let resolve = pendingOperations[deviceId] as? (NativeDevice) -> Void {
-            let device = createNativeDevice(from: peripheral)
-            resolve(device)
-            pendingOperations.removeValue(forKey: deviceId)
-        }
-    }
-    
-    public func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {
-        let deviceId = peripheral.identifier.uuidString
-        connectedDevices.removeValue(forKey: deviceId)
-        
-        let device = createNativeDevice(from: peripheral)
-        let bleError = error != nil ? createBleError(.DeviceDisconnected, message: error!.localizedDescription) : nil
-        
-        deviceDisconnectListeners[deviceId]?(bleError, device)
-        deviceDisconnectListeners.removeValue(forKey: deviceId)
-        
-        if let resolve = pendingOperations[deviceId] as? (NativeDevice) -> Void {
-            resolve(device)
-            pendingOperations.removeValue(forKey: deviceId)
-        }
-    }
-    
-    public func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) {
-        let deviceId = peripheral.identifier.uuidString
-        
-        if let reject = pendingOperations[deviceId] as? (Error) -> Void {
-            let bleError = createBleError(.DeviceConnectionFailed, message: error?.localizedDescription ?? "Connection failed")
-            reject(bleError)
-            pendingOperations.removeValue(forKey: deviceId)
-        }
-    }
-    
-    // MARK: - Helper Methods
-    
-    private func mapCBManagerState(_ state: CBManagerState) -> State {
-        switch state {
-        case .unknown:
-            return .Unknown
-        case .resetting:
-            return .Resetting
-        case .unsupported:
-            return .Unsupported
-        case .unauthorized:
-            return .Unauthorized
-        case .poweredOff:
-            return .PoweredOff
-        case .poweredOn:
-            return .PoweredOn
-        @unknown default:
-            return .Unknown
-        }
-    }
-    
-    private func createNativeDevice(from peripheral: CBPeripheral, advertisementData: [String: Any]? = nil, rssi: NSNumber? = nil) -> NativeDevice {
-        var serviceData: [ServiceDataEntry] = []
-        var serviceUUIDs: [String] = []
-        var manufacturerData: String? = nil
-        var localName: String? = nil
-        var txPowerLevel: Double? = nil
-        var isConnectable: Bool? = nil
-        var solicitedServiceUUIDs: [String] = []
-        var overflowServiceUUIDs: [String] = []
-        
-        if let adData = advertisementData {
-            // Parse advertisement data
-            if let services = adData[CBAdvertisementDataServiceUUIDsKey] as? [CBUUID] {
-                serviceUUIDs = services.map { $0.uuidString }
-            }
-            
-            if let data = adData[CBAdvertisementDataManufacturerDataKey] as? Data {
-                manufacturerData = data.base64EncodedString()
-            }
-            
-            localName = adData[CBAdvertisementDataLocalNameKey] as? String
-            txPowerLevel = adData[CBAdvertisementDataTxPowerLevelKey] as? Double
-            isConnectable = adData[CBAdvertisementDataIsConnectable] as? Bool
-            
-            if let services = adData[CBAdvertisementDataSolicitedServiceUUIDsKey] as? [CBUUID] {
-                solicitedServiceUUIDs = services.map { $0.uuidString }
-            }
-            
-            if let services = adData[CBAdvertisementDataOverflowServiceUUIDsKey] as? [CBUUID] {
-                overflowServiceUUIDs = services.map { $0.uuidString }
-            }
-            
-            if let serviceDataDict = adData[CBAdvertisementDataServiceDataKey] as? [CBUUID: Data] {
-                serviceData = serviceDataDict.map { uuid, data in
-                    ServiceDataEntry(uuid: uuid.uuidString, data: data.base64EncodedString())
-                }
-            }
-        }
-        
-        return NativeDevice(
-            id: peripheral.identifier.uuidString,
-            deviceName: peripheral.name ?? localName,
-            rssi: rssi?.doubleValue,
-            mtu: 23.0, // Default MTU on iOS
-            manufacturerData: manufacturerData,
-            serviceData: serviceData,
-            serviceUUIDs: serviceUUIDs.isEmpty ? nil : serviceUUIDs,
-            localName: localName,
-            txPowerLevel: txPowerLevel,
-            solicitedServiceUUIDs: solicitedServiceUUIDs.isEmpty ? nil : solicitedServiceUUIDs,
-            isConnectable: isConnectable,
-            overflowServiceUUIDs: overflowServiceUUIDs.isEmpty ? nil : overflowServiceUUIDs,
-            rawScanRecord: ""  // iOS doesn't provide raw scan record
-        )
-    }
-    
-    private func createBleError(_ errorCode: BleErrorCode, message: String) -> NativeBleError {
-        return NativeBleError(
-            errorCode: errorCode,
-            attErrorCode: nil,
-            iosErrorCode: nil,
-            androidErrorCode: nil,
-            reason: message,
-            deviceID: nil,
-            serviceUUID: nil,
-            characteristicUUID: nil,
-            descriptorUUID: nil,
-            internalMessage: message
-        )
+        return Promise.resolve(withResult: [])
     }
-}
-
-// MARK: - CBPeripheralDelegate Extension
-
-extension BleNitroBleManager: CBPeripheralDelegate {
-    
-    public func peripheral(_ peripheral: CBPeripheral, didReadRSSI RSSI: NSNumber, error: Error?) {
-        let deviceId = peripheral.identifier.uuidString
-        
-        for (transactionId, operation) in pendingOperations {
-            if let resolve = operation as? (NativeDevice) -> Void {
-                let device = createNativeDevice(from: peripheral, rssi: RSSI)
-                resolve(device)
-                pendingOperations.removeValue(forKey: transactionId)
-                break
-            }
-        }
-    }
-    
-    public func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
-        if let error = error {
-            // Handle service discovery error
-            return
-        }
-        
-        // Discover characteristics for all services
-        peripheral.services?.forEach { service in
-            peripheral.discoverCharacteristics(nil, for: service)
-        }
-    }
-    
-    public func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
-        if let error = error {
-            // Handle characteristic discovery error
-            return
-        }
-        
-        // Discover descriptors for all characteristics
-        service.characteristics?.forEach { characteristic in
-            peripheral.discoverDescriptors(for: characteristic)
-        }
-    }
-    
-    public func peripheral(_ peripheral: CBPeripheral, didDiscoverDescriptorsFor characteristic: CBCharacteristic, error: Error?) {
-        // Complete service discovery
-        let deviceId = peripheral.identifier.uuidString
-        
-        for (transactionId, operation) in pendingOperations {
-            if let resolve = operation as? (NativeDevice) -> Void {
-                let device = createNativeDevice(from: peripheral)
-                resolve(device)
-                pendingOperations.removeValue(forKey: transactionId)
-                break
-            }
-        }
-    }
-    
-    // MARK: - CBCentralManagerDelegate State Restoration
-    
-    public func centralManager(_ central: CBCentralManager, willRestoreState dict: [String : Any]) {
-        // Handle state restoration
-        if let peripherals = dict[CBCentralManagerRestoredStatePeripheralsKey] as? [CBPeripheral] {
-            print("BleNitro: Restoring \(peripherals.count) peripherals")
-            
-            // Add restored peripherals to our connected devices
-            for peripheral in peripherals {
-                let deviceId = peripheral.identifier.uuidString
-                connectedDevices[deviceId] = peripheral
-                peripheral.delegate = self
-                
-                print("BleNitro: Restored peripheral: \(deviceId)")
-            }
-            
-            // Store restored state for later retrieval
-            if !peripherals.isEmpty {
-                let restoredDevices = peripherals.map(createNativeDevice)
-                self.restoredState = BleRestoredState(connectedPeripherals: restoredDevices)
-                print("BleNitro: Stored restored state with \(restoredDevices.count) devices")
-            }
-        }
+    
+    public func characteristicsForDevice(deviceIdentifier: String, serviceUUID: String) throws -> Promise<[NativeCharacteristic]> {
+        return Promise.resolve(withResult: [])
     }
     
-}
-
-/**
- * Simple subscription implementation for cleanup
- */
-private class SubscriptionImpl {
-    private let cleanup: () -> Void
+    public func readCharacteristicForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, transactionId: String?) throws -> Promise<NativeCharacteristic> {
+        return Promise.reject(error: BleError.notImplemented("readCharacteristicForDevice not implemented on iOS yet"))
+    }
     
-    init(_ cleanup: @escaping () -> Void) {
-        self.cleanup = cleanup
+    public func writeCharacteristicWithResponseForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, base64Value: String, transactionId: String?) throws -> Promise<NativeCharacteristic> {
+        return Promise.reject(error: BleError.notImplemented("writeCharacteristicWithResponseForDevice not implemented on iOS yet"))
     }
     
-    public func remove() {
-        cleanup()
+    public func writeCharacteristicWithoutResponseForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, base64Value: String, transactionId: String?) throws -> Promise<NativeCharacteristic> {
+        return Promise.reject(error: BleError.notImplemented("writeCharacteristicWithoutResponseForDevice not implemented on iOS yet"))
     }
     
-    public func toSubscription() -> Subscription {
-        return Subscription(remove: self.cleanup)
+    public func monitorCharacteristicForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, listener: @escaping (NativeBleError?, NativeCharacteristic?) -> Void, transactionId: String?, subscriptionType: CharacteristicSubscriptionType?) throws -> Subscription {
+        return Subscription(remove: {})
     }
+    
+    public func descriptorsForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String) throws -> Promise<[NativeDescriptor]> {
+        return Promise.resolve(withResult: [])
+    }
+    
+    public func readDescriptorForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, descriptorUUID: String, transactionId: String?) throws -> Promise<NativeDescriptor> {
+        return Promise.reject(error: BleError.notImplemented("readDescriptorForDevice not implemented on iOS yet"))
+    }
+    
+    public func writeDescriptorForDevice(deviceIdentifier: String, serviceUUID: String, characteristicUUID: String, descriptorUUID: String, valueBase64: String, transactionId: String?) throws -> Promise<NativeDescriptor> {
+        return Promise.reject(error: BleError.notImplemented("writeDescriptorForDevice not implemented on iOS yet"))
+    }
+}
+
+// MARK: - Error Helper
+
+enum BleError: Error {
+    case notImplemented(String)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-ble-nitro",
-  "version": "1.0.0-beta.15",
+  "version": "1.0.0-beta.17",
   "description": "High-performance React Native BLE library built on Nitro Modules - drop-in replacement for react-native-ble-plx",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",