munim-bluetooth 0.3.2 → 0.3.4

package/ios/HybridMunimBluetooth.swift

@@ -14,14 +14,14 @@ class HybridMunimBluetooth: HybridMunimBluetoothSpec {
     // Peripheral Manager
     private var peripheralManager: CBPeripheralManager?
     private var peripheralServices: [CBMutableService] = []
-    private var currentAdvertisingData: [String: Any] = [:]
+    private var currentAdvertisingData: AdvertisingDataTypes?
     
     // Central Manager
     private var centralManager: CBCentralManager?
     private var discoveredPeripherals: [String: CBPeripheral] = [:]
     private var connectedPeripherals: [String: CBPeripheral] = [:]
     private var peripheralCharacteristics: [String: [CBCharacteristic]] = [:]
-    private var scanOptions: [String: Any]?
+    private var scanOptions: ScanOptions?
     private var isScanning = false
     
     // Event emitter
@@ -36,7 +36,7 @@ class HybridMunimBluetooth: HybridMunimBluetoothSpec {
     
     // MARK: - Peripheral Features
     
-    func startAdvertising(options: [String: Any]) throws {
+    override func startAdvertising(options: AdvertisingOptions) throws {
         guard let peripheralManager = peripheralManager,
               peripheralManager.state == .poweredOn else {
             throw NSError(domain: "MunimBluetooth", code: 1, userInfo: [NSLocalizedDescriptionKey: "Bluetooth is not powered on"])
@@ -44,31 +44,33 @@ class HybridMunimBluetooth: HybridMunimBluetoothSpec {
         
         var advertisingData: [String: Any] = [:]
         
-        // Process comprehensive advertising data
-        if let advertisingDataDict = options["advertisingData"] as? [String: Any] {
-            processAdvertisingData(advertisingDataDict, into: &advertisingData)
+        // Service UUIDs
+        if !options.serviceUUIDs.isEmpty {
+            let uuids = options.serviceUUIDs.compactMap { CBUUID(string: $0) }
+            advertisingData[CBAdvertisementDataServiceUUIDsKey] = uuids
         }
         
-        // Legacy support
-        if let localName = options["localName"] as? String {
+        // Local name
+        if let localName = options.localName {
             advertisingData[CBAdvertisementDataLocalNameKey] = localName
         }
         
-        if let serviceUUIDs = options["serviceUUIDs"] as? [String], !serviceUUIDs.isEmpty {
-            let uuids = serviceUUIDs.compactMap { CBUUID(string: $0) }
-            advertisingData[CBAdvertisementDataServiceUUIDsKey] = uuids
-        }
-        
-        if let manufacturerData = options["manufacturerData"] as? String,
+        // Manufacturer data
+        if let manufacturerData = options.manufacturerData,
            let data = hexStringToData(manufacturerData) {
             advertisingData[CBAdvertisementDataManufacturerDataKey] = data
         }
         
-        currentAdvertisingData = advertisingData
+        // Advertising data
+        if let advertisingDataTypes = options.advertisingData {
+            processAdvertisingData(advertisingDataTypes, into: &advertisingData)
+        }
+        
+        currentAdvertisingData = options.advertisingData
         peripheralManager.startAdvertising(advertisingData as? [String: Any])
     }
     
-    func updateAdvertisingData(advertisingData: [String: Any]) throws {
+    override func updateAdvertisingData(advertisingData: AdvertisingDataTypes) throws {
         guard let peripheralManager = peripheralManager,
               peripheralManager.state == .poweredOn else {
             throw NSError(domain: "MunimBluetooth", code: 1, userInfo: [NSLocalizedDescriptionKey: "Bluetooth is not powered on"])
@@ -79,360 +81,231 @@ class HybridMunimBluetooth: HybridMunimBluetoothSpec {
         var newAdvertisingData: [String: Any] = [:]
         processAdvertisingData(advertisingData, into: &newAdvertisingData)
         
-        currentAdvertisingData = newAdvertisingData
+        currentAdvertisingData = advertisingData
         peripheralManager.startAdvertising(newAdvertisingData as? [String: Any])
     }
     
-    func getAdvertisingData() throws -> [String: Any] {
-        return currentAdvertisingData
+    override func getAdvertisingData() throws -> Promise<AdvertisingDataTypes> {
+        return Promise { resolver in
+            resolver.resolve(self.currentAdvertisingData ?? AdvertisingDataTypes())
+        }
     }
     
-    func stopAdvertising() throws {
+    override func stopAdvertising() throws {
         peripheralManager?.stopAdvertising()
-        currentAdvertisingData = [:]
+        currentAdvertisingData = nil
     }
     
-    func setServices(services: [[String: Any]]) throws {
+    override func setServices(services: [GATTService]) throws {
         peripheralServices.removeAll()
         
-        for serviceDict in services {
-            guard let uuidString = serviceDict["uuid"] as? String else { continue }
-            
-            let serviceUUID = CBUUID(string: uuidString)
-            let service = CBMutableService(type: serviceUUID, primary: true)
+        for service in services {
+            let serviceUUID = CBUUID(string: service.uuid)
+            let mutableService = CBMutableService(type: serviceUUID, primary: true)
             
             var characteristics: [CBMutableCharacteristic] = []
             
-            if let characteristicsArray = serviceDict["characteristics"] as? [[String: Any]] {
-                for charDict in characteristicsArray {
-                    guard let charUUIDString = charDict["uuid"] as? String else { continue }
-                    
-                    let charUUID = CBUUID(string: charUUIDString)
-                    var properties: CBCharacteristicProperties = []
-                    
-                    if let propertiesArray = charDict["properties"] as? [String] {
-                        for prop in propertiesArray {
-                            switch prop {
-                            case "read":
-                                properties.insert(.read)
-                            case "write":
-                                properties.insert(.write)
-                            case "notify":
-                                properties.insert(.notify)
-                            case "indicate":
-                                properties.insert(.indicate)
-                            default:
-                                break
-                            }
-                        }
+            for characteristic in service.characteristics {
+                let charUUID = CBUUID(string: characteristic.uuid)
+                
+                var properties: CBCharacteristicProperties = []
+                for prop in characteristic.properties {
+                    switch prop {
+                    case "read":
+                        properties.insert(.read)
+                    case "write":
+                        properties.insert(.write)
+                    case "writeWithoutResponse":
+                        properties.insert(.writeWithoutResponse)
+                    case "notify":
+                        properties.insert(.notify)
+                    case "indicate":
+                        properties.insert(.indicate)
+                    default:
+                        break
                     }
-                    
-                    var value: Data?
-                    if let valueString = charDict["value"] as? String {
-                        value = valueString.data(using: .utf8)
+                }
+                
+                var value: Data?
+                if let valueString = characteristic.value {
+                    value = hexStringToData(valueString)
+                    if !properties.contains(.read) {
                         properties.insert(.read)
                     }
-                    
-                    let permissions: CBAttributePermissions = value != nil ? .readable : [.readable, .writeable]
-                    
-                    let characteristic = CBMutableCharacteristic(
-                        type: charUUID,
-                        properties: properties,
-                        value: value,
-                        permissions: permissions
-                    )
-                    
-                    characteristics.append(characteristic)
                 }
+                
+                let permissions: CBAttributePermissions = value != nil ? .readable : [.readable, .writeable]
+                
+                let mutableChar = CBMutableCharacteristic(
+                    type: charUUID,
+                    properties: properties,
+                    value: value,
+                    permissions: permissions
+                )
+                
+                characteristics.append(mutableChar)
             }
             
-            service.characteristics = characteristics
-            peripheralServices.append(service)
+            mutableService.characteristics = characteristics
+            peripheralServices.append(mutableService)
         }
         
-        peripheralManager?.removeAllServices()
         for service in peripheralServices {
             peripheralManager?.add(service)
         }
     }
     
-    // MARK: - Central Features
+    // MARK: - Central/Manager Features
     
-    func isBluetoothEnabled() throws -> Bool {
-        guard let centralManager = centralManager else { return false }
-        return centralManager.state == .poweredOn
+    override func isBluetoothEnabled() throws -> Promise<Bool> {
+        return Promise { resolver in
+            let isEnabled = self.centralManager?.state == .poweredOn
+            resolver.resolve(isEnabled ?? false)
+        }
     }
     
-    func requestBluetoothPermission() throws -> Bool {
-        guard let centralManager = centralManager else { return false }
-        // On iOS, permission is requested automatically when creating CBCentralManager
-        // The state will be .unauthorized if permission is denied
-        return centralManager.state != .unauthorized
+    override func requestBluetoothPermission() throws -> Promise<Bool> {
+        return Promise { resolver in
+            // In iOS, permissions are handled by CBPeripheralManager/CBCentralManager
+            resolver.resolve(true)
+        }
     }
     
-    func startScan(options: [String: Any]?) throws {
+    override func startScan(options: ScanOptions?) throws {
         guard let centralManager = centralManager,
               centralManager.state == .poweredOn else {
             throw NSError(domain: "MunimBluetooth", code: 1, userInfo: [NSLocalizedDescriptionKey: "Bluetooth is not powered on"])
         }
         
-        guard !isScanning else { return }
-        
         scanOptions = options
         isScanning = true
-        discoveredPeripherals.removeAll()
         
-        var serviceUUIDs: [CBUUID]?
-        if let serviceUUIDsArray = options?["serviceUUIDs"] as? [String] {
-            serviceUUIDs = serviceUUIDsArray.compactMap { CBUUID(string: $0) }
+        var scanOptions: [String: Any] = [:]
+        if let options = options {
+            scanOptions[CBCentralManagerScanOptionAllowDuplicatesKey] = options.allowDuplicates ?? false
         }
         
-        centralManager.scanForPeripherals(withServices: serviceUUIDs, options: [
-            CBCentralManagerScanOptionAllowDuplicatesKey: options?["allowDuplicates"] as? Bool ?? false
-        ])
+        centralManager.scanForPeripherals(withServices: nil, options: scanOptions as [String : Any])
     }
     
-    func stopScan() throws {
-        guard isScanning else { return }
+    override func stopScan() throws {
         centralManager?.stopScan()
         isScanning = false
-        scanOptions = nil
     }
     
-    func connect(deviceId: String) throws {
-        guard let peripheral = discoveredPeripherals[deviceId] else {
-            throw NSError(domain: "MunimBluetooth", code: 2, userInfo: [NSLocalizedDescriptionKey: "Device not found"])
+    override func connect(deviceId: String) throws -> Promise<Void> {
+        return Promise { resolver in
+            guard let peripheral = self.discoveredPeripherals[deviceId] else {
+                resolver.reject(NSError(domain: "MunimBluetooth", code: 1, userInfo: [NSLocalizedDescriptionKey: "Device not found"]))
+                return
+            }
+            
+            self.centralManager?.connect(peripheral, options: nil)
+            self.connectedPeripherals[deviceId] = peripheral
+            resolver.resolve(())
         }
-        
-        centralManager?.connect(peripheral, options: nil)
     }
     
-    func disconnect(deviceId: String) throws {
-        guard let peripheral = connectedPeripherals[deviceId] ?? discoveredPeripherals[deviceId] else {
-            return
-        }
-        
+    override func disconnect(deviceId: String) throws {
+        guard let peripheral = connectedPeripherals[deviceId] else { return }
         centralManager?.cancelPeripheralConnection(peripheral)
+        connectedPeripherals.removeValue(forKey: deviceId)
     }
     
-    func discoverServices(deviceId: String) throws -> [[String: Any]] {
-        guard let peripheral = connectedPeripherals[deviceId] else {
-            throw NSError(domain: "MunimBluetooth", code: 2, userInfo: [NSLocalizedDescriptionKey: "Device not connected"])
+    override func discoverServices(deviceId: String) throws -> Promise<[GATTService]> {
+        return Promise { resolver in
+            guard let peripheral = self.connectedPeripherals[deviceId] else {
+                resolver.reject(NSError(domain: "MunimBluetooth", code: 1, userInfo: [NSLocalizedDescriptionKey: "Device not connected"]))
+                return
+            }
+            
+            peripheral.discoverServices(nil)
+            resolver.resolve([])
         }
-        
-        peripheral.discoverServices(nil)
-        
-        // Wait for services to be discovered (in real implementation, this would be async)
-        // For now, return empty array - services will be discovered via delegate callbacks
-        return []
     }
     
-    func readCharacteristic(deviceId: String, serviceUUID: String, characteristicUUID: String) throws -> [String: Any] {
-        guard let peripheral = connectedPeripherals[deviceId] else {
-            throw NSError(domain: "MunimBluetooth", code: 2, userInfo: [NSLocalizedDescriptionKey: "Device not connected"])
-        }
-        
-        guard let characteristics = peripheralCharacteristics[deviceId],
-              let characteristic = characteristics.first(where: {
-                  $0.service?.uuid == CBUUID(string: serviceUUID) &&
-                  $0.uuid == CBUUID(string: characteristicUUID)
-              }) else {
-            throw NSError(domain: "MunimBluetooth", code: 3, userInfo: [NSLocalizedDescriptionKey: "Characteristic not found"])
+    override func readCharacteristic(deviceId: String, serviceUUID: String, characteristicUUID: String) throws -> Promise<CharacteristicValue> {
+        return Promise { resolver in
+            resolver.reject(NSError(domain: "MunimBluetooth", code: 1, userInfo: [NSLocalizedDescriptionKey: "Not implemented"]))
         }
-        
-        peripheral.readValue(for: characteristic)
-        
-        // Return empty for now - value will come via delegate callback
-        return [
-            "value": "",
-            "serviceUUID": serviceUUID,
-            "characteristicUUID": characteristicUUID
-        ]
     }
     
-    func writeCharacteristic(deviceId: String, serviceUUID: String, characteristicUUID: String, value: String, writeType: String?) throws {
-        guard let peripheral = connectedPeripherals[deviceId] else {
-            throw NSError(domain: "MunimBluetooth", code: 2, userInfo: [NSLocalizedDescriptionKey: "Device not connected"])
-        }
-        
-        guard let characteristics = peripheralCharacteristics[deviceId],
-              let characteristic = characteristics.first(where: {
-                  $0.service?.uuid == CBUUID(string: serviceUUID) &&
-                  $0.uuid == CBUUID(string: characteristicUUID)
-              }) else {
-            throw NSError(domain: "MunimBluetooth", code: 3, userInfo: [NSLocalizedDescriptionKey: "Characteristic not found"])
-        }
-        
-        guard let data = hexStringToData(value) else {
-            throw NSError(domain: "MunimBluetooth", code: 4, userInfo: [NSLocalizedDescriptionKey: "Invalid hex string"])
+    override func writeCharacteristic(deviceId: String, serviceUUID: String, characteristicUUID: String, value: String, writeType: WriteType?) throws -> Promise<Void> {
+        return Promise { resolver in
+            resolver.reject(NSError(domain: "MunimBluetooth", code: 1, userInfo: [NSLocalizedDescriptionKey: "Not implemented"]))
         }
-        
-        let type: CBCharacteristicWriteType = (writeType == "writeWithoutResponse") ? .withoutResponse : .withResponse
-        peripheral.writeValue(data, for: characteristic, type: type)
     }
     
-    func subscribeToCharacteristic(deviceId: String, serviceUUID: String, characteristicUUID: String) throws {
-        guard let peripheral = connectedPeripherals[deviceId] else {
-            throw NSError(domain: "MunimBluetooth", code: 2, userInfo: [NSLocalizedDescriptionKey: "Device not connected"])
-        }
-        
-        guard let characteristics = peripheralCharacteristics[deviceId],
-              let characteristic = characteristics.first(where: {
-                  $0.service?.uuid == CBUUID(string: serviceUUID) &&
-                  $0.uuid == CBUUID(string: characteristicUUID)
-              }) else {
-            throw NSError(domain: "MunimBluetooth", code: 3, userInfo: [NSLocalizedDescriptionKey: "Characteristic not found"])
-        }
-        
-        peripheral.setNotifyValue(true, for: characteristic)
+    override func subscribeToCharacteristic(deviceId: String, serviceUUID: String, characteristicUUID: String) throws {
+        // Not implemented
     }
     
-    func unsubscribeFromCharacteristic(deviceId: String, serviceUUID: String, characteristicUUID: String) throws {
-        guard let peripheral = connectedPeripherals[deviceId] else {
-            throw NSError(domain: "MunimBluetooth", code: 2, userInfo: [NSLocalizedDescriptionKey: "Device not connected"])
-        }
-        
-        guard let characteristics = peripheralCharacteristics[deviceId],
-              let characteristic = characteristics.first(where: {
-                  $0.service?.uuid == CBUUID(string: serviceUUID) &&
-                  $0.uuid == CBUUID(string: characteristicUUID)
-              }) else {
-            throw NSError(domain: "MunimBluetooth", code: 3, userInfo: [NSLocalizedDescriptionKey: "Characteristic not found"])
-        }
-        
-        peripheral.setNotifyValue(false, for: characteristic)
+    override func unsubscribeFromCharacteristic(deviceId: String, serviceUUID: String, characteristicUUID: String) throws {
+        // Not implemented
     }
     
-    func getConnectedDevices() throws -> [String] {
-        return Array(connectedPeripherals.keys)
+    override func getConnectedDevices() throws -> Promise<[String]> {
+        return Promise { resolver in
+            resolver.resolve(Array(self.connectedPeripherals.keys))
+        }
     }
     
-    func readRSSI(deviceId: String) throws -> Double {
-        guard let peripheral = connectedPeripherals[deviceId] else {
-            throw NSError(domain: "MunimBluetooth", code: 2, userInfo: [NSLocalizedDescriptionKey: "Device not connected"])
+    override func readRSSI(deviceId: String) throws -> Promise<Double> {
+        return Promise { resolver in
+            guard let peripheral = self.connectedPeripherals[deviceId] else {
+                resolver.reject(NSError(domain: "MunimBluetooth", code: 1, userInfo: [NSLocalizedDescriptionKey: "Device not connected"]))
+                return
+            }
+            
+            peripheral.readRSSI()
+            resolver.resolve(0)
         }
-        
-        peripheral.readRSSI()
-        // RSSI will come via delegate callback
-        return 0.0
     }
     
-    // MARK: - Event Management
-    
-    func addListener(eventName: String) throws {
-        // Event listeners are handled by the event emitter
-        // This is a no-op as Nitro modules handle events differently
+    override func addListener(eventName: String) throws {
+        // Event management
     }
     
-    func removeListeners(count: Double) throws {
-        // Event listeners are handled by the event emitter
-        // This is a no-op as Nitro modules handle events differently
+    override func removeListeners(count: Double) throws {
+        // Event management
     }
     
     // MARK: - Helper Methods
     
-    private func processAdvertisingData(_ dataDict: [String: Any], into advertisingData: inout [String: Any]) {
-        // Flags
-        if let flags = dataDict["flags"] as? Int {
-            let isConnectable = (flags & 0x02) != 0
-            advertisingData[CBAdvertisementDataIsConnectable] = isConnectable
-        }
-        
-        // Service UUIDs
-        addServiceUUIDs(dataDict["incompleteServiceUUIDs16"], to: &advertisingData, key: CBAdvertisementDataServiceUUIDsKey)
-        addServiceUUIDs(dataDict["completeServiceUUIDs16"], to: &advertisingData, key: CBAdvertisementDataServiceUUIDsKey)
-        addServiceUUIDs(dataDict["incompleteServiceUUIDs32"], to: &advertisingData, key: CBAdvertisementDataServiceUUIDsKey)
-        addServiceUUIDs(dataDict["completeServiceUUIDs32"], to: &advertisingData, key: CBAdvertisementDataServiceUUIDsKey)
-        addServiceUUIDs(dataDict["incompleteServiceUUIDs128"], to: &advertisingData, key: CBAdvertisementDataServiceUUIDsKey)
-        addServiceUUIDs(dataDict["completeServiceUUIDs128"], to: &advertisingData, key: CBAdvertisementDataServiceUUIDsKey)
-        
-        // Local Name
-        if let shortenedName = dataDict["shortenedLocalName"] as? String {
-            advertisingData[CBAdvertisementDataLocalNameKey] = shortenedName
-        }
-        if let completeName = dataDict["completeLocalName"] as? String {
-            advertisingData[CBAdvertisementDataLocalNameKey] = completeName
-        }
+    private func hexStringToData(_ hex: String) -> Data? {
+        var data = Data()
+        var hex = hex
         
-        // Tx Power Level
-        if let txPower = dataDict["txPowerLevel"] as? Int {
-            advertisingData[CBAdvertisementDataTxPowerLevelKey] = txPower
+        if hex.count % 2 != 0 {
+            hex = "0" + hex
         }
         
-        // Service Solicitation
-        addServiceUUIDs(dataDict["serviceSolicitationUUIDs16"], to: &advertisingData, key: CBAdvertisementDataSolicitedServiceUUIDsKey)
-        addServiceUUIDs(dataDict["serviceSolicitationUUIDs128"], to: &advertisingData, key: CBAdvertisementDataSolicitedServiceUUIDsKey)
-        addServiceUUIDs(dataDict["serviceSolicitationUUIDs32"], to: &advertisingData, key: CBAdvertisementDataSolicitedServiceUUIDsKey)
-        
-        // Service Data
-        addServiceData(dataDict["serviceData16"], to: &advertisingData)
-        addServiceData(dataDict["serviceData32"], to: &advertisingData)
-        addServiceData(dataDict["serviceData128"], to: &advertisingData)
-        
-        // Appearance
-        if let appearance = dataDict["appearance"] as? Int {
-            let appearanceData = Data(bytes: [UInt8(appearance & 0xFF), UInt8((appearance >> 8) & 0xFF)], count: 2)
-            advertisingData[CBUUID(string: "1800")] = appearanceData
+        let regex = try! NSRegularExpression(pattern: "[0-9a-f]{1,2}", options: .caseInsensitive)
+        regex.enumerateMatches(in: hex, range: NSRange(hex.startIndex..., in: hex)) { match, _, _ in
+            let byteStr = (hex as NSString).substring(with: match!.range)
+            let num = UInt8(byteStr, radix: 16)!
+            data.append(num)
         }
         
-        // Manufacturer Data
-        if let manufacturerData = dataDict["manufacturerData"] as? String,
-           let data = hexStringToData(manufacturerData) {
-            advertisingData[CBAdvertisementDataManufacturerDataKey] = data
-        }
+        return data.isEmpty ? nil : data
     }
     
-    private func addServiceUUIDs(_ uuids: Any?, to advertisingData: inout [String: Any], key: String) {
-        guard let uuidArray = uuids as? [String] else { return }
-        
-        let cbUUIDs = uuidArray.compactMap { CBUUID(string: $0) }
-        if !cbUUIDs.isEmpty {
-            if var existing = advertisingData[key] as? [CBUUID] {
-                existing.append(contentsOf: cbUUIDs)
-                advertisingData[key] = existing
-            } else {
-                advertisingData[key] = cbUUIDs
-            }
+    private func processAdvertisingData(_ data: AdvertisingDataTypes, into advertisingData: inout [String: Any]) {
+        if let flags = data.flags {
+            advertisingData[CBAdvertisementDataIsConnectable] = true
         }
-    }
-    
-    private func addServiceData(_ serviceDataArray: Any?, to advertisingData: inout [String: Any]) {
-        guard let array = serviceDataArray as? [[String: Any]] else { return }
         
-        for serviceData in array {
-            guard let uuid = serviceData["uuid"] as? String,
-                  let dataString = serviceData["data"] as? String,
-                  let data = hexStringToData(dataString) else { continue }
-            
-            advertisingData[uuid] = data
+        if let completeLocalName = data.completeLocalName {
+            advertisingData[CBAdvertisementDataLocalNameKey] = completeLocalName
         }
-    }
-    
-    private func hexStringToData(_ hexString: String) -> Data? {
-        let cleanHex = hexString.replacingOccurrences(of: " ", with: "")
-        guard cleanHex.count % 2 == 0 else { return nil }
         
-        var data = Data()
-        var index = cleanHex.startIndex
-        
-        while index < cleanHex.endIndex {
-            let nextIndex = cleanHex.index(index, offsetBy: 2)
-            guard nextIndex <= cleanHex.endIndex else { break }
-            
-            let byteString = String(cleanHex[index..<nextIndex])
-            if let byte = UInt8(byteString, radix: 16) {
-                data.append(byte)
-            }
-            
-            index = nextIndex
+        if let txPowerLevel = data.txPowerLevel {
+            advertisingData[CBAdvertisementDataTxPowerLevelKey] = txPowerLevel
         }
-        
-        return data
     }
 }
 
 // MARK: - CBPeripheralManagerDelegate
-
 extension HybridMunimBluetooth: CBPeripheralManagerDelegate {
     func peripheralManagerDidUpdateState(_ peripheral: CBPeripheralManager) {
         // Handle state updates
@@ -440,34 +313,36 @@ extension HybridMunimBluetooth: CBPeripheralManagerDelegate {
     
     func peripheralManagerDidStartAdvertising(_ peripheral: CBPeripheralManager, error: Error?) {
         if let error = error {
-            // Emit error event
+            eventEmitter?.emit("advertisingError", ["error": error.localizedDescription])
+        } else {
+            eventEmitter?.emit("advertisingStarted", [:])
         }
     }
     
     func peripheralManager(_ peripheral: CBPeripheralManager, didAdd service: CBService, error: Error?) {
         if let error = error {
-            // Emit error event
+            eventEmitter?.emit("serviceError", ["error": error.localizedDescription])
+        } else {
+            eventEmitter?.emit("serviceAdded", ["uuid": service.uuid.uuidString])
         }
     }
 }
 
 // MARK: - CBCentralManagerDelegate
-
 extension HybridMunimBluetooth: CBCentralManagerDelegate {
     func centralManagerDidUpdateState(_ central: CBCentralManager) {
-        // Handle state updates
+        let state = central.state
+        eventEmitter?.emit("bluetoothStateChanged", ["state": state.rawValue])
     }
     
     func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String: Any], rssi RSSI: NSNumber) {
         let deviceId = peripheral.identifier.uuidString
         discoveredPeripherals[deviceId] = peripheral
         
-        // Emit deviceFound event
         eventEmitter?.emit("deviceFound", [
             "id": deviceId,
             "name": peripheral.name ?? "",
-            "rssi": RSSI.intValue,
-            "advertisingData": advertisementData
+            "rssi": RSSI.intValue
         ])
     }
     
@@ -476,7 +351,6 @@ extension HybridMunimBluetooth: CBCentralManagerDelegate {
         connectedPeripherals[deviceId] = peripheral
         peripheral.delegate = self
         
-        // Emit deviceConnected event
         eventEmitter?.emit("deviceConnected", ["id": deviceId])
     }
     
@@ -485,14 +359,11 @@ extension HybridMunimBluetooth: CBCentralManagerDelegate {
         connectedPeripherals.removeValue(forKey: deviceId)
         peripheralCharacteristics.removeValue(forKey: deviceId)
         
-        // Emit deviceDisconnected event
         eventEmitter?.emit("deviceDisconnected", ["id": deviceId])
     }
     
     func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) {
         let deviceId = peripheral.identifier.uuidString
-        
-        // Emit connectionFailed event
         eventEmitter?.emit("connectionFailed", [
             "id": deviceId,
             "error": error?.localizedDescription ?? "Unknown error"
@@ -501,24 +372,17 @@ extension HybridMunimBluetooth: CBCentralManagerDelegate {
 }
 
 // MARK: - CBPeripheralDelegate
-
 extension HybridMunimBluetooth: CBPeripheralDelegate {
     func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
         let deviceId = peripheral.identifier.uuidString
         
         guard let services = peripheral.services else { return }
         
-        var servicesArray: [[String: Any]] = []
         for service in services {
             peripheral.discoverCharacteristics(nil, for: service)
-            servicesArray.append(["uuid": service.uuid.uuidString])
         }
         
-        // Emit servicesDiscovered event
-        eventEmitter?.emit("servicesDiscovered", [
-            "id": deviceId,
-            "services": servicesArray
-        ])
+        eventEmitter?.emit("servicesDiscovered", ["id": deviceId])
     }
     
     func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
@@ -531,26 +395,7 @@ extension HybridMunimBluetooth: CBPeripheralDelegate {
         }
         peripheralCharacteristics[deviceId]?.append(contentsOf: characteristics)
         
-        // Emit characteristicsDiscovered event
-        var characteristicsArray: [[String: Any]] = []
-        for characteristic in characteristics {
-            var properties: [String] = []
-            if characteristic.properties.contains(.read) { properties.append("read") }
-            if characteristic.properties.contains(.write) { properties.append("write") }
-            if characteristic.properties.contains(.notify) { properties.append("notify") }
-            if characteristic.properties.contains(.indicate) { properties.append("indicate") }
-            
-            characteristicsArray.append([
-                "uuid": characteristic.uuid.uuidString,
-                "properties": properties
-            ])
-        }
-        
-        eventEmitter?.emit("characteristicsDiscovered", [
-            "id": deviceId,
-            "serviceUUID": service.uuid.uuidString,
-            "characteristics": characteristicsArray
-        ])
+        eventEmitter?.emit("characteristicsDiscovered", ["id": deviceId])
     }
     
     func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
@@ -560,7 +405,6 @@ extension HybridMunimBluetooth: CBPeripheralDelegate {
         
         let hexString = data.map { String(format: "%02x", $0) }.joined()
         
-        // Emit characteristicValueChanged event
         eventEmitter?.emit("characteristicValueChanged", [
             "id": deviceId,
             "serviceUUID": characteristic.service?.uuid.uuidString ?? "",
@@ -575,29 +419,10 @@ extension HybridMunimBluetooth: CBPeripheralDelegate {
         if let error = error {
             eventEmitter?.emit("writeError", [
                 "id": deviceId,
-                "serviceUUID": characteristic.service?.uuid.uuidString ?? "",
-                "characteristicUUID": characteristic.uuid.uuidString,
                 "error": error.localizedDescription
             ])
         } else {
-            eventEmitter?.emit("writeSuccess", [
-                "id": deviceId,
-                "serviceUUID": characteristic.service?.uuid.uuidString ?? "",
-                "characteristicUUID": characteristic.uuid.uuidString
-            ])
-        }
-    }
-    
-    func peripheral(_ peripheral: CBPeripheral, didUpdateNotificationStateFor characteristic: CBCharacteristic, error: Error?) {
-        let deviceId = peripheral.identifier.uuidString
-        
-        if let error = error {
-            eventEmitter?.emit("subscriptionError", [
-                "id": deviceId,
-                "serviceUUID": characteristic.service?.uuid.uuidString ?? "",
-                "characteristicUUID": characteristic.uuid.uuidString,
-                "error": error.localizedDescription
-            ])
+            eventEmitter?.emit("writeSuccess", ["id": deviceId])
         }
     }
     
@@ -605,21 +430,14 @@ extension HybridMunimBluetooth: CBPeripheralDelegate {
         let deviceId = peripheral.identifier.uuidString
         
         if let error = error {
-            eventEmitter?.emit("rssiError", [
-                "id": deviceId,
-                "error": error.localizedDescription
-            ])
+            eventEmitter?.emit("rssiError", ["error": error.localizedDescription])
         } else {
-            eventEmitter?.emit("rssiUpdated", [
-                "id": deviceId,
-                "rssi": RSSI.intValue
-            ])
+            eventEmitter?.emit("rssiUpdated", ["id": deviceId, "rssi": RSSI.intValue])
         }
     }
 }
 
-// MARK: - Event Emitter Helper
-
+// MARK: - Helper Classes
 class NitroEventEmitter {
     private let moduleName: String
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "munim-bluetooth",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "A comprehensive React Native library for all your Bluetooth Low Energy (BLE) needs, supporting both peripheral and central roles with Expo support",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/module/index.js",