incyclist-devices 1.5.15 → 1.5.17

package/lib/antv2/ant-device.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { Device } from '../protocol';
 import { IChannel, ISensor } from 'incyclist-ant-plus';
 import AntProtocol from './incyclist-protocol';
@@ -28,6 +29,8 @@ export default class AntAdapter extends IncyclistDevice implements Device {
     selected: boolean;
     settings: any;
     onDataFn: OnDeviceDataCallback;
+    protected ivDataTimeout: NodeJS.Timer;
+    protected lastDataTS: number;
     constructor(sensor: ISensor, protocol: AntProtocol, settings?: any);
     isBike(): boolean;
     isPower(): boolean;
@@ -45,6 +48,8 @@ export default class AntAdapter extends IncyclistDevice implements Device {
     setIgnorePower(ignore: any): void;
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;
+    startDataTimeoutCheck(): void;
+    stopDataTimeoutCheck(): void;
     start(props?: any): Promise<any>;
     stop(): Promise<boolean>;
     isStopped(): boolean;

package/lib/antv2/ant-device.js

@@ -17,6 +17,7 @@ const incyclist_protocol_1 = require("./incyclist-protocol");
 const ant_interface_1 = __importDefault(require("./ant-interface"));
 const device_1 = __importDefault(require("../device"));
 exports.DEFAULT_UPDATE_FREQUENCY = 1000;
+const NO_DATA_TIMEOUT = 5000;
 class AntAdapter extends device_1.default {
     constructor(sensor, protocol, settings) {
         super(protocol, settings);
@@ -92,6 +93,24 @@ class AntAdapter extends device_1.default {
             resolve(true);
         });
     }
+    startDataTimeoutCheck() {
+        if (this.ivDataTimeout)
+            return;
+        this.ivDataTimeout = setInterval(() => {
+            console.log('~~~ check', this.lastDataTS);
+            if (!this.lastDataTS)
+                return;
+            if (this.lastDataTS + NO_DATA_TIMEOUT < Date.now()) {
+                this.emit('disconnected', Date.now() - this.lastDataTS);
+            }
+        }, 1000);
+    }
+    stopDataTimeoutCheck() {
+        if (!this.ivDataTimeout)
+            return;
+        clearInterval(this.ivDataTimeout);
+        this.ivDataTimeout = undefined;
+    }
     start(props) {
         return __awaiter(this, void 0, void 0, function* () {
             if (props && props.user)
@@ -104,6 +123,7 @@ class AntAdapter extends device_1.default {
     }
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
+            this.stopDataTimeoutCheck();
             this.stopped = true;
             return true;
         });

package/lib/antv2/fe.js

@@ -112,6 +112,9 @@ class AntFEAdapter extends ant_device_1.default {
         if (!this.started || this.isStopped())
             return;
         this.deviceData = deviceData;
+        this.lastDataTS = Date.now();
+        if (!this.ivDataTimeout)
+            this.startDataTimeoutCheck();
         try {
             const logData = this.getLogData(deviceData, ['PairedDevices', 'RawData']);
             this.logger.logEvent({ message: 'onDeviceData', data: logData });

package/lib/antv2/hr.js

@@ -40,6 +40,9 @@ class AntHrAdapter extends ant_device_1.default {
         if (!this.started)
             return;
         this.deviceData = deviceData;
+        this.lastDataTS = Date.now();
+        if (!this.ivDataTimeout)
+            this.startDataTimeoutCheck();
         try {
             if (this.onDataFn && !this.ignoreHrm && !this.paused) {
                 if (this.lastUpdate === undefined || (Date.now() - this.lastUpdate) > this.updateFrequency) {

package/lib/antv2/pwr.js

@@ -58,7 +58,9 @@ class AntPwrAdapter extends ant_device_1.default {
         if (!this.started)
             return;
         this.deviceData = deviceData;
-        this.deviceData = deviceData;
+        this.lastDataTS = Date.now();
+        if (!this.ivDataTimeout)
+            this.startDataTimeoutCheck();
         try {
             if (this.onDataFn && !(this.ignoreBike && this.ignorePower) && !this.paused) {
                 if (!this.lastUpdate || (Date.now() - this.lastUpdate) > this.updateFrequency) {

package/lib/ble/fm.js

@@ -554,7 +554,7 @@ class FmAdapter extends device_1.default {
         if (this.device)
             this.device.setLogger(this.logger);
     }
-    isBike() { return this.device.isBike(); }
+    isBike() { return this.device.isBike() || this.device.isPower(); }
     isHrm() { return this.device.isHrm(); }
     isPower() { return this.device.isPower(); }
     isSame(device) {
@@ -708,6 +708,7 @@ class FmAdapter extends device_1.default {
                     bleDevice.on('data', (data) => {
                         this.onDeviceData(data);
                     });
+                    bleDevice.on('disconnected', this.emit);
                     return true;
                 }
             }

package/lib/daum/classic/DaumClassicAdapter.d.ts

@@ -15,10 +15,10 @@ export default class DaumClassicAdapter extends DaumAdapter {
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;
     check(): Promise<unknown>;
-    relaunch(props: any): Promise<boolean>;
+    startRide(props: any): Promise<boolean>;
     start(props: any): Promise<boolean>;
     launch(props: any, isRelaunch?: boolean): Promise<boolean>;
-    startRide(props?: {
+    performStart(props?: {
         user?: any;
         bikeSettings?: any;
         gear?: any;

package/lib/daum/classic/DaumClassicAdapter.js

@@ -58,7 +58,6 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
             pause: { get: () => super.pause }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            console.log('~~~~~~~~~~ PAUSE');
             const paused = yield _super.pause.call(this);
             this.bike.pauseLogging();
             return paused;
@@ -100,34 +99,46 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
             }
         }));
     }
-    relaunch(props) {
+    startRide(props) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'relaunch()' });
+            this.logger.logEvent({ message: 'relaunch of device' });
             return yield this.launch(props, true);
         });
     }
     start(props) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'start(-)' });
+            this.logger.logEvent({ message: 'initial start of device' });
             return yield this.launch(props, false);
         });
     }
     launch(props, isRelaunch = false) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (isRelaunch) {
-                yield this.stop();
-            }
-            return this.startRide(props)
-                .then(data => {
+            try {
+                if (isRelaunch) {
+                    yield this.stop();
+                }
+                yield this.performStart(props);
+                if (!isRelaunch) {
+                    try {
+                        const version = yield this.bike.getVersion();
+                        const { serialNo, cockpit } = version || {};
+                        this.logEvent({ message: 'device info', deviceInfo: { serialNo, cockpit } });
+                    }
+                    catch (_a) { }
+                }
                 this.stopped = false;
                 this.paused = false;
                 this.startUpdatePull();
                 return true;
-            });
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'start result: error', error: err.message });
+                throw new Error(`could not start device, reason:${err.message}`);
+            }
         });
     }
