react-native-ble-nitro 1.3.1 → 1.4.0

package/lib/index.d.ts

@@ -1,195 +1,5 @@
-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;

package/lib/index.js

@@ -1,444 +1,11 @@
-import BleNitroNative from './specs/NativeBleNitro';
-import { AndroidScanMode as NativeAndroidScanMode, } from './specs/NativeBleNitro';
-export var BLEState;
-(function (BLEState) {
-    BLEState["Unknown"] = "Unknown";
-    BLEState["Resetting"] = "Resetting";
-    BLEState["Unsupported"] = "Unsupported";
-    BLEState["Unauthorized"] = "Unauthorized";
-    BLEState["PoweredOff"] = "PoweredOff";
-    BLEState["PoweredOn"] = "PoweredOn";
-})(BLEState || (BLEState = {}));
-;
-export var AndroidScanMode;
-(function (AndroidScanMode) {
-    AndroidScanMode["LowLatency"] = "LowLatency";
-    AndroidScanMode["Balanced"] = "Balanced";
-    AndroidScanMode["LowPower"] = "LowPower";
-    AndroidScanMode["Opportunistic"] = "Opportunistic";
-})(AndroidScanMode || (AndroidScanMode = {}));
-function mapNativeBLEStateToBLEState(nativeState) {
-    const map = {
-        0: BLEState.Unknown,
-        1: BLEState.Resetting,
-        2: BLEState.Unsupported,
-        3: BLEState.Unauthorized,
-        4: BLEState.PoweredOff,
-        5: BLEState.PoweredOn,
-    };
-    return map[nativeState];
-}
-function mapAndroidScanModeToNativeAndroidScanMode(scanMode) {
-    const map = {
-        LowLatency: NativeAndroidScanMode.LowLatency,
-        Balanced: NativeAndroidScanMode.Balanced,
-        LowPower: NativeAndroidScanMode.LowPower,
-        Opportunistic: NativeAndroidScanMode.Opportunistic,
-    };
-    return map[scanMode];
-}
-function convertNativeBleDeviceToBleDevice(nativeBleDevice) {
-    return {
-        ...nativeBleDevice,
-        serviceUUIDs: BleNitro.normalizeGattUUIDs(nativeBleDevice.serviceUUIDs),
-        manufacturerData: {
-            companyIdentifiers: nativeBleDevice.manufacturerData.companyIdentifiers.map(entry => ({
-                id: entry.id,
-                data: arrayBufferToByteArray(entry.data)
-            }))
-        }
-    };
-}
-function arrayBufferToByteArray(buffer) {
-    return Array.from(new Uint8Array(buffer));
-}
-function byteArrayToArrayBuffer(data) {
-    return new Uint8Array(data).buffer;
-}
+import { BleNitroManager } from "./manager";
+export { BLEState, AndroidScanMode, } from "./manager";
 let _instance;
