incyclist-devices 2.2.9 → 2.3.0

package/lib/ble/base/interface.d.ts

@@ -0,0 +1,96 @@
+import EventEmitter from "events";
+import { DeviceSettings, InterfaceProps } from "../../types";
+import { EventLogger } from "gd-eventlog";
+import { BleBinding, BleInterfaceState, BlePeripheralAnnouncement, BlePeripheralInfo, BleRawPeripheral, BleScanProps, IBlePeripheral } from "../types";
+import { IBleInterface } from '../../ble/types';
+import { InteruptableTask, TaskState } from "../../utils/task";
+import { InterfaceFactory } from "./types";
+interface Announcement {
+    service: BlePeripheralAnnouncement;
+    ts: number;
+}
+export declare class BleInterface extends EventEmitter implements IBleInterface<BlePeripheralAnnouncement> {
+    protected static _instance: BleInterface;
+    static readonly INTERFACE_NAME: string;
+    protected logger: EventLogger;
+    protected props: InterfaceProps;
+    protected logEnabled: boolean;
+    protected binding: BleBinding;
+    protected debug: boolean;
+    protected logDisabled: boolean;
+    protected internalEvents: EventEmitter;
+    protected services: Announcement[];
+    protected incompleteServices: BlePeripheralAnnouncement[];
+    protected unsupported: BlePeripheralAnnouncement[];
+    protected expectedServices: string[];
+    protected matching: string[];
+    protected connectTask: InteruptableTask<TaskState, boolean>;
+    protected scanTask: InteruptableTask<TaskState, void>;
+    protected discoverTask: InteruptableTask<TaskState, void>;
+    protected onDiscovered: (peripheral: BlePeripheralInfo) => void;
+    protected instanceId: number;
+    protected connectedPeripherals: IBlePeripheral[];
+    static getInstance(props?: InterfaceProps): BleInterface;
+    protected constructor(props: InterfaceProps);
+    getLogger(): EventLogger;
+    setLogger(logger: EventLogger): void;
+    getName(): string;
+    setBinding(binding: BleBinding): void;
+    getBinding(): BleBinding;
+    protected autoConnect(): void;
+    connect(reconnect?: boolean): Promise<boolean>;
+    disconnect(): Promise<boolean>;
+    isConnected(): boolean;
+    registerConnected(peripheral: IBlePeripheral): void;
+    protected isConnecting(): boolean;
+    scan(props: BleScanProps): Promise<DeviceSettings[]>;
+    stopScan(): Promise<boolean>;
+    onScanDone(): DeviceSettings[];
+    pauseLogging(): void;
+    resumeLogging(): void;
+    isLoggingPaused(): boolean;
+    createPeripheral(announcement: BlePeripheralAnnouncement): IBlePeripheral;
+    createPeripheralFromSettings(settings: DeviceSettings): IBlePeripheral;
+    waitForPeripheral(settings: DeviceSettings): Promise<IBlePeripheral>;
+    createDeviceSetting(service: BlePeripheralAnnouncement): DeviceSettings;
+    protected reconnect(): Promise<void>;
+    protected startPeripheralScan(retry?: boolean): Promise<void>;
+    protected stopPeripheralScan(): Promise<void>;
+    protected isDiscovering(): boolean;
+    protected discoverPeripherals(): Promise<void>;
+    pauseDiscovery(): Promise<void>;
+    resumeDiscovery(): Promise<void>;
+    protected onPeripheralFound(peripheral: BleRawPeripheral): void;
+    protected buildAnnouncement(peripheral: BleRawPeripheral): BlePeripheralAnnouncement;
+    protected updateWithServices(announcement: BlePeripheralAnnouncement): Promise<BlePeripheralAnnouncement>;
+    protected discoverServices(announcement: BlePeripheralAnnouncement): Promise<string[]>;
+    protected isScanning(): boolean;
+    protected startScan(): Promise<unknown>;
+    private emitCachedDevices;
+    protected emitDevice(service: BlePeripheralAnnouncement): void;
+    protected buildDeviceSettings(matching?: string[]): {
+        interface: string;
+        name: string;
+    }[];
+    protected addCompleting(service: BlePeripheralAnnouncement): void;
+    protected addUnsupported(service: BlePeripheralAnnouncement): void;
+    protected isKnownUnsupported(service: BlePeripheralAnnouncement): boolean;
+    protected removeCompleting(service: BlePeripheralAnnouncement): void;
+    protected isCompleting(service: BlePeripheralAnnouncement): boolean;
+    protected addService(service: BlePeripheralAnnouncement): void;
+    protected isSupportedPeripheral(service: BlePeripheralAnnouncement): boolean;
+    protected find(service: BlePeripheralAnnouncement): Announcement;
+    protected getAll(): Announcement[];
+    setDebug(enabled: boolean): void;
+    protected connectBle(): Promise<boolean>;
+    protected waitForBleConnected(): Promise<boolean>;
+    protected onBleStateChange(state: BleInterfaceState): void;
+    logEvent(event: any): void;
+    logError(err: Error, fn: string, args?: any): void;
+}
+export declare class BleInterfaceFactory extends InterfaceFactory {
+    protected iface: BleInterface;
+    constructor();
+    getInterface(): BleInterface;
+}
+export {};

