react-native-ble-nitro 1.0.0-beta.9 → 1.1.0

package/ios/BleNitroBleManager.swift

@@ -1,575 +1,577 @@
-///
-/// BleNitroBleManager.swift
-/// React Native BLE Nitro - iOS Implementation
-/// Copyright © 2025 Zyke (https://zyke.co)
-///
-
 import Foundation
 import CoreBluetooth
 import NitroModules
-
 /**
- * Core BLE Manager implementation using CoreBluetooth
- * Implements the HybridBleManagerSpec protocol generated by Nitro
+ * iOS implementation of the BLE Nitro Manager
+ * Implements the HybridNativeBleNitroSpec protocol for Core Bluetooth operations
  */
-public class BleNitroBleManager: HybridBleManagerSpec, CBCentralManagerDelegate {
+public class BleNitroBleManager: HybridNativeBleNitroSpec {
     
-    // MARK: - Properties
+    // MARK: - Private Properties
     private var centralManager: CBCentralManager!
-    private var logLevel: LogLevel = .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?
-    
+    private var connectedPeripherals: [String: CBPeripheral] = [:]
+    private var discoveredPeripherals: [String: CBPeripheral] = [:]
+    private var peripheralDelegates: [String: BlePeripheralDelegate] = [:]
+    private var intentionalDisconnections: Set<String> = []
+    private var scanCallback: ((BLEDevice) -> Void)?
+    private var stateChangeCallback: ((BLEState) -> Void)?
+    private var isCurrentlyScanning = false
+    private var currentScanFilter: ScanFilter?
+    private var centralManagerDelegate: BleCentralManagerDelegate!
+
     // MARK: - Initialization
     public override init() {
         super.init()
-        // Initialize with default options - will be reconfigured in initialize() method
-        self.centralManager = CBCentralManager(delegate: self, queue: nil)
+        setupCentralManager()
     }
     
-    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)
+    private func setupCentralManager() {
+        centralManagerDelegate = BleCentralManagerDelegate(manager: self)
+        centralManager = CBCentralManager(delegate: centralManagerDelegate, queue: DispatchQueue.main)
     }
     
-    public override var memorySize: Int {
-        return MemorySize.MemorySize_estimate(self)
+    // MARK: - State Management
+    public func state() throws -> BLEState {
+        let bleState = mapCBManagerStateToBLEState(centralManager.state)
+        return bleState
     }
     
-    // MARK: - HybridBleManagerSpec Implementation
-    
-    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(())
-        }
+    public func requestBluetoothEnable(callback: @escaping (Bool, String) -> Void) throws {
+        // iOS doesn't allow programmatic Bluetooth enabling
+        // We can only check the current state
+        callback(false, "Not supported")
     }
     
-    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")
-        })
+    public func subscribeToStateChange(
+        stateCallback: @escaping (BLEState) -> Void
+    ) throws -> OperationResult {
+        self.stateChangeCallback = stateCallback
+        return OperationResult(success: true, error: nil)
     }
-    
-    public func getRestoredState() throws -> Promise<BleRestoredState?> {
-        return Promise.resolve(withBlock: {
-            return self.restoredState
-        })
-    }
-    
-    public func setLogLevel(logLevel: LogLevel) throws -> Promise<LogLevel> {
-        return Promise.resolve(withBlock: {
-            self.logLevel = logLevel
-            return logLevel
-        })
-    }
-    
-    public func logLevel() throws -> Promise<LogLevel> {
-        return Promise.resolve(self.logLevel)
+
+    public func unsubscribeFromStateChange() throws -> OperationResult {
+        self.stateChangeCallback = nil
+        return OperationResult(success: true, error: nil)
     }
     
-    public func cancelTransaction(transactionId: String) throws -> Promise<Void> {
-        return Promise.async { resolve, reject in
-            self.pendingOperations.removeValue(forKey: transactionId)
-            resolve(())
+    // MARK: - Scanning Operations
+    public func startScan(filter: ScanFilter, callback: @escaping (BLEDevice) -> Void) throws {
+        guard centralManager.state == .poweredOn else {
+            throw NSError(domain: "BleNitroError", code: 1, userInfo: [
+                NSLocalizedDescriptionKey: "Bluetooth is not powered on"
+            ])
         }
-    }
-    
-    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)
-            }
+        
+        self.scanCallback = callback
+        self.currentScanFilter = filter
+        self.isCurrentlyScanning = true
+        
+        // Convert service UUIDs to CBUUIDs
+        let serviceUUIDs = filter.serviceUUIDs.isEmpty ? nil : filter.serviceUUIDs.compactMap { CBUUID(string: $0) }
+        
+        // Configure scan options
+        var options: [String: Any] = [:]
+        if filter.allowDuplicates {
+            options[CBCentralManagerScanOptionAllowDuplicatesKey] = true
         }
+        
+        centralManager.scanForPeripherals(withServices: serviceUUIDs, options: options)
     }
     
