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

package/src/BleManagerCompatFactory.ts

@@ -1,371 +0,0 @@
-/**
- * BleManager Compatibility Factory
- * 
- * Creates BleManager instances with full react-native-ble-plx compatibility
- * by wrapping the Nitro implementation with compatibility shims
- */
-
-import { createBleManager } from './BleManagerFactory';
-import type { BleManager as BleManagerInterface } from './specs/BleManager.nitro';
-import type { 
-  BleManagerOptions,
-  UUID,
-  DeviceId,
-  TransactionId,
-  ConnectionPriority,
-  ConnectionOptions,
-  ScanOptions,
-  NativeDevice,
-  NativeService,
-  NativeCharacteristic,
-  NativeDescriptor,
-  LogLevel,
-  Subscription
-} from './specs/types';
-import { DeviceWrapper } from './compatibility/deviceWrapper';
-import { 
-  stateToString,
-  logLevelToString,
-  normalizeLogLevel,
-  normalizeCharacteristicSubscriptionType,
-  State as PlxState,
-  LogLevel as PlxLogLevel
-} from './compatibility/enums';
-
-
-/**
- * BleManager wrapper that provides react-native-ble-plx compatibility
- */
-export class BleManagerCompat {
-  private bleManager: BleManagerInterface;
-
-  constructor(options?: BleManagerOptions) {
-    this.bleManager = createBleManager(options);
-  }
-
-  // Lifecycle
-  async destroy(): Promise<void> {
-    return await this.bleManager.destroy();
-  }
-
-  // Common operations with compatibility
-  async setLogLevel(logLevel: LogLevel | string): Promise<PlxLogLevel> {
-    const normalizedLogLevel = normalizeLogLevel(logLevel);
-    const result = await this.bleManager.setLogLevel(normalizedLogLevel);
-    return logLevelToString(result);
-  }
-
-  async logLevel(): Promise<PlxLogLevel> {
-    const result = await this.bleManager.logLevel();
-    return logLevelToString(result);
-  }
-
-  async cancelTransaction(transactionId: TransactionId): Promise<void> {
-    return await this.bleManager.cancelTransaction(transactionId);
-  }
-
-  // State management with string conversion
-  async enable(transactionId?: TransactionId): Promise<BleManagerCompat> {
-    await this.bleManager.enable(transactionId);
-    return this;
-  }
-
-  async disable(transactionId?: TransactionId): Promise<BleManagerCompat> {
-    await this.bleManager.disable(transactionId);
-    return this;
-  }
-
-  async state(): Promise<PlxState> {
-    const result = await this.bleManager.state();
-    return stateToString(result);
-  }
-
-  onStateChange(
-    listener: (newState: PlxState) => void, 
-    emitCurrentState?: boolean
-  ): Subscription {
-    return this.bleManager.onStateChange((state) => {
-      listener(stateToString(state));
-    }, emitCurrentState);
-  }
-
-  // Device scanning with compatibility wrappers
-  async startDeviceScan(
-    uuids: UUID[] | null,
-    options: ScanOptions | null,
-    listener: (error: any | null, scannedDevice: DeviceWrapper | null) => void // TODO: COMPAT! remove any and move to BleError as react-native-ble-plx uses this type as well!
-  ): Promise<void> {
-    return await this.bleManager.startDeviceScan(uuids, options, (error, device) => {
-      listener(error, device ? new DeviceWrapper(this.createDeviceFromNative(device)) : null);
-    });
-  }
-
-  async stopDeviceScan(): Promise<void> {
-    return await this.bleManager.stopDeviceScan();
-  }
-
-  // Connection management
-  async connectToDevice(
-    deviceIdentifier: DeviceId,
-    options?: Partial<ConnectionOptions>
-  ): Promise<DeviceWrapper> {
-    // Provide defaults for Nitro's required fields
-    const connectionOptions: ConnectionOptions = {
-      autoConnect: options?.autoConnect ?? false,
-      requestMTU: options?.requestMTU ?? 23,
-      timeout: options?.timeout ?? 0,
-    };
-
-    const result = await this.bleManager.connectToDevice(deviceIdentifier, connectionOptions);
-    return new DeviceWrapper(this.createDeviceFromNative(result));
-  }
-
-  async cancelDeviceConnection(deviceIdentifier: DeviceId): Promise<DeviceWrapper> {
-    const result = await this.bleManager.cancelDeviceConnection(deviceIdentifier);
-    return new DeviceWrapper(this.createDeviceFromNative(result));
-  }
-
-  async isDeviceConnected(deviceIdentifier: DeviceId): Promise<boolean> {
-    return await this.bleManager.isDeviceConnected(deviceIdentifier);
-  }
-
-  onDeviceDisconnected(
-    deviceIdentifier: DeviceId,
-    listener: (error: any | null, device: DeviceWrapper | null) => void // TODO: COMPAT! use propper error type like in react-native-ble-plx!!!
-  ): Subscription {
-    return this.bleManager.onDeviceDisconnected(deviceIdentifier, (error, device) => {
-      listener(error, device ? new DeviceWrapper(this.createDeviceFromNative(device)) : null);
-    });
-  }
-
-  // Device discovery
-  async devices(deviceIdentifiers: DeviceId[]): Promise<DeviceWrapper[]> {
-    const result = await this.bleManager.devices(deviceIdentifiers);
-    return result.map(device => new DeviceWrapper(this.createDeviceFromNative(device)));
-  }
-
-  async connectedDevices(serviceUUIDs: UUID[]): Promise<DeviceWrapper[]> {
-    const result = await this.bleManager.connectedDevices(serviceUUIDs);
-    return result.map(device => new DeviceWrapper(this.createDeviceFromNative(device)));
-  }
-
-  // RSSI and MTU operations
-  async readRSSIForDevice(
-    deviceIdentifier: DeviceId,
-    transactionId?: TransactionId
-  ): Promise<DeviceWrapper> {
-    const result = await this.bleManager.readRSSIForDevice(deviceIdentifier, transactionId);
-    return new DeviceWrapper(this.createDeviceFromNative(result));
-  }
-
-  async requestMTUForDevice(
-    deviceIdentifier: DeviceId,
-    mtu: number,
-    transactionId?: TransactionId
-  ): Promise<DeviceWrapper> {
-    const result = await this.bleManager.requestMTUForDevice(deviceIdentifier, mtu, transactionId);
-    return new DeviceWrapper(this.createDeviceFromNative(result));
-  }
-
-  async requestConnectionPriorityForDevice(
-    deviceIdentifier: DeviceId,
-    connectionPriority: ConnectionPriority,
-    transactionId?: TransactionId
-  ): Promise<DeviceWrapper> {
-    const result = await this.bleManager.requestConnectionPriorityForDevice(
-      deviceIdentifier,
-      connectionPriority,
-      transactionId
-    );
-    return new DeviceWrapper(this.createDeviceFromNative(result));
-  }
-
-  // Service discovery
-  async discoverAllServicesAndCharacteristicsForDevice(
-    deviceIdentifier: DeviceId,
-    transactionId?: TransactionId
-  ): Promise<DeviceWrapper> {
-    const result = await this.bleManager.discoverAllServicesAndCharacteristicsForDevice(
-      deviceIdentifier,
-      transactionId
-    );
-    return new DeviceWrapper(this.createDeviceFromNative(result));
-  }
-
-  // Service operations
-  async servicesForDevice(deviceIdentifier: DeviceId): Promise<NativeService[]> {
-    return await this.bleManager.servicesForDevice(deviceIdentifier);
-  }
-
-  // Characteristic operations
-  async characteristicsForDevice(
-    deviceIdentifier: DeviceId,
-    serviceUUID: UUID
-  ): Promise<NativeCharacteristic[]> {
-    return await this.bleManager.characteristicsForDevice(deviceIdentifier, serviceUUID);
-  }
-
-  async readCharacteristicForDevice(
-    deviceIdentifier: DeviceId,
-    serviceUUID: UUID,
-    characteristicUUID: UUID,
-    transactionId?: TransactionId
-  ): Promise<NativeCharacteristic> {
-    return await this.bleManager.readCharacteristicForDevice(
-      deviceIdentifier,
-      serviceUUID,
-      characteristicUUID,
-      transactionId
-    );
-  }
-
-  async writeCharacteristicWithResponseForDevice(
-    deviceIdentifier: DeviceId,
-    serviceUUID: UUID,
-    characteristicUUID: UUID,
-    base64Value: string,
-    transactionId?: TransactionId
-  ): Promise<NativeCharacteristic> {
-    return await this.bleManager.writeCharacteristicWithResponseForDevice(
-      deviceIdentifier,
-      serviceUUID,
-      characteristicUUID,
-      base64Value,
-      transactionId
-    );
-  }
-
-  async writeCharacteristicWithoutResponseForDevice(
-    deviceIdentifier: DeviceId,
-    serviceUUID: UUID,
-    characteristicUUID: UUID,
-    base64Value: string,
-    transactionId?: TransactionId
-  ): Promise<NativeCharacteristic> {
-    return await this.bleManager.writeCharacteristicWithoutResponseForDevice(
-      deviceIdentifier,
-      serviceUUID,
-      characteristicUUID,
-      base64Value,
-      transactionId
-    );
-  }
-
-  monitorCharacteristicForDevice(
-    deviceIdentifier: DeviceId,
-    serviceUUID: UUID,
-    characteristicUUID: UUID,
-    listener: (error: any | null, characteristic: NativeCharacteristic | null) => void, // TODO: COMPAT! use proper error type like in react-native-ble-plx
-    transactionId?: TransactionId,
-    subscriptionType?: 'notification' | 'indication'
-  ): Subscription {
-    const nitroSubscriptionType = subscriptionType 
-      ? normalizeCharacteristicSubscriptionType(subscriptionType)
-      : undefined;
-
-    return this.bleManager.monitorCharacteristicForDevice(
-      deviceIdentifier,
-      serviceUUID,
-      characteristicUUID,
-      listener,
-      transactionId,
-      nitroSubscriptionType
-    );
-  }
-
-  // Descriptor operations
-  async descriptorsForDevice(
-    deviceIdentifier: DeviceId,
-    serviceUUID: UUID,
-    characteristicUUID: UUID
-  ): Promise<NativeDescriptor[]> {
-    return await this.bleManager.descriptorsForDevice(
-      deviceIdentifier,
-      serviceUUID,
-      characteristicUUID
-    );
-  }
-
-  async readDescriptorForDevice(
-    deviceIdentifier: DeviceId,
-    serviceUUID: UUID,
-    characteristicUUID: UUID,
-    descriptorUUID: UUID,
-    transactionId?: TransactionId
-  ): Promise<NativeDescriptor> {
-    return await this.bleManager.readDescriptorForDevice(
-      deviceIdentifier,
-      serviceUUID,
-      characteristicUUID,
-      descriptorUUID,
-      transactionId
-    );
-  }
-
-  async writeDescriptorForDevice(
-    deviceIdentifier: DeviceId,
-    serviceUUID: UUID,
-    characteristicUUID: UUID,
-    descriptorUUID: UUID,
-    valueBase64: string,
-    transactionId?: TransactionId
-  ): Promise<NativeDescriptor> {
-    return await this.bleManager.writeDescriptorForDevice(
-      deviceIdentifier,
-      serviceUUID,
-      characteristicUUID,
-      descriptorUUID,
-      valueBase64,
-      transactionId
-    );
-  }
-
-  /**
-   * Helper method to create a Device wrapper from NativeDevice data
-   * This is a temporary method until we have proper Device Nitro objects
-   */
-  private createDeviceFromNative(nativeDevice: NativeDevice) {
-    // This is a placeholder - in the actual implementation, we'd need to create
-    // proper Nitro Device objects, but for now we'll work with the native data
-    return {
-      id: nativeDevice.id,
-      deviceName: nativeDevice.name,
-      rssi: nativeDevice.rssi,
-      mtu: nativeDevice.mtu,
-      manufacturerData: nativeDevice.manufacturerData,
-      rawScanRecord: nativeDevice.rawScanRecord,
-      serviceData: nativeDevice.serviceData,
-      serviceUUIDs: nativeDevice.serviceUUIDs,
-      localName: nativeDevice.localName,
-      txPowerLevel: nativeDevice.txPowerLevel,
-      solicitedServiceUUIDs: nativeDevice.solicitedServiceUUIDs,
-      isConnectable: nativeDevice.isConnectable,
-      overflowServiceUUIDs: nativeDevice.overflowServiceUUIDs,
-      // Add placeholder methods - these would be implemented in the actual Device class
-      requestConnectionPriority: async () => this.createDeviceFromNative(nativeDevice),
-      readRSSI: async () => this.createDeviceFromNative(nativeDevice),
-      requestMTU: async () => this.createDeviceFromNative(nativeDevice),
-      connect: async () => this.createDeviceFromNative(nativeDevice),
-      cancelConnection: async () => this.createDeviceFromNative(nativeDevice),
-      isConnected: async () => false,
-      onDisconnected: () => ({ remove: () => {} }),
-      discoverAllServicesAndCharacteristics: async () => this.createDeviceFromNative(nativeDevice),
-      services: async () => [],
-      characteristicsForService: async () => [],
-      readCharacteristicForService: async () => ({}),
-      writeCharacteristicWithResponseForService: async () => ({}),
-      writeCharacteristicWithoutResponseForService: async () => ({}),
-      monitorCharacteristicForService: () => ({ remove: () => {} }),
-      descriptorsForService: async () => [],
-      readDescriptorForService: async () => ({}),
-      writeDescriptorForService: async () => ({}),
-    };
-  }
-}
-
-/**
- * Factory function to create a compatibility BleManager
- */
-export function createBleManagerCompat(options?: BleManagerOptions): BleManagerCompat {
-  return new BleManagerCompat(options);
-}

package/src/BleManagerFactory.ts

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