incyclist-devices 1.4.42 → 1.4.45

package/lib/ble/ble-interface.js

@@ -13,18 +13,19 @@ const gd_eventlog_1 = require("gd-eventlog");
 const utils_1 = require("../utils");
 const ble_1 = require("./ble");
 const CONNECT_TIMEOUT = 5000;
+const DEFAULT_SCAN_TIMEOUT = 20000;
+const BACKGROUND_SCAN_TIMEOUT = 30000;
+const DEFAULT_SERVICES = ['1818', '180d', '1826'];
 class BleInterface extends ble_1.BleInterfaceClass {
     constructor(props = {}) {
         super(props);
         this.scanState = { isScanning: false, isConnecting: false, timeout: undefined, isBackgroundScan: false };
         this.connectState = { isConnecting: false, isConnected: false, isInitSuccess: false };
         this.devices = [];
-        this.deviceCache = [];
+        this.peripheralCache = [];
         if (props.logger)
             this.logger = props.logger;
-        else if (props.log) {
-            this.logger = new gd_eventlog_1.EventLogger('BLE');
-        }
+        this.logger = new gd_eventlog_1.EventLogger('BLE');
     }
     static getInstance(props = {}) {
         if (!BleInterface._instance) {
@@ -71,7 +72,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
         const timeout = props.timeout || 2000;
         const runBackgroundScan = () => {
             this.scanState.isBackgroundScan = true;
-            this.scan({ timeout: 5000, isBackgroundScan: true })
+            this.scan({ timeout: BACKGROUND_SCAN_TIMEOUT, isBackgroundScan: true })
                 .then(() => {
                 this.scanState.isBackgroundScan = false;
             })
@@ -210,7 +211,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
             });
         };
         if (typeof services === 'string') {
-            return get(deviceTypes, (s) => s === ble_1.uuid(services));
+            return get(deviceTypes, (s) => s === (0, ble_1.uuid)(services));
         }
         if (Array.isArray(services)) {
             return get(deviceTypes, s => services.map(ble_1.uuid).includes(s));
@@ -218,19 +219,24 @@ class BleInterface extends ble_1.BleInterfaceClass {
         return [];
     }
     getServicesFromDeviceTypes(deviceTypes) {
-        if (!deviceTypes || !Array.isArray(deviceTypes) || deviceTypes.length === 0) {
-            return [];
-        }
-        const services = [];
-        deviceTypes.forEach(DeviceType => {
-            if (DeviceType.services) {
-                const dtServices = DeviceType.services;
-                dtServices.forEach(s => {
-                    if (!services.find(s2 => s2 === s))
-                        services.push(s);
-                });
+        let services = [];
+        try {
+            if (!deviceTypes || !Array.isArray(deviceTypes) || deviceTypes.length === 0) {
+                return [];
             }
-        });
+            deviceTypes.forEach(DeviceType => {
+                if (DeviceType.services) {
+                    const dtServices = DeviceType.services;
+                    dtServices.forEach(s => {
+                        if (!services.find(s2 => s2 === s))
+                            services.push(s);
+                    });
+                }
+            });
+        }
+        catch (err) {
+            console.log(err);
+        }
         return services;
     }
     getServicesFromDevice(device) {
@@ -260,15 +266,117 @@ class BleInterface extends ble_1.BleInterfaceClass {
             }, 100);
         });
     }
