react-native-ble-nitro
Version:
High-performance React Native BLE library built on Nitro Modules - drop-in replacement for react-native-ble-plx
260 lines (259 loc) • 9.82 kB
JavaScript
/**
* 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);
}
}