react-native-ble-nitro 1.5.0 → 1.7.0

package/lib/index.js

@@ -1,11 +1,2 @@
-import { BleNitroManager } from "./manager";
-export { BLEState, AndroidScanMode, } from "./manager";
-let _instance;
-export class BleNitro extends BleNitroManager {
-    static instance() {
-        if (!_instance) {
-            _instance = new BleNitro();
-        }
-        return _instance;
-    }
-}
+export { BLEState, AndroidScanMode, BleNitroManager, } from "./manager";
+export { BleNitro } from './singleton';

package/lib/manager.d.ts

@@ -20,6 +20,7 @@ export interface BLEDevice {
     manufacturerData: ManufacturerData;
     serviceUUIDs: string[];
     isConnectable: boolean;
+    isConnected: boolean;
 }
 export type ScanCallback = (device: BLEDevice) => void;
 export type RestoreStateCallback = (connectedPeripherals: BLEDevice[]) => void;
@@ -45,6 +46,7 @@ export declare enum AndroidScanMode {
     Opportunistic = "Opportunistic"
 }
 export type BleNitroManagerOptions = {
+    restoreIdentifier?: string;
     onRestoredState?: RestoreStateCallback;
 };
 export declare function mapNativeBLEStateToBLEState(nativeState: NativeBLEState): BLEState;
