react-native-ble-nitro 1.0.0-beta.0 → 1.0.0-beta.10

package/android/build.gradle

@@ -36,6 +36,9 @@ android {
     }
 }
 
+// Apply Nitro autolinking
+apply from: '../nitrogen/generated/android/BleNitro+autolinking.gradle'
+
 dependencies {
     implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
     implementation 'androidx.core:core-ktx:1.9.0'

package/android/src/main/kotlin/{co → com/margelo/nitro/co}/zyke/ble/BleNitroBleManager.kt

@@ -4,7 +4,7 @@
  * Copyright © 2025 Zyke (https://zyke.co)
  */
 
-package co.zyke.ble
+package com.margelo.nitro.co.zyke.ble
 
 import android.bluetooth.*
 import android.bluetooth.le.*
@@ -15,6 +15,7 @@ import android.util.Base64
 import android.util.Log
 import androidx.core.content.ContextCompat
 import com.facebook.react.bridge.ReactApplicationContext
+import com.margelo.nitro.co.zyke.ble.HybridBleManagerSpec
 import com.margelo.nitro.NitroModules
 import kotlinx.coroutines.*
 import kotlinx.coroutines.channels.Channel
@@ -33,7 +34,12 @@ import com.margelo.nitro.co.zyke.ble.*
  * Core BLE Manager implementation using Android BLE APIs
  * Implements the HybridBleManagerSpec interface generated by Nitro
  */
-class BleNitroBleManager(private val context: ReactApplicationContext) : HybridBleManagerSpec {
+class BleNitroBleManager : HybridBleManagerSpec {
+    
+    // Get context from Nitro's context system
+    private val context: ReactApplicationContext by lazy {
+        NitroModules.getReactApplicationContext()
+    }
     
     companion object {
         private const val TAG = "BleNitroBleManager"
@@ -57,6 +63,11 @@ class BleNitroBleManager(private val context: ReactApplicationContext) : HybridB
     private var logLevel: LogLevel = LogLevel.None
     private var isScanning = false
     private var scanCallback: ScanCallback? = null
+    
+    // State restoration
+    private var restoreIdentifier: String? = null
+    private var isInitialized = false
+    private var restoredState: BleRestoredState? = null
     private var scanListener: ((NativeBleError?, NativeDevice?) -> Unit)? = null
     private var stateChangeListener: ((State) -> Unit)? = null
     
@@ -100,6 +111,104 @@ class BleNitroBleManager(private val context: ReactApplicationContext) : HybridB
         }
     }
     
+    override fun initialize(options: BleManagerNitroOptions): Promise<Unit> = Promise.resolve {
+        options.restoreStateIdentifier?.let { restoreId ->
+            this.restoreIdentifier = restoreId
+            
+            // Attempt to restore previous state from SharedPreferences
+            restoreConnectionState(restoreId)
+            
+            Log.d(TAG, "BleNitro: Initialized with restore state identifier: $restoreId")
+        }
+        
+        this.isInitialized = true
+        Log.d(TAG, "BleNitro: BLE Manager initialized")
+        Unit
+    }
+    
+    override fun getRestoredState(): Promise<BleRestoredState?> = Promise.resolve {
+        restoredState
+    }
+    
+    private fun restoreConnectionState(restoreId: String) {
+        try {
+            val sharedPrefs = context.getSharedPreferences("BleNitro_$restoreId", Context.MODE_PRIVATE)
+            val connectedDevicesJson = sharedPrefs.getString("connected_devices", null)
+            
+            connectedDevicesJson?.let { json ->
+                // Parse stored device IDs and attempt to reconnect
+                val deviceIds = json.split(",").filter { it.isNotEmpty() }
+                
+                if (deviceIds.isNotEmpty()) {
+                    Log.d(TAG, "BleNitro: Restoring ${deviceIds.size} devices")
+                    
+                    deviceIds.forEach { deviceId ->
+                        // Attempt to reconnect to previously connected devices
+                        restoreDeviceConnection(deviceId)
+                    }
+                    
+                    // Store restored state (initially empty, will be populated as devices reconnect)
+                    val initialDevices = deviceIds.mapNotNull { deviceId ->
+                        bluetoothAdapter?.getRemoteDevice(deviceId)?.let { device ->
+                            createNativeDevice(device, null, -1) // Initial state without GATT
+                        }
+                    }
+                    
+                    if (initialDevices.isNotEmpty()) {
+                        this.restoredState = BleRestoredState(initialDevices)
+                        Log.d(TAG, "BleNitro: Stored restored state with ${initialDevices.size} devices")
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "BleNitro: Error restoring connection state", e)
+        }
+    }
+    
+    private fun restoreDeviceConnection(deviceId: String) {
+        try {
+            val bluetoothDevice = bluetoothAdapter?.getRemoteDevice(deviceId)
+            bluetoothDevice?.let { device ->
+                Log.d(TAG, "BleNitro: Attempting to restore connection to $deviceId")
+                
+                val gatt = device.connectGatt(context, true, object : BluetoothGattCallback() {
+                    override fun onConnectionStateChange(gatt: BluetoothGatt?, status: Int, newState: Int) {
+                        if (newState == BluetoothProfile.STATE_CONNECTED) {
+                            connectedDevices[deviceId] = gatt!!
+                            Log.d(TAG, "BleNitro: Successfully restored connection to $deviceId")
+                        } else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
+                            Log.d(TAG, "BleNitro: Failed to restore connection to $deviceId")
+                            gatt?.close()
+                        }
+                    }
+                })
+                
+                if (gatt != null) {
+                    deviceCallbacks[deviceId] = gatt
+                }
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "BleNitro: Error restoring device connection for $deviceId", e)
+        }
+    }
+    
+    private fun saveConnectionState() {
+        restoreIdentifier?.let { restoreId ->
+            try {
+                val sharedPrefs = context.getSharedPreferences("BleNitro_$restoreId", Context.MODE_PRIVATE)
+                val deviceIds = connectedDevices.keys.joinToString(",")
+                
+                sharedPrefs.edit()
+                    .putString("connected_devices", deviceIds)
+                    .apply()
+                
+                Log.d(TAG, "BleNitro: Saved connection state for ${connectedDevices.size} devices")
+            } catch (e: Exception) {
+                Log.e(TAG, "BleNitro: Error saving connection state", e)
+            }
+        }
+    }
+    
     override fun setLogLevel(logLevel: LogLevel): Promise<LogLevel> = Promise.resolve {
         this.logLevel = logLevel
         logLevel

package/app.plugin.cjs

@@ -0,0 +1 @@
+module.exports = require('./plugin/build/index.js').default; // eslint-disable-line @typescript-eslint/no-var-requires

package/ios/BleNitroBleManager.swift

@@ -26,12 +26,28 @@ public class BleNitroBleManager: HybridBleManagerSpec, CBCentralManagerDelegate
     private var characteristicMonitors: [String: ((_ error: NativeBleError?, _ characteristic: NativeCharacteristic?) -> Void)] = [:]
     private var pendingOperations: [String: Any] = [:]
     
+    // State restoration
+    private var restoreIdentifier: String?
+    private var isInitialized = false
+    private var restoredState: BleRestoredState?
+    
     // MARK: - Initialization
     public override init() {
         super.init()
+        // Initialize with default options - will be reconfigured in initialize() method
         self.centralManager = CBCentralManager(delegate: self, queue: nil)
     }
     
+    private func reinitializeCentralManager() {
+        // Create CBCentralManager with state restoration if identifier is provided
+        var options: [String: Any] = [:]
+        if let restoreId = restoreIdentifier {
+            options[CBCentralManagerOptionRestoreIdentifierKey] = restoreId
+        }
+        
+        self.centralManager = CBCentralManager(delegate: self, queue: nil, options: options.isEmpty ? nil : options)
+    }
+    
     public override var memorySize: Int {
         return MemorySize.MemorySize_estimate(self)
     }
@@ -51,6 +67,29 @@ public class BleNitroBleManager: HybridBleManagerSpec, CBCentralManagerDelegate
         }
     }
     
+    public func initialize(options: BleManagerNitroOptions) throws -> Promise<Void> {
+        return Promise.resolve(withBlock: {
+            if let restoreId = options.restoreStateIdentifier {
+                // Store the restore identifier
+                self.restoreIdentifier = restoreId
+                
+                // Reinitialize the central manager with state restoration
+                self.reinitializeCentralManager()
+                
+                print("BleNitro: Initialized with restore state identifier: \(restoreId)")
+            }
+            
+            self.isInitialized = true
+            print("BleNitro: BLE Manager initialized")
+        })
+    }
+    
+    public func getRestoredState() throws -> Promise<BleRestoredState?> {
+        return Promise.resolve(withBlock: {
+            return self.restoredState
+        })
+    }
+    
     public func setLogLevel(logLevel: LogLevel) throws -> Promise<LogLevel> {
         return Promise.resolve(withBlock: {
             self.logLevel = logLevel
@@ -296,6 +335,7 @@ public class BleNitroBleManager: HybridBleManagerSpec, CBCentralManagerDelegate
     public func centralManagerDidUpdateState(_ central: CBCentralManager) {
         let state = mapCBManagerState(central.state)
         stateChangeListener?(state)
+        print("BleNitro: Central manager state changed to: \(central.state.rawValue)")
     }
     
     public func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String: Any], rssi RSSI: NSNumber) {
@@ -491,6 +531,32 @@ extension BleNitroBleManager: CBPeripheralDelegate {
             }
         }
     }
+    
+    // MARK: - CBCentralManagerDelegate State Restoration
+    
+    public func centralManager(_ central: CBCentralManager, willRestoreState dict: [String : Any]) {
+        // Handle state restoration
+        if let peripherals = dict[CBCentralManagerRestoredStatePeripheralsKey] as? [CBPeripheral] {
+            print("BleNitro: Restoring \(peripherals.count) peripherals")
+            
+            // Add restored peripherals to our connected devices
+            for peripheral in peripherals {
+                let deviceId = peripheral.identifier.uuidString
+                connectedDevices[deviceId] = peripheral
+                peripheral.delegate = self
+                
+                print("BleNitro: Restored peripheral: \(deviceId)")
+            }
+            
+            // Store restored state for later retrieval
+            if !peripherals.isEmpty {
+                let restoredDevices = peripherals.map(createNativeDevice)
+                self.restoredState = BleRestoredState(connectedPeripherals: restoredDevices)
+                print("BleNitro: Stored restored state with \(restoredDevices.count) devices")
+            }
+        }
+    }
+    
 }
 
 /**

package/ios/BleNitroModule.swift

@@ -19,13 +19,6 @@ public class BleNitroModule: NSObject {
     public func constantsToExport() -> [String: Any] {
         return [:]
     }
-}
-
-/**
- * Nitro module factory for creating BLE manager instances
- */
-@_cdecl("create_ble_nitro_manager")
-public func createBleNitroManager() -> UnsafeMutableRawPointer {
-    let manager = BleNitroBleManager()
-    return Unmanaged.passRetained(manager).toOpaque()
+    
+    // Autolinking handles the Nitro registration automatically
 }

package/lib/BleManagerCompatFactory.d.ts

@@ -4,9 +4,9 @@
  * Creates BleManager instances with full react-native-ble-plx compatibility
  * by wrapping the Nitro implementation with compatibility shims
  */
-import type { BleManagerOptions, UUID, DeviceId, TransactionId, ConnectionPriority, ConnectionOptions, ScanOptions, NativeService, NativeCharacteristic, NativeDescriptor, LogLevel, Subscription } from './specs/types.js';
-import { DeviceWrapper } from './compatibility/deviceWrapper.js';
-import { State as PlxState, LogLevel as PlxLogLevel } from './compatibility/enums.js';
+import type { BleManagerOptions, UUID, DeviceId, TransactionId, ConnectionPriority, ConnectionOptions, ScanOptions, NativeService, NativeCharacteristic, NativeDescriptor, LogLevel, Subscription } from './specs/types';
+import { DeviceWrapper } from './compatibility/deviceWrapper';
+import { State as PlxState, LogLevel as PlxLogLevel } from './compatibility/enums';
 /**
  * BleManager wrapper that provides react-native-ble-plx compatibility
  */
@@ -38,7 +38,8 @@ export declare class BleManagerCompat {
     readCharacteristicForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, transactionId?: TransactionId): Promise<NativeCharacteristic>;
     writeCharacteristicWithResponseForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, base64Value: string, transactionId?: TransactionId): Promise<NativeCharacteristic>;
     writeCharacteristicWithoutResponseForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, base64Value: string, transactionId?: TransactionId): Promise<NativeCharacteristic>;
