react-native-ble-nitro 1.0.0-alpha.1

package/src/specs/types.ts

@@ -0,0 +1,259 @@
+// Base types from react-native-ble-plx
+export type Base64 = string;
+export type UUID = string;
+export type Identifier = number;
+export type DeviceId = string;
+export type TransactionId = string;
+
+export enum RefreshGattMoment {
+  OnConnected = 0
+}
+
+export enum CharacteristicSubscriptionType {
+  Notification = 0,
+  Indication = 1
+}
+
+// Service Data structure for BLE devices - since Nitro doesn't support index signatures,
+// we'll use a more concrete structure or pass it as Base64 and handle parsing in native code
+export interface ServiceDataEntry {
+  uuid: UUID;
+  data: Base64;
+}
+
+// Enums
+export enum State {
+  Unknown = 0,
+  Resetting = 1,
+  Unsupported = 2,
+  Unauthorized = 3,
+  PoweredOff = 4,
+  PoweredOn = 5
+}
+
+export enum LogLevel {
+  None = 0,
+  Verbose = 1,
+  Debug = 2,
+  Info = 3,
+  Warning = 4,
+  Error = 5
+}
+
+export enum ScanMode {
+  Opportunistic = -1,
+  LowPower = 0,
+  Balanced = 1,
+  LowLatency = 2
+}
+
+export enum ScanCallbackType {
+  AllMatches = 1,
+  FirstMatch = 2,
+  MatchLost = 4
+}
+
+export enum ConnectionPriority {
+  Balanced = 0,
+  High = 1,
+  LowPower = 2
+}
+
+// Complex error code enums
+export enum BleErrorCode {
+  UnknownError = 0,
+  BluetoothManagerDestroyed = 1,
+  OperationCancelled = 2,
+  OperationTimedOut = 3,
+  OperationStartFailed = 4,
+  InvalidIdentifiers = 5,
+  BluetoothUnsupported = 100,
+  BluetoothUnauthorized = 101,
+  BluetoothPoweredOff = 102,
+  BluetoothInUnknownState = 103,
+  BluetoothResetting = 104,
+  BluetoothStateChangeFailed = 105,
+  DeviceConnectionFailed = 200,
+  DeviceDisconnected = 201,
+  DeviceRSSIReadFailed = 202,
+  DeviceAlreadyConnected = 203,
+  DeviceNotFound = 204,
+  DeviceNotConnected = 205,
+  DeviceMTUChangeFailed = 206,
+  ServicesDiscoveryFailed = 300,
+  IncludedServicesDiscoveryFailed = 301,
+  ServiceNotFound = 302,
+  ServicesNotDiscovered = 303,
+  CharacteristicsDiscoveryFailed = 400,
+  CharacteristicWriteFailed = 401,
+  CharacteristicReadFailed = 402,
+  CharacteristicNotifyChangeFailed = 403,
+  CharacteristicNotFound = 404,
+  CharacteristicsNotDiscovered = 405,
+  CharacteristicInvalidDataFormat = 406,
+  DescriptorsDiscoveryFailed = 500,
+  DescriptorWriteFailed = 501,
+  DescriptorReadFailed = 502,
+  DescriptorNotFound = 503,
+  DescriptorsNotDiscovered = 504,
+  DescriptorInvalidDataFormat = 505,
+  DescriptorWriteNotAllowed = 506,
+  ScanStartFailed = 600,
+  LocationServicesDisabled = 601
+}
+
+export enum BleATTErrorCode {
+  Success = 0,
+  InvalidHandle = 1,
+  ReadNotPermitted = 2,
+  WriteNotPermitted = 3,
+  InvalidPdu = 4,
+  InsufficientAuthentication = 5,
+  RequestNotSupported = 6,
+  InvalidOffset = 7,
+  InsufficientAuthorization = 8,
+  PrepareQueueFull = 9,
+  AttributeNotFound = 10,
+  AttributeNotLong = 11,
+  InsufficientEncryptionKeySize = 12,
+  InvalidAttributeValueLength = 13,
+  UnlikelyError = 14,
+  InsufficientEncryption = 15,
+  UnsupportedGroupType = 16,
+  InsufficientResources = 17
+}
+
+export enum BleIOSErrorCode {
+  Unknown = 0,
+  InvalidParameters = 1,
+  InvalidHandle = 2,
+  NotConnected = 3,
+  OutOfSpace = 4,
+  OperationCancelled = 5,
+  ConnectionTimeout = 6,
+  PeripheralDisconnected = 7,
+  UuidNotAllowed = 8,
+  AlreadyAdvertising = 9,
+  ConnectionFailed = 10,
+  ConnectionLimitReached = 11,
+  UnknownDevice = 12
+}
+
+export enum BleAndroidErrorCode {
+  NoResources = 0x80,
+  InternalError = 0x81,
+  WrongState = 0x82,
+  DbFull = 0x83,
+  Busy = 0x84,
+  Error = 0x85,
+  CmdStarted = 0x86,
+  IllegalParameter = 0x87,
+  Pending = 0x88,
+  AuthFail = 0x89,
+  More = 0x8a,
+  InvalidCfg = 0x8b,
+  ServiceStarted = 0x8c,
+  EncrypedNoMitm = 0x8d,
+  NotEncrypted = 0x8e,
+  Congested = 0x8f
+}
+
+// Interfaces for configuration and options
+export interface ScanOptions {
+  allowDuplicates?: boolean;
+  scanMode?: ScanMode;
+  callbackType?: ScanCallbackType;
+  legacyScan?: boolean;
+}
+
+export interface ConnectionOptions {
+  autoConnect: boolean;
+  requestMTU: number;
+  timeout: number;
+}
+
+export interface BleManagerOptions {
+  restoreStateIdentifier?: string;
+  restoreStateFunction?: (restoredState: BleRestoredState | null) => void;
+  errorCodesToMessagesMapping?: BleErrorCodeMessageMapping;
+}
+
+export interface BleRestoredState {
+  connectedPeripherals: NativeDevice[];
+}
+
+export type BleErrorCodeMessageMapping = { [key in BleErrorCode]: string };
+
+// Native device/service/characteristic/descriptor interfaces
+export interface NativeDevice {
+  id: DeviceId;
+  name: string | null;
+  rssi: number | null;
+  mtu: number;
+  manufacturerData: Base64 | null;
+  rawScanRecord: Base64;
+  serviceData: ServiceDataEntry[] | null;
+  serviceUUIDs: UUID[] | null;
+  localName: string | null;
+  txPowerLevel: number | null;
+  solicitedServiceUUIDs: UUID[] | null;
+  isConnectable: boolean | null;
+  overflowServiceUUIDs: UUID[] | null;
+}
+
+export interface NativeService {
+  id: Identifier;
+  uuid: UUID;
+  deviceID: DeviceId;
+  isPrimary: boolean;
+}
+
+export interface NativeCharacteristic {
+  id: Identifier;
+  uuid: UUID;
+  serviceID: Identifier;
+  serviceUUID: UUID;
+  deviceID: DeviceId;
+  isReadable: boolean;
+  isWritableWithResponse: boolean;
+  isWritableWithoutResponse: boolean;
+  isNotifiable: boolean;
+  isNotifying: boolean;
+  isIndicatable: boolean;
+  value: Base64 | null;
+}
+
+export interface NativeDescriptor {
+  id: Identifier;
+  uuid: UUID;
+  characteristicID: Identifier;
+  characteristicUUID: UUID;
+  serviceID: Identifier;
+  serviceUUID: UUID;
+  deviceID: DeviceId;
+  value: Base64 | null;
+}
+
+export interface NativeBleError {
+  errorCode: BleErrorCode;
+  attErrorCode: BleATTErrorCode | null;
+  iosErrorCode: BleIOSErrorCode | null;
+  androidErrorCode: BleAndroidErrorCode | null;
+  reason: string | null;
+  deviceID?: string;
+  serviceUUID?: string;
+  characteristicUUID?: string;
+  descriptorUUID?: string;
+  internalMessage?: string;
+}
+
+// Subscription interface
+export interface Subscription {
+  remove(): void;
+}
+
+// Callback types for listeners
+export type StateListener = (newState: State) => void;
+export type DeviceScanListener = (error: NativeBleError | null, scannedDevice: NativeDevice | null) => void;
+export type DeviceDisconnectedListener = (error: NativeBleError | null, device: NativeDevice | null) => void;
+export type CharacteristicMonitorListener = (error: NativeBleError | null, characteristic: NativeCharacteristic | null) => void;