-    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)
-        }
+    public func stopScan() throws -> Bool {
+        centralManager.stopScan()
+        isCurrentlyScanning = false
+        scanCallback = nil
+        currentScanFilter = nil
+        // Keep discovered peripherals for potential connections
+        return true
     }
     
-    public func state() throws -> Promise<State> {
-        return Promise.resolve(self.mapCBManagerState(self.centralManager.state))
+    public func isScanning() throws -> Bool {
+        return isCurrentlyScanning
     }
     
-    public func onStateChange(listener: @escaping (_ newState: State) -> Void, emitCurrentState: Bool?) throws -> Subscription {
-        self.stateChangeListener = listener
+    // MARK: - Device Discovery
+    public func getConnectedDevices(services: [String]) throws -> [BLEDevice] {
+        var connectedDevices: [BLEDevice] = []
         
-        if emitCurrentState == true {
-            listener(self.mapCBManagerState(self.centralManager.state))
+        // First check our tracked connected peripherals
+        for (deviceId, peripheral) in connectedPeripherals {
+            let device = BLEDevice(
+                id: deviceId,
+                name: peripheral.name ?? "Unknown Device",
+                rssi: 0, // RSSI not available for connected devices without explicit read
+                manufacturerData: ManufacturerData(companyIdentifiers: []), // Not available for connected devices
+                serviceUUIDs: peripheral.services?.map { $0.uuid.uuidString } ?? [],
+                isConnectable: true // Already connected, so it was connectable
+            )
+            connectedDevices.append(device)
         }
         
-        return SubscriptionImpl {
-            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
+        // Check previously discovered peripherals to see if any are still connected
+        for (deviceId, peripheral) in discoveredPeripherals {
+            // Skip if we already know it's connected
+            if connectedPeripherals.keys.contains(deviceId) {
+                continue
             }
             
-            self.scanListener = listener
-            self.isScanning = true
-            
-            var serviceUUIDs: [CBUUID]? = nil
-            if let uuids = uuids {
-                serviceUUIDs = uuids.compactMap { CBUUID(string: $0) }
+            // Check if this peripheral is actually connected by checking its state
+            if peripheral.state == .connected {
+                let device = BLEDevice(
+                    id: deviceId,
+                    name: peripheral.name ?? "Unknown Device",
+                    rssi: 0,
+                    manufacturerData: ManufacturerData(companyIdentifiers: []),
+                    serviceUUIDs: peripheral.services?.map { $0.uuid.uuidString } ?? [],
+                    isConnectable: true
+                )
+                connectedDevices.append(device)
+                
+                // Add to our tracking dictionary
+                connectedPeripherals[deviceId] = peripheral
             }
-            
-            var scanOptions: [String: Any] = [:]
-            if let options = options {
-                if options.allowDuplicates == true {
-                    scanOptions[CBCentralManagerScanOptionAllowDuplicatesKey] = true
+        }
+        
+        // Query system connected peripherals with specified services
+        let withServices: [CBUUID] = services.compactMap { CBUUID(string: $0) }
+        
+        for service in withServices {
+            let peripherals = centralManager.retrieveConnectedPeripherals(withServices: [service])
+            for peripheral in peripherals {
+                let deviceId = peripheral.identifier.uuidString
+                
+                // Only add if we don't already have it in our list
+                if !connectedPeripherals.keys.contains(deviceId) {
+                    let device = BLEDevice(
+                        id: deviceId,
+                        name: peripheral.name ?? "Unknown Device",
+                        rssi: 0,
+                        manufacturerData: ManufacturerData(companyIdentifiers: []),
+                        serviceUUIDs: peripheral.services?.map { $0.uuid.uuidString } ?? [],
+                        isConnectable: true
+                    )
+                    connectedDevices.append(device)
+                    
+                    // Add to our tracking dictionaries for future use
+                    discoveredPeripherals[deviceId] = peripheral
+                    connectedPeripherals[deviceId] = peripheral
                 }
             }
-            
-            self.centralManager.scanForPeripherals(withServices: serviceUUIDs, options: scanOptions)
-            resolve(())
         }
+        
+        return connectedDevices
     }
     
-    public func stopDeviceScan() throws -> Promise<Void> {
-        return Promise.resolve(withBlock: {
-            if self.isScanning {
-                self.centralManager.stopScan()
-                self.isScanning = false
-                self.scanListener = nil
-            }
-        })
-    }
-    
-    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)
-            }
+    // MARK: - Connection Management
+    public func connect(deviceId: String, callback: @escaping (Bool, String, String) -> Void, disconnectCallback: ((String, Bool, String) -> Void)?) throws {
+        // Find peripheral by identifier
+        guard let peripheral = findPeripheral(by: deviceId) else {
+            callback(false, "", "Peripheral not found")
+            return
         }
-    }
-    
-    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()
+        
+        // Check if already connected
+        if peripheral.state == .connected {
+            callback(true, deviceId, "")
+            return
         }
+        
+        // Store connection callback and disconnect callback
+        let delegate = BlePeripheralDelegate(deviceId: deviceId, manager: self)
+        delegate.connectionCallback = callback
+        delegate.disconnectEventCallback = disconnectCallback
+        peripheralDelegates[deviceId] = delegate
+        peripheral.delegate = delegate
+        
+        // Connect to peripheral
+        centralManager.connect(peripheral, options: nil)
     }
     
-    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)
-            }
+    public func disconnect(deviceId: String, callback: @escaping (Bool, String) -> Void) throws {
+        guard let peripheral = connectedPeripherals[deviceId] else {
+            callback(false, "Peripheral not connected")
+            return
         }
+        
+        // Store disconnect callback in delegate
+        peripheralDelegates[deviceId]?.disconnectionCallback = callback
+        
+        // Mark this as an intentional disconnection
+        intentionalDisconnections.insert(deviceId)
+        
+        centralManager.cancelPeripheralConnection(peripheral)
     }
     
-    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
-            }
-        })
-    }
-    
-    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) }
-        })
+    public func isConnected(deviceId: String) throws -> Bool {
+        if let peripheral = connectedPeripherals[deviceId] {
+            return peripheral.state == .connected
+        } else {
+            return false
+        }
     }
     