-    monitorCharacteristicForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, listener: (error: any | null, characteristic: NativeCharacteristic | null) => void, transactionId?: TransactionId, subscriptionType?: 'notification' | 'indication'): Subscription;
+    monitorCharacteristicForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, listener: (error: any | null, characteristic: NativeCharacteristic | null) => void, // TODO: COMPAT! use proper error type like in react-native-ble-plx
+    transactionId?: TransactionId, subscriptionType?: 'notification' | 'indication'): Subscription;
     descriptorsForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID): Promise<NativeDescriptor[]>;
     readDescriptorForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, descriptorUUID: UUID, transactionId?: TransactionId): Promise<NativeDescriptor>;
     writeDescriptorForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, descriptorUUID: UUID, valueBase64: string, transactionId?: TransactionId): Promise<NativeDescriptor>;

package/lib/BleManagerCompatFactory.js

@@ -4,9 +4,9 @@
  * Creates BleManager instances with full react-native-ble-plx compatibility
  * by wrapping the Nitro implementation with compatibility shims
  */
-import { createBleManager } from './BleManagerFactory.js';
-import { DeviceWrapper } from './compatibility/deviceWrapper.js';
-import { stateToString, logLevelToString, normalizeLogLevel, normalizeCharacteristicSubscriptionType } from './compatibility/enums.js';
+import { createBleManager } from './BleManagerFactory';
+import { DeviceWrapper } from './compatibility/deviceWrapper';
+import { stateToString, logLevelToString, normalizeLogLevel, normalizeCharacteristicSubscriptionType } from './compatibility/enums';
 /**
  * BleManager wrapper that provides react-native-ble-plx compatibility
  */