@@ -57,8 +59,15 @@ export declare class BleNitroManager {
     private _connectedDevices;
     private _restoredStateCallback;
     private _restoredState;
+    private _restoreStateIdentifier;
+    private Instance;
     constructor(options?: BleNitroManagerOptions);
     private onNativeRestoreStateCallback;
+    /**
+     *
+     * Registers callback and returns restored peripheral state in it. Not working from 1.7.x upwards for singleton implementation!
+     * @deprecated This method is deprecated and will be removed in 2.x, use onRestoredState option in BleNitroManageroptions instead!
+     */
     onRestoredState(callback: RestoreStateCallback): void;
     /**
      * Converts a 16- oder 32-Bit UUID to a 128-Bit UUID
@@ -72,17 +81,17 @@ export declare class BleNitroManager {
      * 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
+     * @returns void
      */
     startScan(filter: ScanFilter | undefined, callback: ScanCallback, onError?: (error: string) => void): void;
     /**
      * Stop scanning for Bluetooth devices
-     * @returns Promise resolving to success state
+     * @returns void
      */
     stopScan(): void;
     /**
      * Check if currently scanning for devices
-     * @returns Promise resolving to scanning state
+     * @returns Boolean indicating if currently scanning
      */
     isScanning(): boolean;
     /**
@@ -95,9 +104,20 @@ export declare class BleNitroManager {
      * 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
+     * @returns Promise resolving deviceId when connected
      */
-    connect(deviceId: string, onDisconnect?: DisconnectEventCallback): Promise<string>;
+    connect(deviceId: string, onDisconnect?: DisconnectEventCallback, autoConnectAndroid?: boolean): Promise<string>;
+    /**
+     * Scans for a device and connects to it
+     * @param deviceId ID of the device to connect to
+     * @param scanTimeout Optional timeout for the scan in milliseconds (default: 5000ms)
+     * @returns Promise resolving deviceId when connected
+     */
+    findAndConnect(deviceId: string, options?: {
+        scanTimeout?: number;
+        autoConnectAndroid?: boolean;
+        onDisconnect?: DisconnectEventCallback;
+    }): Promise<string>;
     /**
      * Disconnect from a Bluetooth device
      * @param deviceId ID of the device to disconnect from
@@ -107,7 +127,7 @@ export declare class BleNitroManager {
     /**
      * Check if connected to a device
      * @param deviceId ID of the device to check
-     * @returns Promise resolving to connection state
+     * @returns Boolean indicating if device is connected
      */
     isConnected(deviceId: string): boolean;
     /**
@@ -139,15 +159,26 @@ export declare class BleNitroManager {
      * 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
+     * @returns array of characteristic UUIDs
      */
     getCharacteristics(deviceId: string, serviceId: string): string[];
+    /**
+     * Get services and characteristics for a connected device
+     * @param deviceId ID of the device
+     * @returns Promise resolving to array of service and characteristic UUIDs
+     * @see getServices
+     * @see getCharacteristics
+     */
+    getServicesWithCharacteristics(deviceId: string): Promise<{
+        uuid: string;
+        characteristics: 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
+     * @returns Promise resolving to the characteristic data as ByteArray
      */
     readCharacteristic(deviceId: string, serviceId: string, characteristicId: string): Promise<ByteArray>;
     /**
@@ -166,7 +197,7 @@ export declare class BleNitroManager {
      * @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
+     * @returns Subscription
      */
     subscribeToCharacteristic(deviceId: string, serviceId: string, characteristicId: string, callback: CharacteristicUpdateCallback): Subscription;
     /**
@@ -179,7 +210,7 @@ export declare class BleNitroManager {
     unsubscribeFromCharacteristic(deviceId: string, serviceId: string, characteristicId: string): Promise<void>;
     /**
      * Check if Bluetooth is enabled
-     * @returns Promise resolving to Bluetooth state
+     * @returns returns Boolean according to Bluetooth state
      */
     isBluetoothEnabled(): boolean;
     /**
@@ -189,7 +220,7 @@ export declare class BleNitroManager {
     requestBluetoothEnable(): Promise<boolean>;
     /**
      * Get the current Bluetooth state
-     * @returns Promise resolving to Bluetooth state
+     * @returns Bluetooth state
      * @see BLEState
      */
     state(): BLEState;
@@ -197,7 +228,7 @@ export declare class BleNitroManager {
      * 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
+     * @returns Subscription
      * @see BLEState
      */
     subscribeToStateChange(callback: (state: BLEState) => void, emitInitial?: boolean): Subscription;

package/lib/manager.js

@@ -1,4 +1,4 @@
-import BleNitroNative from './specs/NativeBleNitro';
+import BleNitroNativeFactory from './specs/NativeBleNitroFactory';
 import { AndroidScanMode as NativeAndroidScanMode, } from './specs/NativeBleNitro';
 export var BLEState;
 (function (BLEState) {
@@ -59,13 +59,19 @@ export class BleNitroManager {
     constructor(options) {
         this._isScanning = false;
         this._connectedDevices = {};
-        this._restoredStateCallback = null;
         this._restoredState = null;
-        this._restoredStateCallback = options?.onRestoredState || null;
-        BleNitroNative.setRestoreStateCallback((peripherals) => this.onNativeRestoreStateCallback(peripherals));
+        this._restoreStateIdentifier = null;
+        this._restoredStateCallback = options?.onRestoredState ?? null;
+        this._restoreStateIdentifier = options?.restoreIdentifier ?? null;
+        this.Instance = BleNitroNativeFactory.create(options?.restoreIdentifier, (peripherals) => this.onNativeRestoreStateCallback(peripherals));
     }
     onNativeRestoreStateCallback(peripherals) {
+        if (!this._restoreStateIdentifier)
+            return;
         const bleDevices = peripherals.map((peripheral) => convertNativeBleDeviceToBleDevice(peripheral));
+        bleDevices.forEach((device) => {
+            this._connectedDevices[device.id] = device.isConnected;
+        });
         if (this._restoredStateCallback) {
             this._restoredStateCallback(bleDevices);
         }
@@ -73,7 +79,14 @@ export class BleNitroManager {
             this._restoredState = bleDevices;
         }
     }
+    /**
+     *
+     * Registers callback and returns restored peripheral state in it. Not working from 1.7.x upwards for singleton implementation!
+     * @deprecated This method is deprecated and will be removed in 2.x, use onRestoredState option in BleNitroManageroptions instead!
+     */
     onRestoredState(callback) {
+        if (!this._restoreStateIdentifier)
+            return;
         if (this._restoredState) {
             callback(this._restoredState);
             this._restoredState = null;
@@ -104,7 +117,7 @@ export class BleNitroManager {
      * 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
+     * @returns void
      */
     startScan(filter = {}, callback, onError) {
         if (this._isScanning) {
@@ -130,26 +143,26 @@ export class BleNitroManager {
             callback(convertedDevice);
         };
         // Start scan
-        BleNitroNative.startScan(nativeFilter, scanCallback);
+        this.Instance.startScan(nativeFilter, scanCallback);
         this._isScanning = true;
     }
     /**
      * Stop scanning for Bluetooth devices
-     * @returns Promise resolving to success state
+     * @returns void
      */
     stopScan() {
         if (!this._isScanning) {
             return;
         }
-        BleNitroNative.stopScan();
+        this.Instance.stopScan();
         this._isScanning = false;
     }
     /**
      * Check if currently scanning for devices
-     * @returns Promise resolving to scanning state
+     * @returns Boolean indicating if currently scanning
      */
     isScanning() {
-        this._isScanning = BleNitroNative.isScanning();
+        this._isScanning = this.Instance.isScanning();
         return this._isScanning;
     }
     /**
@@ -158,7 +171,7 @@ export class BleNitroManager {
      * @returns Array of connected devices
      */
     getConnectedDevices(services) {
-        const devices = BleNitroNative.getConnectedDevices(services || []);
+        const devices = this.Instance.getConnectedDevices(services || []);
         // Normalize service UUIDs - manufacturer data already comes as ArrayBuffers
         return devices.map(device => convertNativeBleDeviceToBleDevice(device));
     }
@@ -166,16 +179,16 @@ export class BleNitroManager {
      * 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
+     * @returns Promise resolving deviceId when connected
      */
-    connect(deviceId, onDisconnect) {
+    connect(deviceId, onDisconnect, autoConnectAndroid) {
         return new Promise((resolve, reject) => {
             // Check if already connected
             if (this._connectedDevices[deviceId]) {
                 resolve(deviceId);
                 return;
             }
-            BleNitroNative.connect(deviceId, (success, connectedDeviceId, error) => {
+            this.Instance.connect(deviceId, (success, connectedDeviceId, error) => {
                 if (success) {
                     this._connectedDevices[deviceId] = true;
                     resolve(connectedDeviceId);
@@ -187,7 +200,39 @@ export class BleNitroManager {
                 // Remove from connected devices when disconnected
                 delete this._connectedDevices[deviceId];
                 onDisconnect(deviceId, interrupted, error);
-            } : undefined);
+            } : undefined, autoConnectAndroid ?? false);
+        });
+    }
+    /**
+     * Scans for a device and connects to it
+     * @param deviceId ID of the device to connect to
+     * @param scanTimeout Optional timeout for the scan in milliseconds (default: 5000ms)
+     * @returns Promise resolving deviceId when connected
+     */
+    findAndConnect(deviceId, options) {
+        const isConnected = this.isConnected(deviceId);
+        if (isConnected) {
+            return Promise.resolve(deviceId);
+        }
+        if (this._isScanning) {
+            this.stopScan();
+        }
+        return new Promise((resolve, reject) => {
+            const timeoutScan = setTimeout(() => {
+                this.stopScan();
+                reject(new Error('Scan timed out'));
+            }, options?.scanTimeout ?? 5000);
+            this.startScan(undefined, (device) => {
+                if (device.id === deviceId) {
+                    this.stopScan();
+                    clearTimeout(timeoutScan);
+                    this.connect(deviceId, options?.onDisconnect, options?.autoConnectAndroid).then(async (connectedDeviceId) => {
+                        resolve(connectedDeviceId);
+                    }).catch((error) => {
+                        reject(error);
+                    });
+                }
+            });
         });
     }
     /**
@@ -202,7 +247,7 @@ export class BleNitroManager {
                 resolve();
                 return;
             }
-            BleNitroNative.disconnect(deviceId, (success, error) => {
+            this.Instance.disconnect(deviceId, (success, error) => {
                 if (success) {
                     delete this._connectedDevices[deviceId];
                     resolve();
@@ -216,10 +261,10 @@ export class BleNitroManager {
     /**
      * Check if connected to a device
      * @param deviceId ID of the device to check
-     * @returns Promise resolving to connection state
+     * @returns Boolean indicating if device is connected
      */
     isConnected(deviceId) {
-        return BleNitroNative.isConnected(deviceId);
+        return this.Instance.isConnected(deviceId);
     }
     /**
      * Request a new MTU size
@@ -229,7 +274,7 @@ export class BleNitroManager {
      */
     requestMTU(deviceId, mtu) {
         mtu = parseInt(mtu.toString(), 10);
-        const deviceMtu = BleNitroNative.requestMTU(deviceId, mtu);
+        const deviceMtu = this.Instance.requestMTU(deviceId, mtu);
         return deviceMtu;
     }
     /**
@@ -244,7 +289,7 @@ export class BleNitroManager {
                 reject(new Error('Device not connected'));
                 return;
             }
-            BleNitroNative.readRSSI(deviceId, (success, rssi, error) => {
+            this.Instance.readRSSI(deviceId, (success, rssi, error) => {
                 if (success) {
                     resolve(rssi);
                 }
@@ -266,7 +311,7 @@ export class BleNitroManager {
                 reject(new Error('Device not connected'));
                 return;
             }
-            BleNitroNative.discoverServices(deviceId, (success, error) => {
+            this.Instance.discoverServices(deviceId, (success, error) => {
                 if (success) {
                     resolve(true);
                 }
@@ -293,7 +338,7 @@ export class BleNitroManager {
                 reject(new Error('Failed to discover services'));
                 return;
             }
-            const services = BleNitroNative.getServices(deviceId);
+            const services = this.Instance.getServices(deviceId);
             resolve(BleNitroManager.normalizeGattUUIDs(services));
         });
     }
@@ -301,21 +346,38 @@ export class BleNitroManager {
      * 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
+     * @returns array of characteristic UUIDs
      */
     getCharacteristics(deviceId, serviceId) {
         if (!this._connectedDevices[deviceId]) {
             throw new Error('Device not connected');
         }
-        const characteristics = BleNitroNative.getCharacteristics(deviceId, BleNitroManager.normalizeGattUUID(serviceId));
+        const characteristics = this.Instance.getCharacteristics(deviceId, BleNitroManager.normalizeGattUUID(serviceId));
         return BleNitroManager.normalizeGattUUIDs(characteristics);
     }
+    /**
+     * Get services and characteristics for a connected device
+     * @param deviceId ID of the device
+     * @returns Promise resolving to array of service and characteristic UUIDs
+     * @see getServices
+     * @see getCharacteristics
+     */
+    async getServicesWithCharacteristics(deviceId) {
+        await this.discoverServices(deviceId);
+        const services = await this.getServices(deviceId);
+        return services.map((service) => {
+            return {
+                uuid: service,
+                characteristics: this.getCharacteristics(deviceId, service),
+            };
+        });
+    }
     /**
      * 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
+     * @returns Promise resolving to the characteristic data as ByteArray
      */
     readCharacteristic(deviceId, serviceId, characteristicId) {
         return new Promise((resolve, reject) => {
@@ -324,7 +386,7 @@ export class BleNitroManager {
                 reject(new Error('Device not connected'));
                 return;
             }
-            BleNitroNative.readCharacteristic(deviceId, BleNitroManager.normalizeGattUUID(serviceId), BleNitroManager.normalizeGattUUID(characteristicId), (success, data, error) => {
+            this.Instance.readCharacteristic(deviceId, BleNitroManager.normalizeGattUUID(serviceId), BleNitroManager.normalizeGattUUID(characteristicId), (success, data, error) => {
                 if (success) {
                     resolve(arrayBufferToByteArray(data));
                 }
@@ -350,7 +412,7 @@ export class BleNitroManager {
                 reject(new Error('Device not connected'));
                 return;
             }
-            BleNitroNative.writeCharacteristic(deviceId, BleNitroManager.normalizeGattUUID(serviceId), BleNitroManager.normalizeGattUUID(characteristicId), byteArrayToArrayBuffer(data), withResponse, (success, responseData, error) => {
+            this.Instance.writeCharacteristic(deviceId, BleNitroManager.normalizeGattUUID(serviceId), BleNitroManager.normalizeGattUUID(characteristicId), byteArrayToArrayBuffer(data), withResponse, (success, responseData, error) => {
                 if (success) {
                     // Convert ArrayBuffer response to ByteArray
                     const responseByteArray = arrayBufferToByteArray(responseData);
@@ -368,7 +430,7 @@ export class BleNitroManager {
      * @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
+     * @returns Subscription
      */
     subscribeToCharacteristic(deviceId, serviceId, characteristicId, callback) {
         // Check if connected first
@@ -376,7 +438,7 @@ export class BleNitroManager {
             throw new Error('Device not connected');
         }
         let _success = false;
-        BleNitroNative.subscribeToCharacteristic(deviceId, BleNitroManager.normalizeGattUUID(serviceId), BleNitroManager.normalizeGattUUID(characteristicId), (charId, data) => {
+        this.Instance.subscribeToCharacteristic(deviceId, BleNitroManager.normalizeGattUUID(serviceId), BleNitroManager.normalizeGattUUID(characteristicId), (charId, data) => {
             callback(charId, arrayBufferToByteArray(data));
         }, (success, error) => {
             _success = success;
@@ -407,7 +469,7 @@ export class BleNitroManager {
                 reject(new Error('Device not connected'));
                 return;
             }
-            BleNitroNative.unsubscribeFromCharacteristic(deviceId, BleNitroManager.normalizeGattUUID(serviceId), BleNitroManager.normalizeGattUUID(characteristicId), (success, error) => {
+            this.Instance.unsubscribeFromCharacteristic(deviceId, BleNitroManager.normalizeGattUUID(serviceId), BleNitroManager.normalizeGattUUID(characteristicId), (success, error) => {
                 if (success) {
                     resolve();
                 }
@@ -419,7 +481,7 @@ export class BleNitroManager {
     }
     /**
      * Check if Bluetooth is enabled
-     * @returns Promise resolving to Bluetooth state
+     * @returns returns Boolean according to Bluetooth state
      */
     isBluetoothEnabled() {
         return this.state() === BLEState.PoweredOn;
@@ -430,7 +492,7 @@ export class BleNitroManager {
      */
     requestBluetoothEnable() {
         return new Promise((resolve, reject) => {
-            BleNitroNative.requestBluetoothEnable((success, error) => {
+            this.Instance.requestBluetoothEnable((success, error) => {
                 if (success) {
                     resolve(true);
                 }
@@ -442,17 +504,17 @@ export class BleNitroManager {
     }
     /**
      * Get the current Bluetooth state
-     * @returns Promise resolving to Bluetooth state
+     * @returns Bluetooth state
      * @see BLEState
      */
     state() {
-        return mapNativeBLEStateToBLEState(BleNitroNative.state());
+        return mapNativeBLEStateToBLEState(this.Instance.state());
     }
     /**
      * 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
+     * @returns Subscription
      * @see BLEState
      */
     subscribeToStateChange(callback, emitInitial = false) {
@@ -460,12 +522,12 @@ export class BleNitroManager {
             const state = this.state();
             callback(state);
         }
-        BleNitroNative.subscribeToStateChange((nativeState) => {
+        this.Instance.subscribeToStateChange((nativeState) => {
             callback(mapNativeBLEStateToBLEState(nativeState));
         });
         return {
             remove: () => {
-                BleNitroNative.unsubscribeFromStateChange();
+                this.Instance.unsubscribeFromStateChange();
             },
         };
     }
@@ -474,6 +536,6 @@ export class BleNitroManager {
      * @returns Promise resolving when settings are opened
      */
     openSettings() {
-        return BleNitroNative.openSettings();
+        return this.Instance.openSettings();
     }
 }

package/lib/singleton.d.ts

@@ -0,0 +1,9 @@
+import { BleNitroManager } from "./manager";
+export declare class BleNitro extends BleNitroManager {
+    /**
+     * Get a singleton instance of BleNitro, will create one if it does not exist.
+     * Singleton implementation does not allow to use state restoration on iOS!
+     * @returns {BleNitroManager} An instance of BleNitro
+     */
+    static instance(): BleNitroManager;
+}

package/lib/singleton.js

@@ -0,0 +1,15 @@
+import { BleNitroManager } from "./manager";
+let _instance;
+export class BleNitro extends BleNitroManager {
+    /**
+     * Get a singleton instance of BleNitro, will create one if it does not exist.
+     * Singleton implementation does not allow to use state restoration on iOS!
+     * @returns {BleNitroManager} An instance of BleNitro
+     */
+    static instance() {
+        if (!_instance) {
+            _instance = new BleNitro();
+        }
+        return _instance;
+    }
+}

package/lib/specs/NativeBleNitro.d.ts

@@ -1,4 +1,4 @@
-import type { NativeBleNitro } from './NativeBleNitro.nitro';
+import { NativeBleNitro } from './NativeBleNitro.nitro';
 declare const NativeBleNitroImpl: NativeBleNitro;
 export default NativeBleNitroImpl;
 export * from './NativeBleNitro.nitro';

package/lib/specs/NativeBleNitro.js

@@ -1,5 +1,6 @@
 import { NitroModules } from 'react-native-nitro-modules';
 // Export the native implementation
 const NativeBleNitroImpl = NitroModules.createHybridObject('NativeBleNitro');
+// export default NativeBleNitroImpl;
 export default NativeBleNitroImpl;
 export * from './NativeBleNitro.nitro';

package/lib/specs/NativeBleNitro.nitro.d.ts

@@ -22,6 +22,7 @@ export interface BLEDevice {
     manufacturerData: ManufacturerData;
     serviceUUIDs: string[];
     isConnectable: boolean;
+    isConnected: boolean;
 }
 export declare enum AndroidScanMode {
     LowLatency = 0,
@@ -60,12 +61,13 @@ export interface NativeBleNitro extends HybridObject<{
     ios: 'swift';
     android: 'kotlin';
 }> {
+    restoreStateIdentifier?: string;
     setRestoreStateCallback(callback: RestoreCallback): void;
     startScan(filter: ScanFilter, callback: ScanCallback): void;
     stopScan(): boolean;
     isScanning(): boolean;
     getConnectedDevices(services: string[]): BLEDevice[];
-    connect(deviceId: string, callback: ConnectionCallback, disconnectCallback?: DisconnectionEventCallback): void;
+    connect(deviceId: string, callback: ConnectionCallback, disconnectCallback?: DisconnectionEventCallback, autoConnectAndroid?: boolean): void;
     disconnect(deviceId: string, callback: OperationCallback): void;
     isConnected(deviceId: string): boolean;
     requestMTU(deviceId: string, mtu: number): number;

package/lib/specs/NativeBleNitroFactory.d.ts

@@ -0,0 +1,4 @@
+import { NativeBleNitroFactory } from './NativeBleNitroFactory.nitro';
+declare const NativeBleNitroFactoryImpl: NativeBleNitroFactory;
+export default NativeBleNitroFactoryImpl;
+export * from './NativeBleNitro.nitro';

package/lib/specs/NativeBleNitroFactory.js

@@ -0,0 +1,6 @@
+import { NitroModules } from 'react-native-nitro-modules';
+// Export the native implementation
+const NativeBleNitroFactoryImpl = NitroModules.createHybridObject('NativeBleNitroFactory');
+// export default NativeBleNitroImpl;
+export default NativeBleNitroFactoryImpl;
+export * from './NativeBleNitro.nitro';

package/lib/specs/NativeBleNitroFactory.nitro.d.ts

@@ -0,0 +1,8 @@
+import { HybridObject } from "react-native-nitro-modules";
+import { BLEDevice, NativeBleNitro } from "./NativeBleNitro.nitro";
+export interface NativeBleNitroFactory extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    create(nativeRestoreStateIdentifier?: string, restoreStateCallback?: (peripherals: BLEDevice[]) => void): NativeBleNitro;
+}

package/lib/specs/NativeBleNitroFactory.nitro.js

@@ -0,0 +1 @@
+export {};

package/nitro.json

@@ -12,6 +12,10 @@
     "NativeBleNitro": {
       "swift": "BleNitroBleManager",
       "kotlin": "BleNitroBleManager"
+    },
+    "NativeBleNitroFactory": {
+      "swift": "BleNitroBleManagerFactory",
+      "kotlin": "BleNitroBleManagerFactory"
     }
   },
   "ignorePaths": [

package/nitrogen/generated/android/BleNitro+autolinking.cmake

@@ -28,8 +28,10 @@ target_sources(
   ../nitrogen/generated/android/BleNitroOnLoad.cpp
   # Shared Nitrogen C++ sources
   ../nitrogen/generated/shared/c++/HybridNativeBleNitroSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridNativeBleNitroFactorySpec.cpp
   # Android-specific Nitrogen C++ sources
   ../nitrogen/generated/android/c++/JHybridNativeBleNitroSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridNativeBleNitroFactorySpec.cpp
 )
 
 # Define a flag to check if we are building properly

package/nitrogen/generated/android/BleNitroOnLoad.cpp

@@ -25,6 +25,7 @@
 #include "JFunc_void_bool_std__shared_ptr_ArrayBuffer__std__string.hpp"
 #include "JFunc_void_std__string_std__shared_ptr_ArrayBuffer_.hpp"
 #include "JFunc_void_BLEState.hpp"
+#include "JHybridNativeBleNitroFactorySpec.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
 
 namespace margelo::nitro::co::zyke::ble {
@@ -46,6 +47,7 @@ int initialize(JavaVM* vm) {
     margelo::nitro::co::zyke::ble::JFunc_void_bool_std__shared_ptr_ArrayBuffer__std__string_cxx::registerNatives();
     margelo::nitro::co::zyke::ble::JFunc_void_std__string_std__shared_ptr_ArrayBuffer__cxx::registerNatives();
     margelo::nitro::co::zyke::ble::JFunc_void_BLEState_cxx::registerNatives();
+    margelo::nitro::co::zyke::ble::JHybridNativeBleNitroFactorySpec::registerNatives();
 
     // Register Nitro Hybrid Objects
     HybridObjectRegistry::registerHybridObjectConstructor(
@@ -57,6 +59,15 @@ int initialize(JavaVM* vm) {
         return globalRef->cthis()->shared();
       }
     );
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "NativeBleNitroFactory",
+      []() -> std::shared_ptr<HybridObject> {
+        static DefaultConstructableObject<JHybridNativeBleNitroFactorySpec::javaobject> object("com/margelo/nitro/co/zyke/ble/BleNitroBleManagerFactory");
+        auto instance = object.create();
+        auto globalRef = jni::make_global(instance);
+        return globalRef->cthis()->shared();
+      }
+    );
   });
 }