-    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)
+    // MARK: - Service Discovery
+    public func discoverServices(deviceId: String, callback: @escaping (Bool, String) -> Void) throws {
+        guard let peripheral = connectedPeripherals[deviceId] else {
+            callback(false, "Peripheral not connected")
+            return
         }
+        
+        peripheralDelegates[deviceId]?.serviceDiscoveryCallback = callback
+        peripheral.discoverServices(nil)
     }
     
-    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 getServices(deviceId: String) throws -> [String] {
+        guard let peripheral = connectedPeripherals[deviceId] else {
+            return []
         }
+        
+        let serviceUUIDs = peripheral.services?.map { $0.uuid.uuidString } ?? []
+        return serviceUUIDs
     }
     
-    public func onDeviceDisconnected(deviceIdentifier: String, listener: @escaping (_ error: NativeBleError?, _ device: NativeDevice?) -> Void) throws -> Subscription {
-        self.deviceDisconnectListeners[deviceIdentifier] = listener
+    public func getCharacteristics(
+        deviceId: String,
+        serviceId: String,
+    ) throws -> [String] {
+        guard let peripheral = connectedPeripherals[deviceId] else {
+            return []
+        }
         
-        return SubscriptionImpl {
-            self.deviceDisconnectListeners.removeValue(forKey: deviceIdentifier)
+        // Find service using CBUUID comparison
+        let serviceUUID = CBUUID(string: serviceId)
+        guard let service = peripheral.services?.first(where: { $0.uuid == serviceUUID }) else {
+            return []
         }
-    }
-    
-    public func isDeviceConnected(deviceIdentifier: String) throws -> Promise<Bool> {
-        return Promise.resolve(withBlock: {
-            return self.connectedDevices[deviceIdentifier] != nil
-        })
-    }
-    
-    // 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 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)
+        
+        let characteristicUUIDs = service.characteristics?.map { $0.uuid.uuidString } ?? []
+        return characteristicUUIDs
+    }
+    
+    // MARK: - Characteristic Operations
+    public func readCharacteristic(
+        deviceId: String,
+        serviceId: String,
+        characteristicId: String,
+        callback: @escaping (Bool, [Double], String) -> Void
+    ) throws {
+        guard let characteristic = findCharacteristic(deviceId: deviceId, serviceId: serviceId, characteristicId: characteristicId) else {
+            callback(false, [], "Characteristic not found")
+            return
+        }
+        
+        // Ensure peripheral delegate exists
+        guard let delegate = peripheralDelegates[deviceId] else {
+            callback(false, [], "Device not properly connected or delegate not found")
+            return
+        }
+        
+        // Store callback in delegate using CBUUID for reliable matching
+        delegate.readCallbacks[characteristic.uuid] = callback
+        
+        // Read characteristic value - the delegate will handle the response
+        characteristic.service?.peripheral?.readValue(for: characteristic)
+    }
+    
+    public func writeCharacteristic(
+        deviceId: String,
+        serviceId: String,
+        characteristicId: String,
+        data: [Double],
+        withResponse: Bool,
+        callback: @escaping (Bool, String) -> Void
+    ) throws {
+        guard let characteristic = findCharacteristic(deviceId: deviceId, serviceId: serviceId, characteristicId: characteristicId) else {
+            callback(false, "Characteristic not found")
+            return
+        }
+        
+        let writeData = Data(data.map { UInt8($0) })
+        let writeType: CBCharacteristicWriteType = withResponse ? .withResponse : .withoutResponse
+        
+        if withResponse {
+            // Ensure peripheral delegate exists for response handling
+            guard let delegate = peripheralDelegates[deviceId] else {
+                callback(false, "Device not properly connected or delegate not found")
                 return
             }
-            
-            if let transactionId = transactionId {
-                self.pendingOperations[transactionId] = resolve
-            }
-            
-            peripheral.discoverServices(nil)
+            delegate.writeCallbacks[characteristic.uuid] = callback
         }
-    }
-    
-    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)
+        characteristic.service?.peripheral?.writeValue(writeData, for: characteristic, type: writeType)
+        
+        if !withResponse {
+            callback(true, "")
+        }
     }
     