-    connectDevice(requested, timeout = CONNECT_TIMEOUT) {
+    addPeripheralToCache(peripheral, props = {}) {
+        this.peripheralCache.push(Object.assign({ address: peripheral.address, ts: Date.now(), peripheral }, props));
+    }
+    getCharacteristics(peripheral) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { id, name, address, getProfile } = requested;
-            const profile = getProfile && typeof (getProfile) === 'function' ? getProfile() : undefined;
+            let characteristics = undefined;
+            let chachedPeripheralInfo = this.peripheralCache.find(i => i.address === peripheral.address);
+            if (chachedPeripheralInfo && Date.now() - chachedPeripheralInfo.ts > 600000) {
+                chachedPeripheralInfo.ts = Date.now();
+            }
+            if (!chachedPeripheralInfo) {
+                this.addPeripheralToCache(peripheral);
+                chachedPeripheralInfo = this.peripheralCache.find(i => i.address === peripheral.address);
+            }
+            if (!chachedPeripheralInfo.characteristics) {
+                try {
+                    chachedPeripheralInfo.state = { isConfigured: false, isLoading: true, isInterrupted: false };
+                    if (chachedPeripheralInfo.peripheral && chachedPeripheralInfo.peripheral.state !== 'connected') {
+                        yield peripheral.connectAsync();
+                        chachedPeripheralInfo.peripheral.state = peripheral.state;
+                    }
+                    else {
+                        peripheral.state = chachedPeripheralInfo.peripheral.state;
+                    }
+                    const res = yield peripheral.discoverSomeServicesAndCharacteristicsAsync([], []);
+                    if (!chachedPeripheralInfo.state.isInterrupted) {
+                        this.logEvent({ message: 'characteristic info (+):', info: res.characteristics.map(c => `${peripheral.address} ${c.uuid} ${c.properties}`) });
+                        chachedPeripheralInfo.characteristics = res.characteristics;
+                        chachedPeripheralInfo.state = { isConfigured: true, isLoading: false, isInterrupted: false };
+                        characteristics = res.characteristics;
+                    }
+                    else {
+                        this.logEvent({ message: 'characteristic info:', info: 'interrupted' });
+                        chachedPeripheralInfo.state = { isConfigured: false, isLoading: false, isInterrupted: false };
+                        throw new Error('interrupted');
+                    }
+                }
+                catch (err) {
+                    console.log(err);
+                }
+            }
+            else {
+                characteristics = chachedPeripheralInfo.characteristics;
+                this.logEvent({ message: 'characteristic info (*):', info: characteristics.map(c => `${peripheral.address} ${c.uuid} ${c.properties}`) });
+            }
+            if (!characteristics)
+                this.logEvent({ message: 'characteristic info:', info: 'none' });
+            return characteristics;
+        });
+    }
+    getDeviceClasses(peripheral, props = {}) {
+        let DeviceClasses;
+        const { deviceTypes, profile } = props;
+        if ((!deviceTypes || deviceTypes.length === 0)) {
+            const classes = BleInterface.deviceClasses.map(c => c.Class);
+            DeviceClasses = this.getDevicesFromServices(classes, peripheral.advertisement.serviceUuids);
+        }
+        else {
+            DeviceClasses = this.getDevicesFromServices(deviceTypes, peripheral.advertisement.serviceUuids);
+        }
+        if (profile && DeviceClasses && DeviceClasses.length > 0) {
+            DeviceClasses = DeviceClasses.filter(C => {
+                const device = new C({ peripheral });
+                if (device.getProfile() !== profile)
+                    return false;
+                return true;
+            });
+        }
+        return DeviceClasses;
+    }
+    createDevice(DeviceClass, peripheral, characteristics) {
+        const C = DeviceClass;
+        const device = new C({ peripheral });
+        device.setInterface(this);
+        device.characteristics = characteristics;
+        return device;
+    }
+    connectDevice(requested, timeout = DEFAULT_SCAN_TIMEOUT + CONNECT_TIMEOUT) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { id, name, address } = requested;
+            const profile = requested instanceof ble_1.BleDeviceClass ?
+                (requested.getProfile && typeof (requested.getProfile) === 'function' ? requested.getProfile() : undefined) :
+                requested.profile;
             this.logEvent({ message: 'connectDevice', id, name, address, profile, isbusy: this.scanState.isConnecting });
             if (this.scanState.isConnecting) {
-                yield this.waitForConnectFinished(10000);
+                yield this.waitForConnectFinished(CONNECT_TIMEOUT);
             }
             this.scanState.isConnecting = true;