@@ -50,7 +50,8 @@ export class BleManagerCompat {
         }, emitCurrentState);
     }
     // Device scanning with compatibility wrappers
-    async startDeviceScan(uuids, options, listener) {
+    async startDeviceScan(uuids, options, listener // TODO: COMPAT! remove any and move to BleError as react-native-ble-plx uses this type as well!
+    ) {
         return await this.bleManager.startDeviceScan(uuids, options, (error, device) => {
             listener(error, device ? new DeviceWrapper(this.createDeviceFromNative(device)) : null);
         });
@@ -76,7 +77,8 @@ export class BleManagerCompat {
     async isDeviceConnected(deviceIdentifier) {
         return await this.bleManager.isDeviceConnected(deviceIdentifier);
     }
-    onDeviceDisconnected(deviceIdentifier, listener) {
+    onDeviceDisconnected(deviceIdentifier, listener // TODO: COMPAT! use propper error type like in react-native-ble-plx!!!
+    ) {
         return this.bleManager.onDeviceDisconnected(deviceIdentifier, (error, device) => {
             listener(error, device ? new DeviceWrapper(this.createDeviceFromNative(device)) : null);
         });
@@ -125,7 +127,8 @@ export class BleManagerCompat {
     async writeCharacteristicWithoutResponseForDevice(deviceIdentifier, serviceUUID, characteristicUUID, base64Value, transactionId) {
         return await this.bleManager.writeCharacteristicWithoutResponseForDevice(deviceIdentifier, serviceUUID, characteristicUUID, base64Value, transactionId);
     }
-    monitorCharacteristicForDevice(deviceIdentifier, serviceUUID, characteristicUUID, listener, transactionId, subscriptionType) {
+    monitorCharacteristicForDevice(deviceIdentifier, serviceUUID, characteristicUUID, listener, // TODO: COMPAT! use proper error type like in react-native-ble-plx
+    transactionId, subscriptionType) {
         const nitroSubscriptionType = subscriptionType
             ? normalizeCharacteristicSubscriptionType(subscriptionType)
             : undefined;

package/lib/BleManagerFactory.d.ts

@@ -1,12 +1,30 @@
-import type { BleManager as BleManagerInterface } from './specs/BleManager.nitro.js';
-import type { BleManagerOptions } from './specs/types.js';
+import type { BleManager as BleManagerInterface } from './specs/BleManager.nitro';
+import type { BleManagerOptions } from './specs/types';
 /**
  * Creates a BleManager instance using Nitro Modules
  * This function maintains compatibility with react-native-ble-plx's BleManager constructor
  */
 export declare function createBleManager(options?: BleManagerOptions): BleManagerInterface;
+/**
+ * Helper function to retrieve stored callbacks for a BleManager instance
+ * This is used internally when callbacks need to be invoked
+ */
+export declare function getStoredCallbacks(manager: BleManagerInterface): {
+    restoreStateFunction?: (restoredState: any) => void;
+    errorCodesToMessagesMapping?: {
+        [key: number]: string;
+    };
+} | undefined;
+/**
+ * Helper function to get custom error message if available
+ * @param manager The BleManager instance
+ * @param errorCode The BLE error code
+ * @param defaultMessage Default error message
+ * @returns Custom message if available, otherwise default message
+ */
+export declare function getCustomErrorMessage(manager: BleManagerInterface, errorCode: number, defaultMessage: string): string;
 /**
  * Legacy compatibility: Export a BleManager constructor function
  * This maintains compatibility with code that imports { BleManager } from 'react-native-ble-plx'
  */
-export declare const BleManager: any;
+export declare const BleManager: (options?: BleManagerOptions) => BleManagerInterface;

package/lib/BleManagerFactory.js

@@ -1,4 +1,6 @@
 import { NitroModules } from 'react-native-nitro-modules';
+// Store callbacks that can't be passed to Nitro
+const storedCallbacks = new WeakMap();
 /**
  * Creates a BleManager instance using Nitro Modules
  * This function maintains compatibility with react-native-ble-plx's BleManager constructor
@@ -9,10 +11,59 @@ export function createBleManager(options) {
         throw new Error('Failed to create BleManager: Nitro module not found. ' +
             'Make sure react-native-ble-nitro is properly installed and linked.');
     }
-    // If options are provided, we could initialize with them
-    // For now, we return the module directly as Nitro handles the native initialization
+    // Initialize with options if provided
+    if (options) {
+        // Extract Nitro-compatible options
+        const nitroOptions = {
+            restoreStateIdentifier: options.restoreStateIdentifier,
+        };
+        // Store callbacks and mappings that can't be passed to Nitro
+        if (options.restoreStateFunction || options.errorCodesToMessagesMapping) {
+            storedCallbacks.set(BleManagerModule, {
+                restoreStateFunction: options.restoreStateFunction,
+                errorCodesToMessagesMapping: options.errorCodesToMessagesMapping,
+            });
+        }
+        // Note: initialize() is async but we need to maintain sync compatibility with react-native-ble-plx
+        // The initialization will happen asynchronously in the background
+        BleManagerModule.initialize(nitroOptions).then(async () => {
+            // Check for restored state and call the callback if available
+            if (options.restoreStateFunction) {
+                try {
+                    const restoredState = await BleManagerModule.getRestoredState();
+                    if (restoredState) {
+                        options.restoreStateFunction(restoredState);
+                    }
+                }
+                catch (error) {
+                    console.warn('BleManager restore state callback failed:', error);
+                }
+            }
+        }).catch(error => {
+            console.warn('BleManager initialization failed:', error);
+        });
+    }
     return BleManagerModule;
 }
+/**
+ * Helper function to retrieve stored callbacks for a BleManager instance
+ * This is used internally when callbacks need to be invoked
+ */
+export function getStoredCallbacks(manager) {
+    return storedCallbacks.get(manager);
+}
+/**
+ * Helper function to get custom error message if available
+ * @param manager The BleManager instance
+ * @param errorCode The BLE error code
+ * @param defaultMessage Default error message
+ * @returns Custom message if available, otherwise default message
+ */
+export function getCustomErrorMessage(manager, errorCode, defaultMessage) {
+    const callbacks = storedCallbacks.get(manager);
+    const customMessage = callbacks?.errorCodesToMessagesMapping?.[errorCode];
+    return customMessage || defaultMessage;
+}
 /**
  * Legacy compatibility: Export a BleManager constructor function
  * This maintains compatibility with code that imports { BleManager } from 'react-native-ble-plx'

package/lib/commonjs/BleManagerCompatFactory.d.ts

@@ -0,0 +1,56 @@
+/**
+ * BleManager Compatibility Factory
+ *
+ * Creates BleManager instances with full react-native-ble-plx compatibility
+ * by wrapping the Nitro implementation with compatibility shims
+ */
+import type { BleManagerOptions, UUID, DeviceId, TransactionId, ConnectionPriority, ConnectionOptions, ScanOptions, NativeService, NativeCharacteristic, NativeDescriptor, LogLevel, Subscription } from './specs/types';
+import { DeviceWrapper } from './compatibility/deviceWrapper';
+import { State as PlxState, LogLevel as PlxLogLevel } from './compatibility/enums';
+/**
+ * BleManager wrapper that provides react-native-ble-plx compatibility
+ */
+export declare class BleManagerCompat {
+    private bleManager;
+    constructor(options?: BleManagerOptions);
+    destroy(): Promise<void>;
+    setLogLevel(logLevel: LogLevel | string): Promise<PlxLogLevel>;
+    logLevel(): Promise<PlxLogLevel>;
+    cancelTransaction(transactionId: TransactionId): Promise<void>;
+    enable(transactionId?: TransactionId): Promise<BleManagerCompat>;
+    disable(transactionId?: TransactionId): Promise<BleManagerCompat>;
+    state(): Promise<PlxState>;
+    onStateChange(listener: (newState: PlxState) => void, emitCurrentState?: boolean): Subscription;
+    startDeviceScan(uuids: UUID[] | null, options: ScanOptions | null, listener: (error: any | null, scannedDevice: DeviceWrapper | null) => void): Promise<void>;
+    stopDeviceScan(): Promise<void>;
+    connectToDevice(deviceIdentifier: DeviceId, options?: Partial<ConnectionOptions>): Promise<DeviceWrapper>;
+    cancelDeviceConnection(deviceIdentifier: DeviceId): Promise<DeviceWrapper>;
+    isDeviceConnected(deviceIdentifier: DeviceId): Promise<boolean>;
+    onDeviceDisconnected(deviceIdentifier: DeviceId, listener: (error: any | null, device: DeviceWrapper | null) => void): Subscription;
+    devices(deviceIdentifiers: DeviceId[]): Promise<DeviceWrapper[]>;
+    connectedDevices(serviceUUIDs: UUID[]): Promise<DeviceWrapper[]>;
+    readRSSIForDevice(deviceIdentifier: DeviceId, transactionId?: TransactionId): Promise<DeviceWrapper>;
+    requestMTUForDevice(deviceIdentifier: DeviceId, mtu: number, transactionId?: TransactionId): Promise<DeviceWrapper>;
+    requestConnectionPriorityForDevice(deviceIdentifier: DeviceId, connectionPriority: ConnectionPriority, transactionId?: TransactionId): Promise<DeviceWrapper>;
+    discoverAllServicesAndCharacteristicsForDevice(deviceIdentifier: DeviceId, transactionId?: TransactionId): Promise<DeviceWrapper>;
+    servicesForDevice(deviceIdentifier: DeviceId): Promise<NativeService[]>;
+    characteristicsForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID): Promise<NativeCharacteristic[]>;
+    readCharacteristicForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, transactionId?: TransactionId): Promise<NativeCharacteristic>;
+    writeCharacteristicWithResponseForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, base64Value: string, transactionId?: TransactionId): Promise<NativeCharacteristic>;
+    writeCharacteristicWithoutResponseForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, base64Value: string, transactionId?: TransactionId): Promise<NativeCharacteristic>;
+    monitorCharacteristicForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, listener: (error: any | null, characteristic: NativeCharacteristic | null) => void, // TODO: COMPAT! use proper error type like in react-native-ble-plx
+    transactionId?: TransactionId, subscriptionType?: 'notification' | 'indication'): Subscription;
+    descriptorsForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID): Promise<NativeDescriptor[]>;
+    readDescriptorForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, descriptorUUID: UUID, transactionId?: TransactionId): Promise<NativeDescriptor>;
+    writeDescriptorForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, descriptorUUID: UUID, valueBase64: string, transactionId?: TransactionId): Promise<NativeDescriptor>;
+    /**
+     * Helper method to create a Device wrapper from NativeDevice data
+     * This is a temporary method until we have proper Device Nitro objects
+     */
+    private createDeviceFromNative;
+}
+/**
+ * Factory function to create a compatibility BleManager
+ */
+export declare function createBleManagerCompat(options?: BleManagerOptions): BleManagerCompat;
+//# sourceMappingURL=BleManagerCompatFactory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BleManagerCompatFactory.d.ts","sourceRoot":"","sources":["../../src/BleManagerCompatFactory.ts"],"names":[],"mappings":"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"}