react-native-ble-nitro 1.5.0 → 1.7.0

package/nitrogen/generated/shared/c++/HybridNativeBleNitroSpec.hpp

@@ -24,12 +24,12 @@ namespace margelo::nitro::co::zyke::ble { enum class BLEState; }
 // Forward declaration of `OperationResult` to properly resolve imports.
 namespace margelo::nitro::co::zyke::ble { struct OperationResult; }
 
+#include <string>
+#include <optional>
 #include "BLEDevice.hpp"
 #include <vector>
 #include <functional>
 #include "ScanFilter.hpp"
-#include <optional>
-#include <string>
 #include <NitroModules/ArrayBuffer.hpp>
 #include "BLEState.hpp"
 #include "OperationResult.hpp"
@@ -62,7 +62,8 @@ namespace margelo::nitro::co::zyke::ble {
 
     public:
       // Properties
-      
+      virtual std::optional<std::string> getRestoreStateIdentifier() = 0;
+      virtual void setRestoreStateIdentifier(const std::optional<std::string>& restoreStateIdentifier) = 0;
 
     public:
       // Methods
@@ -71,7 +72,7 @@ namespace margelo::nitro::co::zyke::ble {
       virtual bool stopScan() = 0;
       virtual bool isScanning() = 0;
       virtual std::vector<BLEDevice> getConnectedDevices(const std::vector<std::string>& services) = 0;
-      virtual void connect(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* deviceId */, const std::string& /* error */)>& callback, const std::optional<std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)>>& disconnectCallback) = 0;
+      virtual void connect(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* deviceId */, const std::string& /* error */)>& callback, const std::optional<std::function<void(const std::string& /* deviceId */, bool /* interrupted */, const std::string& /* error */)>>& disconnectCallback, std::optional<bool> autoConnectAndroid) = 0;
       virtual void disconnect(const std::string& deviceId, const std::function<void(bool /* success */, const std::string& /* error */)>& callback) = 0;
       virtual bool isConnected(const std::string& deviceId) = 0;
       virtual double requestMTU(const std::string& deviceId, double mtu) = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-ble-nitro",
-  "version": "1.5.0",
+  "version": "1.7.0",
   "description": "High-performance React Native BLE library built on Nitro Modules",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -23,6 +23,14 @@
       "types": "./lib/manager.d.ts",
       "default": "./src/manager.ts"
     },
