@sfourdrinier/react-native-ble-plx/lib/typescript/src/NativeBlePlx.d.ts

React Native Bluetooth Low Energy library

import type { TurboModule } from 'react-native';
type DeviceId = string;
type Identifier = number;
type UUID = string;
type Base64 = string;
type TransactionId = string;
type ConnectionPriority = number;
type CharacteristicSubscriptionType = 'notification' | 'indication';
type NativeState = 'Unknown' | 'Resetting' | 'Unsupported' | 'Unauthorized' | 'PoweredOff' | 'PoweredOn';
type NativeLogLevel = 'None' | 'Verbose' | 'Debug' | 'Info' | 'Warning' | 'Error';
type ScanOptions = {
    allowDuplicates?: boolean;
    scanMode?: number;
    callbackType?: number;
    legacyScan?: boolean;
};
type ConnectionOptions = {
    autoConnect?: boolean;
    requestMTU?: number;
    refreshGatt?: 'OnConnected';
    timeout?: number;
};
type BackgroundModeOptions = {
    notificationTitle?: string;
    notificationText?: string;
};
type NativeDevice = {
    id: DeviceId;
    name: string | null;
    rssi: number | null;
    mtu: number;
    manufacturerData: Base64 | null;
    rawScanRecord: Base64;
    serviceData: {
        [uuid: string]: Base64;
    } | null;
    serviceUUIDs: Array<UUID> | null;
    localName: string | null;
    txPowerLevel: number | null;
    solicitedServiceUUIDs: Array<UUID> | null;
    isConnectable: boolean | null;
    overflowServiceUUIDs: Array<UUID> | null;
};
type NativeService = {
    id: Identifier;
    uuid: UUID;
    deviceID: DeviceId;
    isPrimary: boolean;
};
type 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;
};
type NativeDescriptor = {
    id: Identifier;
    uuid: UUID;
    characteristicID: Identifier;
    characteristicUUID: UUID;
    serviceID: Identifier;
    serviceUUID: UUID;
    deviceID: DeviceId;
    value: Base64 | null;
};
export type NativeBlePlxConstants = {
    ScanEvent: string;
    ReadEvent: string;
    StateChangeEvent: string;
    RestoreStateEvent: string;
    DisconnectionEvent: string;
};
export type RestorationStatus = {
    blePlxRestorationAdapterFound: boolean;
    bleRestorationRegistryFound: boolean;
    hasRegisterSelector: boolean;
    initializeWasCalled: boolean;
};
export interface Spec extends TurboModule {
    getConstants(): NativeBlePlxConstants;
    addListener(eventType: string): void;
    removeListeners(count: number): void;
    createClient(restoreIdentifierKey: string | null): void;
    checkRestorationStatus(): Promise<RestorationStatus>;
    destroyClient(): Promise<void>;
    state(): Promise<NativeState>;
    startDeviceScan(filteredUUIDs: Array<UUID> | null, options: ScanOptions | null): Promise<void>;
    stopDeviceScan(): Promise<void>;
    requestConnectionPriorityForDevice(deviceIdentifier: DeviceId, connectionPriority: ConnectionPriority, transactionId: TransactionId): Promise<NativeDevice>;
    readRSSIForDevice(deviceIdentifier: DeviceId, transactionId: TransactionId): Promise<NativeDevice>;
    requestMTUForDevice(deviceIdentifier: DeviceId, mtu: number, transactionId: TransactionId): Promise<NativeDevice>;
    devices(deviceIdentifiers: Array<DeviceId>): Promise<Array<NativeDevice>>;
    connectedDevices(serviceUUIDs: Array<UUID>): Promise<Array<NativeDevice>>;
    connectToDevice(deviceIdentifier: DeviceId, options: ConnectionOptions | null): Promise<NativeDevice>;
    cancelDeviceConnection(deviceIdentifier: DeviceId): Promise<NativeDevice>;
    isDeviceConnected(deviceIdentifier: DeviceId): Promise<boolean>;
    discoverAllServicesAndCharacteristicsForDevice(deviceIdentifier: DeviceId, transactionId: TransactionId): Promise<NativeDevice>;
    servicesForDevice(deviceIdentifier: DeviceId): Promise<Array<NativeService>>;
    characteristicsForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID): Promise<Array<NativeCharacteristic>>;
    characteristicsForService(serviceIdentifier: Identifier): Promise<Array<NativeCharacteristic>>;
    descriptorsForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID): Promise<Array<NativeDescriptor>>;
    descriptorsForService(serviceIdentifier: Identifier, characteristicUUID: UUID): Promise<Array<NativeDescriptor>>;
    descriptorsForCharacteristic(characteristicIdentifier: Identifier): Promise<Array<NativeDescriptor>>;
    readCharacteristicForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, transactionId: TransactionId): Promise<NativeCharacteristic>;
    readCharacteristicForService(serviceIdentifier: Identifier, characteristicUUID: UUID, transactionId: TransactionId): Promise<NativeCharacteristic>;
    readCharacteristic(characteristicIdentifier: Identifier, transactionId: TransactionId): Promise<NativeCharacteristic>;
    writeCharacteristicForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, valueBase64: Base64, withResponse: boolean, transactionId: TransactionId): Promise<NativeCharacteristic>;
    writeCharacteristicForService(serviceIdentifier: Identifier, characteristicUUID: UUID, valueBase64: Base64, withResponse: boolean, transactionId: TransactionId): Promise<NativeCharacteristic>;
    writeCharacteristic(characteristicIdentifier: Identifier, valueBase64: Base64, withResponse: boolean, transactionId: TransactionId): Promise<NativeCharacteristic>;
    monitorCharacteristicForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, transactionId: TransactionId, subscriptionType: CharacteristicSubscriptionType | null): Promise<void>;
    monitorCharacteristicForService(serviceIdentifier: Identifier, characteristicUUID: UUID, transactionId: TransactionId, subscriptionType: CharacteristicSubscriptionType | null): Promise<void>;
    monitorCharacteristic(characteristicIdentifier: Identifier, transactionId: TransactionId, subscriptionType: CharacteristicSubscriptionType | null): Promise<void>;
    readDescriptorForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, descriptorUUID: UUID, transactionId: TransactionId): Promise<NativeDescriptor>;
    readDescriptorForService(serviceIdentifier: Identifier, characteristicUUID: UUID, descriptorUUID: UUID, transactionId: TransactionId): Promise<NativeDescriptor>;
    readDescriptorForCharacteristic(characteristicIdentifier: Identifier, descriptorUUID: UUID, transactionId: TransactionId): Promise<NativeDescriptor>;
    readDescriptor(descriptorIdentifier: Identifier, transactionId: TransactionId): Promise<NativeDescriptor>;
    writeDescriptorForDevice(deviceIdentifier: DeviceId, serviceUUID: UUID, characteristicUUID: UUID, descriptorUUID: UUID, valueBase64: Base64, transactionId: TransactionId): Promise<NativeDescriptor>;
    writeDescriptorForService(serviceIdentifier: Identifier, characteristicUUID: UUID, descriptorUUID: UUID, valueBase64: Base64, transactionId: TransactionId): Promise<NativeDescriptor>;
    writeDescriptorForCharacteristic(characteristicIdentifier: Identifier, descriptorUUID: UUID, valueBase64: Base64, transactionId: TransactionId): Promise<NativeDescriptor>;
    writeDescriptor(descriptorIdentifier: Identifier, valueBase64: Base64, transactionId: TransactionId): Promise<NativeDescriptor>;
    enableBackgroundMode(options: BackgroundModeOptions | null): Promise<boolean>;
    disableBackgroundMode(): Promise<boolean>;
    updateBackgroundNotification(options: BackgroundModeOptions | null): Promise<boolean>;
    isBackgroundModeEnabled(): Promise<boolean>;
    cancelTransaction(transactionId: TransactionId): Promise<void>;
    setLogLevel(logLevel: NativeLogLevel): Promise<NativeLogLevel | void>;
    logLevel(): Promise<NativeLogLevel>;
}
declare const _default: Spec;
export default _default;
//# sourceMappingURL=NativeBlePlx.d.ts.map