react-native-ble-nitro 1.0.0-beta.9 → 1.0.0

package/lib/index.d.ts

@@ -1,10 +1,174 @@
-export * from './compatibility/constants';
-export * from './utils/index';
-export { BleManagerCompat as BleManager, createBleManagerCompat as createBleManager } from './BleManagerCompatFactory';
-export { getCustomErrorMessage, getStoredCallbacks } from './BleManagerFactory';
-export * from './errors/BleError';
-export { DeviceWrapper as Device } from './compatibility/deviceWrapper';
-export type { BleManagerOptions, ScanOptions, ConnectionOptions, NativeBleError, NativeDevice, NativeService, NativeCharacteristic, NativeDescriptor, Subscription } from './specs/types';
-export { State, LogLevel } from './compatibility/enums';
-export type { CharacteristicSubscriptionType, RefreshGattMoment } from './compatibility/enums';
-export { fullUUID } from './utils/uuid';
+export interface ScanFilter {
+    serviceUUIDs?: string[];
+    rssiThreshold?: number;
+    allowDuplicates?: boolean;
+}
+export interface ManufacturerDataEntry {
+    id: string;
+    data: number[];
+}
+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 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: number[]) => void;
+export type Subscription = {
+    remove: () => Promise<void>;
+};
+export declare enum BLEState {
+    Unknown = "Unknown",
+    Resetting = "Resetting",
+    Unsupported = "Unsupported",
+    Unauthorized = "Unauthorized",
+    PoweredOff = "PoweredOff",
+    PoweredOn = "PoweredOn"
+}
+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): Promise<boolean>;
+    /**
+     * Stop scanning for Bluetooth devices
+     * @returns Promise resolving to success state
+     */
+    stopScan(): Promise<boolean>;
+    /**
+     * Check if currently scanning for devices
+     * @returns Promise resolving to scanning state
+     */
+    isScanning(): Promise<boolean>;
+    /**
+     * Get all currently connected devices
+     * @returns Promise resolving to array of connected devices
+     */
+    getConnectedDevices(): Promise<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<boolean>;
+    /**
+     * Check if connected to a device
+     * @param deviceId ID of the device to check
+     * @returns Promise resolving to connection state
+     */
+    isConnected(deviceId: string): Promise<boolean>;
+    /**
+     * 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): Promise<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 byte array
+     */
+    readCharacteristic(deviceId: string, serviceId: string, characteristicId: string): Promise<number[]>;
+    /**
+     * 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 an array of bytes
+     * @param withResponse Whether to wait for response
+     * @returns Promise resolving when write is complete
+     */
+    writeCharacteristic(deviceId: string, serviceId: string, characteristicId: string, data: number[], 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): Promise<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(): Promise<boolean>;
+    /**
+     * Request to enable Bluetooth
+     * @returns Promise resolving when Bluetooth is enabled
+     */
+    requestBluetoothEnable(): Promise<boolean>;
+    /**
+     * Get the current Bluetooth state
+     * @returns Promise resolving to Bluetooth state
+     * @see BLEState
+     */
+    state(): Promise<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): Promise<Subscription>;
+    /**
+     * Open Bluetooth settings
+     * @returns Promise resolving when settings are opened
+     */
+    openSettings(): Promise<void>;
+}
+export declare const ble: BleNitro;

package/lib/index.js