package/lib/ble/base/interface.js

@@ -0,0 +1,544 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BleInterfaceFactory = exports.BleInterface = void 0;
+const events_1 = __importDefault(require("events"));
+const gd_eventlog_1 = require("gd-eventlog");
+const task_1 = require("../../utils/task");
+const peripheral_1 = require("./peripheral");
+const utils_1 = require("../utils");
+const types_1 = require("./types");
+const factories_1 = require("../factories");
+const BLE_DEFAULT_SCAN_TIMEOUT = 30 * 1000;
+const BLE_EXPIRATION_TIMEOUT = 10 * 1000 * 60;
+const BLE_DEFAULT_CONNECT_TIMEOUT = 30 * 1000;
+let instanceCount = 0;
+class BleInterface extends events_1.default {
+    static getInstance(props = {}) {
+        if (BleInterface._instance === undefined)
+            BleInterface._instance = new BleInterface(props);
+        else {
+            if (props.binding) {
+                BleInterface._instance.setBinding(props.binding);
+            }
+            if (props.logger) {
+                BleInterface._instance.logger = props.logger;
+            }
+            if (props.log && !BleInterface._instance.logger) {
+                BleInterface._instance.logger = new gd_eventlog_1.EventLogger('BLE');
+            }
+        }
+        return BleInterface._instance;
+    }
+    constructor(props) {
+        var _a;
+        super();
+        this.services = [];
+        this.incompleteServices = [];
+        this.unsupported = [];
+        this.expectedServices = ['180d', '1818', '1826', '6e40fec1'];
+        this.matching = [];
+        this.connectedPeripherals = [];
+        this.instanceId = ++instanceCount;
+        this.props = props;
+        this.logEnabled = props.log || true;
+        const { binding } = props;
+        this.setLogger((_a = props.logger) !== null && _a !== void 0 ? _a : new gd_eventlog_1.EventLogger('Ble'));
+        if (binding) {
+            this.setBinding(binding);
+        }
+        this.internalEvents = new events_1.default();
+        this.onDiscovered = this.onPeripheralFound.bind(this);
+        if (this.binding)
+            this.autoConnect();
+    }
+    getLogger() {
+        return this.logger;
+    }
+    setLogger(logger) {
+        this.logger = logger;
+    }
+    getName() {
+        return BleInterface.INTERFACE_NAME;
+    }
+    setBinding(binding) {
+        this.binding = binding;
+    }
+    getBinding() {
+        return this.binding;
+    }
+    autoConnect() {
+        this.connect();
+    }
+    connect(reconnect) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.getBinding()) {
+                this.logEvent({ message: 'BLE not available' });
+                return false;
+            }
+            if (this.isConnecting()) {
+                this.logEvent({ message: 'connect - already connecting' });
+                return this.connectTask.getPromise();
+            }
+            if (this.isConnected())
+                return true;
+            this.logEvent({ message: 'Ble connect request' });
+            this.connectTask = new task_1.InteruptableTask(this.connectBle(), {
+                timeout: BLE_DEFAULT_CONNECT_TIMEOUT,
+                name: 'connect',
+                errorOnTimeout: false,
+                log: this.logEvent.bind(this),
+            });
+            const success = yield this.connectTask.run();
+            if (success) {
+                this.startPeripheralScan();
+            }
+            this.expectedServices = factories_1.BleAdapterFactory.getInstance('ble').getAllSupportedServices();
+            return success;
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.getBinding()) {
+                return false;
+            }
+            if (!this.isConnected())
+                return true;
+            this.logEvent({ message: 'disconnect request' });
+            yield this.stopPeripheralScan();
+            const promises = this.connectedPeripherals.map(p => p.disconnect());
+            yield Promise.allSettled(promises);
+            this.connectedPeripherals = [];
+            yield this.connectTask.stop();
+            this.getBinding().removeAllListeners();
+            return true;
+        });
+    }
+    isConnected() {
+        var _a;
+        return ((_a = this.getBinding()) === null || _a === void 0 ? void 0 : _a.state) === 'poweredOn';
+    }
+    registerConnected(peripheral) {
+        this.connectedPeripherals.push(peripheral);
+    }
+    isConnecting() {
+        var _a;
+        return ((_a = this.connectTask) === null || _a === void 0 ? void 0 : _a.isRunning()) === true;
+    }
+    scan(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.resumeLogging();
+            if (this.isScanning()) {
+                this.logEvent({ message: 'starting scan - already scanning' });
+                return this.scanTask.getPromise()
+                    .then(() => { return this.onScanDone(); })
+                    .catch(() => []);
+            }
+            this.logEvent({ message: 'starting scan ..' });
+            this.scanTask = new task_1.InteruptableTask(this.startScan(), {
+                timeout: props.timeout,
+                name: 'scan',
+                errorOnTimeout: false,
+                log: this.logEvent.bind(this),
+            });
+            try {
+                yield this.scanTask.run();
+            }
+            catch (err) {
+                this.logError(err, 'scan');
+            }
+            return this.onScanDone();
+        });
+    }
+    stopScan() {
+        if (!this.isScanning())
+            return Promise.resolve(true);
+        this.logEvent({ message: 'stopping scan ...' });
+        this.scanTask.stop();
+    }
+    onScanDone() {
+        this.logEvent({ message: 'scan stopped' });
+        delete this.scanTask;
+        return this.buildDeviceSettings(this.matching);
+    }
+    pauseLogging() {
+        this.logDisabled = true;
+    }
+    resumeLogging() {
+        this.logDisabled = false;
+    }
+    isLoggingPaused() {
+        return this.logDisabled;
+    }
+    createPeripheral(announcement) {
+        return new peripheral_1.BlePeripheral(announcement);
+    }
+    createPeripheralFromSettings(settings) {
+        const info = this.getAll().find(a => a.service.name === settings.name);
+        if (!(info === null || info === void 0 ? void 0 : info.service))
+            return null;
+        return this.createPeripheral(info.service);
+    }
+    waitForPeripheral(settings) {
+        const peripheral = this.createPeripheralFromSettings(settings);
+        if (peripheral)
+            return Promise.resolve(peripheral);
+        return new Promise((done) => {
+            const onDevice = (device) => {
+                if (device.name === settings.name) {
+                    const peripheral = this.createPeripheralFromSettings(settings);
+                    if (peripheral) {
+                        this.off('device', onDevice);
+                        done(peripheral);
+                    }
+                }
+            };
+            this.on('device', onDevice);
+        });
+    }
+    createDeviceSetting(service) {
+        const name = service.name;
+        return { interface: BleInterface.INTERFACE_NAME, name };
+    }
+    reconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.disconnect();
+            yield this.connect(true);
+        });
+    }
+    startPeripheralScan() {
+        return __awaiter(this, arguments, void 0, function* (retry = false) {
+            if (!retry)
+                this.logEvent({ message: 'starting peripheral discovery ...' });
+            if (!this.isConnected() || this.isDiscovering()) {
+                return;
+            }
+            this.discoverTask = new task_1.InteruptableTask(this.discoverPeripherals(), {
+                errorOnTimeout: false,
+                name: 'discover',
+                log: this.logEvent.bind(this),
+            });
+            try {
+                yield this.discoverTask.run();
+            }
+            catch (err) {
+                this.logError(err, 'discover');
+            }
+            if (this.discoverTask.getState().result !== 'stopped') {
+                this.startPeripheralScan(true);
+            }
+        });
+    }
+    stopPeripheralScan() {
+        if (!this.isConnected() || !this.isDiscovering())
+            return;
+        this.logEvent({ message: 'stopping peripheral discovery ...' });
+        this.discoverTask.stop();
+        this.getBinding().off('discover', this.onDiscovered);
+        return new Promise(done => {
+            this.getBinding().stopScanning(() => {
+                done();
+            });
+        });
+    }
+    isDiscovering() {
+        var _a;
+        return ((_a = this.discoverTask) === null || _a === void 0 ? void 0 : _a.isRunning()) === true;
+    }
+    discoverPeripherals() {
+        return new Promise(done => {
+            const ble = this.getBinding();
+            ble.startScanning([], true, (err) => {
+                if (err) {
+                    this.logEvent({ message: 'start scanning error', error: err.message });
+                    ble.stopScanning(() => {
+                        done();
+                    });
+                }
+                else {
+                    ble.on('discover', this.onDiscovered);
+                    ble.on('error', (err) => {
+                        this.logEvent({ message: 'error during discovery', error: err.message });
+                    });
+                }
+            });
+        });
+    }
+    pauseDiscovery() {
+        this.getBinding().off('discover', this.onDiscovered);
+        return new Promise(done => {
+            try {
+                this.getBinding().stopScanning();
+                done();
+            }
+            catch (err) {
+                done();
+            }
+        });
+    }
+    resumeDiscovery() {
+        return this.discoverPeripherals();
+    }
+    onPeripheralFound(peripheral) {
+        if (!this.isConnected() || !this.isDiscovering())
+            return;
+        const announcement = this.buildAnnouncement(peripheral);
+        if (!announcement.name || this.isKnownUnsupported(announcement)) {
+            return;
+        }
+        const device = Object.assign({}, announcement);
+        delete device.peripheral;
+        if (this.find(announcement)) {
+            return;
+        }
+        if (announcement.serviceUUIDs.length === 0) {
+            if (this.isCompleting(announcement)) {
+                return;
+            }
+            this.addCompleting(announcement);
+            setTimeout(() => {
+                if (this.find(announcement)) {
+                    this.removeCompleting(announcement);
+                    return;
+                }
+                this.updateWithServices(announcement)
+                    .then(() => {
+                    if (this.isSupportedPeripheral(announcement))
+                        this.addService(announcement);
+                });
+            }, 1000);
+        }
+        this.addService(announcement);
+    }
+    buildAnnouncement(peripheral) {
+        var _a;
+        return {
+            advertisement: peripheral.advertisement,
+            name: peripheral.advertisement.localName,
+            serviceUUIDs: (_a = peripheral.advertisement.serviceUuids) !== null && _a !== void 0 ? _a : [],
+            peripheral,
+            transport: this.getName()
+        };
+    }
+    updateWithServices(announcement) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isConnected() || !this.isDiscovering())
+                return;
+            try {
+                yield this.discoverServices(announcement);
+                return announcement;
+            }
+            catch (err) {
+                this.logError(err, 'updateWithServices');
+            }
+            this.removeCompleting(announcement);
+        });
+    }
+    discoverServices(announcement) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const device = Object.assign({}, announcement);
+            delete device.peripheral;
+            const { peripheral } = announcement;
+            let paused = false;
+            try {
+                peripheral.on('error', (err) => {
+                    peripheral.removeAllListeners();
+                    this.logEvent({ message: 'Device error', error: err.message });
+                });
+                peripheral.on('disconnect', () => {
+                    peripheral.removeAllListeners();
+                    this.logEvent({ message: 'Device disconnected' });
+                });
+                yield peripheral.connectAsync();
+                if (peripheral.discoverServicesAsync !== undefined) {
+                    const services = yield peripheral.discoverServicesAsync([]);
+                    announcement.serviceUUIDs = services.map(s => s.uuid);
+                }
+                else {
+                    const res = yield peripheral.discoverSomeServicesAndCharacteristicsAsync([], []);
+                    announcement.serviceUUIDs = res.services.map(s => s.uuid);
+                }
+                peripheral.removeAllListeners();
+            }
+            catch (err) {
+                this.logEvent({ message: 'discover services failed', reason: err.message, device });
+            }
+            if (paused) {
+                yield this.resumeDiscovery();
+            }
+            return device.serviceUUIDs;
+        });
+    }
+    isScanning() {
+        var _a;
+        return ((_a = this.scanTask) === null || _a === void 0 ? void 0 : _a.isRunning()) === true;
+    }
+    startScan() {
+        this.logEvent({ message: 'scan started', scanning: this.isScanning() });
+        this.emitCachedDevices();
+        return new Promise(() => {
+        });
+    }
+    emitCachedDevices() {
+        const announced = this.getAll();
+        this.matching = announced.map(a => a.service.name);
+        announced.forEach(a => {
+            this.emitDevice(a.service);
+        });
+    }
+    emitDevice(service) {
+        const settings = this.createDeviceSetting(service);
+        this.emit('device', settings, service);
+    }
+    buildDeviceSettings(matching = []) {
+        return matching.map((name) => ({ interface: BleInterface.INTERFACE_NAME, name }));
+    }
+    addCompleting(service) {
+        const existing = this.incompleteServices.find(s => s.name === service.name);
+        if (existing) {
+            const idx = this.incompleteServices.indexOf(existing);
+            this.incompleteServices[idx] = service;
+        }
+        else {
+            this.incompleteServices.push(service);
+        }
+    }
+    addUnsupported(service) {
+        const existing = this.unsupported.find(s => s.name === service.name);
+        if (existing) {
+            const idx = this.unsupported.indexOf(existing);
+            this.unsupported[idx] = service;
+        }
+        else {
+            this.unsupported.push(service);
+        }
+    }
+    isKnownUnsupported(service) {
+        return this.unsupported.find(s => s.name === service.name) !== undefined;
+    }
+    removeCompleting(service) {
+        const existingIdx = this.incompleteServices.findIndex(s => s.name === service.name);
+        if (existingIdx !== -1) {
+            this.incompleteServices.splice(existingIdx, 1);
+        }
+    }
+    isCompleting(service) {
+        return this.incompleteServices.find(s => s.name === service.name) !== undefined;
+    }
+    addService(service) {
+        try {
+            const isSuported = this.isSupportedPeripheral(service);
+            if (!isSuported) {
+                return;
+            }
+            const existing = this.find(service);
+            if (existing) {
+                const idx = this.services.indexOf(existing);
+                this.services[idx] = { ts: Date.now(), service };
+            }
+            else {
+                const device = Object.assign({}, service);
+                delete device.peripheral;
+                this.logEvent({ message: 'device announced', device });
+                this.matching.push(service.name);
+                this.services.push({ ts: Date.now(), service });
+                this.emitDevice(service);
+            }
+        }
+        catch (err) {
+            this.logError(err, 'addService');
+        }
+    }
+    isSupportedPeripheral(service) {
+        var _a, _b;
+        if (!((_a = service.serviceUUIDs) === null || _a === void 0 ? void 0 : _a.length) || service.name === undefined)
+            return false;
+        const found = service.serviceUUIDs.map(utils_1.parseUUID);
+        const expected = this.expectedServices.map(utils_1.parseUUID);
+        const supported = (_b = found.filter(uuid => expected.includes(uuid))) !== null && _b !== void 0 ? _b : [];
+        if (!supported.length) {
+            this.logEvent({ message: 'service not supported', name: service.name, uuids: service.serviceUUIDs });
+            this.addUnsupported(service);
+        }
+        return supported.length > 0;
+    }
+    find(service) {
+        return this.services.find(a => a.service.name === service.name && a.ts > Date.now() - BLE_EXPIRATION_TIMEOUT);
+    }
+    getAll() {
+        return this.services.filter(a => a.ts > Date.now() - BLE_EXPIRATION_TIMEOUT);
+    }
+    setDebug(enabled) {
+        this.debug = enabled;
+    }
+    connectBle() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const state = this.getBinding().state;
+            if (state === 'poweredOn') {
+                return true;
+            }
+            const res = yield this.waitForBleConnected();
+            return res;
+        });
+    }
+    waitForBleConnected() {
+        return new Promise((done) => {
+            this.getBinding().once('error', (err) => {
+                this.logEvent({ message: 'Ble connect result: error', error: err.message });
+                return done(false);
+            });
+            this.getBinding().on('stateChange', (state) => {
+                if (state === 'poweredOn') {
+                    this.logEvent({ message: 'Ble connect result: success' });
+                    this.getBinding().removeAllListeners('stateChange');
+                    this.getBinding().on('stateChange', this.onBleStateChange.bind(this));
+                    this.getBinding().on('error', console.log);
+                    return done(true);
+                }
+                else {
+                    this.logEvent({ message: 'BLE state change', state });
+                }
+            });
+        });
+    }
+    onBleStateChange(state) {
+    }
+    logEvent(event) {
+        if (this.logDisabled && event.message !== 'Error')
+            return;
+        this.getLogger().logEvent(event);
+        const emitPayload = Object.assign({}, event);
+        delete emitPayload.ts;
+        this.emit('log', emitPayload);
+        const w = global.window;
+        if (this.debug || (w === null || w === void 0 ? void 0 : w.SERVICE_DEBUG) || process.env.DEBUG)
+            console.log(`~~~ ${this.logger.getName().toUpperCase()}-SVC`, event);
+    }
+    logError(err, fn, args) {
+        const logInfo = args || {};
+        this.logEvent(Object.assign(Object.assign({ message: 'Error', fn }, logInfo), { error: err.message, stack: err.stack }));
+    }
+}
+exports.BleInterface = BleInterface;
+BleInterface.INTERFACE_NAME = 'ble';
+class BleInterfaceFactory extends types_1.InterfaceFactory {
+    constructor() {
+        super();
+        this.iface = BleInterface.getInstance();
+    }
+    getInterface() {
+        return this.iface;
+    }
+}
+exports.BleInterfaceFactory = BleInterfaceFactory;

