react-native-ble-nitro 1.3.1 → 1.4.1

package/README.md

@@ -192,8 +192,7 @@ const data = await ble.readCharacteristic(deviceId, serviceUUID, characteristicU
 
 // Example: Reading battery level
 const batteryData = await ble.readCharacteristic(deviceId, '180f', '2a19');
-const batteryArray = new Uint8Array(batteryData);
-const batteryLevel = batteryArray[0]; // First byte is battery percentage
+const batteryLevel = batteryData[0]; // First byte is battery percentage
 console.log('Battery level:', batteryLevel + '%');
 ```
 
@@ -201,23 +200,26 @@ console.log('Battery level:', batteryLevel + '%');
 
 ```typescript
 // Write to a characteristic with response
-const data = new Uint8Array([0x01, 0x02, 0x03]);
-await ble.writeCharacteristic(
+const data = [0x01, 0x02, 0x03];
+const result = await ble.writeCharacteristic(
   deviceId, 
   serviceUUID, 
   characteristicUUID, 
-  data.buffer, // Data as ArrayBuffer
+  data, // Data as ArrayBuffer
   true // withResponse = true (default)
 );
+// result is array of integers (may be empty depending on characteristic)
+// Android returns the written data if withResponse=true and characteristic returns no data, on iOS it is an empty array
 
 // Write without response (faster, no confirmation)
-await ble.writeCharacteristic(
+const emptyResult = await ble.writeCharacteristic(
   deviceId, 
   serviceUUID, 
   characteristicUUID, 
-  data.buffer,
+  data,
   false // withResponse = false
 );
+// emptyResult is always empty array
 ```
 
 #### 📡 Characteristic Notifications
@@ -258,8 +260,7 @@ const subscription = ble.subscribeToCharacteristic(
   HEART_RATE_SERVICE,
   HEART_RATE_MEASUREMENT,
   (_, data) => {
-    const dataArray = new Uint8Array(data);
-    const heartRate = dataArray[1]; // Second byte contains BPM
+    const heartRate = data[1]; // Second byte contains BPM
     console.log('Heart rate:', heartRate, 'BPM');
   }
 );
@@ -279,8 +280,7 @@ const batteryData = await ble.readCharacteristic(
   BATTERY_SERVICE,
   BATTERY_LEVEL_CHARACTERISTIC
 );
-const batteryArray = new Uint8Array(batteryData);
-const batteryPercentage = batteryArray[0];
+const batteryPercentage = batteryData[0];
 console.log('Battery:', batteryPercentage + '%');
 ```
 
@@ -291,12 +291,12 @@ const CUSTOM_SERVICE = 'your-custom-service-uuid';
 const COMMAND_CHARACTERISTIC = 'your-command-characteristic-uuid';
 
 // Send a custom command
-const enableLedCommand = new Uint8Array([0x01, 0x1f, 0x01]); // Your protocol
+const enableLedCommand = [0x01, 0x1f, 0x01]; // Your protocol
 await ble.writeCharacteristic(
   deviceId,
   CUSTOM_SERVICE,
   COMMAND_CHARACTERISTIC,
-  enableLedCommand.buffer
+  enableLedCommand
 );
 ```
 
@@ -330,6 +330,30 @@ const fullUUIDs = BleNitro.normalizeGattUUIDs(['180d', '180f']);
 // Returns: ['0000180d-0000-1000-8000-00805f9b34fb', '0000180f-0000-1000-8000-00805f9b34fb']
 ```
 
+### iOS Restore State
+
+There are two ways to handle state restoration on iOS:
+
+```typescript
+// Enable state restoration in BleNitro singleton
+const ble = BleNitro.instance();
+ble.onRestoreState((peripherals) => {
+  console.log('Restored peripherals:', peripherals);
+});
+```
+
+```typescript
+// Or use BleNitroManager with options
+// This way you have to assure that only one instance of BleNitroManager is created and that you always use this instance.
+import { BleNitroManager, BLEDevice } from 'react-native-ble-nitro/manager';
+
+const customBleInstance = new BleNitroManager({
+  onRestoreState: (peripherals: BLEDevice[]) => {
+    console.log('Restored peripherals:', peripherals);
+  }
+});
+```
+
 ### TypeScript Types
 
 ```typescript

package/android/src/main/java/com/margelo/nitro/co/zyke/ble/BleNitroBleManager.kt

@@ -37,6 +37,7 @@ class BleNitroBleManager : HybridNativeBleNitroSpec() {
     private var bluetoothAdapter: BluetoothAdapter? = null
     private var stateCallback: ((state: BLEState) -> Unit)? = null
     private var bluetoothStateReceiver: BroadcastReceiver? = null
+    private var restoreStateCallback: ((devices: List<BLEDevice>) -> Unit)? = null
     
     // BLE Scanning
     private var bleScanner: BluetoothLeScanner? = null
@@ -49,6 +50,9 @@ class BleNitroBleManager : HybridNativeBleNitroSpec() {
     private val connectedDevices = ConcurrentHashMap<String, BluetoothGatt>()
     private val deviceCallbacks = ConcurrentHashMap<String, DeviceCallbacks>()
     
+    // Write callback storage for proper response handling (key: deviceId:characteristicId)
+    private val writeCallbacks = ConcurrentHashMap<String, (Boolean, ArrayBuffer, String) -> Unit>()
+    
     // Helper class to store device callbacks
     private data class DeviceCallbacks(
         var connectCallback: ((success: Boolean, deviceId: String, error: String) -> Unit)? = null,
@@ -279,7 +283,23 @@ class BleNitroBleManager : HybridNativeBleNitroSpec() {
             
             override fun onCharacteristicWrite(gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic, status: Int) {
                 // Handle characteristic write result
-                // This will be handled by pending operations
+                val deviceId = gatt.device.address
+                val characteristicId = characteristic.uuid.toString()
+                val callbackKey = "$deviceId:$characteristicId"
+                
+                writeCallbacks.remove(callbackKey)?.let { callback ->
+                    if (status == BluetoothGatt.GATT_SUCCESS) {
+                        // Get response data from characteristic value (may be null/empty for acknowledgments)
+                        val responseData = characteristic.value ?: byteArrayOf()
+                        val directBuffer = java.nio.ByteBuffer.allocateDirect(responseData.size)
+                        directBuffer.put(responseData)
+                        directBuffer.flip()
+                        val arrayBuffer = ArrayBuffer.wrap(directBuffer)
+                        callback(true, arrayBuffer, "")
+                    } else {
+                        callback(false, ArrayBuffer.allocate(0), "Write failed with status: $status")
+                    }
+                }
             }
             
             override fun onCharacteristicChanged(gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic) {
@@ -304,6 +324,11 @@ class BleNitroBleManager : HybridNativeBleNitroSpec() {
         }
     }
 
+    override fun setRestoreStateCallback(callback: (restoredPeripherals: Array<BLEDevice>) -> Unit) {
+        restoreStateCallback = { devices -> callback(devices.toTypedArray()) }
+        return
+    }
+
     // Scanning operations
     override fun startScan(filter: com.margelo.nitro.co.zyke.ble.ScanFilter, callback: (device: BLEDevice?, error: String?) -> Unit) {
         try {
@@ -640,24 +665,24 @@ class BleNitroBleManager : HybridNativeBleNitroSpec() {
         characteristicId: String,
         data: ArrayBuffer,
         withResponse: Boolean,
-        callback: (success: Boolean, error: String) -> Unit
+        callback: (success: Boolean, responseData: ArrayBuffer, error: String) -> Unit
     ) {
         try {
             val gatt = connectedDevices[deviceId]
             if (gatt == null) {
-                callback(false, "Device not connected")
+                callback(false, ArrayBuffer.allocate(0), "Device not connected")
                 return
             }
             
             val service = gatt.getService(UUID.fromString(serviceId))
             if (service == null) {
-                callback(false, "Service not found")
+                callback(false, ArrayBuffer.allocate(0), "Service not found")
                 return
             }
             
             val characteristic = service.getCharacteristic(UUID.fromString(characteristicId))
             if (characteristic == null) {
-                callback(false, "Characteristic not found")
+                callback(false, ArrayBuffer.allocate(0), "Characteristic not found")
                 return
             }
             
@@ -673,11 +698,27 @@ class BleNitroBleManager : HybridNativeBleNitroSpec() {
                 BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE
             }
             
+            if (withResponse) {
+                // Store callback for when response comes back
+                val callbackKey = "$deviceId:$characteristicId"
+                writeCallbacks[callbackKey] = callback
+            }
+            
             val success = gatt.writeCharacteristic(characteristic)
-            callback(success, if (success) "" else "Write operation failed")
+            
+            if (!withResponse) {
+                // For no response, call callback immediately
+                callback(success, ArrayBuffer.allocate(0), if (success) "" else "Write operation failed")
+            } else if (!success) {
+                // If write initiation failed, remove callback and notify
+                val callbackKey = "$deviceId:$characteristicId"
+                writeCallbacks.remove(callbackKey)
+                callback(false, ArrayBuffer.allocate(0), "Write operation failed to initiate")
+            }
+            // If withResponse and success, wait for onCharacteristicWrite
             
         } catch (e: Exception) {
-            callback(false, "Write error: ${e.message}")
+            callback(false, ArrayBuffer.allocate(0), "Write error: ${e.message}")
         }
     }
 

package/ios/BleNitroBleManager.swift

@@ -5,7 +5,13 @@ import NitroModules
  * iOS implementation of the BLE Nitro Manager
  * Implements the HybridNativeBleNitroSpec protocol for Core Bluetooth operations
  */
-public class BleNitroBleManager: HybridNativeBleNitroSpec {
+public class BleNitroBleManager: HybridNativeBleNitroSpec_base, HybridNativeBleNitroSpec_protocol {
+    
+    // MARK: - Constants
+    private static let restoreStateIdentifier = "react-native-ble-nitro"
+    
+    // MARK: - Static Properties
+    private static var globalRestoreStateCallback: (([BLEDevice]) -> Void)?
     
     // MARK: - Private Properties
     private var centralManager: CBCentralManager!
@@ -18,6 +24,9 @@ public class BleNitroBleManager: HybridNativeBleNitroSpec {
     private var isCurrentlyScanning = false
     private var currentScanFilter: ScanFilter?
     private var centralManagerDelegate: BleCentralManagerDelegate!
+    
+    // MARK: - Restore State Properties
+    private var restoreStateCallback: (([BLEDevice]) -> Void)?
 
     // MARK: - Initialization
     public override init() {
@@ -27,9 +36,16 @@ public class BleNitroBleManager: HybridNativeBleNitroSpec {
     
     private func setupCentralManager() {
         centralManagerDelegate = BleCentralManagerDelegate(manager: self)
-        centralManager = CBCentralManager(delegate: centralManagerDelegate, queue: DispatchQueue.main)
+        
+        // Create options dictionary for central manager with fixed restore identifier
+        let options: [String: Any] = [
+            CBCentralManagerOptionRestoreIdentifierKey: BleNitroBleManager.restoreStateIdentifier
+        ]
+        
+        centralManager = CBCentralManager(delegate: centralManagerDelegate, queue: DispatchQueue.main, options: options)
     }
     
+    
     // MARK: - State Management
     public func state() throws -> BLEState {
         let bleState = mapCBManagerStateToBLEState(centralManager.state)
@@ -54,6 +70,15 @@ public class BleNitroBleManager: HybridNativeBleNitroSpec {
         return OperationResult(success: true, error: nil)
     }
     
+    // MARK: - Restore State Management
+    public func setRestoreStateCallback(callback: @escaping ([BLEDevice]) -> Void) throws {
+        print("🔄 setRestoreStateCallback called")
+        // Set both static and instance variables
+        BleNitroBleManager.globalRestoreStateCallback = callback
+        self.restoreStateCallback = callback
+        print("🔄 Callback set successfully")
+    }
+    
     // MARK: - Scanning Operations
     public func startScan(filter: ScanFilter, callback: @escaping (BLEDevice?, String?) -> Void) throws {
         guard centralManager.state == .poweredOn else {
@@ -305,10 +330,11 @@ public class BleNitroBleManager: HybridNativeBleNitroSpec {
         characteristicId: String,
         data: ArrayBuffer,
         withResponse: Bool,
-        callback: @escaping (Bool, 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")
+            let emptyBuffer = try! ArrayBuffer.copy(data: Data())
+            callback(false, emptyBuffer, "Characteristic not found")
             return
         }
         
@@ -318,16 +344,20 @@ public class BleNitroBleManager: HybridNativeBleNitroSpec {
         if withResponse {
             // Ensure peripheral delegate exists for response handling
             guard let delegate = peripheralDelegates[deviceId] else {
-                callback(false, "Device not properly connected or delegate not found")
+                let emptyBuffer = try! ArrayBuffer.copy(data: Data())
+                callback(false, emptyBuffer, "Device not properly connected or delegate not found")
                 return
             }
             delegate.writeCallbacks[characteristic.uuid] = callback
+            // Store written data for comparison
+            delegate.writtenData[characteristic.uuid] = writeData
         }
         
         characteristic.service?.peripheral?.writeValue(writeData, for: characteristic, type: writeType)
         
         if !withResponse {
-            callback(true, "")
+            let emptyBuffer = try! ArrayBuffer.copy(data: Data())
+            callback(true, emptyBuffer, "")
         }
     }
     
@@ -407,6 +437,8 @@ public class BleNitroBleManager: HybridNativeBleNitroSpec {
               let characteristic = service.characteristics?.first(where: { $0.uuid == characteristicUUID }) else {
             return nil
         }
+        
+        
         return characteristic
     }
     
@@ -435,6 +467,59 @@ public class BleNitroBleManager: HybridNativeBleNitroSpec {
         stateChangeCallback?(state)
     }
     
+    internal func handleStateRestoration(_ dict: [String: Any]) {
+        // Restore connected peripherals
+        if let peripherals = dict[CBCentralManagerRestoredStatePeripheralsKey] as? [CBPeripheral] {
+            var restoredDevices: [BLEDevice] = []
+            
+            for peripheral in peripherals {
+                let deviceId = peripheral.identifier.uuidString
+                
+                // Add to our tracking dictionaries
+                discoveredPeripherals[deviceId] = peripheral
+                if peripheral.state == .connected {
+                    connectedPeripherals[deviceId] = peripheral
+                }
+                
+                // Create BLE device for the callback
+                let device = BLEDevice(
+                    id: deviceId,
+                    name: peripheral.name ?? "Restored Device",
+                    rssi: 0, // RSSI not available for restored peripherals
+                    manufacturerData: ManufacturerData(companyIdentifiers: []),
+                    serviceUUIDs: peripheral.services?.map { $0.uuid.uuidString } ?? [],
+                    isConnectable: true
+                )
+                restoredDevices.append(device)
+                
+                // Set up delegate for restored peripheral
+                let delegate = BlePeripheralDelegate(deviceId: deviceId, manager: self)
+                peripheralDelegates[deviceId] = delegate
+                peripheral.delegate = delegate
+            }
+            
+            // Call the restore state callback if set (prioritize static over instance)
+            let callback = BleNitroBleManager.globalRestoreStateCallback ?? restoreStateCallback
+            callback?(restoredDevices)
+        }
+        
+        // Restore scanning state if it was active
+        if let scanServiceUUIDs = dict[CBCentralManagerRestoredStateScanServicesKey] as? [CBUUID] {
+            // The system was scanning when the app was terminated
+            // We can choose to resume scanning or let the app decide
+            isCurrentlyScanning = true
+            
+            // Note: We don't automatically resume scanning here to give the app control
+            // The app can check isScanning() and decide whether to resume or stop
+        }
+        
+        // Restore scan options if available
+        if let scanOptions = dict[CBCentralManagerRestoredStateScanOptionsKey] as? [String: Any] {
+            // Store scan options for potential resume
+            // This information can be used if the app decides to resume scanning
+        }
+    }
+    
     internal func handleDeviceDiscovered(
         _ peripheral: CBPeripheral,
         advertisementData: [String: Any],
@@ -613,4 +698,8 @@ class BleCentralManagerDelegate: NSObject, CBCentralManagerDelegate {
     func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {
         manager?.handleDeviceDisconnected(peripheral, error: error)
     }
+    
+    func centralManager(_ central: CBCentralManager, willRestoreState dict: [String: Any]) {
+        manager?.handleStateRestoration(dict)
+    }
 }

package/ios/BlePeripheralDelegate.swift

@@ -21,10 +21,13 @@ class BlePeripheralDelegate: NSObject, CBPeripheralDelegate {
     
     // Operation callbacks - using CBUUID as key for reliable UUID matching
     var readCallbacks: [CBUUID: (Bool, ArrayBuffer, String) -> Void] = [:]
-    var writeCallbacks: [CBUUID: (Bool, String) -> Void] = [:]
+    var writeCallbacks: [CBUUID: (Bool, ArrayBuffer, String) -> Void] = [:]
     var subscriptionCallbacks: [CBUUID: (Bool, String) -> Void] = [:]
     var unsubscriptionCallbacks: [CBUUID: (Bool, String) -> Void] = [:]
     
+    // Store written data for comparison
+    var writtenData: [CBUUID: Data] = [:]
+    
     // Notification callbacks
     var notificationCallbacks: [CBUUID: (String, ArrayBuffer) -> Void] = [:]
     
@@ -133,11 +136,17 @@ class BlePeripheralDelegate: NSObject, CBPeripheralDelegate {
         // Handle write callback using CBUUID
         if let writeCallback = writeCallbacks[characteristicUUID] {
             if let error = error {
-                writeCallback(false, error.localizedDescription)
+                let emptyBuffer = try! ArrayBuffer.copy(data: Data())
+                writeCallback(false, emptyBuffer, error.localizedDescription)
             } else {
-                writeCallback(true, "")
+                // For write operations in iOS, didWriteValueFor indicates successful acknowledgment
+                // Check if characteristic value was updated (may contain response data or written data)
+                let responseData = characteristic.value ?? Data()
+                let responseBuffer = try! ArrayBuffer.copy(data: responseData)
+                writeCallback(true, responseBuffer, "")
             }
             writeCallbacks.removeValue(forKey: characteristicUUID)
+            writtenData.removeValue(forKey: characteristicUUID)
         }
     }
     
@@ -195,6 +204,7 @@ class BlePeripheralDelegate: NSObject, CBPeripheralDelegate {
         characteristicDiscoveryCallbacks.removeAll()
         readCallbacks.removeAll()
         writeCallbacks.removeAll()
+        writtenData.removeAll()
         subscriptionCallbacks.removeAll()
         unsubscriptionCallbacks.removeAll()
         notificationCallbacks.removeAll()

package/lib/commonjs/index.d.ts

@@ -1,196 +1,6 @@
-export type ByteArray = number[];
-export interface ScanFilter {
-    serviceUUIDs?: string[];
-    rssiThreshold?: number;
-    allowDuplicates?: boolean;
-    androidScanMode?: AndroidScanMode;
+import { BleNitroManager } from "./manager";
+export { type ByteArray, type ScanFilter, type BLEDevice, type ScanCallback, type ManufacturerDataEntry, type ManufacturerData, type ConnectionCallback, type DisconnectEventCallback, type OperationCallback, type CharacteristicUpdateCallback, type Subscription, type BleNitroManager, type BleNitroManagerOptions, BLEState, AndroidScanMode, } from "./manager";
+export declare class BleNitro extends BleNitroManager {
+    static instance(): BleNitroManager;
 }
-export interface ManufacturerDataEntry {
-    id: string;
-    data: ByteArray;
-}
-export interface ManufacturerData {
-    companyIdentifiers: ManufacturerDataEntry[];
-}
-export interface BLEDevice {
-    id: string;
-    name: string;
-    rssi: number;
-    manufacturerData: ManufacturerData;
-    serviceUUIDs: string[];
-    isConnectable: boolean;
-}
-export type ScanCallback = (device: BLEDevice) => void;
-export type RestoreStateCallback = (connectedPeripherals: 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: ByteArray) => void;
-export type Subscription = {
-    remove: () => void;
-};
-export declare enum BLEState {
-    Unknown = "Unknown",
-    Resetting = "Resetting",
-    Unsupported = "Unsupported",
-    Unauthorized = "Unauthorized",
-    PoweredOff = "PoweredOff",
-    PoweredOn = "PoweredOn"
-}
-export declare enum AndroidScanMode {
-    LowLatency = "LowLatency",
-    Balanced = "Balanced",
-    LowPower = "LowPower",
-    Opportunistic = "Opportunistic"
-}
-export type BleNitroOptions = {
-    restoreStateIdentifier?: string;
-    onRestoreState?: RestoreStateCallback;
-};
-export declare class BleNitro {
-    private _isScanning;
-    private _connectedDevices;
-    static instance(): BleNitro;
-    /**
-     * Converts a 16- oder 32-Bit UUID to a 128-Bit UUID
-     *
-     * @param uuid 16-, 32- or 128-Bit UUID as string
-     * @returns Full 128-Bit UUID
-     */
-    static normalizeGattUUID(uuid: string): string;
-    static normalizeGattUUIDs(uuids: string[]): string[];
-    /**
-     * Start scanning for Bluetooth devices
-     * @param filter Optional scan filter
-     * @param callback Callback function called when a device is found
-     * @returns Promise resolving to success state
-     */
-    startScan(filter: ScanFilter | undefined, callback: ScanCallback, onError?: (error: string) => void): void;
-    /**
-     * Stop scanning for Bluetooth devices
-     * @returns Promise resolving to success state
-     */
-    stopScan(): void;
-    /**
-     * Check if currently scanning for devices
-     * @returns Promise resolving to scanning state
-     */
-    isScanning(): boolean;
-    /**
-     * Get all currently connected devices
-     * @param services Optional list of service UUIDs to filter by
-     * @returns Array of connected devices
-     */
-    getConnectedDevices(services?: string[]): BLEDevice[];
-    /**
-     * Connect to a Bluetooth device
-     * @param deviceId ID of the device to connect to
-     * @param onDisconnect Optional callback for disconnect events
-     * @returns Promise resolving when connected
-     */
-    connect(deviceId: string, onDisconnect?: DisconnectEventCallback): Promise<string>;
-    /**
-     * Disconnect from a Bluetooth device
-     * @param deviceId ID of the device to disconnect from
-     * @returns Promise resolving when disconnected
-     */
-    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): 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
-     * @returns Promise resolving when services are discovered
-     */
-    discoverServices(deviceId: string): Promise<boolean>;
-    /**
-     * Get services for a connected device
-     * @param deviceId ID of the device
-     * @returns Promise resolving to array of service UUIDs
-     */
-    getServices(deviceId: string): Promise<string[]>;
-    /**
-     * Get characteristics for a service
-     * @param deviceId ID of the device
-     * @param serviceId ID of the service
-     * @returns Promise resolving to array of characteristic UUIDs
-     */
-    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 ArrayBuffer
-     */
-    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 ByteArray (number[])
-     * @param withResponse Whether to wait for response
-     * @returns Promise resolving when write is complete
-     */
-    writeCharacteristic(deviceId: string, serviceId: string, characteristicId: string, data: ByteArray, withResponse?: boolean): Promise<boolean>;
-    /**
-     * Subscribe to characteristic notifications
-     * @param deviceId ID of the device
-     * @param serviceId ID of the service
-     * @param characteristicId ID of the characteristic
-     * @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): Subscription;
-    /**
-     * Unsubscribe from characteristic notifications
-     * @param deviceId ID of the device
-     * @param serviceId ID of the service
-     * @param characteristicId ID of the characteristic
-     * @returns Promise resolving when unsubscription is complete
-     */
-    unsubscribeFromCharacteristic(deviceId: string, serviceId: string, characteristicId: string): Promise<void>;
-    /**
-     * Check if Bluetooth is enabled
-     * @returns Promise resolving to Bluetooth state
-     */
-    isBluetoothEnabled(): boolean;
-    /**
-     * Request to enable Bluetooth (Android only)
-     * @returns Promise resolving when Bluetooth is enabled
-     */
-    requestBluetoothEnable(): Promise<boolean>;
-    /**
-     * Get the current Bluetooth state
-     * @returns Promise resolving to Bluetooth state
-     * @see BLEState
-     */
-    state(): BLEState;
-    /**
-     * Subscribe to Bluetooth state changes
-     * @param callback Callback function called when state changes
-     * @param emitInitial Whether to emit initial state callback
-     * @returns Promise resolving when subscription is complete
-     * @see BLEState
-     */
-    subscribeToStateChange(callback: (state: BLEState) => void, emitInitial?: boolean): Subscription;
-    /**
-     * Open Bluetooth settings
-     * @returns Promise resolving when settings are opened
-     */
-    openSettings(): Promise<void>;
-}
-export declare const ble: BleNitro;
 //# sourceMappingURL=index.d.ts.map

package/lib/commonjs/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAE5C,OAAO,EACL,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,qBAAqB,EAC1B,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EACvB,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EACtB,KAAK,4BAA4B,EACjC,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,QAAQ,EACR,eAAe,GAChB,MAAM,WAAW,CAAC;AAInB,qBAAa,QAAS,SAAQ,eAAe;WAC7B,QAAQ;CAMvB"}