munim-bluetooth 0.3.3 → 0.3.4

package/ios/HybridMunimBluetooth.swift

@@ -307,161 +307,42 @@ class HybridMunimBluetooth: HybridMunimBluetoothSpec {
 
 // MARK: - CBPeripheralManagerDelegate
 extension HybridMunimBluetooth: CBPeripheralManagerDelegate {
-        guard let peripheralManager = peripheralManager,
-              peripheralManager.state == .poweredOn else {
-            throw NSError(domain: "MunimBluetooth", code: 1, userInfo: [NSLocalizedDescriptionKey: "Bluetooth is not powered on"])
-        }
-        
-        var advertisingData: [String: Any] = [:]
-        
-        // Process comprehensive advertising data
-        if let advertisingDataDict = options["advertisingData"] as? [String: Any] {
-            processAdvertisingData(advertisingDataDict, into: &advertisingData)
-        }
-        
-        // Legacy support
-        if let localName = options["localName"] as? String {
-            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,
-           let data = hexStringToData(manufacturerData) {
-            advertisingData[CBAdvertisementDataManufacturerDataKey] = data
-        }
-        
-        currentAdvertisingData = advertisingData
-        peripheralManager.startAdvertising(advertisingData as? [String: Any])
-    }
-    
-    func updateAdvertisingData(advertisingData: [String: Any]) throws {
-        guard let peripheralManager = peripheralManager,
-              peripheralManager.state == .poweredOn else {
-            throw NSError(domain: "MunimBluetooth", code: 1, userInfo: [NSLocalizedDescriptionKey: "Bluetooth is not powered on"])
-        }
-        
-        peripheralManager.stopAdvertising()
-        
-        var newAdvertisingData: [String: Any] = [:]
-        processAdvertisingData(advertisingData, into: &newAdvertisingData)
-        
-        currentAdvertisingData = newAdvertisingData
-        peripheralManager.startAdvertising(newAdvertisingData as? [String: Any])
-    }
-    
-    func getAdvertisingData() throws -> [String: Any] {
-        return currentAdvertisingData
-    }
-    
-    func stopAdvertising() throws {
-        peripheralManager?.stopAdvertising()
-        currentAdvertisingData = [:]
-    }
-    
-    func setServices(services: [[String: Any]]) 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)
-            
-            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
-                            }
-                        }
-                    }
-                    
-                    var value: Data?
-                    if let valueString = charDict["value"] as? String {
-                        value = valueString.data(using: .utf8)
-                        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)
-                }
-            }
-            
-            service.characteristics = characteristics
-            peripheralServices.append(service)
-        }
-        
-        peripheralManager?.removeAllServices()
-        for service in peripheralServices {
-            peripheralManager?.add(service)
-        }
-    }
-    
-    // MARK: - CBPeripheralManagerDelegate
-    extension HybridMunimBluetooth: CBPeripheralManagerDelegate {
     func peripheralManagerDidUpdateState(_ peripheral: CBPeripheralManager) {
         // Handle state updates
     }
     
     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
         ])
     }
     
@@ -470,7 +351,6 @@ extension HybridMunimBluetooth: CBCentralManagerDelegate {
         connectedPeripherals[deviceId] = peripheral
         peripheral.delegate = self
         
-        // Emit deviceConnected event
         eventEmitter?.emit("deviceConnected", ["id": deviceId])
     }
     
@@ -479,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"
@@ -495,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?) {
@@ -525,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?) {
@@ -554,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 ?? "",
@@ -569,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])
         }
     }
     
@@ -599,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.3",
+  "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",