react-native-ble-nitro 1.0.0 → 1.2.0

package/README.md

@@ -5,7 +5,7 @@
 
 A high-performance React Native BLE library built on [Nitro Modules](https://nitro.margelo.com/).
 
-Originally developed for [Zyke Band](https://zykeband.com) - a fitness and health tracker created by a small team.
+Originally developed for [Zyke Band](https://zykeband.com?utm_source=github&utm_medium=readme&utm_campaign=opensource) - a fitness and health tracker created by a small team.
 
 ## ✨ Features
 
@@ -83,22 +83,22 @@ const ble = BleNitro.instance();
 
 ```typescript
 // Check if Bluetooth is enabled
-const isEnabled = await ble.isBluetoothEnabled();
+const isEnabled = ble.isBluetoothEnabled();
 
 // Get current Bluetooth state
-const state = await ble.state();
+const state = ble.state();
 // Returns: BLEState.PoweredOn, BLEState.PoweredOff, etc.
 
 // Request to enable Bluetooth (Android only)
 await ble.requestBluetoothEnable();
 
 // Subscribe to state changes
-const subscription = await ble.subscribeToStateChange((state) => {
+const subscription = ble.subscribeToStateChange((state) => {
   console.log('Bluetooth state changed:', state);
 }, true); // true = emit initial state
 
 // Unsubscribe from state changes
-await subscription.remove();
+subscription.remove();
 
 // Open Bluetooth settings
 await ble.openSettings();
@@ -108,7 +108,7 @@ await ble.openSettings();
 
 ```typescript
 // Start scanning for devices
-await ble.startScan({
+ble.startScan({
   serviceUUIDs: ['180d'], // Optional: filter by service UUIDs
   rssiThreshold: -80,     // Optional: minimum signal strength
   allowDuplicates: false  // Optional: allow duplicate discoveries
@@ -117,13 +117,13 @@ await ble.startScan({
 });
 
 // Stop scanning
-await ble.stopScan();
+ble.stopScan();
 
 // Check if currently scanning
-const isScanning = await ble.isScanning();
+const isScanning = ble.isScanning();
 
 // Get already connected devices
-const connectedDevices = await ble.getConnectedDevices();
+const connectedDevices = ble.getConnectedDevices(['180d']); // Optional: filter by service UUIDs
 ```
 
 #### 🔗 Device Connection
@@ -147,7 +147,11 @@ const deviceId = await ble.connect(deviceId);
 await ble.disconnect(deviceId);
 
 // Check connection status
-const isConnected = await ble.isConnected(deviceId);
+const isConnected = ble.isConnected(deviceId);
+
+// MTU negotiation (Android only, as iOS manages MTU automatically)
+// iOS returns current MTU size
+const mtu = await ble.requestMTU(deviceId, 256); // Request MTU size
 ```
 
 #### 🔧 Service Discovery
@@ -162,13 +166,13 @@ const services = await ble.getServices(deviceId);
 // Always returns full 128-bit UUIDs
 
 // Get characteristics for a service
-const characteristics = await ble.getCharacteristics(deviceId, serviceUUID);
+const characteristics = ble.getCharacteristics(deviceId, serviceUUID);
 // Returns: ['00002a37-0000-1000-8000-00805f9b34fb', '00002a38-0000-1000-8000-00805f9b34fb', ...] 
 // Always returns full 128-bit UUIDs
 
 // Note: You can use either short or long form UUIDs as input:
-const characteristics1 = await ble.getCharacteristics(deviceId, '180d'); // Short form
-const characteristics2 = await ble.getCharacteristics(deviceId, '0000180d-0000-1000-8000-00805f9b34fb'); // Long form
+const characteristics1 = ble.getCharacteristics(deviceId, '180d'); // Short form
+const characteristics2 = ble.getCharacteristics(deviceId, '0000180d-0000-1000-8000-00805f9b34fb'); // Long form
 // Both work identically - conversion handled automatically
 ```
 
@@ -211,7 +215,7 @@ await ble.writeCharacteristic(
 
 ```typescript
 // Subscribe to characteristic notifications
-const subscription = await ble.subscribeToCharacteristic(
+const subscription = ble.subscribeToCharacteristic(
   deviceId,
   serviceUUID,
   characteristicUUID,
@@ -222,7 +226,7 @@ const subscription = await ble.subscribeToCharacteristic(
 );
 
 // Unsubscribe from notifications
-await subscription.remove();
+subscription.remove();
 
 // Or unsubscribe directly
 await ble.unsubscribeFromCharacteristic(deviceId, serviceUUID, characteristicUUID);
@@ -240,7 +244,7 @@ const HEART_RATE_MEASUREMENT = '2a37';
 const deviceId = await ble.connect(heartRateDeviceId);
 await ble.discoverServices(deviceId);
 
-const subscription = await ble.subscribeToCharacteristic(
+const subscription = ble.subscribeToCharacteristic(
   deviceId,
   HEART_RATE_SERVICE,
   HEART_RATE_MEASUREMENT,
@@ -249,6 +253,9 @@ const subscription = await ble.subscribeToCharacteristic(
     console.log('Heart rate:', heartRate, 'BPM');
   }
 );
+
+// Unsubscribe when done
+subscription.remove();
 ```
 
 #### Battery Level Reading
@@ -478,10 +485,11 @@ MIT License - see [LICENSE](./LICENSE) file.
 
 ## 🙏 Acknowledgments
 
-- [Zyke Band](https://zykeband.com) - The fitness tracker project that inspired this library
+- [Zyke Band](https://zykeband.com?utm_source=github&utm_medium=readme&utm_campaign=opensource) - The fitness tracker project that inspired this library
 - [Marc Rousavy](https://github.com/mrousavy) - Creator of Nitro Modules and CEO of Margelo
 - [Nitro Modules](https://nitro.margelo.com/) - High-performance native module framework
 - [Margelo](https://margelo.com/) - Nitro Modules creators
+- [Alvinotuya84](https://github.com/Alvinotuya84) - For the API inspiration I took from his repo [react-native-bluetooth-nitro-nexus](https://github.com/Alvinotuya84/react-native-bluetooth-nitro-nexus)
 
 ## 📞 Support
 

package/ios/BleNitroBleManager.swift

@@ -1,7 +1,6 @@
 import Foundation
 import CoreBluetooth
 import NitroModules
-
 /**
  * iOS implementation of the BLE Nitro Manager
  * Implements the HybridNativeBleNitroSpec protocol for Core Bluetooth operations
@@ -19,7 +18,7 @@ public class BleNitroBleManager: HybridNativeBleNitroSpec {
     private var isCurrentlyScanning = false
     private var currentScanFilter: ScanFilter?
     private var centralManagerDelegate: BleCentralManagerDelegate!
-    
+
     // MARK: - Initialization
     public override init() {
         super.init()
@@ -32,39 +31,27 @@ public class BleNitroBleManager: HybridNativeBleNitroSpec {
     }
     
     // MARK: - State Management
-    public func state(callback: @escaping (BLEState) -> Void) throws {
+    public func state() throws -> BLEState {
         let bleState = mapCBManagerStateToBLEState(centralManager.state)
-        callback(bleState)
-    }
-    
-    public func isBluetoothEnabled(callback: @escaping (Bool) -> Void) throws {
-        let isEnabled = centralManager.state == .poweredOn
-        callback(isEnabled)
+        return bleState
     }
     
     public func requestBluetoothEnable(callback: @escaping (Bool, String) -> Void) throws {
         // iOS doesn't allow programmatic Bluetooth enabling
         // We can only check the current state
-        if centralManager.state == .poweredOn {
-            callback(true, "")
-        } else {
-            callback(false, "Bluetooth must be enabled manually in Settings")
-        }
+        callback(false, "Not supported")
     }
     
     public func subscribeToStateChange(
-        stateCallback: @escaping (BLEState) -> Void,
-        resultCallback: @escaping (Bool, String) -> Void
-    ) throws {
+        stateCallback: @escaping (BLEState) -> Void
+    ) throws -> OperationResult {
         self.stateChangeCallback = stateCallback
-        resultCallback(true, "")
+        return OperationResult(success: true, error: nil)
     }
 
-    public func unsubscribeFromStateChange(
-        resultCallback: @escaping (Bool, String) -> Void
-    ) throws {
+    public func unsubscribeFromStateChange() throws -> OperationResult {
         self.stateChangeCallback = nil
-        resultCallback(true, "")
+        return OperationResult(success: true, error: nil)
     }
     
     // MARK: - Scanning Operations
@@ -91,25 +78,25 @@ public class BleNitroBleManager: HybridNativeBleNitroSpec {
         centralManager.scanForPeripherals(withServices: serviceUUIDs, options: options)
     }
     
-    public func stopScan(callback: @escaping (Bool, String) -> Void) throws {
+    public func stopScan() throws -> Bool {
         centralManager.stopScan()
         isCurrentlyScanning = false
         scanCallback = nil
         currentScanFilter = nil
         // Keep discovered peripherals for potential connections
-        callback(true, "")
+        return true
     }
     
-    public func isScanning(callback: @escaping (Bool) -> Void) throws {
-        callback(isCurrentlyScanning)
+    public func isScanning() throws -> Bool {
+        return isCurrentlyScanning
     }
     
     // MARK: - Device Discovery
-    public func getConnectedDevices(callback: @escaping ([BLEDevice]) -> Void) throws {
+    public func getConnectedDevices(services: [String]) throws -> [BLEDevice] {
         var connectedDevices: [BLEDevice] = []
         
+        // First check our tracked connected peripherals
         for (deviceId, peripheral) in connectedPeripherals {
-            // Create BLEDevice from connected peripheral
             let device = BLEDevice(
                 id: deviceId,
                 name: peripheral.name ?? "Unknown Device",
@@ -121,7 +108,58 @@ public class BleNitroBleManager: HybridNativeBleNitroSpec {
             connectedDevices.append(device)
         }
         
-        callback(connectedDevices)
+        // 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
+            }
+            
+            // 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
+            }
+        }
+        
+        // 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
+                }
+            }
+        }
+        
+        return connectedDevices
     }
     
     // MARK: - Connection Management
@@ -164,12 +202,20 @@ public class BleNitroBleManager: HybridNativeBleNitroSpec {
         centralManager.cancelPeripheralConnection(peripheral)
     }
     
-    public func isConnected(deviceId: String, callback: @escaping (Bool) -> Void) throws {
+    public func isConnected(deviceId: String) throws -> Bool {
         if let peripheral = connectedPeripherals[deviceId] {
-            callback(peripheral.state == .connected)
+            return peripheral.state == .connected
         } else {
-            callback(false)
+            return false
+        }
+    }
+    
+    public func requestMTU(deviceId: String, mtu: Double) throws -> Double {
+        guard let peripheral = connectedPeripherals[deviceId] else {
+            return Double(-1)
         }
+        
+        return Double(peripheral.maximumWriteValueLength(for: .withoutResponse))
     }
     
     // MARK: - Service Discovery
@@ -183,35 +229,31 @@ public class BleNitroBleManager: HybridNativeBleNitroSpec {
         peripheral.discoverServices(nil)
     }
     
-    public func getServices(deviceId: String, callback: @escaping ([String]) -> Void) throws {
+    public func getServices(deviceId: String) throws -> [String] {
         guard let peripheral = connectedPeripherals[deviceId] else {
-            callback([])
-            return
+            return []
         }
         
         let serviceUUIDs = peripheral.services?.map { $0.uuid.uuidString } ?? []
-        callback(serviceUUIDs)
+        return serviceUUIDs
     }
     
     public func getCharacteristics(
         deviceId: String,
         serviceId: String,
-        callback: @escaping ([String]) -> Void
-    ) throws {
+    ) throws -> [String] {
         guard let peripheral = connectedPeripherals[deviceId] else {
-            callback([])
-            return
+            return []
         }
         
         // Find service using CBUUID comparison
         let serviceUUID = CBUUID(string: serviceId)
         guard let service = peripheral.services?.first(where: { $0.uuid == serviceUUID }) else {
-            callback([])
-            return
+            return []
         }
         
         let characteristicUUIDs = service.characteristics?.map { $0.uuid.uuidString } ?? []
-        callback(characteristicUUIDs)
+        return characteristicUUIDs
     }
     
     // MARK: - Characteristic Operations
@@ -219,16 +261,30 @@ public class BleNitroBleManager: HybridNativeBleNitroSpec {
         deviceId: String,
         serviceId: String,
         characteristicId: String,
-        callback: @escaping (Bool, [Double], String) -> Void
+        callback: @escaping (Bool, ArrayBuffer, String) -> Void
     ) throws {
         guard let characteristic = findCharacteristic(deviceId: deviceId, serviceId: serviceId, characteristicId: characteristicId) else {
-            callback(false, [], "Characteristic not found")
+            do {
+                let emptyData = Data(capacity: 0)
+                let emptyBuffer = try ArrayBuffer.copy(data: emptyData)
+                callback(false, emptyBuffer, "Characteristic not found")
+            } catch {
+                let emptyBuffer = try! ArrayBuffer.copy(data: Data())
+                callback(false, emptyBuffer, "Characteristic not found")
+            }
             return
         }
         
         // Ensure peripheral delegate exists
         guard let delegate = peripheralDelegates[deviceId] else {
-            callback(false, [], "Device not properly connected or delegate not found")
+            do {
+                let emptyData = Data(capacity: 0)
+                let emptyBuffer = try ArrayBuffer.copy(data: emptyData)
+                callback(false, emptyBuffer, "Device not properly connected or delegate not found")
+            } catch {
+                let emptyBuffer = try! ArrayBuffer.copy(data: Data())
+                callback(false, emptyBuffer, "Device not properly connected or delegate not found")
+            }
             return
         }
         
@@ -243,7 +299,7 @@ public class BleNitroBleManager: HybridNativeBleNitroSpec {
         deviceId: String,
         serviceId: String,
         characteristicId: String,
-        data: [Double],
+        data: ArrayBuffer,
         withResponse: Bool,
         callback: @escaping (Bool, String) -> Void
     ) throws {
@@ -252,7 +308,7 @@ public class BleNitroBleManager: HybridNativeBleNitroSpec {
             return
         }
         
-        let writeData = Data(data.map { UInt8($0) })
+        let writeData = data.toData(copyIfNeeded: true)
         let writeType: CBCharacteristicWriteType = withResponse ? .withResponse : .withoutResponse
         
         if withResponse {
@@ -275,7 +331,7 @@ public class BleNitroBleManager: HybridNativeBleNitroSpec {
         deviceId: String,
         serviceId: String,
         characteristicId: String,
-        updateCallback: @escaping (String, [Double]) -> Void,
+        updateCallback: @escaping (String, ArrayBuffer) -> Void,
         resultCallback: @escaping (Bool, String) -> Void
     ) throws {
         guard let characteristic = findCharacteristic(deviceId: deviceId, serviceId: serviceId, characteristicId: characteristicId) else {
@@ -485,17 +541,30 @@ public class BleNitroBleManager: HybridNativeBleNitroSpec {
         }
         
         let companyId = manufacturerDataRaw.prefix(2).withUnsafeBytes { $0.load(as: UInt16.self) }
-        let data = Array(manufacturerDataRaw.dropFirst(2)).map { Double($0) }
+        let dataBytes = Data(manufacturerDataRaw.dropFirst(2))
         
-        let entry = ManufacturerDataEntry(
-            id: String(companyId),
-            data: data
-        )
-        
-        return ManufacturerData(companyIdentifiers: [entry])
+        do {
+            let capacityData = Data(capacity: dataBytes.count)
+            let finalData = capacityData + dataBytes
+            let arrayBuffer = try ArrayBuffer.copy(data: finalData)
+            
+            let entry = ManufacturerDataEntry(
+                id: String(companyId),
+                data: arrayBuffer
+            )
+            
+            return ManufacturerData(companyIdentifiers: [entry])
+        } catch {
+            let emptyBuffer = try! ArrayBuffer.copy(data: Data())
+            let entry = ManufacturerDataEntry(
+                id: String(companyId),
+                data: emptyBuffer
+            )
+            return ManufacturerData(companyIdentifiers: [entry])
+        }
     }
 
-    public func openSettings() throws -> NitroModules.Promise<Void> {
+    public func openSettings() throws -> Promise<Void> {
         return Promise.async {
             if let url = URL(string: UIApplication.openSettingsURLString) {
                 // Ask the system to open that URL.

package/ios/BlePeripheralDelegate.swift

@@ -20,13 +20,13 @@ class BlePeripheralDelegate: NSObject, CBPeripheralDelegate {
     var characteristicDiscoveryCallbacks: [String: (Bool, String) -> Void] = [:]
     
     // Operation callbacks - using CBUUID as key for reliable UUID matching
-    var readCallbacks: [CBUUID: (Bool, [Double], String) -> Void] = [:]
+    var readCallbacks: [CBUUID: (Bool, ArrayBuffer, String) -> Void] = [:]
     var writeCallbacks: [CBUUID: (Bool, String) -> Void] = [:]
     var subscriptionCallbacks: [CBUUID: (Bool, String) -> Void] = [:]
     var unsubscriptionCallbacks: [CBUUID: (Bool, String) -> Void] = [:]
     
     // Notification callbacks
-    var notificationCallbacks: [CBUUID: (String, [Double]) -> Void] = [:]
+    var notificationCallbacks: [CBUUID: (String, ArrayBuffer) -> Void] = [:]
     
     // MARK: - Initialization
     init(deviceId: String, manager: BleNitroBleManager) {
@@ -76,12 +76,33 @@ class BlePeripheralDelegate: NSObject, CBPeripheralDelegate {
         // Handle read callback using CBUUID - no normalization needed
         if let readCallback = readCallbacks[characteristicUUID] {
             if let error = error {
-                readCallback(false, [], error.localizedDescription)
+                do {
+                    let emptyData = Data(capacity: 0)
+                    let emptyBuffer = try ArrayBuffer.copy(data: emptyData)
+                    readCallback(false, emptyBuffer, error.localizedDescription)
+                } catch {
+                    let emptyBuffer = try! ArrayBuffer.copy(data: Data())
+                    readCallback(false, emptyBuffer, error.localizedDescription)
+                }
             } else if let data = characteristic.value {
-                let doubleArray = data.map { Double($0) }
-                readCallback(true, doubleArray, "")
+                do {
+                    let capacityData = Data(capacity: data.count)
+                    let finalData = capacityData + data
+                    let arrayBuffer = try ArrayBuffer.copy(data: finalData)
+                    readCallback(true, arrayBuffer, "")
+                } catch {
+                    let emptyBuffer = try! ArrayBuffer.copy(data: Data())
+                    readCallback(false, emptyBuffer, "Failed to create ArrayBuffer")
+                }
             } else {
-                readCallback(false, [], "No data received")
+                do {
+                    let emptyData = Data(capacity: 0)
+                    let emptyBuffer = try ArrayBuffer.copy(data: emptyData)
+                    readCallback(false, emptyBuffer, "No data received")
+                } catch {
+                    let emptyBuffer = try! ArrayBuffer.copy(data: Data())
+                    readCallback(false, emptyBuffer, "No data received")
+                }
             }
             readCallbacks.removeValue(forKey: characteristicUUID)
         }
@@ -89,8 +110,15 @@ class BlePeripheralDelegate: NSObject, CBPeripheralDelegate {
         // Handle notification callback using CBUUID
         if let notificationCallback = notificationCallbacks[characteristicUUID],
            let data = characteristic.value {
-            let doubleArray = data.map { Double($0) }
-            notificationCallback(characteristicUUID.uuidString, doubleArray)
+            do {
+                let capacityData = Data(capacity: data.count)
+                let finalData = capacityData + data
+                let arrayBuffer = try ArrayBuffer.copy(data: finalData)
+                notificationCallback(characteristicUUID.uuidString, arrayBuffer)
+            } catch {
+                let emptyBuffer = try! ArrayBuffer.copy(data: Data())
+                notificationCallback(characteristicUUID.uuidString, emptyBuffer)
+            }
         }
     }
     

package/lib/commonjs/index.d.ts

@@ -1,3 +1,4 @@
+export type ByteArray = number[];
 export interface ScanFilter {
     serviceUUIDs?: string[];
     rssiThreshold?: number;
@@ -5,7 +6,7 @@ export interface ScanFilter {
 }
 export interface ManufacturerDataEntry {
     id: string;
-    data: number[];
+    data: ByteArray;
 }
 export interface ManufacturerData {
     companyIdentifiers: ManufacturerDataEntry[];
@@ -22,9 +23,9 @@ export type ScanCallback = (device: BLEDevice) => void;
 export type ConnectionCallback = (success: boolean, deviceId: string, error: string) => void;
 export type DisconnectEventCallback = (deviceId: string, interrupted: boolean, error: string) => void;
 export type OperationCallback = (success: boolean, error: string) => void;
-export type CharacteristicUpdateCallback = (characteristicId: string, data: number[]) => void;
+export type CharacteristicUpdateCallback = (characteristicId: string, data: ByteArray) => void;
 export type Subscription = {
-    remove: () => Promise<void>;
+    remove: () => void;
 };
 export declare enum BLEState {
     Unknown = "Unknown",
@@ -52,22 +53,23 @@ export declare class BleNitro {
      * @param callback Callback function called when a device is found
      * @returns Promise resolving to success state
      */
-    startScan(filter: ScanFilter | undefined, callback: ScanCallback): Promise<boolean>;
+    startScan(filter: ScanFilter | undefined, callback: ScanCallback): void;
     /**
      * Stop scanning for Bluetooth devices
      * @returns Promise resolving to success state
      */
-    stopScan(): Promise<boolean>;
+    stopScan(): void;
     /**
      * Check if currently scanning for devices
      * @returns Promise resolving to scanning state
      */
-    isScanning(): Promise<boolean>;
+    isScanning(): boolean;
     /**
      * Get all currently connected devices
-     * @returns Promise resolving to array of connected devices
+     * @param services Optional list of service UUIDs to filter by
+     * @returns Array of connected devices
      */
-    getConnectedDevices(): Promise<BLEDevice[]>;
+    getConnectedDevices(services?: string[]): BLEDevice[];
     /**
      * Connect to a Bluetooth device
      * @param deviceId ID of the device to connect to
@@ -80,13 +82,20 @@ export declare class BleNitro {
      * @param deviceId ID of the device to disconnect from
      * @returns Promise resolving when disconnected
      */
-    disconnect(deviceId: string): Promise<boolean>;
+    disconnect(deviceId: string): Promise<void>;
     /**
      * Check if connected to a device
      * @param deviceId ID of the device to check
      * @returns Promise resolving to connection state
      */
-    isConnected(deviceId: string): Promise<boolean>;
+    isConnected(deviceId: string): boolean;
+    /**
+     * Request a new MTU size
+     * @param deviceId ID of the device
+     * @param mtu New MTU size, min is 23, max is 517
+     * @returns On Android: new MTU size; on iOS: current MTU size as it is handled by iOS itself; on error: -1
+     */
+    requestMTU(deviceId: string, mtu: number): number;
     /**
      * Discover services for a connected device
      * @param deviceId ID of the device
@@ -105,25 +114,25 @@ export declare class BleNitro {
      * @param serviceId ID of the service
      * @returns Promise resolving to array of characteristic UUIDs
      */
-    getCharacteristics(deviceId: string, serviceId: string): Promise<string[]>;
+    getCharacteristics(deviceId: string, serviceId: string): string[];
     /**
      * Read a characteristic value
      * @param deviceId ID of the device
      * @param serviceId ID of the service
      * @param characteristicId ID of the characteristic
-     * @returns Promise resolving to the characteristic data as byte array
+     * @returns Promise resolving to the characteristic data as ByteArray
      */
-    readCharacteristic(deviceId: string, serviceId: string, characteristicId: string): Promise<number[]>;
+    readCharacteristic(deviceId: string, serviceId: string, characteristicId: string): Promise<ByteArray>;
     /**
      * Write a value to a characteristic
      * @param deviceId ID of the device
      * @param serviceId ID of the service
      * @param characteristicId ID of the characteristic
-     * @param data Data to write as an array of bytes
+     * @param data Data to write as ByteArray(number[])
      * @param withResponse Whether to wait for response
      * @returns Promise resolving when write is complete
      */
-    writeCharacteristic(deviceId: string, serviceId: string, characteristicId: string, data: number[], withResponse?: boolean): Promise<boolean>;
+    writeCharacteristic(deviceId: string, serviceId: string, characteristicId: string, data: ByteArray, withResponse?: boolean): Promise<boolean>;
     /**
      * Subscribe to characteristic notifications
      * @param deviceId ID of the device
@@ -132,7 +141,7 @@ export declare class BleNitro {
      * @param callback Callback function called when notification is received
      * @returns Promise resolving when subscription is complete
      */
-    subscribeToCharacteristic(deviceId: string, serviceId: string, characteristicId: string, callback: CharacteristicUpdateCallback): Promise<Subscription>;
+    subscribeToCharacteristic(deviceId: string, serviceId: string, characteristicId: string, callback: CharacteristicUpdateCallback): Subscription;
     /**
      * Unsubscribe from characteristic notifications
      * @param deviceId ID of the device
@@ -145,9 +154,9 @@ export declare class BleNitro {
      * Check if Bluetooth is enabled
      * @returns Promise resolving to Bluetooth state
      */
-    isBluetoothEnabled(): Promise<boolean>;
+    isBluetoothEnabled(): boolean;
     /**
-     * Request to enable Bluetooth
+     * Request to enable Bluetooth (Android only)
      * @returns Promise resolving when Bluetooth is enabled
      */
     requestBluetoothEnable(): Promise<boolean>;
@@ -156,7 +165,7 @@ export declare class BleNitro {
      * @returns Promise resolving to Bluetooth state
      * @see BLEState
      */
-    state(): Promise<BLEState>;
+    state(): BLEState;
     /**
      * Subscribe to Bluetooth state changes
      * @param callback Callback function called when state changes
@@ -164,7 +173,7 @@ export declare class BleNitro {
      * @returns Promise resolving when subscription is complete
      * @see BLEState
      */
-    subscribeToStateChange(callback: (state: BLEState) => void, emitInitial?: boolean): Promise<Subscription>;
+    subscribeToStateChange(callback: (state: BLEState) => void, emitInitial?: boolean): Subscription;
     /**
      * Open Bluetooth settings
      * @returns Promise resolving when settings are opened