package/src/utils/base64.ts

@@ -0,0 +1,80 @@
+import type { Base64 } from '../specs/types';
+
+/**
+ * Utility functions for Base64 encoding/decoding
+ * Maintains compatibility with react-native-ble-plx Base64 operations
+ */
+
+/**
+ * Converts a string to Base64
+ */
+export function stringToBase64(str: string): Base64 {
+  if (typeof Buffer !== 'undefined') {
+    // Node.js environment
+    return Buffer.from(str, 'utf8').toString('base64');
+  } else if (typeof btoa !== 'undefined') {
+    // Browser environment
+    return btoa(str);
+  } else {
+    throw new Error('Base64 encoding not supported in this environment');
+  }
+}
+
+/**
+ * Converts Base64 to string
+ */
+export function base64ToString(base64: Base64): string {
+  if (typeof Buffer !== 'undefined') {
+    // Node.js environment
+    return Buffer.from(base64, 'base64').toString('utf8');
+  } else if (typeof atob !== 'undefined') {
+    // Browser environment
+    return atob(base64);
+  } else {
+    throw new Error('Base64 decoding not supported in this environment');
+  }
+}
+
+/**
+ * Converts Uint8Array to Base64
+ */
+export function uint8ArrayToBase64(uint8Array: Uint8Array): Base64 {
+  if (typeof Buffer !== 'undefined') {
+    // Node.js environment
+    return Buffer.from(uint8Array).toString('base64');
+  } else {
+    // Browser environment
+    const binary = Array.from(uint8Array, byte => String.fromCharCode(byte)).join('');
+    return btoa(binary);
+  }
+}
+
+/**
+ * Converts Base64 to Uint8Array
+ */
+export function base64ToUint8Array(base64: Base64): Uint8Array {
+  if (typeof Buffer !== 'undefined') {
+    // Node.js environment
+    return new Uint8Array(Buffer.from(base64, 'base64'));
+  } else {
+    // Browser environment
+    const binary = atob(base64);
+    const uint8Array = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      uint8Array[i] = binary.charCodeAt(i);
+    }
+    return uint8Array;
+  }
+}
+
+/**
+ * Validates if a string is valid Base64
+ */
+export function isValidBase64(str: string): boolean {
+  try {
+    const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
+    return base64Regex.test(str) && (str.length % 4 === 0);
+  } catch {
+    return false;
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './uuid';
+export * from './base64';

package/src/utils/uuid.ts

@@ -0,0 +1,45 @@
+import type { UUID } from '../specs/types';
+
+/**
+ * Converts UUID to full 128bit, lowercase format which should be used to compare UUID values.
+ * This function maintains 100% compatibility with react-native-ble-plx
+ *
+ * @param uuid 16bit, 32bit or 128bit UUID.
+ * @returns 128bit lowercase UUID.
+ */
+export function fullUUID(uuid: UUID): UUID {
+  if (typeof uuid !== 'string') {
+    throw new Error('UUID must be a string');
+  }
+
+  // Remove dashes and convert to lowercase
+  const cleanUuid = uuid.replace(/-/g, '').toLowerCase();
+
+  // 16-bit UUID (4 characters)
+  if (cleanUuid.length === 4) {
+    return `0000${cleanUuid}-0000-1000-8000-00805f9b34fb`;
+  }
+
+  // 32-bit UUID (8 characters)
+  if (cleanUuid.length === 8) {
+    return `${cleanUuid}-0000-1000-8000-00805f9b34fb`;
+  }
+
+  // 128-bit UUID (32 characters)
+  if (cleanUuid.length === 32) {
+    return [
+      cleanUuid.substring(0, 8),
+      cleanUuid.substring(8, 12),
+      cleanUuid.substring(12, 16),
+      cleanUuid.substring(16, 20),
+      cleanUuid.substring(20, 32)
+    ].join('-');
+  }
+
+  // Already formatted UUID with dashes
+  if (cleanUuid.length === 36 && uuid.match(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i)) {
+    return uuid.toLowerCase();
+  }
+
+  throw new Error(`Invalid UUID format: ${uuid}`);
+}