-export class BleNitro {
-    constructor() {
-        this._isScanning = false;
-        this._connectedDevices = {};
-    }
+export class BleNitro extends BleNitroManager {
     static instance() {
         if (!_instance) {
             _instance = new BleNitro();
         }
         return _instance;
     }
-    /**
-     * 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) {
-        const cleanUuid = uuid.toLowerCase();
-        // 128-Bit UUID → normalisieren
-        if (cleanUuid.length === 36 && cleanUuid.includes("-")) {
-            return cleanUuid;
-        }
-        // GATT-Service UUIDs
-        // 16- oder 32-Bit UUID → 128-Bit UUID
-        const padded = cleanUuid.padStart(8, "0");
-        return `${padded}-0000-1000-8000-00805f9b34fb`;
-    }
-    static normalizeGattUUIDs(uuids) {
-        return uuids.map((uuid) => BleNitro.normalizeGattUUID(uuid));
-    }
-    /**
-     * 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 = {}, callback, onError) {
-        if (this._isScanning) {
-            return;
-        }
-        // Create native scan filter with defaults
-        const nativeFilter = {
-            serviceUUIDs: filter.serviceUUIDs || [],
-            rssiThreshold: filter.rssiThreshold ?? -100,
-            allowDuplicates: filter.allowDuplicates ?? false,
-            androidScanMode: mapAndroidScanModeToNativeAndroidScanMode(filter.androidScanMode ?? AndroidScanMode.Balanced),
-        };
-        // Create callback wrapper
-        const scanCallback = (device, error) => {
-            if (error && !device) {
-                this._isScanning = false;
-                onError?.(error);
-                return;
-            }
-            device = device; // eslint-disable-line @typescript-eslint/no-non-null-assertion
-            // Convert manufacturer data to Uint8Arrays
-            const convertedDevice = convertNativeBleDeviceToBleDevice(device);
-            callback(convertedDevice);
-        };
-        // Start scan
-        BleNitroNative.startScan(nativeFilter, scanCallback);
-        this._isScanning = true;
-    }
-    /**
-     * Stop scanning for Bluetooth devices
-     * @returns Promise resolving to success state
-     */
-    stopScan() {
-        if (!this._isScanning) {
-            return;
-        }
-        BleNitroNative.stopScan();
-        this._isScanning = false;
-    }
-    /**
-     * Check if currently scanning for devices
-     * @returns Promise resolving to scanning state
-     */
-    isScanning() {
-        this._isScanning = BleNitroNative.isScanning();
-        return this._isScanning;
-    }
-    /**
-     * Get all currently connected devices
-     * @param services Optional list of service UUIDs to filter by
-     * @returns Array of connected devices
-     */
-    getConnectedDevices(services) {
-        const devices = BleNitroNative.getConnectedDevices(services || []);
-        // Normalize service UUIDs - manufacturer data already comes as ArrayBuffers
-        return devices.map(device => convertNativeBleDeviceToBleDevice(device));
-    }
-    /**
-     * 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, onDisconnect) {
-        return new Promise((resolve, reject) => {
-            // Check if already connected
-            if (this._connectedDevices[deviceId]) {
-                resolve(deviceId);
-                return;
-            }
-            BleNitroNative.connect(deviceId, (success, connectedDeviceId, error) => {
-                if (success) {
-                    this._connectedDevices[deviceId] = true;
-                    resolve(connectedDeviceId);
-                }
-                else {
-                    reject(new Error(error));
-                }
-            }, onDisconnect ? (deviceId, interrupted, error) => {
-                // Remove from connected devices when disconnected
-                delete this._connectedDevices[deviceId];
-                onDisconnect(deviceId, interrupted, error);
-            } : undefined);
-        });
-    }
-    /**
-     * Disconnect from a Bluetooth device
-     * @param deviceId ID of the device to disconnect from
-     * @returns Promise resolving when disconnected
-     */
-    disconnect(deviceId) {
-        return new Promise((resolve, reject) => {
-            // Check if already disconnected
-            if (!this._connectedDevices[deviceId]) {
-                resolve();
-                return;
-            }
-            BleNitroNative.disconnect(deviceId, (success, error) => {
-                if (success) {
-                    delete this._connectedDevices[deviceId];
-                    resolve();
-                }
-                else {
-                    reject(new Error(error));
-                }
-            });
-        });
-    }
-    /**
-     * Check if connected to a device
-     * @param deviceId ID of the device to check
-     * @returns Promise resolving to connection state
-     */
-    isConnected(deviceId) {
-        return BleNitroNative.isConnected(deviceId);
-    }
-    /**
-     * 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, mtu) {
-        mtu = parseInt(mtu.toString(), 10);
-        const deviceMtu = BleNitroNative.requestMTU(deviceId, mtu);
-        return deviceMtu;
-    }
-    /**
-     * Discover services for a connected device
-     * @param deviceId ID of the device
-     * @returns Promise resolving when services are discovered
-     */
-    discoverServices(deviceId) {
-        return new Promise((resolve, reject) => {
-            // Check if connected first
-            if (!this._connectedDevices[deviceId]) {
-                reject(new Error('Device not connected'));
-                return;
-            }
-            BleNitroNative.discoverServices(deviceId, (success, error) => {
-                if (success) {
-                    resolve(true);
-                }
-                else {
-                    reject(new Error(error));
-                }
-            });
-        });
-    }
-    /**
-     * Get services for a connected device
-     * @param deviceId ID of the device
-     * @returns Promise resolving to array of service UUIDs
-     */
-    getServices(deviceId) {
-        return new Promise(async (resolve, reject) => {
-            // Check if connected first
-            if (!this._connectedDevices[deviceId]) {
-                reject(new Error('Device not connected'));
-                return;
-            }
-            const success = await this.discoverServices(deviceId);
-            if (!success) {
-                reject(new Error('Failed to discover services'));
-                return;
-            }
-            const services = BleNitroNative.getServices(deviceId);
-            resolve(BleNitro.normalizeGattUUIDs(services));
-        });
-    }
-    /**
-     * 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, serviceId) {
-        if (!this._connectedDevices[deviceId]) {
-            throw new Error('Device not connected');
-        }
-        const characteristics = BleNitroNative.getCharacteristics(deviceId, BleNitro.normalizeGattUUID(serviceId));
-        return BleNitro.normalizeGattUUIDs(characteristics);
-    }
-    /**
-     * 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, serviceId, characteristicId) {
-        return new Promise((resolve, reject) => {
-            // Check if connected first
-            if (!this._connectedDevices[deviceId]) {
-                reject(new Error('Device not connected'));
-                return;
-            }
-            BleNitroNative.readCharacteristic(deviceId, BleNitro.normalizeGattUUID(serviceId), BleNitro.normalizeGattUUID(characteristicId), (success, data, error) => {
-                if (success) {
-                    resolve(arrayBufferToByteArray(data));
-                }
-                else {
-                    reject(new Error(error));
-                }
-            });
-        });
-    }
-    /**
-     * 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, serviceId, characteristicId, data, withResponse = true) {
-        return new Promise((resolve, reject) => {
-            // Check if connected first
-            if (!this._connectedDevices[deviceId]) {
-                reject(new Error('Device not connected'));
-                return;
-            }
-            BleNitroNative.writeCharacteristic(deviceId, BleNitro.normalizeGattUUID(serviceId), BleNitro.normalizeGattUUID(characteristicId), byteArrayToArrayBuffer(data), withResponse, (success, error) => {
-                if (success) {
-                    resolve(true);
-                }
-                else {
-                    reject(new Error(error));
-                }
-            });
-        });
-    }
-    /**
-     * 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, serviceId, characteristicId, callback) {
-        // Check if connected first
-        if (!this._connectedDevices[deviceId]) {
-            throw new Error('Device not connected');
-        }
-        let _success = false;
-        BleNitroNative.subscribeToCharacteristic(deviceId, BleNitro.normalizeGattUUID(serviceId), BleNitro.normalizeGattUUID(characteristicId), (charId, data) => {
-            callback(charId, arrayBufferToByteArray(data));
-        }, (success, error) => {
-            _success = success;
-            if (!success) {
-                throw new Error(error);
-            }
-        });
-        return {
-            remove: () => {
-                if (!_success) {
-                    return;
-                }
-                this.unsubscribeFromCharacteristic(deviceId, serviceId, characteristicId).catch(() => { });
-            }
-        };
-    }
-    /**
-     * 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, serviceId, characteristicId) {
-        return new Promise((resolve, reject) => {
-            // Check if connected first
-            if (!this._connectedDevices[deviceId]) {
-                reject(new Error('Device not connected'));
-                return;
-            }
-            BleNitroNative.unsubscribeFromCharacteristic(deviceId, BleNitro.normalizeGattUUID(serviceId), BleNitro.normalizeGattUUID(characteristicId), (success, error) => {
-                if (success) {
-                    resolve();
-                }
-                else {
-                    reject(new Error(error));
-                }
-            });
-        });
-    }
-    /**
-     * Check if Bluetooth is enabled
-     * @returns Promise resolving to Bluetooth state
-     */
-    isBluetoothEnabled() {
-        return this.state() === BLEState.PoweredOn;
-    }
-    /**
-     * Request to enable Bluetooth (Android only)
-     * @returns Promise resolving when Bluetooth is enabled
-     */
-    requestBluetoothEnable() {
-        return new Promise((resolve, reject) => {
-            BleNitroNative.requestBluetoothEnable((success, error) => {
-                if (success) {
-                    resolve(true);
-                }
-                else {
-                    reject(new Error(error));
-                }
-            });
-        });
-    }
-    /**
-     * Get the current Bluetooth state
-     * @returns Promise resolving to Bluetooth state
-     * @see BLEState
-     */
-    state() {
-        return mapNativeBLEStateToBLEState(BleNitroNative.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
-     * @see BLEState
-     */
-    subscribeToStateChange(callback, emitInitial = false) {
-        if (emitInitial) {
-            const state = this.state();
-            callback(state);
-        }
-        BleNitroNative.subscribeToStateChange((nativeState) => {
-            callback(mapNativeBLEStateToBLEState(nativeState));
-        });
-        return {
-            remove: () => {
-                BleNitroNative.unsubscribeFromStateChange();
-            },
-        };
-    }
-    /**
-     * Open Bluetooth settings
-     * @returns Promise resolving when settings are opened
-     */
-    openSettings() {
-        return BleNitroNative.openSettings();
-    }
 }
-// Singleton instance
-export const ble = BleNitro.instance();