package/lib/ble/base/peripheral.d.ts

@@ -0,0 +1,34 @@
+import { BleCharacteristic, BlePeripheralAnnouncement, BleRawCharacteristic, BleRawPeripheral, BleService, BleWriteProps, IBlePeripheral } from "../types";
+import { BleInterface } from "./interface";
+export declare class BlePeripheral implements IBlePeripheral {
+    protected announcement: BlePeripheralAnnouncement;
+    protected connected: boolean;
+    protected characteristics: Record<string, BleRawCharacteristic>;
+    protected onDisconnectHandler?: () => void;
+    protected ble: BleInterface;
+    protected subscribed: Array<{
+        uuid: string;
+        callback: (data: Buffer) => void;
+    }>;
+    protected disconnecting: boolean;
+    constructor(announcement: BlePeripheralAnnouncement);
+    get services(): BleService[];
+    protected getPeripheral(): BleRawPeripheral;
+    connect(): Promise<boolean>;
+    disconnect(): Promise<boolean>;
+    isConnected(): boolean;
+    isConnecting(): boolean;
+    onDisconnect(callback: () => void): void;
+    discoverServices(): Promise<string[]>;
+    discoverCharacteristics(serviceUUID: string): Promise<BleCharacteristic[]>;
+    subscribe(characteristicUUID: string, callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
+    unsubscribe(characteristicUUID: string): Promise<boolean>;
+    subscribeSelected(characteristics: string[], callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
+    discoverAllCharacteristics(): Promise<string[]>;
+    subscribeAll(callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
+    unsubscribeAll(): Promise<boolean>;
+    read(characteristicUUID: string): Promise<Buffer>;
+    write(characteristicUUID: string, data: Buffer, options?: BleWriteProps): Promise<Buffer>;
+    protected getRawCharacteristic(uuid: string): BleRawCharacteristic;
+    logEvent(event: any): void;
+}