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

package/lib/BleManagerCompatFactory.js

@@ -0,0 +1,191 @@
+/**
+ * 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 { DeviceWrapper } from './compatibility/deviceWrapper';
+import { stateToString, logLevelToString, normalizeLogLevel, normalizeCharacteristicSubscriptionType } from './compatibility/enums';
+/**
+ * BleManager wrapper that provides react-native-ble-plx compatibility
+ */
+export class BleManagerCompat {
+    constructor(options) {
+        this.bleManager = createBleManager(options);
+    }
+    // Lifecycle
+    async destroy() {
+        return await this.bleManager.destroy();
+    }
+    // Common operations with compatibility
+    async setLogLevel(logLevel) {
+        const normalizedLogLevel = normalizeLogLevel(logLevel);
+        const result = await this.bleManager.setLogLevel(normalizedLogLevel);
+        return logLevelToString(result);
+    }
+    async logLevel() {
+        const result = await this.bleManager.logLevel();
+        return logLevelToString(result);
+    }
+    async cancelTransaction(transactionId) {
+        return await this.bleManager.cancelTransaction(transactionId);
+    }
+    // State management with string conversion
+    async enable(transactionId) {
+        await this.bleManager.enable(transactionId);
+        return this;
+    }
+    async disable(transactionId) {
+        await this.bleManager.disable(transactionId);
+        return this;
+    }
+    async state() {
+        const result = await this.bleManager.state();
+        return stateToString(result);
+    }
+    onStateChange(listener, emitCurrentState) {
+        return this.bleManager.onStateChange((state) => {
+            listener(stateToString(state));
+        }, emitCurrentState);
+    }
+    // Device scanning with compatibility wrappers
+    async startDeviceScan(uuids, options, listener) {
+        return await this.bleManager.startDeviceScan(uuids, options, (error, device) => {
+            listener(error, device ? new DeviceWrapper(this.createDeviceFromNative(device)) : null);
+        });
+    }
+    async stopDeviceScan() {
+        return await this.bleManager.stopDeviceScan();
+    }
+    // Connection management
+    async connectToDevice(deviceIdentifier, options) {
+        // Provide defaults for Nitro's required fields
+        const 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) {
+        const result = await this.bleManager.cancelDeviceConnection(deviceIdentifier);
+        return new DeviceWrapper(this.createDeviceFromNative(result));
+    }
+    async isDeviceConnected(deviceIdentifier) {
+        return await this.bleManager.isDeviceConnected(deviceIdentifier);
+    }
+    onDeviceDisconnected(deviceIdentifier, listener) {
+        return this.bleManager.onDeviceDisconnected(deviceIdentifier, (error, device) => {
+            listener(error, device ? new DeviceWrapper(this.createDeviceFromNative(device)) : null);
+        });
+    }
+    // Device discovery
+    async devices(deviceIdentifiers) {
+        const result = await this.bleManager.devices(deviceIdentifiers);
+        return result.map(device => new DeviceWrapper(this.createDeviceFromNative(device)));
+    }
+    async connectedDevices(serviceUUIDs) {
+        const result = await this.bleManager.connectedDevices(serviceUUIDs);
+        return result.map(device => new DeviceWrapper(this.createDeviceFromNative(device)));
+    }
+    // RSSI and MTU operations
+    async readRSSIForDevice(deviceIdentifier, transactionId) {
+        const result = await this.bleManager.readRSSIForDevice(deviceIdentifier, transactionId);
+        return new DeviceWrapper(this.createDeviceFromNative(result));
+    }
+    async requestMTUForDevice(deviceIdentifier, mtu, transactionId) {
+        const result = await this.bleManager.requestMTUForDevice(deviceIdentifier, mtu, transactionId);
+        return new DeviceWrapper(this.createDeviceFromNative(result));
+    }
+    async requestConnectionPriorityForDevice(deviceIdentifier, connectionPriority, transactionId) {
+        const result = await this.bleManager.requestConnectionPriorityForDevice(deviceIdentifier, connectionPriority, transactionId);
+        return new DeviceWrapper(this.createDeviceFromNative(result));
+    }
+    // Service discovery
+    async discoverAllServicesAndCharacteristicsForDevice(deviceIdentifier, transactionId) {
+        const result = await this.bleManager.discoverAllServicesAndCharacteristicsForDevice(deviceIdentifier, transactionId);
+        return new DeviceWrapper(this.createDeviceFromNative(result));
+    }
+    // Service operations
+    async servicesForDevice(deviceIdentifier) {
+        return await this.bleManager.servicesForDevice(deviceIdentifier);
+    }
+    // Characteristic operations
+    async characteristicsForDevice(deviceIdentifier, serviceUUID) {
+        return await this.bleManager.characteristicsForDevice(deviceIdentifier, serviceUUID);
+    }
+    async readCharacteristicForDevice(deviceIdentifier, serviceUUID, characteristicUUID, transactionId) {
+        return await this.bleManager.readCharacteristicForDevice(deviceIdentifier, serviceUUID, characteristicUUID, transactionId);
+    }
+    async writeCharacteristicWithResponseForDevice(deviceIdentifier, serviceUUID, characteristicUUID, base64Value, transactionId) {
+        return await this.bleManager.writeCharacteristicWithResponseForDevice(deviceIdentifier, serviceUUID, characteristicUUID, base64Value, transactionId);
+    }
+    async writeCharacteristicWithoutResponseForDevice(deviceIdentifier, serviceUUID, characteristicUUID, base64Value, transactionId) {
+        return await this.bleManager.writeCharacteristicWithoutResponseForDevice(deviceIdentifier, serviceUUID, characteristicUUID, base64Value, transactionId);
+    }
+    monitorCharacteristicForDevice(deviceIdentifier, serviceUUID, characteristicUUID, listener, transactionId, subscriptionType) {
+        const nitroSubscriptionType = subscriptionType
+            ? normalizeCharacteristicSubscriptionType(subscriptionType)
+            : undefined;
+        return this.bleManager.monitorCharacteristicForDevice(deviceIdentifier, serviceUUID, characteristicUUID, listener, transactionId, nitroSubscriptionType);
+    }
+    // Descriptor operations
+    async descriptorsForDevice(deviceIdentifier, serviceUUID, characteristicUUID) {
+        return await this.bleManager.descriptorsForDevice(deviceIdentifier, serviceUUID, characteristicUUID);
+    }
+    async readDescriptorForDevice(deviceIdentifier, serviceUUID, characteristicUUID, descriptorUUID, transactionId) {
+        return await this.bleManager.readDescriptorForDevice(deviceIdentifier, serviceUUID, characteristicUUID, descriptorUUID, transactionId);
+    }
+    async writeDescriptorForDevice(deviceIdentifier, serviceUUID, characteristicUUID, descriptorUUID, valueBase64, transactionId) {
+        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
+     */
+    createDeviceFromNative(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) {
+    return new BleManagerCompat(options);
+}

package/lib/BleManagerFactory.d.ts

@@ -0,0 +1,12 @@
+import type { BleManager as BleManagerInterface } from './specs/BleManager.nitro';
+import type { BleManagerOptions } from './specs/types';
+/**
+ * Creates a BleManager instance using Nitro Modules
+ * This function maintains compatibility with react-native-ble-plx's BleManager constructor
+ */
+export declare function createBleManager(options?: BleManagerOptions): BleManagerInterface;
+/**
+ * Legacy compatibility: Export a BleManager constructor function
+ * This maintains compatibility with code that imports { BleManager } from 'react-native-ble-plx'
+ */
+export declare const BleManager: any;

package/lib/BleManagerFactory.js

@@ -0,0 +1,22 @@
+import { NitroModules } from 'react-native-nitro-modules';
+/**
+ * Creates a BleManager instance using Nitro Modules
+ * This function maintains compatibility with react-native-ble-plx's BleManager constructor
+ */
+export function createBleManager(options) {
+    const BleManagerModule = NitroModules.createHybridObject('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.');
+    }
+    // If options are provided, we could initialize with them
+    // For now, we return the module directly as Nitro handles the native initialization
+    return BleManagerModule;
+}
+/**
+ * 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) {
+    return createBleManager(options);
+};

package/lib/compatibility/constants.d.ts

@@ -0,0 +1,49 @@
+/**
+ * React-native-ble-plx compatibility constants
+ *
+ * Re-exports all constants and types to maintain API compatibility
+ */
+export declare const State: {
+    readonly Unknown: "Unknown";
+    readonly Resetting: "Resetting";
+    readonly Unsupported: "Unsupported";
+    readonly Unauthorized: "Unauthorized";
+    readonly PoweredOff: "PoweredOff";
+    readonly PoweredOn: "PoweredOn";
+};
+export declare const LogLevel: {
+    readonly None: "None";
+    readonly Verbose: "Verbose";
+    readonly Debug: "Debug";
+    readonly Info: "Info";
+    readonly Warning: "Warning";
+    readonly Error: "Error";
+};
+export type StateString = typeof State[keyof typeof State];
+export type LogLevelString = typeof LogLevel[keyof typeof LogLevel];
+export declare const CharacteristicSubscriptionType: {
+    readonly Notification: "notification";
+    readonly Indication: "indication";
+};
+export type CharacteristicSubscriptionTypeString = typeof CharacteristicSubscriptionType[keyof typeof CharacteristicSubscriptionType];
+export declare const RefreshGattMoment: {
+    readonly OnConnected: "OnConnected";
+};
+export type RefreshGattMomentString = typeof RefreshGattMoment[keyof typeof RefreshGattMoment];
+export declare const ScanMode: {
+    readonly Opportunistic: -1;
+    readonly LowPower: 0;
+    readonly Balanced: 1;
+    readonly LowLatency: 2;
+};
+export declare const ScanCallbackType: {
+    readonly AllMatches: 1;
+    readonly FirstMatch: 2;
+    readonly MatchLost: 4;
+};
+export declare const ConnectionPriority: {
+    readonly Balanced: 0;
+    readonly High: 1;
+    readonly LowPower: 2;
+};
+export { BleErrorCode, BleATTErrorCode, BleIOSErrorCode, BleAndroidErrorCode } from '../specs/types';

package/lib/compatibility/constants.js

@@ -0,0 +1,50 @@
+/**
+ * React-native-ble-plx compatibility constants
+ *
+ * Re-exports all constants and types to maintain API compatibility
+ */
+// Re-export original string-based constants for backward compatibility
+export const State = {
+    Unknown: 'Unknown',
+    Resetting: 'Resetting',
+    Unsupported: 'Unsupported',
+    Unauthorized: 'Unauthorized',
+    PoweredOff: 'PoweredOff',
+    PoweredOn: 'PoweredOn',
+};
+export const LogLevel = {
+    None: 'None',
+    Verbose: 'Verbose',
+    Debug: 'Debug',
+    Info: 'Info',
+    Warning: 'Warning',
+    Error: 'Error',
+};
+// Subscription type constants
+export const CharacteristicSubscriptionType = {
+    Notification: 'notification',
+    Indication: 'indication',
+};
+// Connection options constants
+export const RefreshGattMoment = {
+    OnConnected: 'OnConnected',
+};
+// Scan mode constants (these remain numeric as in original)
+export const ScanMode = {
+    Opportunistic: -1,
+    LowPower: 0,
+    Balanced: 1,
+    LowLatency: 2,
+};
+export const ScanCallbackType = {
+    AllMatches: 1,
+    FirstMatch: 2,
+    MatchLost: 4,
+};
+export const ConnectionPriority = {
+    Balanced: 0,
+    High: 1,
+    LowPower: 2,
+};
+// Re-export all BLE error codes
+export { BleErrorCode, BleATTErrorCode, BleIOSErrorCode, BleAndroidErrorCode } from '../specs/types';

package/lib/compatibility/deviceWrapper.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Device wrapper for compatibility
+ *
+ * Wraps Nitro Device objects to provide the original react-native-ble-plx API
+ */
+import type { Device as NitroDevice } from '../specs/Device.nitro';
+import type { UUID, Base64, DeviceId, TransactionId, ConnectionPriority, ConnectionOptions, NativeService, NativeCharacteristic, NativeDescriptor, Subscription } from '../specs/types';
+/**
+ * Device wrapper that provides react-native-ble-plx compatibility
+ * Maps Nitro device properties to the expected API surface
+ */
+export declare class DeviceWrapper {
+    private nitroDevice;
+    constructor(nitroDevice: NitroDevice | any);
+    get id(): DeviceId;
+    get name(): string | null;
+    get rssi(): number | null;
+    get mtu(): number;
+    get manufacturerData(): Base64 | null;
+    get rawScanRecord(): Base64;
+    get serviceData(): {
+        [uuid: string]: Base64;
+    } | null;
+    get serviceUUIDs(): UUID[] | null;
+    get localName(): string | null;
+    get txPowerLevel(): number | null;
+    get solicitedServiceUUIDs(): UUID[] | null;
+    get isConnectable(): boolean | null;
+    get overflowServiceUUIDs(): UUID[] | null;
+    requestConnectionPriority(connectionPriority: ConnectionPriority, transactionId?: TransactionId): Promise<DeviceWrapper>;
+    readRSSI(transactionId?: TransactionId): Promise<DeviceWrapper>;
+    requestMTU(mtu: number, transactionId?: TransactionId): Promise<DeviceWrapper>;
+    connect(options?: Partial<ConnectionOptions>): Promise<DeviceWrapper>;
+    cancelConnection(): Promise<DeviceWrapper>;
+    isConnected(): Promise<boolean>;
+    onDisconnected(listener: (error: any | null, device: DeviceWrapper) => void): Subscription;
+    discoverAllServicesAndCharacteristics(transactionId?: TransactionId): Promise<DeviceWrapper>;
+    services(): Promise<ServiceWrapper[]>;
+    characteristicsForService(serviceUUID: UUID): Promise<CharacteristicWrapper[]>;
+    readCharacteristicForService(serviceUUID: UUID, characteristicUUID: UUID, transactionId?: TransactionId): Promise<CharacteristicWrapper>;
+    writeCharacteristicWithResponseForService(serviceUUID: UUID, characteristicUUID: UUID, valueBase64: Base64, transactionId?: TransactionId): Promise<CharacteristicWrapper>;
+    writeCharacteristicWithoutResponseForService(serviceUUID: UUID, characteristicUUID: UUID, valueBase64: Base64, transactionId?: TransactionId): Promise<CharacteristicWrapper>;
+    monitorCharacteristicForService(serviceUUID: UUID, characteristicUUID: UUID, listener: (error: any | null, characteristic: CharacteristicWrapper | null) => void, transactionId?: TransactionId, subscriptionType?: 'notification' | 'indication'): Subscription;
+    descriptorsForService(serviceUUID: UUID, characteristicUUID: UUID): Promise<DescriptorWrapper[]>;
+    readDescriptorForService(serviceUUID: UUID, characteristicUUID: UUID, descriptorUUID: UUID, transactionId?: TransactionId): Promise<DescriptorWrapper>;
+    writeDescriptorForService(serviceUUID: UUID, characteristicUUID: UUID, descriptorUUID: UUID, valueBase64: Base64, transactionId?: TransactionId): Promise<DescriptorWrapper>;
+}
+/**
+ * Service wrapper for compatibility
+ */
+export declare class ServiceWrapper {
+    private nativeService;
+    private nitroDevice;
+    constructor(nativeService: NativeService, nitroDevice: NitroDevice);
+    get id(): number;
+    get uuid(): UUID;
+    get deviceID(): DeviceId;
+    get isPrimary(): boolean;
+    characteristics(): Promise<CharacteristicWrapper[]>;
+    readCharacteristic(characteristicUUID: UUID, transactionId?: TransactionId): Promise<CharacteristicWrapper>;
+}
+/**
+ * Characteristic wrapper for compatibility
+ */
+export declare class CharacteristicWrapper {
+    private nativeCharacteristic;
+    private nitroDevice;
+    constructor(nativeCharacteristic: NativeCharacteristic, nitroDevice: NitroDevice);
+    get id(): number;
+    get uuid(): UUID;
+    get serviceID(): number;
+    get serviceUUID(): UUID;
+    get deviceID(): DeviceId;
+    get isReadable(): boolean;
+    get isWritableWithResponse(): boolean;
+    get isWritableWithoutResponse(): boolean;
+    get isNotifiable(): boolean;
+    get isNotifying(): boolean;
+    get isIndicatable(): boolean;
+    get value(): Base64 | null;
+    read(transactionId?: TransactionId): Promise<CharacteristicWrapper>;
+}
+/**
+ * Descriptor wrapper for compatibility
+ */
+export declare class DescriptorWrapper {
+    private nativeDescriptor;
+    private nitroDevice;
+    constructor(nativeDescriptor: NativeDescriptor, nitroDevice: NitroDevice);
+    get id(): number;
+    get uuid(): UUID;
+    get characteristicID(): number;
+    get characteristicUUID(): UUID;
+    get serviceID(): number;
+    get serviceUUID(): UUID;
+    get deviceID(): DeviceId;
+    get value(): Base64 | null;
+    read(transactionId?: TransactionId): Promise<DescriptorWrapper>;
+}

package/lib/compatibility/deviceWrapper.js

@@ -0,0 +1,259 @@
+/**
+ * Device wrapper for compatibility
+ *
+ * Wraps Nitro Device objects to provide the original react-native-ble-plx API
+ */
+import { serviceDataArrayToMap } from './serviceData';
+import { normalizeCharacteristicSubscriptionType } from './enums';
+/**
+ * Device wrapper that provides react-native-ble-plx compatibility
+ * Maps Nitro device properties to the expected API surface
+ */
+export class DeviceWrapper {
+    constructor(nitroDevice) {
+        this.nitroDevice = nitroDevice;
+    }
+    // Device identification
+    get id() {
+        return this.nitroDevice.id;
+    }
+    // Map deviceName back to name for compatibility
+    get name() {
+        return this.nitroDevice.deviceName || null;
+    }
+    get rssi() {
+        return this.nitroDevice.rssi || null;
+    }
+    get mtu() {
+        return this.nitroDevice.mtu;
+    }
+    // Advertisement data
+    get manufacturerData() {
+        return this.nitroDevice.manufacturerData || null;
+    }
+    get rawScanRecord() {
+        return this.nitroDevice.rawScanRecord;
+    }
+    // Convert ServiceDataEntry[] back to { [uuid: string]: Base64 }
+    get serviceData() {
+        return serviceDataArrayToMap(this.nitroDevice.serviceData || null);
+    }
+    get serviceUUIDs() {
+        return this.nitroDevice.serviceUUIDs || null;
+    }
+    get localName() {
+        return this.nitroDevice.localName || null;
+    }
+    get txPowerLevel() {
+        return this.nitroDevice.txPowerLevel || null;
+    }
+    get solicitedServiceUUIDs() {
+        return this.nitroDevice.solicitedServiceUUIDs || null;
+    }
+    get isConnectable() {
+        return this.nitroDevice.isConnectable || null;
+    }
+    get overflowServiceUUIDs() {
+        return this.nitroDevice.overflowServiceUUIDs || null;
+    }
+    // Connection management methods
+    async requestConnectionPriority(connectionPriority, transactionId) {
+        const result = await this.nitroDevice.requestConnectionPriority(connectionPriority, transactionId);
+        return new DeviceWrapper(result);
+    }
+    async readRSSI(transactionId) {
+        const result = await this.nitroDevice.readRSSI(transactionId);
+        return new DeviceWrapper(result);
+    }
+    async requestMTU(mtu, transactionId) {
+        const result = await this.nitroDevice.requestMTU(mtu, transactionId);
+        return new DeviceWrapper(result);
+    }
+    async connect(options) {
+        // Provide defaults for required fields in Nitro interface
+        const connectionOptions = {
+            autoConnect: options?.autoConnect ?? false,
+            requestMTU: options?.requestMTU ?? 23,
+            timeout: options?.timeout ?? 0,
+        };
+        const result = await this.nitroDevice.connect(connectionOptions);
+        return new DeviceWrapper(result);
+    }
+    async cancelConnection() {
+        const result = await this.nitroDevice.cancelConnection();
+        return new DeviceWrapper(result);
+    }
+    async isConnected() {
+        return await this.nitroDevice.isConnected();
+    }
+    onDisconnected(listener) {
+        return this.nitroDevice.onDisconnected((error, device) => {
+            listener(error, new DeviceWrapper(device));
+        });
+    }
+    // Service discovery
+    async discoverAllServicesAndCharacteristics(transactionId) {
+        const result = await this.nitroDevice.discoverAllServicesAndCharacteristics(transactionId);
+        return new DeviceWrapper(result);
+    }
+    async services() {
+        const services = await this.nitroDevice.services();
+        return services.map((service) => new ServiceWrapper(service, this.nitroDevice));
+    }
+    // Characteristic operations
+    async characteristicsForService(serviceUUID) {
+        const characteristics = await this.nitroDevice.characteristicsForService(serviceUUID);
+        return characteristics.map((char) => new CharacteristicWrapper(char, this.nitroDevice));
+    }
+    async readCharacteristicForService(serviceUUID, characteristicUUID, transactionId) {
+        const result = await this.nitroDevice.readCharacteristicForService(serviceUUID, characteristicUUID, transactionId);
+        return new CharacteristicWrapper(result, this.nitroDevice);
+    }
+    async writeCharacteristicWithResponseForService(serviceUUID, characteristicUUID, valueBase64, transactionId) {
+        const result = await this.nitroDevice.writeCharacteristicWithResponseForService(serviceUUID, characteristicUUID, valueBase64, transactionId);
+        return new CharacteristicWrapper(result, this.nitroDevice);
+    }
+    async writeCharacteristicWithoutResponseForService(serviceUUID, characteristicUUID, valueBase64, transactionId) {
+        const result = await this.nitroDevice.writeCharacteristicWithoutResponseForService(serviceUUID, characteristicUUID, valueBase64, transactionId);
+        return new CharacteristicWrapper(result, this.nitroDevice);
+    }
+    monitorCharacteristicForService(serviceUUID, characteristicUUID, listener, transactionId, subscriptionType) {
+        const nitroSubscriptionType = subscriptionType
+            ? normalizeCharacteristicSubscriptionType(subscriptionType)
+            : undefined;
+        return this.nitroDevice.monitorCharacteristicForService(serviceUUID, characteristicUUID, (error, characteristic) => {
+            listener(error, characteristic ? new CharacteristicWrapper(characteristic, this.nitroDevice) : null);
+        }, transactionId, nitroSubscriptionType);
+    }
+    // Descriptor operations
+    async descriptorsForService(serviceUUID, characteristicUUID) {
+        const descriptors = await this.nitroDevice.descriptorsForService(serviceUUID, characteristicUUID);
+        return descriptors.map((desc) => new DescriptorWrapper(desc, this.nitroDevice));
+    }
+    async readDescriptorForService(serviceUUID, characteristicUUID, descriptorUUID, transactionId) {
+        const result = await this.nitroDevice.readDescriptorForService(serviceUUID, characteristicUUID, descriptorUUID, transactionId);
+        return new DescriptorWrapper(result, this.nitroDevice);
+    }
+    async writeDescriptorForService(serviceUUID, characteristicUUID, descriptorUUID, valueBase64, transactionId) {
+        const result = await this.nitroDevice.writeDescriptorForService(serviceUUID, characteristicUUID, descriptorUUID, valueBase64, transactionId);
+        return new DescriptorWrapper(result, this.nitroDevice);
+    }
+}
+/**
+ * Service wrapper for compatibility
+ */
+export class ServiceWrapper {
+    constructor(nativeService, nitroDevice) {
+        this.nativeService = nativeService;
+        this.nitroDevice = nitroDevice;
+    }
+    get id() {
+        return this.nativeService.id;
+    }
+    get uuid() {
+        return this.nativeService.uuid;
+    }
+    get deviceID() {
+        return this.nativeService.deviceID;
+    }
+    get isPrimary() {
+        return this.nativeService.isPrimary;
+    }
+    // Delegate to device methods
+    async characteristics() {
+        const device = new DeviceWrapper(this.nitroDevice);
+        return await device.characteristicsForService(this.uuid);
+    }
+    async readCharacteristic(characteristicUUID, transactionId) {
+        const device = new DeviceWrapper(this.nitroDevice);
+        return await device.readCharacteristicForService(this.uuid, characteristicUUID, transactionId);
+    }
+}
+/**
+ * Characteristic wrapper for compatibility
+ */
+export class CharacteristicWrapper {
+    constructor(nativeCharacteristic, nitroDevice) {
+        this.nativeCharacteristic = nativeCharacteristic;
+        this.nitroDevice = nitroDevice;
+    }
+    get id() {
+        return this.nativeCharacteristic.id;
+    }
+    get uuid() {
+        return this.nativeCharacteristic.uuid;
+    }
+    get serviceID() {
+        return this.nativeCharacteristic.serviceID;
+    }
+    get serviceUUID() {
+        return this.nativeCharacteristic.serviceUUID;
+    }
+    get deviceID() {
+        return this.nativeCharacteristic.deviceID;
+    }
+    get isReadable() {
+        return this.nativeCharacteristic.isReadable;
+    }
+    get isWritableWithResponse() {
+        return this.nativeCharacteristic.isWritableWithResponse;
+    }
+    get isWritableWithoutResponse() {
+        return this.nativeCharacteristic.isWritableWithoutResponse;
+    }
+    get isNotifiable() {
+        return this.nativeCharacteristic.isNotifiable;
+    }
+    get isNotifying() {
+        return this.nativeCharacteristic.isNotifying;
+    }
+    get isIndicatable() {
+        return this.nativeCharacteristic.isIndicatable;
+    }
+    get value() {
+        return this.nativeCharacteristic.value;
+    }
+    // Delegate to device methods
+    async read(transactionId) {
+        const device = new DeviceWrapper(this.nitroDevice);
+        return await device.readCharacteristicForService(this.serviceUUID, this.uuid, transactionId);
+    }
+}
+/**
+ * Descriptor wrapper for compatibility
+ */
+export class DescriptorWrapper {
+    constructor(nativeDescriptor, nitroDevice) {
+        this.nativeDescriptor = nativeDescriptor;
+        this.nitroDevice = nitroDevice;
+    }
+    get id() {
+        return this.nativeDescriptor.id;
+    }
+    get uuid() {
+        return this.nativeDescriptor.uuid;
+    }
+    get characteristicID() {
+        return this.nativeDescriptor.characteristicID;
+    }
+    get characteristicUUID() {
+        return this.nativeDescriptor.characteristicUUID;
+    }
+    get serviceID() {
+        return this.nativeDescriptor.serviceID;
+    }
+    get serviceUUID() {
+        return this.nativeDescriptor.serviceUUID;
+    }
+    get deviceID() {
+        return this.nativeDescriptor.deviceID;
+    }
+    get value() {
+        return this.nativeDescriptor.value;
+    }
+    // Delegate to device methods
+    async read(transactionId) {
+        const device = new DeviceWrapper(this.nitroDevice);
+        return await device.readDescriptorForService(this.serviceUUID, this.characteristicUUID, this.uuid, transactionId);
+    }
+}