-    startRide(props = {}) {
-        this.stopUpdatePull();
+    performStart(props = {}) {
+        this.stop();
         const { user, bikeSettings } = props;
         if (user && user.weight)
             this.userSettings.weight = user.weight;
@@ -182,6 +193,8 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
         }), 5, 1000);
     }
     getCurrentBikeData() {
+        if (this.stopped)
+            return;
         return this.getBike().runData();
     }
 }

package/lib/daum/premium/DaumPremiumAdapter.d.ts

@@ -9,7 +9,7 @@ export default class DaumPremiumDevice extends DaumAdapter {
     check(): Promise<unknown>;
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;
-    relaunch(props: any): Promise<boolean>;
+    startRide(props: any): Promise<boolean>;
     start(props: any): Promise<boolean>;
     launch(props: any, isRelaunch?: boolean): Promise<boolean>;
     getCurrentBikeData(): Promise<any>;

package/lib/daum/premium/DaumPremiumAdapter.js

@@ -82,16 +82,30 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
             return resumed;
         });
     }
-    relaunch(props) {
+    startRide(props) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'relaunch()' });
-            return yield this.launch(props, true);
+            this.logger.logEvent({ message: 'relaunch of device' });
+            try {
+                yield this.launch(props, true);
+                return true;
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'start result: error', error: err.message });
+                throw new Error(`could not start device, reason:${err.message}`);
+            }
         });
     }
     start(props) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'start()' });
-            return yield this.launch(props, false);
+            this.logger.logEvent({ message: 'initial start of device' });
+            try {
+                yield this.launch(props, false);
+                return true;
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'start result: error', error: err.message });
+                throw new Error(`could not start device, reason:${err.message}`);
+            }
         });
     }
     launch(props, isRelaunch = false) {
@@ -138,7 +152,6 @@ class DaumPremiumDevice extends DaumAdapter_1.default {
                     return;
                 }
                 catch (err) {
-                    console.error(err);
                     throw (new Error(`could not start device, reason:${err.message}`));
                 }
             }), 5, 1500)

package/lib/device.d.ts

@@ -1,5 +1,7 @@
+/// <reference types="node" />
 import { DeviceProtocol, Device } from './protocol';
 import CyclingMode from './cycling-mode';
+import EventEmitter from 'events';
 export declare const DEFAULT_BIKE_WEIGHT = 10;
 export declare const DEFAULT_USER_WEIGHT = 75;
 export declare type DeviceData = {
@@ -50,7 +52,7 @@ export interface DeviceAdapter extends Device {
     sendUpdate(request: any): void;
     onData(callback: OnDeviceDataCallback): void;
 }
-export default class IncyclistDevice implements DeviceAdapter {
+export default class IncyclistDevice extends EventEmitter implements DeviceAdapter {
     protocol: DeviceProtocol;
     detected: boolean;
     selected: boolean;

package/lib/device.js

@@ -1,10 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_USER_WEIGHT = exports.DEFAULT_BIKE_WEIGHT = void 0;
+const events_1 = __importDefault(require("events"));
 exports.DEFAULT_BIKE_WEIGHT = 10;
 exports.DEFAULT_USER_WEIGHT = 75;
-class IncyclistDevice {
+class IncyclistDevice extends events_1.default {
     constructor(proto, settings) {
+        super();
         this.protocol = proto;
         this.detected = false;
         this.selected = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "1.5.15",
+  "version": "1.5.17",
   "dependencies": {
     "@serialport/parser-byte-length": "^9.0.1",
     "@serialport/parser-delimiter": "^9.0.1",