munim-bluetooth 0.3.7 → 0.3.10

package/ios/HybridMunimBluetooth.swift

@@ -10,7 +10,7 @@ import CoreBluetooth
 import NitroModules
 import React
 
-class HybridMunimBluetooth: HybridMunimBluetoothSpec, CBPeripheralManagerDelegate, CBCentralManagerDelegate, CBPeripheralDelegate {
+class HybridMunimBluetooth: HybridMunimBluetoothSpec {
     // Peripheral Manager
     private var peripheralManager: CBPeripheralManager?
     private var peripheralServices: [CBMutableService] = []
@@ -24,19 +24,15 @@ class HybridMunimBluetooth: HybridMunimBluetoothSpec, CBPeripheralManagerDelegat
     private var scanOptions: ScanOptions?
     private var isScanning = false
     
-    // Event emitter
-    private var eventEmitter: NitroEventEmitter?
-    
     override init() {
         super.init()
         peripheralManager = CBPeripheralManager(delegate: self, queue: nil)
         centralManager = CBCentralManager(delegate: self, queue: nil)
-        eventEmitter = NitroEventEmitter(moduleName: "MunimBluetooth")
     }
     
     // MARK: - Peripheral Features
     
-    func startAdvertising(options: AdvertisingOptions) 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"])
@@ -70,7 +66,7 @@ class HybridMunimBluetooth: HybridMunimBluetoothSpec, CBPeripheralManagerDelegat
         peripheralManager.startAdvertising(advertisingData as? [String: Any])
     }
     
-    func updateAdvertisingData(advertisingData: AdvertisingDataTypes) 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"])
@@ -85,18 +81,18 @@ class HybridMunimBluetooth: HybridMunimBluetoothSpec, CBPeripheralManagerDelegat
         peripheralManager.startAdvertising(newAdvertisingData as? [String: Any])
     }
     
-    func getAdvertisingData() throws -> Promise<AdvertisingDataTypes> {
+    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 = nil
     }
     
