incyclist-devices 2.1.6 → 2.1.8

package/lib/ble/base/adapter.js

@@ -18,6 +18,7 @@ const INTERFACE_NAME = 'ble';
 class BleAdapter extends adpater_1.default {
     constructor(settings, props) {
         super(settings, props);
+        this.onDeviceDataHandler = this.onDeviceData.bind(this);
         if (this.settings.interface !== INTERFACE_NAME)
             throw new Error('Incorrect interface');
         this.deviceData = {};
@@ -139,23 +140,38 @@ class BleAdapter extends adpater_1.default {
     check() {
         return this.start({ scanOnly: true });
     }
-    start(props = {}) {
+    startPreChecks(props) {
         return __awaiter(this, void 0, void 0, function* () {
+            const wasPaused = this.paused;
             const wasStopped = this.stopped;
-            this.resume();
-            if (this.started && !wasStopped)
-                return true;
             this.stopped = false;
+            if (wasPaused)
+                this.resume();
+            if (this.started && !wasPaused && !wasStopped) {
+                return 'done';
+            }
+            if (this.started && wasPaused) {
+                return 'done';
+            }
             const connected = yield this.connect();
             if (!connected)
+                return 'connection-failed';
+            return 'connected';
+        });
+    }
+    start(props = {}) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const preCheckResult = yield this.startPreChecks(props);
+            if (preCheckResult === 'done')
+                return this.started;
+            if (preCheckResult === 'connection-failed')
                 throw new Error(`could not start device, reason:could not connect`);
-            this.logger.logEvent({ message: 'start requested', protocol: this.getProtocolName(), props });
+            this.logEvent({ message: 'starting device', device: this.getName(), props, isStarted: this.started });
             try {
                 const comms = this.device;
                 if (comms) {
-                    comms.on('data', (data) => {
-                        this.onDeviceData(data);
-                    });
+                    comms.on('data', this.onDeviceDataHandler);
                     this.resetData();
                     this.stopped = false;
                     this.started = true;
@@ -165,14 +181,16 @@ class BleAdapter extends adpater_1.default {
             }
             catch (err) {
                 this.logger.logEvent({ message: 'start result: error', error: err.message, protocol: this.getProtocolName() });
+                (_a = this.getComms()) === null || _a === void 0 ? void 0 : _a.pause();
                 throw new Error(`could not start device, reason:${err.message}`);
             }
         });
     }
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'stop requested', protocol: this.getProtocolName() });
+            this.logger.logEvent({ message: 'stopping device', device: this.getName() });
             this.device.reset();
+            this.device.off('data', this.onDeviceDataHandler);
             const stopped = this.device.disconnect();
             if (stopped) {
                 this.stopped = true;

package/lib/ble/bindings/linux.d.ts

@@ -9,6 +9,7 @@ export declare class BleLinuxBinding extends EventEmitter implements BleBinding
     static getInstance(): any;
     startScanning(serviceUUIDs?: string[] | undefined, allowDuplicates?: boolean | undefined, callback?: ((error?: Error | undefined) => void) | undefined): void;
     stopScanning(callback?: (() => void) | undefined): void;
+    setServerDebug(enabled: boolean): void;
     pauseLogging(): void;
     resumeLogging(): void;
     on(eventName: string | symbol, listener: (...args: any[]) => void): this;

package/lib/ble/bindings/linux.js

@@ -23,6 +23,8 @@ class BleLinuxBinding extends events_1.default {
     stopScanning(callback) {
         throw new Error('Method not implemented.');
     }
+    setServerDebug(enabled) {
+    }
     pauseLogging() {
     }
     resumeLogging() {

package/lib/ble/bindings/mock.js

@@ -29,6 +29,8 @@ class Binding extends events_1.default {
         return Binding._instance;
     }
     init() { }
+    setServerDebug(enabled) {
+    }
     pauseLogging() {
     }
     resumeLogging() {

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

@@ -14,6 +14,7 @@ export interface ScanState {
     timeout?: NodeJS.Timeout;
     peripherals?: Map<string, BlePeripheral>;
     detected?: string[];
+    emitter?: EventEmitter;
 }
 export interface ConnectState {
     isConnecting: boolean;
@@ -54,24 +55,25 @@ export default class BleInterface extends EventEmitter implements IncyclistInter
     getBinding(): BleBinding;
     setBinding(binding: BleBinding): void;
     getName(): string;
+    protected getReconnectPause(): number;
     startConnectSensor(): void;
     stopConnectSensor(): void;
     waitForSensorConnectionFinish(): Promise<void>;
     getAdapterFactory(): BleAdapterFactory;
-    pauseLogging(): void;
+    pauseLogging(debugOnly?: boolean): void;
     resumeLogging(): void;
-    isDebugEnabled(): boolean;
-    logEvent(event: any): void;
-    onStateChange(state: BleInterfaceState): void;
-    onError(err: any): void;
+    protected isDebugEnabled(): boolean;
+    protected logEvent(event: any): void;
+    protected onStateChange(state: BleInterfaceState): void;
+    protected onError(err: any): void;
     connect(to?: number): Promise<boolean>;
     disconnect(): Promise<boolean>;
     isConnected(): boolean;
-    waitForConnectFinished(timeout: any): Promise<unknown>;
     onDisconnect(peripheral: any): void;
-    getCharacteristics(peripheral: BlePeripheral): Promise<BleCharacteristic[]>;
-    waitForScanFinished(timeout: any): Promise<unknown>;
-    onPeripheralFound(p: BlePeripheral, callback: any, props?: {
+    protected scannerWaitForConnection(tsTimeoutExpired?: number): Promise<void>;
+    protected getCharacteristics(peripheral: BlePeripheral): Promise<BleCharacteristic[]>;
+    protected waitForScanFinished(timeout: any): Promise<unknown>;
+    protected onPeripheralFound(p: BlePeripheral, callback: any, props?: {
         request?: BleDeviceSettings;
         comms?: BleComms;
         protocolFilter?: BleProtocol[] | null;

package/lib/ble/ble-interface.js

@@ -59,6 +59,9 @@ class BleInterface extends events_1.default {
     getName() {
         return 'ble';
     }
+    getReconnectPause() {
+        return 1000;
+    }
     startConnectSensor() {
         this.sensorIsConnecting = true;
     }
@@ -76,15 +79,19 @@ class BleInterface extends events_1.default {
     getAdapterFactory() {
         return adapter_factory_1.default.getInstance();
     }
-    pauseLogging() {
-        this.logEvent({ message: 'pause logging on BLE Interface' });
-        this.loggingPaused = true;
+    pauseLogging(debugOnly = false) {
+        if (this.loggingPaused)
+            return;
+        this.logEvent({ message: 'pause logging on BLE Interface', debugOnly });
+        this.loggingPaused = debugOnly;
         try {
             this.getBinding().pauseLogging();
         }
         catch (_a) { }
     }
     resumeLogging() {
+        if (!this.loggingPaused)
+            return;
         const event = { message: 'resume logging on BLE Interface' };
         this.logger.logEvent(event);
         if (this.isDebugEnabled()) {
@@ -221,25 +228,23 @@ class BleInterface extends events_1.default {
     isConnected() {
         return this.connectState.isConnected;
     }
-    waitForConnectFinished(timeout) {
-        const waitStart = Date.now();
-        const waitTimeout = waitStart + timeout;
-        return new Promise((resolve, reject) => {
-            const waitIv = setInterval(() => {
-                if (this.scanState.isConnecting && Date.now() > waitTimeout) {
-                    clearInterval(waitIv);
-                    return reject(new Error('Connecting already in progress'));
-                }
-                if (!this.scanState.isConnecting) {
-                    clearInterval(waitIv);
-                    return resolve(true);
-                }
-            }, 100);
-        });
-    }
     onDisconnect(peripheral) {
         this.peripheralCache.remove(peripheral);
     }
+    scannerWaitForConnection(tsTimeoutExpired) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const timeoutExpired = () => {
+                if (!tsTimeoutExpired)
+                    return false;
+                return Date.now() >= tsTimeoutExpired;
+            };
+            while (!this.isConnected() && this.scanState.isScanning && !timeoutExpired()) {
+                const connected = yield this.connect();
+                if (!connected)
+                    yield (0, utils_2.sleep)(this.getReconnectPause());
+            }
+        });
+    }
     getCharacteristics(peripheral) {
         return __awaiter(this, void 0, void 0, function* () {
             let characteristics = undefined;
@@ -369,6 +374,10 @@ class BleInterface extends events_1.default {
             const request = comms.getSettings();
             const { protocol } = request;
             const ble = this.getBinding();
+            try {
+                this.getBinding().setServerDebug(true);
+            }
+            catch (_a) { }
             if (!this.isConnected()) {
                 yield this.connect();
             }
@@ -401,6 +410,10 @@ class BleInterface extends events_1.default {
                     this.logEvent({ message: `${opStr}: stop scanning`, request });
                     ble.stopScanning(() => {
                         this.scanState.isScanning = false;
+                        try {
+                            this.getBinding().setServerDebug(false);
+                        }
+                        catch (_a) { }
                         reject(new Error('device not found'));
                         return;
                     });
@@ -430,6 +443,10 @@ class BleInterface extends events_1.default {
                                 ble.stopScanning(() => {
                                     ble.removeAllListeners('discover');
                                     this.scanState.isScanning = false;
+                                    try {
+                                        this.getBinding().setServerDebug(false);
+                                    }
+                                    catch (_a) { }
                                     resolve(peripheral);
                                 });
                             });
@@ -447,13 +464,17 @@ class BleInterface extends events_1.default {
     }
     scan(props = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { timeout = DEFAULT_SCAN_TIMEOUT, protocol, protocols } = props;
+            this.resumeLogging();
+            this.logEvent({ message: 'starting scan ..' });
+            const { timeout, protocol, protocols } = props;
             const requestedProtocols = protocols || [];
             if (protocol && !requestedProtocols.find(p => p === protocol))
                 requestedProtocols.push(protocol);
             const protocolFilter = requestedProtocols.length > 0 ? requestedProtocols : null;
             const services = protocolFilter === null ? this.getAdapterFactory().getAllSupportedServices() : (0, comms_utils_1.getServicesFromProtocols)(protocolFilter);
             const ble = this.getBinding();
+            if (!ble)
+                throw new Error('no binding defined');
             const opStr = 'scan';
             if (this.scanState.isScanning) {
                 try {
@@ -466,49 +487,49 @@ class BleInterface extends events_1.default {
                 }
             }
             this.scanState.isScanning = true;
+            this.scanState.emitter = new events_1.default();
             const tsStart = Date.now();
-            const tsTimeoutExpired = tsStart + timeout;
-            while (!this.isConnected() && this.scanState.isScanning && Date.now() < tsTimeoutExpired) {
-                const connected = yield this.connect();
-                if (!connected)
-                    yield (0, utils_2.sleep)(1000);
-            }
-            if (Date.now() > tsTimeoutExpired) {
-                return [];
-            }
-            if (!this.scanState.isScanning) {
+            const tsTimeoutExpired = timeout ? tsStart + timeout : undefined;
+            yield this.scannerWaitForConnection(tsTimeoutExpired);
+            if (Date.now() > tsTimeoutExpired || !this.scanState.isScanning) {
                 return [];
             }
-            const adjustedScanTimeout = tsStart - Date.now() + timeout;
+            const adjustedScanTimeout = timeout;
             const supported = adapter_factory_1.default.getInstance().getAll().map(i => i.protocol);
             this.logEvent({ message: 'scan start', services, supported });
             return new Promise((resolve, reject) => {
                 this.scanState.peripherals = new Map();
                 const detected = [];
                 const requested = protocolFilter;
-                const onTimeout = () => {
+                const onTimeoutOrStopped = (wasTimeout = false) => __awaiter(this, void 0, void 0, function* () {
                     if (!this.scanState.isScanning || !this.scanState.timeout)
                         return;
-                    this.scanState.timeout = null;
+                    if (this.scanState.timeout) {
+                        clearTimeout(this.scanState.timeout);
+                        this.scanState.timeout = null;
+                    }
                     const devices = detected.map(d => {
                         const { id, name, address, protocol } = d;
                         return { id, name, address, protocol };
                     });
-                    this.logEvent({ message: `${opStr} result: timeout, devices found`, requested, devices });
+                    if (wasTimeout)
+                        this.logEvent({ message: `${opStr} result: timeout, devices found`, requested, devices });
                     ble.removeAllListeners('discover');
-                    this.logEvent({ message: `${opStr}: stop scanning`, requested });
-                    ble.stopScanning(() => {
-                        this.scanState.isScanning = false;
-                        resolve(detected);
-                    });
+                    yield ble.stopScanning();
+                    resolve(detected);
                     this.emittingAdapters.forEach(a => {
                         a.comms.off('data', a.cb);
                         a.comms.unsubscribeAll();
                     });
                     this.emittingAdapters = [];
-                };
-                this.logEvent({ message: `${opStr}: start scanning`, requested, timeout });
-                this.scanState.timeout = setTimeout(onTimeout, adjustedScanTimeout);
+                    this.emit('scan stopped', true);
+                });
+                if (timeout)
+                    this.scanState.timeout = setTimeout(onTimeoutOrStopped, adjustedScanTimeout);
+                this.scanState.emitter.on('stop', () => {
+                    this.emit('stop-scan');
+                    onTimeoutOrStopped();
+                });
                 ble.startScanning(protocolFilter ? services : [], false, (err) => {
                     if (err) {
                         this.logEvent({ message: `${opStr} result: error`, requested, error: err.message });
@@ -546,24 +567,21 @@ class BleInterface extends events_1.default {
     }
     stopScan() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'scan stop request' });
-            if (!this.scanState.isScanning) {
-                this.logEvent({ message: 'scan stop result: not scanning' });
+            this.logEvent({ message: 'stopping scan ..' });
+            this.pauseLogging(true);
+            if (!this.isScanning()) {
+                this.logEvent({ message: 'stopping scan done ..' });
                 return true;
             }
-            const ble = this.getBinding();
-            if (!ble)
-                throw new Error('no binding defined');
-            ble.removeAllListeners('discover');
-            this.peripheralCache.handleStopScan();
-            ble.stopScanning();
-            this.emittingAdapters.forEach(a => {
-                a.comms.unsubscribeAll();
-                a.comms.off('data', a.cb);
+            yield new Promise(done => {
+                var _a;
+                (_a = this.scanState.emitter) === null || _a === void 0 ? void 0 : _a.emit('stop');
+                this.once('scan stopped', (res) => {
+                    done(res);
+                });
             });
-            this.emittingAdapters = [];
             this.scanState.isScanning = false;
-            this.logEvent({ message: 'scan stop result: success' });
+            this.logEvent({ message: 'stopping scan done ..' });
             return true;
         });
     }

package/lib/ble/cp/comm.js

@@ -18,8 +18,9 @@ class BleCyclingPowerDevice extends comms_1.BleComms {
     static isMatching(characteristics) {
         if (!characteristics)
             return false;
-        const hasCPMeasurement = characteristics.find(c => c === consts_1.CSP_MEASUREMENT) !== undefined;
-        const hasCPFeature = characteristics.find(c => c === consts_1.CSP_FEATURE) !== undefined;
+        const announced = characteristics.map(c => (0, utils_1.uuid)(c));
+        const hasCPMeasurement = announced.find(c => c === consts_1.CSP_MEASUREMENT) !== undefined;
+        const hasCPFeature = announced.find(c => c === consts_1.CSP_FEATURE) !== undefined;
         return hasCPMeasurement && hasCPFeature;
     }
     getProfile() {

package/lib/ble/elite/comms.js

@@ -19,8 +19,9 @@ class BleEliteDevice extends comms_1.BleComms {
     static isMatching(characteristics) {
         if (!characteristics)
             return false;
-        const hasCPMeasurement = characteristics.find(c => c === consts_1.CSP_MEASUREMENT) !== undefined;
-        const hasCPFeature = characteristics.find(c => c === consts_1.CSP_FEATURE) !== undefined;
+        const announced = characteristics.map(c => (0, utils_1.uuid)(c));
+        const hasCPMeasurement = announced.find(c => c === consts_1.CSP_MEASUREMENT) !== undefined;
+        const hasCPFeature = announced.find(c => c === consts_1.CSP_FEATURE) !== undefined;
         return hasCPMeasurement && hasCPFeature;
     }
     getProfile() {

package/lib/ble/fm/comms.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 const consts_1 = require("../consts");
 const comms_1 = require("../base/comms");
+const utils_1 = require("../utils");
 const bit = (nr) => (1 << nr);
 const IndoorBikeDataFlag = {
     MoreData: bit(0),
@@ -82,9 +83,10 @@ class BleFitnessMachineDevice extends comms_1.BleComms {
     static isMatching(characteristics) {
         if (!characteristics)
             return false;
-        const hasStatus = characteristics.find(c => c === consts_1.FTMS_STATUS) !== undefined;
-        const hasCP = characteristics.find(c => c === consts_1.FTMS_CP) !== undefined;
-        const hasIndoorBike = characteristics.find(c => c === consts_1.INDOOR_BIKE_DATA) !== undefined;
+        const announced = characteristics.map(c => (0, utils_1.uuid)(c));
+        const hasStatus = announced.find(c => c === consts_1.FTMS_STATUS) !== undefined;
+        const hasCP = announced.find(c => c === consts_1.FTMS_CP) !== undefined;
+        const hasIndoorBike = announced.find(c => c === consts_1.INDOOR_BIKE_DATA) !== undefined;
         return hasStatus && hasCP && hasIndoorBike;
     }
     subscribeWriteResponse(cuuid) {

package/lib/ble/hr/comm.d.ts

@@ -14,6 +14,7 @@ export default class BleHrmDevice extends BleComms {
     getProfile(): LegacyProfile;
     getProtocol(): BleProtocol;
     getServiceUUids(): string[];
+    static isMatching(characteristics: string[]): boolean;
     parseHrm(_data: Uint8Array): HrmData;
     onData(characteristic: string, data: Buffer): boolean;
 }

package/lib/ble/hr/comm.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const comms_1 = require("../base/comms");
+const consts_1 = require("../consts");
+const utils_1 = require("../utils");
 class BleHrmDevice extends comms_1.BleComms {
     constructor(props) {
         super(props);
@@ -16,6 +18,13 @@ class BleHrmDevice extends comms_1.BleComms {
     getServiceUUids() {
         return BleHrmDevice.services;
     }
+    static isMatching(characteristics) {
+        if (!characteristics)
+            return false;
+        const announced = characteristics.map(c => (0, utils_1.uuid)(c));
+        const hasHRMeasurement = announced.find(c => c === consts_1.HR_MEASUREMENT) !== undefined;
+        return hasHRMeasurement;
+    }
     parseHrm(_data) {
         const data = Buffer.from(_data);
         try {
@@ -51,6 +60,6 @@ class BleHrmDevice extends comms_1.BleComms {
 }
 BleHrmDevice.protocol = 'hr';
 BleHrmDevice.services = ['180d'];
-BleHrmDevice.characteristics = ['2a37', '2a38', '2a39', '2a3c'];
+BleHrmDevice.characteristics = [consts_1.HR_MEASUREMENT, '2a38', '2a39', '2a3c'];
 BleHrmDevice.detectionPriority = 1;
 exports.default = BleHrmDevice;

package/lib/ble/tacx/adapter.d.ts

@@ -2,7 +2,7 @@ import { BleFmAdapter } from '../fm';
 import { BleDeviceSettings, BleStartProperties } from '../types';
 import { DeviceProperties, IAdapter } from '../../types';
 import { LegacyProfile } from '../../antv2/types';
-export default class BleTacxFEAdapter extends BleFmAdapter {
+export default class BleTacxAdapter extends BleFmAdapter {
     protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
     constructor(settings: BleDeviceSettings, props?: DeviceProperties);
     isSame(device: IAdapter): boolean;

package/lib/ble/tacx/adapter.js

@@ -17,7 +17,7 @@ const fm_1 = require("../fm");
 const comms_1 = __importDefault(require("./comms"));
 const consts_1 = require("../../base/consts");
 const types_1 = require("../../types");
-class BleTacxFEAdapter extends fm_1.BleFmAdapter {
+class BleTacxAdapter extends fm_1.BleFmAdapter {
     constructor(settings, props) {
         super(settings, props);
         this.logger = new gd_eventlog_1.EventLogger('BLE-FEC-Tacx');
@@ -31,7 +31,7 @@ class BleTacxFEAdapter extends fm_1.BleFmAdapter {
         ];
     }
     isSame(device) {
-        if (!(device instanceof BleTacxFEAdapter))
+        if (!(device instanceof BleTacxAdapter))
             return false;
         return this.isEqual(device.settings);
     }
@@ -102,5 +102,5 @@ class BleTacxFEAdapter extends fm_1.BleFmAdapter {
         });
     }
 }
-BleTacxFEAdapter.INCYCLIST_PROFILE_NAME = 'Smart Trainer';
-exports.default = BleTacxFEAdapter;
+BleTacxAdapter.INCYCLIST_PROFILE_NAME = 'Smart Trainer';
+exports.default = BleTacxAdapter;

package/lib/ble/tacx/comms.js

@@ -53,8 +53,9 @@ class TacxAdvancedFitnessMachineDevice extends comms_1.default {
     static isMatching(characteristics) {
         if (!characteristics)
             return false;
-        const hasTacxCP = characteristics.find(c => (0, utils_1.matches)(c, consts_1.TACX_FE_C_RX)) !== undefined &&
-            characteristics.find(c => (0, utils_1.matches)(c, consts_1.TACX_FE_C_TX)) !== undefined;
+        const announced = characteristics.map(c => (0, utils_1.uuid)(c));
+        const hasTacxCP = announced.find(c => (0, utils_1.matches)(c, consts_1.TACX_FE_C_RX)) !== undefined &&
+            announced.find(c => (0, utils_1.matches)(c, consts_1.TACX_FE_C_TX)) !== undefined;
         return hasTacxCP;
     }
     setCharacteristicUUIDs(uuids) {