@@ -1,16 +1,456 @@
-// Export compatibility layer types and constants
-export * from './compatibility/constants';
-// Export utility functions
-export * from './utils/index';
-// Export the main BleManager instance with compatibility wrapper
-export { BleManagerCompat as BleManager, createBleManagerCompat as createBleManager } from './BleManagerCompatFactory';
-// Export BleManager factory utilities (for internal use by error handling)
-export { getCustomErrorMessage, getStoredCallbacks } from './BleManagerFactory';
-// Export error handling utilities
-export * from './errors/BleError';
-// Export device wrapper for compatibility
-export { DeviceWrapper as Device } from './compatibility/deviceWrapper';
-// Export react-native-ble-plx compatible enum types (drop-in replacement)
-export { State, LogLevel } from './compatibility/enums';
-// Re-export react-native-ble-plx compatible API
-export { fullUUID } from './utils/uuid';
+import BleNitroNative 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 = {}));
+;
+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];
+}
+let _instance;
+export class BleNitro {
+    constructor() {
+        this._isScanning = false;
+        this._connectedDevices = {};
+    }
+    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) {
+        return new Promise((resolve) => {
+            // Don't start scanning if already scanning
+            if (this._isScanning) {
+                resolve(true);
+                return;
+            }
+            // Create native scan filter with defaults
+            const nativeFilter = {
+                serviceUUIDs: filter.serviceUUIDs || [],
+                rssiThreshold: filter.rssiThreshold ?? -100,
+                allowDuplicates: filter.allowDuplicates ?? false,
+            };
+            // Create callback wrapper
+            const scanCallback = (device) => {
+                device.serviceUUIDs = BleNitro.normalizeGattUUIDs(device.serviceUUIDs);
+                callback(device);
+            };
+            // Start scan
+            BleNitroNative.startScan(nativeFilter, scanCallback);
+            this._isScanning = true;
+            resolve(true);
+        });
+    }
+    /**
+     * Stop scanning for Bluetooth devices
+     * @returns Promise resolving to success state
+     */
+    stopScan() {
+        return new Promise((resolve, reject) => {
+            // Don't stop scanning if not scanning
+            if (!this._isScanning) {
+                resolve(true);
+                return;
+            }
+            BleNitroNative.stopScan((success, error) => {
+                if (success) {
+                    this._isScanning = false;
+                    resolve(true);
+                }
+                else {
+                    reject(new Error(error));
+                }
+            });
+        });
+    }
+    /**
+     * Check if currently scanning for devices
+     * @returns Promise resolving to scanning state
+     */
+    isScanning() {
+        return new Promise((resolve) => {
+            BleNitroNative.isScanning((scanning) => {
+                this._isScanning = scanning;
+                resolve(scanning);
+            });
+        });
+    }
+    /**
+     * Get all currently connected devices
+     * @returns Promise resolving to array of connected devices
+     */
+    getConnectedDevices() {
+        return new Promise((resolve) => {
+            BleNitroNative.getConnectedDevices((devices) => {
+                // Normalize service UUIDs for connected devices
+                const normalizedDevices = devices.map(device => ({
+                    ...device,
+                    serviceUUIDs: BleNitro.normalizeGattUUIDs(device.serviceUUIDs)
+                }));
+                resolve(normalizedDevices);
+            });
+        });
+    }
+    /**
+     * 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(true);
+                return;
+            }
+            BleNitroNative.disconnect(deviceId, (success, error) => {
+                if (success) {
+                    delete this._connectedDevices[deviceId];
+                    resolve(true);
+                }
+                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 new Promise((resolve) => {
+            BleNitroNative.isConnected(deviceId, (connected) => {
+                this._connectedDevices[deviceId] = connected;
+                resolve(connected);
+            });
+        });
+    }
+    /**
+     * 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;
+            }
+            BleNitroNative.getServices(deviceId, (services) => {
+                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) {
+        return new Promise((resolve, reject) => {
+            // Check if connected first
+            if (!this._connectedDevices[deviceId]) {
+                reject(new Error('Device not connected'));
+                return;
+            }
+            BleNitroNative.getCharacteristics(deviceId, BleNitro.normalizeGattUUID(serviceId), (characteristics) => {
+                resolve(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 byte array
+     */
+    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(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 an array of bytes
+     * @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), 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) {
+        return new Promise((resolve, reject) => {
+            // Check if connected first
+            if (!this._connectedDevices[deviceId]) {
+                reject(new Error('Device not connected'));
+                return;
+            }
+            BleNitroNative.subscribeToCharacteristic(deviceId, BleNitro.normalizeGattUUID(serviceId), BleNitro.normalizeGattUUID(characteristicId), (charId, data) => {
+                callback(charId, data);
+            }, (success, error) => {
+                if (success) {
+                    resolve({
+                        remove: () => {
+                            return new Promise((resolve, reject) => {
+                                this.unsubscribeFromCharacteristic(deviceId, serviceId, characteristicId).then(resolve).catch(reject);
+                            });
+                        },
+                    });
+                }
+                else {
+                    reject(new Error(error));
+                }
+            });
+        });
+    }
+    /**
+     * 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 new Promise((resolve) => {
+            BleNitroNative.isBluetoothEnabled((enabled) => {
+                resolve(enabled);
+            });
+        });
+    }
+    /**
+     * Request to enable Bluetooth
+     * @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 new Promise((resolve) => {
+            BleNitroNative.state((state) => {
+                resolve(mapNativeBLEStateToBLEState(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) {
+        return new Promise(async (resolve, reject) => {
+            if (emitInitial) {
+                const state = await this.state().catch(() => {
+                    return BLEState.Unknown;
+                });
+                callback(state);
+            }
+            BleNitroNative.subscribeToStateChange((nativeState) => {
+                callback(mapNativeBLEStateToBLEState(nativeState));
+            }, (success, error) => {
+                if (success) {
+                    resolve({
+                        remove: () => {
+                            return new Promise((resolve, reject) => {
+                                BleNitroNative.unsubscribeFromStateChange((success, error) => {
+                                    if (success) {
+                                        resolve();
+                                    }
+                                    else {
+                                        reject(new Error(error));
+                                    }
+                                });
+                            });
+                        },
+                    });
+                }
+                else {
+                    reject(new Error(error));
+                }
+            });
+        });
+    }
+    /**
+     * Open Bluetooth settings
+     * @returns Promise resolving when settings are opened
+     */
+    openSettings() {
+        return BleNitroNative.openSettings();
+    }
+}
+// Singleton instance
+export const ble = BleNitro.instance();

package/lib/specs/NativeBleNitro.d.ts

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

package/lib/specs/NativeBleNitro.js

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