+    "./singleton": {
+      "react-native": "./src/singleton.ts",
+      "typescript": "./src/singleton.ts",
+      "import": "./lib/singleton.js",
+      "require": "./lib/commonjs/singleton.js",
+      "types": "./lib/singleton.d.ts",
+      "default": "./src/singleton.ts"
+    },
     "./plugin": {
       "import": "./plugin/build/index.js",
       "require": "./plugin/build/index.js",

package/src/__tests__/index.test.ts

@@ -1,31 +1,34 @@
 // Mock the native module import
+const mockNativeInstance = {
+  setRestoreStateCallback: jest.fn(),
+  startScan: jest.fn(),
+  stopScan: jest.fn(),
+  isScanning: jest.fn(),
+  connect: jest.fn(),
+  disconnect: jest.fn(),
+  isConnected: jest.fn(),
+  requestMTU: jest.fn(),
+  readRSSI: jest.fn(),
+  discoverServices: jest.fn(),
+  getServices: jest.fn(),
+  getCharacteristics: jest.fn(),
+  readCharacteristic: jest.fn(),
+  writeCharacteristic: jest.fn(),
+  subscribeToCharacteristic: jest.fn(),
+  unsubscribeFromCharacteristic: jest.fn(),
+  getConnectedDevices: jest.fn(),
+  requestBluetoothEnable: jest.fn(),
+  state: jest.fn(),
+  subscribeToStateChange: jest.fn(),
+  unsubscribeFromStateChange: jest.fn(),
+  openSettings: jest.fn(),
+  restoreStateIdentifier: null,
+};
+
 jest.mock('../specs/NativeBleNitro', () => ({
   __esModule: true,
-  default: {
-    setRestoreStateCallback: jest.fn(),
-    startScan: jest.fn(),
-    stopScan: jest.fn(),
-    isScanning: jest.fn(),
-    connect: jest.fn(),
-    disconnect: jest.fn(),
-    isConnected: jest.fn(),
-    requestMTU: jest.fn(),
-    readRSSI: jest.fn(),
-    discoverServices: jest.fn(),
-    getServices: jest.fn(),
-    getCharacteristics: jest.fn(),
-    readCharacteristic: jest.fn(),
-    writeCharacteristic: jest.fn(),
-    subscribeToCharacteristic: jest.fn(),
-    unsubscribeFromCharacteristic: jest.fn(),
-    getConnectedDevices: jest.fn(),
-    requestBluetoothEnable: jest.fn(),
-    state: jest.fn(),
-    subscribeToStateChange: jest.fn(),
-    unsubscribeFromStateChange: jest.fn(),
-    openSettings: jest.fn(),
-  },
-  BLEState: { 
+  default: mockNativeInstance,
+  BLEState: {
     Unknown: 0,
     Resetting: 1,
     Unsupported: 2,
@@ -41,10 +44,17 @@ jest.mock('../specs/NativeBleNitro', () => ({
   },
 }));
 
+jest.mock('../specs/NativeBleNitroFactory', () => ({
+  __esModule: true,
+  default: {
+    create: jest.fn(() => mockNativeInstance),
+  },
+}));
+
 import { BleNitro } from '../index';
 
 // Get reference to the mocked module
-const mockNative = require('../specs/NativeBleNitro').default; // eslint-disable-line @typescript-eslint/no-var-requires
+const mockNative = mockNativeInstance;
 
 // Get BLE instance
 const BleManager = BleNitro.instance();
@@ -97,8 +107,8 @@ describe('BleNitro', () => {
     });
 
     const result = await BleManager.connect(deviceId);
-    
-    expect(mockNative.connect).toHaveBeenCalledWith(deviceId, expect.any(Function), undefined);
+
+    expect(mockNative.connect).toHaveBeenCalledWith(deviceId, expect.any(Function), undefined, false);
     expect(result).toBe(deviceId);
   });
 
@@ -142,7 +152,7 @@ describe('BleNitro', () => {
 
     const data = [1, 2, 3];
     const result = await BleManager.writeCharacteristic('device-write', 'service', 'char', data, false);
-    
+
     expect(mockNative.writeCharacteristic).toHaveBeenCalledWith(
       'device-write',
       '0service-0000-1000-8000-00805f9b34fb',
@@ -170,7 +180,7 @@ describe('BleNitro', () => {
 
     const data = [1, 2, 3];
     const result = await BleManager.writeCharacteristic('device-write-resp', 'service', 'char', data, true);
-    
+
     expect(mockNative.writeCharacteristic).toHaveBeenCalledWith(
       'device-write-resp',
       '0service-0000-1000-8000-00805f9b34fb',
@@ -196,15 +206,15 @@ describe('BleNitro', () => {
     });
 
     const result = await BleManager.readCharacteristic('device', 'service', 'char');
-    
+
     // UUIDs should be normalized in the call
     expect(mockNative.readCharacteristic).toHaveBeenCalledWith(
-      'device', 
+      'device',
       '0service-0000-1000-8000-00805f9b34fb',  // 'service' padded to 8 chars
       '0000char-0000-1000-8000-00805f9b34fb',  // 'char' padded to 8 chars
       expect.any(Function)
     );
-    
+
     // Result should be number array (ByteArray)
     expect(Array.isArray(result)).toBe(true);
     expect(result).toEqual([85]);
@@ -223,7 +233,7 @@ describe('BleNitro', () => {
     });
 
     const result = await BleManager.disconnect('device');
-    
+
     expect(mockNative.disconnect).toHaveBeenCalledWith('device', expect.any(Function));
     expect(result).toBe(undefined);
   });
@@ -245,10 +255,10 @@ describe('BleNitro', () => {
 
     const notificationCallback = jest.fn();
     const subscription = BleManager.subscribeToCharacteristic('device', 'service', 'char', notificationCallback);
-    
+
     expect(mockNative.subscribeToCharacteristic).toHaveBeenCalled();
     expect(notificationCallback).toHaveBeenCalledWith('char-id', [1, 2, 3]);
-    
+
     // Verify subscription object
     expect(subscription).toHaveProperty('remove');
     expect(typeof subscription.remove).toBe('function');
@@ -257,10 +267,10 @@ describe('BleNitro', () => {
   test('connect with disconnect event callback', async () => {
     const deviceId = 'test-device-2'; // Use different device ID to avoid state conflicts
     const onDisconnect = jest.fn();
-    
+
     mockNative.connect.mockImplementation((id: string, callback: (success: boolean, deviceId: string, error: string) => void, disconnectCallback?: (deviceId: string, interrupted: boolean, error: string) => void) => {
       callback(true, id, '');
-      // Simulate a disconnect event later  
+      // Simulate a disconnect event later
       if (disconnectCallback) {
         setTimeout(() => {
           disconnectCallback(id, true, 'Connection lost'); // interrupted = true
@@ -269,10 +279,10 @@ describe('BleNitro', () => {
     });
 
     const result = await BleManager.connect(deviceId, onDisconnect);
-    
-    expect(mockNative.connect).toHaveBeenCalledWith(deviceId, expect.any(Function), expect.any(Function));
+
+    expect(mockNative.connect).toHaveBeenCalledWith(deviceId, expect.any(Function), expect.any(Function), false);
     expect(result).toBe(deviceId);
-    
+
     // Wait for disconnect callback
     await new Promise(resolve => setTimeout(resolve, 30));
     expect(onDisconnect).toHaveBeenCalledWith(deviceId, true, 'Connection lost');
@@ -297,7 +307,7 @@ describe('BleNitro', () => {
     });
 
     const rssi = await BleManager.readRSSI('device-rssi');
-    
+
     expect(mockNative.readRSSI).toHaveBeenCalledWith(
       'device-rssi',
       expect.any(Function)
@@ -318,7 +328,7 @@ describe('BleNitro', () => {
     });
 
     await expect(BleManager.readRSSI('device-rssi-fail')).rejects.toThrow('RSSI read failed');
-    
+
     expect(mockNative.readRSSI).toHaveBeenCalledWith(
       'device-rssi-fail',
       expect.any(Function)

package/src/index.ts

@@ -1,5 +1,3 @@
-import { BleNitroManager } from "./manager";
-
 export {
   type ByteArray,
   type ScanFilter,
@@ -12,19 +10,10 @@ export {
   type OperationCallback,
   type CharacteristicUpdateCallback,
   type Subscription,
-  type BleNitroManager,
   type BleNitroManagerOptions,
   BLEState,
   AndroidScanMode,
+  BleNitroManager,
 } from "./manager";
 
-let _instance: BleNitroManager;
-
-export class BleNitro extends BleNitroManager {
-  public static instance() {
-    if (!_instance) {
-      _instance = new BleNitro();
-    }
-    return _instance;
-  }
-}
+export { BleNitro } from './singleton';

package/src/manager.ts

@@ -1,4 +1,4 @@
-import BleNitroNative from './specs/NativeBleNitro';
+import BleNitroNativeFactory, { NativeBleNitro } from './specs/NativeBleNitroFactory';
 import {
   ScanFilter as NativeScanFilter,
   BLEDevice as NativeBLEDevice,
@@ -32,6 +32,7 @@ export interface BLEDevice {
   manufacturerData: ManufacturerData;
   serviceUUIDs: string[];
   isConnectable: boolean;
+  isConnected: boolean;
 }
 
 export type ScanCallback = (device: BLEDevice) => void;
@@ -73,6 +74,7 @@ export enum AndroidScanMode {
 }
 
 export type BleNitroManagerOptions = {
+  restoreIdentifier?: string;
   onRestoredState?: RestoreStateCallback;
 };
 
@@ -123,16 +125,24 @@ export class BleNitroManager {
   private _isScanning: boolean = false;
   private _connectedDevices: { [deviceId: string]: boolean } = {};
 
-  private _restoredStateCallback: RestoreStateCallback | null = null;
+  private _restoredStateCallback: RestoreStateCallback | null;
   private _restoredState: BLEDevice[] | null = null;
+  private _restoreStateIdentifier: string | null = null;
+
+  private Instance: NativeBleNitro;
 
   constructor(options?: BleNitroManagerOptions) {
-    this._restoredStateCallback = options?.onRestoredState || null;
-    BleNitroNative.setRestoreStateCallback((peripherals: NativeBLEDevice[]) => this.onNativeRestoreStateCallback(peripherals));
+    this._restoredStateCallback = options?.onRestoredState ?? null;
+    this._restoreStateIdentifier = options?.restoreIdentifier ?? null;
+    this.Instance = BleNitroNativeFactory.create(options?.restoreIdentifier, (peripherals: NativeBLEDevice[]) => this.onNativeRestoreStateCallback(peripherals));
   }
 
   private onNativeRestoreStateCallback(peripherals: NativeBLEDevice[]) {
+    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);
     } else {
@@ -140,7 +150,13 @@ export class BleNitroManager {
     }
   }
 
+  /**
+   * 
+   * 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!
+   */
   public onRestoredState(callback: RestoreStateCallback) {
+    if (!this._restoreStateIdentifier) return;
     if (this._restoredState) {
       callback(this._restoredState);
       this._restoredState = null;
@@ -176,7 +192,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
    */
   public startScan(
     filter: ScanFilter = {},
@@ -209,29 +225,29 @@ export class BleNitroManager {
     };
 
     // 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
    */
   public stopScan(): void {
     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
    */
   public isScanning(): boolean {
-    this._isScanning = BleNitroNative.isScanning();
+    this._isScanning = this.Instance.isScanning();
     return this._isScanning;
   }
 
@@ -241,7 +257,7 @@ export class BleNitroManager {
    * @returns Array of connected devices
    */
   public getConnectedDevices(services?: string[]): BLEDevice[] {
-    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));
   }
@@ -250,11 +266,12 @@ 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
    */
   public connect(
     deviceId: string, 
-    onDisconnect?: DisconnectEventCallback
+    onDisconnect?: DisconnectEventCallback,
+    autoConnectAndroid?: boolean,
   ): Promise<string> {
     return new Promise((resolve, reject) => {
       // Check if already connected
@@ -263,7 +280,7 @@ export class BleNitroManager {
         return;
       }
 
-      BleNitroNative.connect(
+      this.Instance.connect(
         deviceId,
         (success: boolean, connectedDeviceId: string, error: string) => {
           if (success) {
@@ -277,11 +294,45 @@ 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
+   */
+  public findAndConnect(deviceId: string, options?: { scanTimeout?: number, autoConnectAndroid?: boolean, onDisconnect?: DisconnectEventCallback }): Promise<string> {
+    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);
+          });
+        }
+      });
+    });
+  }
+
   /**
    * Disconnect from a Bluetooth device
    * @param deviceId ID of the device to disconnect from
@@ -295,7 +346,7 @@ export class BleNitroManager {
         return;
       }
 
-      BleNitroNative.disconnect(
+      this.Instance.disconnect(
         deviceId,
         (success: boolean, error: string) => {
           if (success) {
@@ -312,10 +363,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
    */
   public isConnected(deviceId: string): boolean {
-    return BleNitroNative.isConnected(deviceId);
+    return this.Instance.isConnected(deviceId);
   }
 
   /**
@@ -326,7 +377,7 @@ export class BleNitroManager {
    */
   public requestMTU(deviceId: string, mtu: number): number {
     mtu = parseInt(mtu.toString(), 10);
-    const deviceMtu = BleNitroNative.requestMTU(deviceId, mtu);
+    const deviceMtu = this.Instance.requestMTU(deviceId, mtu);
     return deviceMtu;
   }
 
@@ -343,7 +394,7 @@ export class BleNitroManager {
         return;
       }
 
-      BleNitroNative.readRSSI(
+      this.Instance.readRSSI(
         deviceId,
         (success: boolean, rssi: number, error: string) => {
           if (success) {
@@ -369,7 +420,7 @@ export class BleNitroManager {
         return;
       }
 
-      BleNitroNative.discoverServices(
+      this.Instance.discoverServices(
         deviceId,
         (success: boolean, error: string) => {
           if (success) {
@@ -400,7 +451,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));
     });
   }
@@ -409,7 +460,7 @@ 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
    */
   public getCharacteristics(
     deviceId: string,
@@ -419,19 +470,37 @@ export class BleNitroManager {
       throw new Error('Device not connected');
     }
 
-    const characteristics = BleNitroNative.getCharacteristics(
+    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
+   */
+  public async getServicesWithCharacteristics(deviceId: string): Promise<{ uuid: string; characteristics: string[] }[]> {
+    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
    */
   public readCharacteristic(
     deviceId: string,
@@ -445,7 +514,7 @@ export class BleNitroManager {
         return;
       }
 
-      BleNitroNative.readCharacteristic(
+      this.Instance.readCharacteristic(
         deviceId,
         BleNitroManager.normalizeGattUUID(serviceId),
         BleNitroManager.normalizeGattUUID(characteristicId),
@@ -483,7 +552,7 @@ export class BleNitroManager {
         return;
       }
 
-      BleNitroNative.writeCharacteristic(
+      this.Instance.writeCharacteristic(
         deviceId,
         BleNitroManager.normalizeGattUUID(serviceId),
         BleNitroManager.normalizeGattUUID(characteristicId),
@@ -508,7 +577,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
    */
   public subscribeToCharacteristic(
     deviceId: string,
@@ -523,7 +592,7 @@ export class BleNitroManager {
 
     let _success = false;
 
-    BleNitroNative.subscribeToCharacteristic(
+    this.Instance.subscribeToCharacteristic(
       deviceId,
       BleNitroManager.normalizeGattUUID(serviceId),
       BleNitroManager.normalizeGattUUID(characteristicId),
@@ -571,7 +640,7 @@ export class BleNitroManager {
         return;
       }
 
-      BleNitroNative.unsubscribeFromCharacteristic(
+      this.Instance.unsubscribeFromCharacteristic(
         deviceId,
         BleNitroManager.normalizeGattUUID(serviceId),
         BleNitroManager.normalizeGattUUID(characteristicId),
@@ -588,7 +657,7 @@ export class BleNitroManager {
 
   /**
    * Check if Bluetooth is enabled
-   * @returns Promise resolving to Bluetooth state
+   * @returns returns Boolean according to Bluetooth state
    */
   public isBluetoothEnabled(): boolean {
     return this.state() === BLEState.PoweredOn;
@@ -600,7 +669,7 @@ export class BleNitroManager {
    */
   public requestBluetoothEnable(): Promise<boolean> {
     return new Promise((resolve, reject) => {
-      BleNitroNative.requestBluetoothEnable(
+      this.Instance.requestBluetoothEnable(
         (success: boolean, error: string) => {
           if (success) {
             resolve(true);
@@ -614,18 +683,18 @@ export class BleNitroManager {
 
   /**
    * Get the current Bluetooth state
-   * @returns Promise resolving to Bluetooth state
+   * @returns Bluetooth state
    * @see BLEState
    */
   public state(): BLEState {
-    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
    */
   public subscribeToStateChange(callback: (state: BLEState) => void, emitInitial = false): Subscription {
@@ -634,13 +703,13 @@ export class BleNitroManager {
         callback(state);
       }
 
-      BleNitroNative.subscribeToStateChange((nativeState: NativeBLEState) => {
+      this.Instance.subscribeToStateChange((nativeState: NativeBLEState) => {
         callback(mapNativeBLEStateToBLEState(nativeState));
       });
 
       return {
         remove: () => {
-          BleNitroNative.unsubscribeFromStateChange();
+          this.Instance.unsubscribeFromStateChange();
         },
       };
   }
@@ -650,6 +719,6 @@ export class BleNitroManager {
    * @returns Promise resolving when settings are opened
    */
   public openSettings(): Promise<void> {
-    return BleNitroNative.openSettings();
+    return this.Instance.openSettings();
   }
 }

package/src/singleton.ts

@@ -0,0 +1,17 @@
+import { BleNitroManager } from "./manager";
+
+let _instance: BleNitroManager;
+
+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
+   */
+  public static instance(): BleNitroManager {
+    if (!_instance) {
+      _instance = new BleNitro();
+    }
+    return _instance;
+  }
+}