incyclist-devices 2.1.3 → 2.1.5

package/lib/antv2/base/adapter.js

@@ -48,6 +48,9 @@ class AntAdapter extends adpater_1.default {
         this.updateFrequency = consts_1.DEFAULT_UPDATE_FREQUENCY;
         this.channel = undefined;
         this.ant = interface_1.default.getInstance();
+        if (this.isDebugEnabled()) {
+            this.ant.setLogger(this);
+        }
     }
     getProfileName() {
         const C = this.constructor;
@@ -116,12 +119,10 @@ class AntAdapter extends adpater_1.default {
             if (!ManId && deviceData.ManId) {
                 this.emit('device-info', this.getSettings(), { manufacturer: (0, utils_2.getBrand)(deviceData.ManId) });
             }
-            if (!this.started || this.isStopped())
-                return;
-            if (!this.canEmitData())
-                return;
             const logData = this.getLogData(deviceData, ['PairedDevices', 'RawData']);
             this.logEvent({ message: 'onDeviceData', data: logData, paused: this.paused });
+            if (!this.started || this.isStopped() || !this.canEmitData())
+                return;
             if (this.isControllable()) {
                 let incyclistData = this.mapData(deviceData);
                 incyclistData = this.getCyclingMode().updateData(incyclistData);
@@ -148,6 +149,7 @@ class AntAdapter extends adpater_1.default {
                         resolve(true);
                     }
                     if (!this.promiseWaitForData) {
+                        resolve(false);
                         clearInterval(iv);
                     }
                 }, 10);
@@ -172,9 +174,9 @@ class AntAdapter extends adpater_1.default {
             }
             try {
                 this.promiseWaitForData = (0, utils_1.runWithTimeout)(this._wait(), timeout);
-                yield this.promiseWaitForData;
+                const hasData = yield this.promiseWaitForData;
                 this.promiseWaitForData = null;
-                return true;
+                return hasData;
             }
             catch (err) {
                 this.promiseWaitForData = null;
@@ -293,8 +295,10 @@ class AntAdapter extends adpater_1.default {
         else {
             this.started = false;
             const { sensorStarted, hasData, interrupted } = this.startStatus;
-            if (interrupted)
-                return;
+            if (interrupted) {
+                this.logEvent({ message: 'start device interrupted', device: this.getName() });
+                return false;
+            }
             if (!sensorStarted) {
                 this.logEvent({ message: 'start device failed', device: this.getName(), reason: 'could not connect' });
                 throw new Error('could not start device, reason:could not connect');
@@ -362,7 +366,7 @@ class AntAdapter extends adpater_1.default {
                         yield this.checkCapabilities();
                         if (this.hasCapability(types_2.IncyclistCapability.Control))
                             yield this.initControl();
-                        if (!this.startStatus.hasData) {
+                        if (!this.startStatus.hasData && !this.startStatus.interrupted) {
                             yield this.stopSensor();
                             yield (0, utils_1.sleep)(retryDelay);
                             continue;
@@ -388,7 +392,7 @@ class AntAdapter extends adpater_1.default {
                 }
                 throw err;
             }
-            return true;
+            return this.started;
         });
     }
     stop() {
@@ -396,8 +400,11 @@ class AntAdapter extends adpater_1.default {
             let stopped;
             this.logger.logEvent({ message: 'stopping device', device: this.getName() });
             this.promiseWaitForData = null;
-            if (this.startStatus)
+            if (this.startStatus) {
                 this.startStatus.interrupted = true;
+                console.log('~~~ still starting');
+                yield (0, utils_1.sleep)(20);
+            }
             try {
                 stopped = yield this.ant.stopSensor(this.sensor);
             }

package/lib/antv2/fe/adapter.d.ts

@@ -5,6 +5,7 @@ import { AntDeviceProperties, AntDeviceSettings, LegacyProfile } from "../types"
 import { IncyclistBikeData, ControllerConfig } from "../../types";
 interface AntFEStartDeviceProperties extends AntDeviceProperties {
     reconnect?: boolean;
+    restart?: boolean;
     reconnectTimeout?: number;
 }
 export default class AntFEAdapter extends AntAdapter<FitnessEquipmentSensorState> {

package/lib/antv2/fe/adapter.js

@@ -123,12 +123,18 @@ class AntFEAdapter extends adapter_1.default {
     resetStartStatus() {
         const props = this.startProps;
         const isReconnect = props.reconnect || false;
+        const isRestart = props.restart || false;
         super.resetStartStatus();
         if (isReconnect) {
             delete props.reconnect;
             this.startStatus.userInitialized = true;
             this.startStatus.controlInitialized = true;
         }
+        if (isRestart) {
+            delete props.restart;
+            this.startStatus.sensorStarted = true;
+            this.startStatus.hasData = true;
+        }
     }
     startPreChecks(props) {
         const _super = Object.create(null, {
@@ -137,6 +143,11 @@ class AntFEAdapter extends adapter_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             this.startProps = props;
             this.setFEDefaultTimeout();
+            if (this.started && this.paused) {
+                this.resume();
+                props.restart = true;
+                return 'connected';
+            }
             return yield _super.startPreChecks.call(this, props);
         });
     }

package/lib/base/adpater.d.ts

@@ -20,6 +20,7 @@ export default class IncyclistDevice<P extends DeviceProperties> extends EventEm
     protected data: IncyclistAdapterData;
     constructor(settings: DeviceSettings, props?: P);
     getLogger(): EventLogger;
+    isDebugEnabled(): boolean;
     logEvent(event: any): void;
     getName(): string;
     getID(): string;

package/lib/base/adpater.js

@@ -30,12 +30,18 @@ class IncyclistDevice extends events_1.default {
         this.cyclingMode = this.getDefaultCyclingMode();
     }
     getLogger() { return this.logger; }
+    isDebugEnabled() {
+        const w = global.window;
+        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG || process.env.ANT_DEBUG) {
+            return true;
+        }
+        return false;
+    }
     logEvent(event) {
         if (!this.logger || this.paused)
             return;
         this.logger.logEvent(event);
-        const w = global.window;
-        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG || process.env.ANT_DEBUG) {
+        if (this.isDebugEnabled()) {
             const logText = `~~~ ${this.getInterface()}: ${this.logger.getName()}`;
             console.log(logText, event);
         }
@@ -63,14 +69,16 @@ class IncyclistDevice extends events_1.default {
     stop() { throw new Error("Method not implemented."); }
     pause() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'pausing device', device: this.getName() });
+            if (this.isStarted() && !this.isStopped())
+                this.logEvent({ message: 'pausing device', device: this.getName() });
             this.paused = true;
             return true;
         });
     }
     resume() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'resuming device', device: this.getName() });
+            if (this.isStarted() && !this.isStopped())
+                this.logger.logEvent({ message: 'resuming device', device: this.getName() });
             this.paused = false;
             return true;
         });