-    func setServices(services: [GATTService]) throws {
+    override func setServices(services: [GATTService]) throws {
         peripheralServices.removeAll()
         
         for service in services {
@@ -157,21 +153,21 @@ class HybridMunimBluetooth: HybridMunimBluetoothSpec, CBPeripheralManagerDelegat
     
     // MARK: - Central/Manager Features
     
-    func isBluetoothEnabled() throws -> Promise<Bool> {
+    override func isBluetoothEnabled() throws -> Promise<Bool> {
         return Promise { resolver in
             let isEnabled = self.centralManager?.state == .poweredOn
             resolver.resolve(isEnabled ?? false)
         }
     }
     
-    func requestBluetoothPermission() throws -> Promise<Bool> {
+    override func requestBluetoothPermission() throws -> Promise<Bool> {
         return Promise { resolver in
             // In iOS, permissions are handled by CBPeripheralManager/CBCentralManager
             resolver.resolve(true)
         }
     }
     
-    func startScan(options: ScanOptions?) 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"])
@@ -188,12 +184,12 @@ class HybridMunimBluetooth: HybridMunimBluetoothSpec, CBPeripheralManagerDelegat
         centralManager.scanForPeripherals(withServices: nil, options: scanOptions as [String : Any])
     }
     
-    func stopScan() throws {
+    override func stopScan() throws {
         centralManager?.stopScan()
         isScanning = false
     }
     
-    func connect(deviceId: String) throws -> Promise<Void> {
+    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"]))
@@ -206,13 +202,13 @@ class HybridMunimBluetooth: HybridMunimBluetoothSpec, CBPeripheralManagerDelegat
         }
     }
     
-    func disconnect(deviceId: String) throws {
+    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 -> Promise<[GATTService]> {
+    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"]))
@@ -224,33 +220,33 @@ class HybridMunimBluetooth: HybridMunimBluetoothSpec, CBPeripheralManagerDelegat
         }
     }
     
-    func readCharacteristic(deviceId: String, serviceUUID: String, characteristicUUID: String) throws -> Promise<CharacteristicValue> {
+    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"]))
         }
     }
     
-    func writeCharacteristic(deviceId: String, serviceUUID: String, characteristicUUID: String, value: String, writeType: WriteType?) throws -> Promise<Void> {
+    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"]))
         }
     }
     
-    func subscribeToCharacteristic(deviceId: String, serviceUUID: String, characteristicUUID: String) throws {
+    override func subscribeToCharacteristic(deviceId: String, serviceUUID: String, characteristicUUID: String) throws {
         // Not implemented
     }
     
-    func unsubscribeFromCharacteristic(deviceId: String, serviceUUID: String, characteristicUUID: String) throws {
+    override func unsubscribeFromCharacteristic(deviceId: String, serviceUUID: String, characteristicUUID: String) throws {
         // Not implemented
     }
     
-    func getConnectedDevices() throws -> Promise<[String]> {
+    override func getConnectedDevices() throws -> Promise<[String]> {
         return Promise { resolver in
             resolver.resolve(Array(self.connectedPeripherals.keys))
         }
     }
     
-    func readRSSI(deviceId: String) throws -> Promise<Double> {
+    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"]))
@@ -262,11 +258,11 @@ class HybridMunimBluetooth: HybridMunimBluetoothSpec, CBPeripheralManagerDelegat
         }
     }
     
-    func addListener(eventName: String) throws {
+    override func addListener(eventName: String) throws {
         // Event management
     }
     
-    func removeListeners(count: Double) throws {
+    override func removeListeners(count: Double) throws {
         // Event management
     }
     
@@ -306,44 +302,40 @@ class HybridMunimBluetooth: HybridMunimBluetoothSpec, CBPeripheralManagerDelegat
 }
 
 // MARK: - CBPeripheralManagerDelegate Implementation
-extension HybridMunimBluetooth {
+extension HybridMunimBluetooth: CBPeripheralManagerDelegate {
     func peripheralManagerDidUpdateState(_ peripheral: CBPeripheralManager) {
         // Handle state updates
     }
     
     func peripheralManagerDidStartAdvertising(_ peripheral: CBPeripheralManager, error: Error?) {
         if let error = error {
-            eventEmitter?.emit("advertisingError", ["error": error.localizedDescription])
+            NSLog("Bluetooth event")
         } else {
-            eventEmitter?.emit("advertisingStarted", [:])
+            NSLog("Bluetooth event")
         }
     }
     
     func peripheralManager(_ peripheral: CBPeripheralManager, didAdd service: CBService, error: Error?) {
         if let error = error {
-            eventEmitter?.emit("serviceError", ["error": error.localizedDescription])
+            NSLog("Bluetooth event")
         } else {
-            eventEmitter?.emit("serviceAdded", ["uuid": service.uuid.uuidString])
+            NSLog("Bluetooth event")
         }
     }
 }
 
 // MARK: - CBCentralManagerDelegate Implementation
-extension HybridMunimBluetooth {
+extension HybridMunimBluetooth: CBCentralManagerDelegate {
     func centralManagerDidUpdateState(_ central: CBCentralManager) {
         let state = central.state
-        eventEmitter?.emit("bluetoothStateChanged", ["state": state.rawValue])
+        NSLog("Bluetooth event")
     }
     
     func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String: Any], rssi RSSI: NSNumber) {
         let deviceId = peripheral.identifier.uuidString
         discoveredPeripherals[deviceId] = peripheral
         
-        eventEmitter?.emit("deviceFound", [
-            "id": deviceId,
-            "name": peripheral.name ?? "",
-            "rssi": RSSI.intValue
-        ])
+        NSLog("Bluetooth: deviceFound")
     }
     
     func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
@@ -351,7 +343,7 @@ extension HybridMunimBluetooth {
         connectedPeripherals[deviceId] = peripheral
         peripheral.delegate = self
         
-        eventEmitter?.emit("deviceConnected", ["id": deviceId])
+        NSLog("Bluetooth event")
     }
     
     func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {
@@ -359,20 +351,17 @@ extension HybridMunimBluetooth {
         connectedPeripherals.removeValue(forKey: deviceId)
         peripheralCharacteristics.removeValue(forKey: deviceId)
         
-        eventEmitter?.emit("deviceDisconnected", ["id": deviceId])
+        NSLog("Bluetooth event")
     }
     
     func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) {
         let deviceId = peripheral.identifier.uuidString
-        eventEmitter?.emit("connectionFailed", [
-            "id": deviceId,
-            "error": error?.localizedDescription ?? "Unknown error"
-        ])
+        NSLog("Bluetooth: connectionFailed")
     }
 }
 
 // MARK: - CBPeripheralDelegate Implementation
-extension HybridMunimBluetooth {
+extension HybridMunimBluetooth: CBPeripheralDelegate {
     func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
         let deviceId = peripheral.identifier.uuidString
         
@@ -382,7 +371,7 @@ extension HybridMunimBluetooth {
             peripheral.discoverCharacteristics(nil, for: service)
         }
         
-        eventEmitter?.emit("servicesDiscovered", ["id": deviceId])
+        NSLog("Bluetooth event")
     }
     
     func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
@@ -395,7 +384,7 @@ extension HybridMunimBluetooth {
         }
         peripheralCharacteristics[deviceId]?.append(contentsOf: characteristics)
         
-        eventEmitter?.emit("characteristicsDiscovered", ["id": deviceId])
+        NSLog("Bluetooth event")
     }
     
     func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
@@ -405,24 +394,16 @@ extension HybridMunimBluetooth {
         
         let hexString = data.map { String(format: "%02x", $0) }.joined()
         
-        eventEmitter?.emit("characteristicValueChanged", [
-            "id": deviceId,
-            "serviceUUID": characteristic.service?.uuid.uuidString ?? "",
-            "characteristicUUID": characteristic.uuid.uuidString,
-            "value": hexString
-        ])
+        NSLog("Bluetooth: characteristicValueChanged")
     }
     
     func peripheral(_ peripheral: CBPeripheral, didWriteValueFor characteristic: CBCharacteristic, error: Error?) {
         let deviceId = peripheral.identifier.uuidString
         
         if let error = error {
-            eventEmitter?.emit("writeError", [
-                "id": deviceId,
-                "error": error.localizedDescription
-            ])
+            NSLog("Bluetooth: writeError")
         } else {
-            eventEmitter?.emit("writeSuccess", ["id": deviceId])
+            NSLog("Bluetooth event")
         }
     }
     
@@ -430,40 +411,9 @@ extension HybridMunimBluetooth {
         let deviceId = peripheral.identifier.uuidString
         
         if let error = error {
-            eventEmitter?.emit("rssiError", ["error": error.localizedDescription])
-        } else {
-            eventEmitter?.emit("rssiUpdated", ["id": deviceId, "rssi": RSSI.intValue])
-        }
-    }
-}
-
-// MARK: - Helper Classes
-class NitroEventEmitter {
-    private let moduleName: String
-    
-    init(moduleName: String) {
-        self.moduleName = moduleName
-    }
-    
-    func emit(_ eventName: String, _ body: [String: Any]) {
-        let sendEvent = {
-            guard let bridge = RCTBridge.current() ?? RCTBridge.currentBridge() else {
-                NSLog("[\(self.moduleName)] Unable to emit event \(eventName): missing bridge")
-                return
-            }
-            
-            bridge.enqueueJSCall(
-                "RCTDeviceEventEmitter",
-                method: "emit",
-                args: [eventName, body],
-                completion: nil
-            )
-        }
-        
-        if Thread.isMainThread {
-            sendEvent()
+            NSLog("Bluetooth event")
         } else {
-            DispatchQueue.main.async(execute: sendEvent)
+            NSLog("Bluetooth event")
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "munim-bluetooth",
-  "version": "0.3.7",
+  "version": "0.3.10",
   "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",