+            const existing = this.devices.find(i => (!profile || i.device.getProfile() === profile) && (i.device.address === requested.address || i.device.id === requested.id || i.device.name === requested.name));
+            if (existing) {
+                const connected = yield existing.device.connect();
+                this.scanState.isConnecting = false;
+                return existing.device;
+            }
+            const peripheralInfo = this.peripheralCache.find(i => (i.address === requested.address || (i.periphal && i.peripheral.id === requested.id)));
+            if (peripheralInfo) {
+                if (!peripheralInfo.characteristic) {
+                    yield this.getCharacteristics(peripheralInfo.periphal);
+                    const DeviceClasses = this.getDeviceClasses(peripheralInfo.peripheral, { profile });
+                    if (!DeviceClasses || DeviceClasses.length === 0)
+                        return;
+                    const devices = DeviceClasses.map(C => this.createDevice(C, peripheralInfo.periphal, peripheralInfo.characteristics));
+                    if (devices && devices.length > 0) {
+                        for (let i = 0; i < devices.length; i++) {
+                            const idx = this.devices.push({ device: devices[i], isConnected: false }) - 1;
+                            yield devices[i].connect();
+                            this.devices[idx].isConnected = true;
+                        }
+                    }
+                }
+            }
             let devices = [];
             let retry = false;
             let retryCount = 0;
@@ -277,7 +385,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
                     this.logEvent({ message: 'retry connect device', id, name, address, profile, retryCount });
                 }
                 try {
-                    devices = yield this.scan({ timeout, device: requested });
+                    devices = yield this.scan({ timeout: DEFAULT_SCAN_TIMEOUT, requested: requested });
                     if (devices.length === 0) {
                         retryCount++;
                         retry = retryCount < 5;
@@ -285,7 +393,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
                 }
                 catch (err) {
                     if (err.message === 'scanning already in progress') {
-                        yield utils_1.sleep(1000);
+                        yield (0, utils_1.sleep)(1000);
                         retryCount++;
                         retry = retryCount < 5;
                         continue;
@@ -330,42 +438,36 @@ class BleInterface extends ble_1.BleInterfaceClass {
             }, 100);
         });
     }
-    addPeripheralToCache(peripheral) {
-        try {
-            this.logEvent({ message: 'adding device to cache', device: { address: peripheral.address, name: peripheral.advertisement ? peripheral.advertisement.localName : '' } });
-            const existing = this.deviceCache.find(p => p.address === peripheral.address);
-            if (!existing)
-                this.deviceCache.push(peripheral);
-            else {
-                if (peripheral.advertisement && peripheral.advertisement.localName !== '' && existing.advertisement && existing.advertisement.localName === '')
-                    existing.advertisement.localName = peripheral.advertisement.localName;
-            }
-        }
-        catch (err) {
-            console.log('~~~ error', err);
-        }
-    }
     scan(props) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { timeout = 5000, deviceTypes = [], device } = props;
-            const scanForDevice = (device !== null && device !== undefined);
-            const services = this.getServicesFromDeviceTypes(deviceTypes);
+            const { timeout = DEFAULT_SCAN_TIMEOUT, deviceTypes = [], requested } = props;
+            let profile;
+            if (requested)
+                profile = requested instanceof ble_1.BleDeviceClass ?
+                    (requested.getProfile && typeof (requested.getProfile) === 'function' ? requested.getProfile() : undefined) :
+                    requested.profile;
+            const { id, address, name } = requested || {};
+            const scanForDevice = (requested !== null && requested !== undefined);
+            const services = (props.isBackgroundScan || !deviceTypes || deviceTypes.length === 0) ? DEFAULT_SERVICES : this.getServicesFromDeviceTypes(deviceTypes);
             const bleBinding = this.getBinding();
             if (!bleBinding)
                 return Promise.reject(new Error('no binding defined'));
             if (!this.isConnected()) {
                 yield this.connect();
             }
-            this.logEvent({ message: 'scan()', props, scanState: this.scanState, cache: this.deviceCache.map(p => ({ name: p.advertisement ? p.advertisement.localName : '', address: p.address })) });
+            const peripheralsProcessed = [];
+            const devicesProcessed = [];
+            this.logEvent({ message: 'scan()', props, scanState: this.scanState,
+                peripheralCache: this.peripheralCache.map(i => ({ address: i.address, ts: i.ts, name: i.peripheral ? i.peripheral.advertisement.localName : '' })),
+                deviceCache: this.devices.map(i => ({ address: i.device.address, profile: i.device.getProfile(), isConnected: i.isConnected }))
+            });
             if (!props.isBackgroundScan && this.scanState.isBackgroundScan) {
                 yield this.stopScan();
                 this.scanState.isBackgroundScan = false;
             }