-    public func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
-        let deviceId = peripheral.identifier.uuidString
-        connectedDevices[deviceId] = peripheral
-        peripheral.delegate = self
+    public func subscribeToCharacteristic(
+        deviceId: String,
+        serviceId: String,
+        characteristicId: String,
+        updateCallback: @escaping (String, [Double]) -> Void,
+        resultCallback: @escaping (Bool, String) -> Void
+    ) throws {
+        guard let characteristic = findCharacteristic(deviceId: deviceId, serviceId: serviceId, characteristicId: characteristicId) else {
+            resultCallback(false, "Characteristic not found")
+            return
+        }
         
-        if let resolve = pendingOperations[deviceId] as? (NativeDevice) -> Void {
-            let device = createNativeDevice(from: peripheral)
-            resolve(device)
-            pendingOperations.removeValue(forKey: deviceId)
+        // Ensure peripheral delegate exists
+        guard let delegate = peripheralDelegates[deviceId] else {
+            resultCallback(false, "Device not properly connected or delegate not found")
+            return
         }
+        
+        delegate.notificationCallbacks[characteristic.uuid] = updateCallback
+        delegate.subscriptionCallbacks[characteristic.uuid] = resultCallback
+        
+        characteristic.service?.peripheral?.setNotifyValue(true, for: characteristic)
     }
     
-    public func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {
-        let deviceId = peripheral.identifier.uuidString
-        connectedDevices.removeValue(forKey: deviceId)
+    public func unsubscribeFromCharacteristic(
+        deviceId: String,
+        serviceId: String,
+        characteristicId: String,
+        callback: @escaping (Bool, String) -> Void
+    ) throws {
+        guard let characteristic = findCharacteristic(deviceId: deviceId, serviceId: serviceId, characteristicId: characteristicId) else {
+            callback(false, "Characteristic not found")
+            return
+        }
         
-        let device = createNativeDevice(from: peripheral)
-        let bleError = error != nil ? createBleError(.DeviceDisconnected, message: error!.localizedDescription) : nil
+        // Ensure peripheral delegate exists
+        guard let delegate = peripheralDelegates[deviceId] else {
+            callback(false, "Device not properly connected or delegate not found")
+            return
+        }
         
-        deviceDisconnectListeners[deviceId]?(bleError, device)
-        deviceDisconnectListeners.removeValue(forKey: deviceId)
+        delegate.notificationCallbacks.removeValue(forKey: characteristic.uuid)
+        delegate.unsubscriptionCallbacks[characteristic.uuid] = callback
         
-        if let resolve = pendingOperations[deviceId] as? (NativeDevice) -> Void {
-            resolve(device)
-            pendingOperations.removeValue(forKey: deviceId)
-        }
+        characteristic.service?.peripheral?.setNotifyValue(false, for: characteristic)
     }
     
-    public func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) {
-        let deviceId = peripheral.identifier.uuidString
+    // MARK: - Helper Methods
+    private func findPeripheral(by deviceId: String) -> CBPeripheral? {
+        // Check connected peripherals first
+        if let peripheral = connectedPeripherals[deviceId] {
+            return peripheral
+        }
         
-        if let reject = pendingOperations[deviceId] as? (Error) -> Void {
-            let bleError = createBleError(.DeviceConnectionFailed, message: error?.localizedDescription ?? "Connection failed")
-            reject(bleError)
-            pendingOperations.removeValue(forKey: deviceId)
+        // Check discovered peripherals
+        if let peripheral = discoveredPeripherals[deviceId] {
+            return peripheral
         }
+        
+        // Try to retrieve by UUID as fallback
+        guard let uuid = UUID(uuidString: deviceId) else { return nil }
+        return centralManager.retrievePeripherals(withIdentifiers: [uuid]).first
     }
     
-    // MARK: - Helper Methods
+    private func findCharacteristic(deviceId: String, serviceId: String, characteristicId: String) -> CBCharacteristic? {
+        guard let peripheral = connectedPeripherals[deviceId] else {
+            return nil
+        }
+        
+        let serviceUUID = CBUUID(string: serviceId)
+        let characteristicUUID = CBUUID(string: characteristicId)
+        
+        guard let service = peripheral.services?.first(where: { $0.uuid == serviceUUID }),
+              let characteristic = service.characteristics?.first(where: { $0.uuid == characteristicUUID }) else {
+            return nil
+        }
+        return characteristic
+    }
     
-    private func mapCBManagerState(_ state: CBManagerState) -> State {
+    internal func mapCBManagerStateToBLEState(_ state: CBManagerState) -> BLEState {
         switch state {
         case .unknown:
-            return .Unknown
+            return .unknown
         case .resetting:
-            return .Resetting
+            return .resetting
         case .unsupported:
-            return .Unsupported
+            return .unsupported
         case .unauthorized:
-            return .Unauthorized
+            return .unauthorized
         case .poweredOff:
-            return .PoweredOff
+            return .poweredoff
         case .poweredOn:
-            return .PoweredOn
+            return .poweredon
         @unknown default:
-            return .Unknown
+            return .unknown
         }
     }
+
+    // MARK: - Helper Methods
     
-    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
-        )
+    internal func handleStateChange(_ state: BLEState) {
+        stateChangeCallback?(state)
     }
     
-    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
+    internal func handleDeviceDiscovered(
+        _ peripheral: CBPeripheral,
+        advertisementData: [String: Any],
+        rssi: NSNumber
+    ) {
+        // Apply RSSI filter if specified
+        if let filter = currentScanFilter, rssi.doubleValue < filter.rssiThreshold {
+            return
+        }
+        
+        // Store discovered peripheral for future connections
+        let deviceId = peripheral.identifier.uuidString
+        discoveredPeripherals[deviceId] = peripheral
+        
+        // Create BLE device
+        let device = createBLEDevice(
+            peripheral: peripheral,
+            advertisementData: advertisementData,
+            rssi: rssi.doubleValue
         )
+        
+        scanCallback?(device)
     }
-}
-
-// MARK: - CBPeripheralDelegate Extension
-
-extension BleNitroBleManager: CBPeripheralDelegate {
     
-    public func peripheral(_ peripheral: CBPeripheral, didReadRSSI RSSI: NSNumber, error: Error?) {
+    internal func handleDeviceConnected(_ peripheral: CBPeripheral) {
         let deviceId = peripheral.identifier.uuidString
+        connectedPeripherals[deviceId] = peripheral
         
-        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
-            }
+        if let delegate = peripheralDelegates[deviceId] {
+            delegate.connectionCallback?(true, deviceId, "")
+            delegate.connectionCallback = nil
         }
     }
     
-    public func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
-        if let error = error {
-            // Handle service discovery error
-            return
-        }
+    internal func handleDeviceConnectionFailed(_ peripheral: CBPeripheral, error: Error?) {
+        let deviceId = peripheral.identifier.uuidString
+        let errorMessage = error?.localizedDescription ?? "Connection failed"
         
-        // 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
+        if let delegate = peripheralDelegates[deviceId] {
+            delegate.connectionCallback?(false, "", errorMessage)
+            delegate.connectionCallback = nil
         }
         
-        // Discover descriptors for all characteristics
-        service.characteristics?.forEach { characteristic in
-            peripheral.discoverDescriptors(for: characteristic)
-        }
+        peripheralDelegates.removeValue(forKey: deviceId)
     }
     
-    public func peripheral(_ peripheral: CBPeripheral, didDiscoverDescriptorsFor characteristic: CBCharacteristic, error: Error?) {
-        // Complete service discovery
+    internal func handleDeviceDisconnected(_ peripheral: CBPeripheral, error: Error?) {
         let deviceId = peripheral.identifier.uuidString
+        connectedPeripherals.removeValue(forKey: deviceId)
         
-        for (transactionId, operation) in pendingOperations {
-            if let resolve = operation as? (NativeDevice) -> Void {
-                let device = createNativeDevice(from: peripheral)
-                resolve(device)
-                pendingOperations.removeValue(forKey: transactionId)
-                break
+        // Determine if this was an intentional or interrupted disconnection
+        let wasIntentional = intentionalDisconnections.contains(deviceId)
+        let interrupted = !wasIntentional
+        intentionalDisconnections.remove(deviceId)
+        
+        if let delegate = peripheralDelegates[deviceId] {
+            // Handle the disconnect() method callback (for intentional disconnections)
+            if let callback = delegate.disconnectionCallback {
+                callback(error == nil, error?.localizedDescription ?? "")
+                delegate.disconnectionCallback = nil
+            }
+            
+            // Handle the disconnect event callback (for both intentional and interrupted)
+            if let disconnectEventCallback = delegate.disconnectEventCallback {
+                let errorMessage = error?.localizedDescription ?? ""
+                disconnectEventCallback(deviceId, interrupted, errorMessage)
             }
         }
+        
+        peripheralDelegates.removeValue(forKey: deviceId)
     }
     
-    // MARK: - CBCentralManagerDelegate State Restoration
+    private func createBLEDevice(
+        peripheral: CBPeripheral,
+        advertisementData: [String: Any],
+        rssi: Double
+    ) -> BLEDevice {
+        let deviceId = peripheral.identifier.uuidString
+        let deviceName = peripheral.name ?? advertisementData[CBAdvertisementDataLocalNameKey] as? String ?? "Unknown"
+        
+        // Extract service UUIDs
+        let serviceUUIDs = (advertisementData[CBAdvertisementDataServiceUUIDsKey] as? [CBUUID])?.map { $0.uuidString } ?? []
+        
+        // Extract manufacturer data
+        let manufacturerData = extractManufacturerData(from: advertisementData)
+        
+        // Check if connectable
+        let isConnectable = (advertisementData[CBAdvertisementDataIsConnectable] as? Bool) ?? true
+        
+        return BLEDevice(
+            id: deviceId,
+            name: deviceName,
+            rssi: rssi,
+            manufacturerData: manufacturerData,
+            serviceUUIDs: serviceUUIDs,
+            isConnectable: isConnectable
+        )
+    }
     
-    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")
+    private func extractManufacturerData(from advertisementData: [String: Any]) -> ManufacturerData {
+        guard let manufacturerDataRaw = advertisementData[CBAdvertisementDataManufacturerDataKey] as? Data else {
+            return ManufacturerData(companyIdentifiers: [])
+        }
+        
+        // Parse manufacturer data (first 2 bytes are company identifier)
+        guard manufacturerDataRaw.count >= 2 else {
+            return ManufacturerData(companyIdentifiers: [])
+        }
+        
+        let companyId = manufacturerDataRaw.prefix(2).withUnsafeBytes { $0.load(as: UInt16.self) }
+        let data = Array(manufacturerDataRaw.dropFirst(2)).map { Double($0) }
+        
+        let entry = ManufacturerDataEntry(
+            id: String(companyId),
+            data: data
+        )
+        
+        return ManufacturerData(companyIdentifiers: [entry])
+    }
+
+    public func openSettings() throws -> NitroModules.Promise<Void> {
+        return Promise.async {
+            if let url = URL(string: UIApplication.openSettingsURLString) {
+                // Ask the system to open that URL.
+                await UIApplication.shared.open(url)
             }
         }
     }
-    
 }
 
-/**
- * Simple subscription implementation for cleanup
- */
-private class SubscriptionImpl: Subscription {
-    private let cleanup: () -> Void
+// MARK: - CBCentralManagerDelegate Implementation
+class BleCentralManagerDelegate: NSObject, CBCentralManagerDelegate {
+    weak var manager: BleNitroBleManager?
+    
+    init(manager: BleNitroBleManager) {
+        self.manager = manager
+        super.init()
+    }
+    
+    func centralManagerDidUpdateState(_ central: CBCentralManager) {
+        guard let manager = manager else { return }
+        let bleState = manager.mapCBManagerStateToBLEState(central.state)
+        manager.handleStateChange(bleState)
+    }
+    
+    func centralManager(
+        _ central: CBCentralManager,
+        didDiscover peripheral: CBPeripheral,
+        advertisementData: [String: Any],
+        rssi RSSI: NSNumber
+    ) {
+        manager?.handleDeviceDiscovered(peripheral, advertisementData: advertisementData, rssi: RSSI)
+    }
+    
+    func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
+        manager?.handleDeviceConnected(peripheral)
+    }
     
-    init(_ cleanup: @escaping () -> Void) {
-        self.cleanup = cleanup
+    func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) {
+        manager?.handleDeviceConnectionFailed(peripheral, error: error)
     }
     
-    public func remove() {
-        cleanup()
+    func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {
+        manager?.handleDeviceDisconnected(peripheral, error: error)
     }
 }