package/lib/ble/base/adapter.js

@@ -141,10 +141,8 @@ class BleAdapter extends adpater_1.default {
     }
     start(props = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const wasPaused = this.paused;
             const wasStopped = this.stopped;
-            if (wasPaused)
-                this.resume();
+            this.resume();
             if (this.started && !wasStopped)
                 return true;
             this.stopped = false;

package/lib/ble/base/comms.js

@@ -61,10 +61,12 @@ class BleComms extends events_1.default {
         return this.connectState.isConnected;
     }
     pause() {
+        this.ble.pauseLogging();
         this.paused = true;
     }
     resume() {
         this.paused = false;
+        this.ble.resumeLogging();
     }
     getServiceUUids() {
         throw new Error("Method not implemented.");
@@ -282,6 +284,7 @@ class BleComms extends events_1.default {
     }
     connect(props) {
         return __awaiter(this, void 0, void 0, function* () {
+            this.ble.resumeLogging();
             if (!this.ble.isConnected()) {
                 try {
                     yield this.ble.connect();
@@ -382,6 +385,7 @@ class BleComms extends events_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             const { id, name, address } = this;
             this.logEvent({ message: 'disconnect requested', device: { id, name, address } });
+            this.ble.pauseLogging();
             this.connectState.isDisconnecting = true;
             if (this.workerIv) {
                 this.stopWorker();

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

@@ -9,6 +9,8 @@ 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;
+    pauseLogging(): void;
+    resumeLogging(): void;
     on(eventName: string | symbol, listener: (...args: any[]) => void): this;
 }
 declare const Binding: any;

package/lib/ble/bindings/linux.js

@@ -23,6 +23,10 @@ class BleLinuxBinding extends events_1.default {
     stopScanning(callback) {
         throw new Error('Method not implemented.');
     }
+    pauseLogging() {
+    }
+    resumeLogging() {
+    }
     on(eventName, listener) {
         super.addListener(eventName, listener);
         if (eventName === 'stateChange') {

package/lib/ble/bindings/mock.js

@@ -29,6 +29,10 @@ class Binding extends events_1.default {
         return Binding._instance;
     }
     init() { }
+    pauseLogging() {
+    }
+    resumeLogging() {
+    }
     addMock(peripheral) {
         this.peripherals.push(peripheral);
     }

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

@@ -43,6 +43,7 @@ export default class BleInterface extends EventEmitter implements IncyclistInter
         comms: BleComms;
         cb: (data: any) => void;
     }[];
+    loggingPaused: boolean;
     static _instance: BleInterface;
     static getInstance(props?: {
         binding?: BleBinding;
@@ -57,6 +58,9 @@ export default class BleInterface extends EventEmitter implements IncyclistInter
     stopConnectSensor(): void;
     waitForSensorConnectionFinish(): Promise<void>;
     getAdapterFactory(): BleAdapterFactory;
+    pauseLogging(): void;
+    resumeLogging(): void;
+    isDebugEnabled(): boolean;
     logEvent(event: any): void;
     onStateChange(state: BleInterfaceState): void;
     onError(err: any): void;

package/lib/ble/ble-interface.js

@@ -51,6 +51,7 @@ class BleInterface extends events_1.default {
             this.logger = props.logger;
         else
             this.logger = new gd_eventlog_1.EventLogger('BLE');
+        this.loggingPaused = false;
     }
     getBinding() { return this.binding; }
     setBinding(binding) { if (binding)
@@ -75,12 +76,38 @@ class BleInterface extends events_1.default {
     getAdapterFactory() {
         return adapter_factory_1.default.getInstance();
     }
-    logEvent(event) {
-        if (this.logger) {
-            this.logger.logEvent(event);
+    pauseLogging() {
+        this.logEvent({ message: 'pause logging on BLE Interface' });
+        this.loggingPaused = true;
+        try {
+            this.getBinding().pauseLogging();
         }
+        catch (_a) { }
+    }
+    resumeLogging() {
+        const event = { message: 'resume logging on BLE Interface' };
+        this.logger.logEvent(event);
+        if (this.isDebugEnabled()) {
+            console.log('~~~ BLE', event);
+        }
+        this.loggingPaused = false;
+        try {
+            this.getBinding().resumeLogging();
+        }
+        catch (_a) { }
+    }
+    isDebugEnabled() {
         const w = global.window;
         if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG) {
+            return true;
+        }
+        return false;
+    }
+    logEvent(event) {
+        if (this.logger && !this.loggingPaused) {
+            this.logger.logEvent(event);
+        }
+        if (this.isDebugEnabled()) {
             console.log('~~~ BLE', event);
         }
     }
@@ -98,6 +125,7 @@ class BleInterface extends events_1.default {
         this.logEvent({ message: 'error', error: err.message, stack: err.stack });
     }
     connect(to) {
+        this.resumeLogging();
         const timeout = this.props.timeout || to || 2000;
         return new Promise((resolve, reject) => {
             if (this.connectState.isConnected) {
@@ -186,6 +214,7 @@ class BleInterface extends events_1.default {
                 this.connectState.timeout = null;
             }
             this.logEvent({ message: 'disconnect result: success' });
+            this.pauseLogging();
             return true;
         });
     }

package/lib/ble/types.d.ts

@@ -8,6 +8,8 @@ export type BleInterfaceState = 'unknown' | 'resetting' | 'unsupported' | 'unaut
 export interface BleBinding extends EventEmitter {
     startScanning(serviceUUIDs?: string[], allowDuplicates?: boolean, callback?: (error?: Error) => void): void;
     stopScanning(callback?: () => void): void;
+    pauseLogging(): any;
+    resumeLogging(): any;
     _bindings: any;
     state: BleInterfaceState;
     on(eventName: string | symbol, listener: (...args: any[]) => void): this;

package/lib/simulator/Simulator.js

@@ -36,7 +36,7 @@ class Simulator extends adpater_1.default {
         this.setCyclingMode(name, modeSettings);
         this.capabilities = [
             types_1.IncyclistCapability.Power, types_1.IncyclistCapability.Speed, types_1.IncyclistCapability.Cadence, types_1.IncyclistCapability.Gear,
-            types_1.IncyclistCapability.Control
+            types_1.IncyclistCapability.Control, types_1.IncyclistCapability.HeartRate
         ];
     }
     isEqual(settings) {
@@ -53,12 +53,13 @@ class Simulator extends adpater_1.default {
     start(props) {
         return __awaiter(this, void 0, void 0, function* () {
             this.startProps = props;
+            this.stopped = false;
             this.paused = false;
             if (props)
                 this.setBikeProps(props);
             return new Promise((resolve) => {
                 if (!this.isBot)
-                    this.logger.logEvent({ message: 'start', iv: this.iv });
+                    this.logEvent({ message: 'starting device', device: this.getName(), props });
                 if (this.started) {
                     return resolve(true);
                 }
@@ -94,32 +95,31 @@ class Simulator extends adpater_1.default {
         });
     }
     pause() {
-        return new Promise((resolve, reject) => {
-            if (!this.started)
-                return reject(new Error('illegal state - pause() has been called before start()'));
-            if (!this.isBot)
-                this.logger.logEvent({ message: 'pause', iv: this.iv });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isBot && this.isStarted())
+                this.logEvent({ message: 'pausing device', device: this.getName() });
             this.paused = true;
-            resolve(true);
+            return true;
         });
     }
     resume() {
-        return new Promise((resolve, reject) => {
-            if (!this.started)
-                reject(new Error('illegal state - resume() has been called before start()'));
-            if (!this.isBot)
-                this.logger.logEvent({ message: 'resume', iv: this.iv });
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isBot && this.isStarted())
+                this.logger.logEvent({ message: 'resuming device', device: this.getName() });
             this.paused = false;
-            resolve(true);
+            return true;
         });
     }
     toggle() {
-        if (this.started) {
-            return this.stop();
-        }
-        else {
-            return this.start().then(() => { return true; });
-        }
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.started) {
+                return yield this.stop();
+            }
+            else {
+                yield this.start();
+                return true;
+            }
+        });
     }
     faster() {
         if (this.speed < 15)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "2.1.3",
+  "version": "2.1.5",
   "dependencies": {
     "@serialport/bindings-interface": "^1.2.2",
     "@serialport/parser-byte-length": "^9.0.1",