-            const detectedPeripherals = {};
             let opStr;
             if (scanForDevice) {
                 opStr = 'search device';
-                const { id, address, name } = device;
                 this.logEvent({ message: 'search device request', device: { id, address, name }, deviceTypes });
             }
             else {
@@ -374,6 +476,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
             }
             if (this.scanState.isScanning) {
                 try {
+                    this.logEvent({ message: `${opStr}: waiting for previous scan to finish` });
                     yield this.waitForScanFinished(timeout);
                 }
                 catch (err) {
@@ -383,151 +486,102 @@ class BleInterface extends ble_1.BleInterfaceClass {
             }
             return new Promise((resolve, reject) => {
                 this.scanState.isScanning = true;
-                if (scanForDevice && device instanceof ble_1.BleDeviceClass) {
+                if (props.isBackgroundScan)
+                    this.scanState.isBackgroundScan = true;
+                if (scanForDevice) {
                     if (this.devices && this.devices.length > 0) {
-                        const connectedDevices = this.devices.map(i => ({ name: i.device.name, address: i.device.address, isConnected: i.isConnected, connectState: i.device.getConnectState() }));
-                        const { name, address } = device;
-                        this.logEvent({ message: `${opStr}: check if already registered`, device: { name, address }, connectedDevices });
-                        const existing = this.devices.find(i => (i.device.address === device.address || i.device.name === device.name));
-                        if (existing) {
-                            const d = device;
-                            const linkedDevice = existing.device;
-                            d.peripheral = existing.device.peripheral;
-                            if (d.setInterface && typeof (d.setInterface) === 'function')
-                                d.setInterface(this);
-                            setTimeout(() => {
-                                let connectState = linkedDevice.getConnectState();
-                                this.logEvent({ message: `${opStr}: device already registered`, device: device.name, address: device.address, connectState });
-                                if (connectState.isConnecting) {
-                                    const waitStart = Date.now();
-                                    const waitTimeout = waitStart + timeout;
-                                    const waitIv = setInterval(() => {
-                                        try {
-                                            connectState = linkedDevice.getConnectState();
-                                            if (connectState.isConnecting && Date.now() > waitTimeout) {
-                                                clearInterval(waitIv);
-                                                this.scanState.isScanning = false;
-                                                return resolve([]);
-                                            }
-                                            if (!connectState.isConnecting) {
-                                                clearInterval(waitIv);
-                                                this.scanState.isScanning = false;
-                                                return resolve([device]);
-                                            }
-                                        }
-                                        catch (err) {
-                                            console.log('~~~ error', err);
-                                        }
-                                    }, 100);
-                                }
-                                else if (connectState.isConnected) {
-                                    this.scanState.isScanning = false;
-                                    resolve([device]);
-                                }
-                                else {
-                                    this.scanState.isScanning = false;
-                                    resolve([]);
-                                }
-                            }, 100);
-                        }
+                        const knownDevices = this.devices.map(i => ({ name: i.device.name, address: i.device.address, isConnected: i.isConnected, connectState: i.device.getConnectState() }));
+                        this.logEvent({ message: `${opStr}: check if already registered`, device: { name, address }, knownDevices });
+                        const existing = this.devices.find(i => (i.device.address === address || i.device.name === name || i.device.id === id));
                     }
                 }
-                const onPeripheralFound = (peripheral, fromCache = false) => {
+                const onTimeout = () => {
+                    if (!this.scanState.isScanning || !this.scanState.timeout)
+                        return;
+                    this.scanState.timeout = null;
+                    this.logEvent({ message: `${opStr} result: devices found`, requested: scanForDevice ? { name, address, profile } : undefined, devices: this.devices.map(i => i.device.name + (!i.device.name || i.device.name === '') ? `addr=${i.device.address}` : '') });
+                    this.getBinding().removeAllListeners('discover');
+                    this.logEvent({ message: `${opStr}: stop scanning`, requested: scanForDevice ? { name, address, profile } : undefined, });
+                    bleBinding.stopScanning(() => {
+                        this.scanState.isScanning = false;
+                        if (scanForDevice) {
+                            reject(new Error('device not found'));
+                            return;
+                        }
+                        resolve(this.devices.map(i => i.device));
+                    });
+                };
+                const onPeripheralFound = (peripheral, fromCache = false) => __awaiter(this, void 0, void 0, function* () {
                     if (fromCache)
                         this.logEvent({ message: 'adding from Cache', peripheral: peripheral.address });
-                    if (!peripheral || !peripheral.advertisement)
+                    if (!peripheral || !peripheral.advertisement || !peripheral.advertisement.serviceUuids || peripheral.advertisement.serviceUuids.length === 0)
                         return;
-                    if (!detectedPeripherals[peripheral.id]) {
-                        if (process.env.BLE_DEBUG)
-                            console.log('discovered', peripheral);
-                        detectedPeripherals[peripheral.id] = peripheral;
-                        this.addPeripheralToCache(peripheral);
-                        let DeviceClasses;
-                        if (scanForDevice && (!deviceTypes || deviceTypes.length === 0)) {
-                            const classes = BleInterface.deviceClasses.map(c => c.Class);
-                            DeviceClasses = this.getDevicesFromServices(classes, peripheral.advertisement.serviceUuids);
+                    const isPeripheralProcessed = peripheralsProcessed.find(p => p === peripheral.address) !== undefined;
+                    if (isPeripheralProcessed)
+                        return;
+                    peripheralsProcessed.push(peripheral.address);
+                    let chachedPeripheralInfo = this.peripheralCache.find(i => i.address === peripheral.address);
+                    const str = fromCache ? 'added' : 'detected';
+                    const characteristics = yield this.getCharacteristics(peripheral);
+                    const DeviceClasses = this.getDeviceClasses(peripheral, { profile });
+                    let cntFound = 0;
+                    DeviceClasses.forEach(DeviceClass => {
+                        if (!DeviceClass)
+                            return;
+                        if (scanForDevice && cntFound > 0)
+                            return;
+                        const d = this.createDevice(DeviceClass, peripheral, characteristics);
+                        if (scanForDevice) {
+                            if ((id && id !== '' && d.id === id) ||
+                                (address && address !== '' && d.address === address) ||
+                                (name && name !== '' && d.name === name))
+                                cntFound++;
                         }
-                        else {
-                            DeviceClasses = this.getDevicesFromServices(deviceTypes, peripheral.advertisement.serviceUuids);
+                        else
+                            cntFound++;
+                        const existing = devicesProcessed.find(device => device.id === d.id && device.getProfile() === d.getProfile());
+                        if (!scanForDevice && cntFound > 0 && !existing) {
+                            this.logEvent({ message: `${opStr}: device found`, device: d.name, address: d.address, services: d.services.join(',') });
+                            this.devices.push({ device: d, isConnected: peripheral.state === 'connected' });
+                            devicesProcessed.push(d);
+                            this.emit('device', d);
+                            return;
                         }
-                        DeviceClasses.forEach(DeviceClass => {
-                            let cntFound = 0;
-                            if (!DeviceClass)
-                                return;
-                            if (scanForDevice && cntFound > 0)
-                                return;
-                            const C = DeviceClass;
-                            const d = new C({ peripheral });
-                            if (device && device.getProfile && device.getProfile() !== d.getProfile())
-                                return;
-                            d.setInterface(this);
-                            if (scanForDevice) {
-                                if ((device.id && device.id !== '' && d.id === device.id) ||
-                                    (device.address && device.address !== '' && d.address === device.address) ||
-                                    (device.name && device.name !== '' && d.name === device.name))
-                                    cntFound++;
-                            }
-                            else
-                                cntFound++;
-                            const existing = this.devices.find(i => i.device.id === d.id && i.device.getProfile() === d.getProfile());
-                            if (!scanForDevice && cntFound > 0 && !existing) {
-                                this.logEvent({ message: `${opStr}: device found`, device: d.name, address: d.address, services: d.services.join(',') });
-                                this.devices.push({ device: d, isConnected: false });
-                                this.emit('device', d);
-                            }
-                            if (scanForDevice && cntFound > 0) {
-                                if (fromCache) {
-                                    resolve([d]);
-                                    return;
-                                }
+                        if (scanForDevice && cntFound > 0) {
+                            this.logEvent({ message: `${opStr}: device found`, device: d.name, address: d.address, services: d.services.join(',') });
+                            this.devices.push({ device: d, isConnected: peripheral.state === 'connected' });
+                            devicesProcessed.push(d);
+                            this.emit('device', d);
+                            process.nextTick(() => {
                                 if (this.scanState.timeout) {
                                     clearTimeout(this.scanState.timeout);
                                     this.scanState.timeout = null;
-                                    this.logEvent({ message: `${opStr}: stop scanning`, requested: scanForDevice ? { name: device.name, address: device.address } : undefined, });
-                                    bleBinding.stopScanning(() => {
-                                        this.getBinding().removeAllListeners('discover');
-                                        this.scanState.isScanning = false;
-                                        resolve([d]);
-                                    });
                                 }
-                                else {
+                                this.logEvent({ message: `${opStr}: stop scanning`, requested: scanForDevice ? { name, address, profile } : undefined, });
+                                bleBinding.stopScanning(() => {
+                                    this.getBinding().removeAllListeners('discover');
+                                    this.scanState.isScanning = false;
                                     resolve([d]);
-                                }
-                            }
-                        });
-                    }
-                    else {
-                    }
-                };
-                this.logEvent({ message: `${opStr}: start scanning`, requested: scanForDevice ? { name: device.name, address: device.address } : undefined, timeout });
-                this.deviceCache.forEach(peripheral => {
-                    onPeripheralFound(peripheral, true);
+                                });
+                            });
+                        }
+                    });
+                });
+                this.logEvent({ message: `${opStr}: start scanning`, requested: scanForDevice ? { name, address, profile } : undefined, timeout });
+                this.peripheralCache.forEach(i => {
+                    onPeripheralFound(i.peripheral, true);
                 });
                 bleBinding.startScanning([], true, (err) => {
                     if (err) {
-                        this.logEvent({ message: `${opStr} result: error`, requested: scanForDevice ? { name: device.name, address: device.address } : undefined, error: err.message });
+                        this.logEvent({ message: `${opStr} result: error`, requested: scanForDevice ? { name, address, profile } : undefined, error: err.message });
                         this.scanState.isScanning = false;
                         return reject(err);
                     }
                     bleBinding.on('discover', (p) => {
-                        console.log('~~~ discovered:', p.address, p.advertisement ? p.advertisement.localName : '');
                         onPeripheralFound(p);
                     });
                 });
-                this.scanState.timeout = setTimeout(() => {
-                    this.scanState.timeout = null;
-                    this.logEvent({ message: `${opStr} result: devices found`, requested: scanForDevice ? { name: device.name, address: device.address } : undefined, devices: this.devices.map(i => i.device.name + (!i.device.name || i.device.name === '') ? `addr=${i.device.address}` : '') });
-                    this.getBinding().removeAllListeners('discover');
-                    this.logEvent({ message: `${opStr}: stop scanning`, requested: scanForDevice ? { name: device.name, address: device.address } : undefined, });
-                    bleBinding.stopScanning(() => {
-                        this.scanState.isScanning = false;
-                        if (scanForDevice) {
-                            reject(new Error('device not found'));
-                            return;
-                        }
-                        resolve(this.devices.map(i => i.device));
-                    });
-                }, timeout);
+                this.scanState.timeout = setTimeout(onTimeout, timeout);
             });
         });
     }
@@ -538,6 +592,9 @@ class BleInterface extends ble_1.BleInterfaceClass {
         if (!this.getBinding())
             return Promise.reject(new Error('no binding defined'));
         this.getBinding().removeAllListeners('discover');
+        const ongoing = this.peripheralCache.filter(i => i.state.isLoading);
+        if (ongoing)
+            ongoing.forEach(i => { i.isInterrupted = true; });
         this.logEvent({ message: 'scan stop request' });
         return new Promise(resolve => {
             this.getBinding().stopScanning(() => {

package/lib/ble/ble.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import EventEmitter from "events";
 export declare type ConnectProps = {
     timeout?: number;
@@ -13,6 +14,20 @@ export interface ConnectState {
     isConnected: boolean;
     isDisconnecting: boolean;
 }
+export declare type BleDeviceInfo = {
+    manufacturer?: string;
+    hwRevision?: string;
+    swRevision?: string;
+    fwRevision?: string;
+    model?: string;
+    serialNo?: string;
+};
+export interface BleDeviceDescription {
+    id?: string;
+    address: string;
+    name?: string;
+    profile: string;
+}
 export declare abstract class BleDeviceClass extends EventEmitter {
     static services: string[];
     id?: string;
@@ -26,6 +41,7 @@ export declare abstract class BleDeviceClass extends EventEmitter {
     abstract getServiceUUids(): string[];
     abstract connect(props?: ConnectProps): Promise<boolean>;
     abstract disconnect(): Promise<boolean>;
+    abstract getDeviceInfo(): Promise<BleDeviceInfo>;
 }
 export interface BleBinding extends EventEmitter {
     startScanning(serviceUUIDs?: string[], allowDuplicates?: boolean, callback?: (error?: Error) => void): void;
@@ -36,7 +52,7 @@ export interface BleBinding extends EventEmitter {
 export declare type ScanProps = {
     timeout?: number;
     deviceTypes?: (typeof BleDeviceClass)[];
-    device?: BleDeviceClass;
+    requested?: BleDeviceClass | BleDeviceDescription;
     isBackgroundScan?: boolean;
 };
 export declare class BleBindingWrapper {
@@ -73,6 +89,9 @@ export interface BlePeripheral extends EventEmitter, BleDeviceIdentifier {
     discoverSomeServicesAndCharacteristicsAsync(serviceUUIDs: string[], characteristicUUIDs: string[]): Promise<any>;
 }
 export interface BleCharacteristic extends EventEmitter {
+    subscribe(callback: (err: Error) => void): void;
+    read(callback: (err: Error, data: Buffer) => void): void;
+    write(data: Buffer, withoutResponse: boolean, callback?: (err: Error) => void): void;
 }
 export declare type BleDeviceProps = {
     id?: string;

package/lib/ble/ble.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.uuid = exports.BleState = exports.BleInterfaceClass = exports.BleBindingWrapper = exports.BleDeviceClass = void 0;
 const events_1 = __importDefault(require("events"));
 class BleDeviceClass extends events_1.default {
     constructor() {
@@ -59,7 +60,7 @@ var BleState;
     BleState["POWERED_OFF"] = "poweredOff";
     BleState["POWERED_ON"] = "poweredOn";
 })(BleState = exports.BleState || (exports.BleState = {}));
-exports.uuid = (s) => {
+const uuid = (s) => {
     if (s) {
         if (s.includes('-')) {
             const parts = s.split('-');
@@ -69,3 +70,4 @@ exports.uuid = (s) => {
         return s;
     }
 };
+exports.uuid = uuid;

package/lib/ble/fm.d.ts

@@ -32,17 +32,27 @@ declare type IndoorBikeData = {
     remainingTime?: number;
     raw?: string;
 };
+declare type IndoorBikeFeatures = {
+    fitnessMachine: number;
+    targetSettings: number;
+};
 export default class BleFitnessMachineDevice extends BleDevice {
     static services: string[];
     static characteristics: string[];
     data: IndoorBikeData;
+    features: IndoorBikeFeatures;
     constructor(props?: any);
+    init(): Promise<boolean>;
     getProfile(): string;
     getServiceUUids(): string[];
+    isBike(): boolean;
+    isPower(): boolean;
+    isHrm(): boolean;
+    parseHrm(_data: Uint8Array): IndoorBikeData;
     parseIndoorBikeData(_data: Uint8Array): IndoorBikeData;
+    getFitnessMachineFeatures(): Promise<IndoorBikeFeatures>;
     onData(characteristic: string, data: Buffer): void;
     write(characteristic: any, data: any): Promise<boolean>;
-    read(characteristic: any): Promise<Buffer>;
     reset(): void;
 }
 export declare class FmAdapter extends DeviceAdapter {