incyclist-devices 2.2.7 → 2.2.9

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

@@ -4,6 +4,7 @@ import IncyclistDevice from '../../base/adpater';
 import { AntDeviceProperties, AntDeviceSettings, LegacyProfile, BaseDeviceData, AdapterStartStatus } from '../types';
 import { IAdapter, IncyclistAdapterData, IncyclistBikeData, IncyclistCapability } from '../../types';
 import EventEmitter from 'events';
+import ICyclingMode from '../../modes/types';
 export default class AntAdapter<TDeviceData extends BaseDeviceData> extends IncyclistDevice<AntDeviceProperties> {
     sensor: ISensor;
     data: IncyclistAdapterData;
@@ -42,6 +43,7 @@ export default class AntAdapter<TDeviceData extends BaseDeviceData> extends Incy
     mapData(deviceData: TDeviceData): IncyclistBikeData;
     transformData(data: IncyclistBikeData, deviceData: TDeviceData): void;
     mapToAdapterData(deviceData: any): void;
+    refreshDeviceData(): void;
     onDeviceData(deviceData: TDeviceData): void;
     isWaitingForData(): boolean;
     _wait(): Promise<boolean>;
@@ -68,4 +70,5 @@ export default class AntAdapter<TDeviceData extends BaseDeviceData> extends Incy
     stop(): Promise<boolean>;
     startSensor(): Promise<boolean>;
     stopSensor(): Promise<void>;
+    setCyclingMode(mode: string | ICyclingMode, settings?: any, sendInitCommands?: boolean): void;
 }

package/lib/antv2/base/adapter.js

@@ -119,6 +119,21 @@ class AntAdapter extends adpater_1.default {
     mapToAdapterData(deviceData) {
         throw new Error('message not implemented');
     }
+    refreshDeviceData() {
+        if (this.isStopped() || this.isPaused())
+            return;
+        const logData = this.getLogData(this.deviceData, ['PairedDevices', 'RawData', '_RawData']);
+        this.logEvent({ message: 'refreshDeviceData', data: logData, paused: this.paused, started: this.started, canEmit: this.canEmitData() });
+        if (this.isControllable()) {
+            let incyclistData = this.mapData(this.deviceData);
+            incyclistData = this.getCyclingMode().updateData(incyclistData);
+            this.transformData(incyclistData, this.deviceData);
+        }
+        else {
+            this.mapToAdapterData(this.deviceData);
+        }
+        this.emitData(this.data);
+    }
     onDeviceData(deviceData) {
         this.dataMsgCount++;
         this.lastDataTS = Date.now();
@@ -423,8 +438,10 @@ class AntAdapter extends adpater_1.default {
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
             let stopped;
-            this.logger.logEvent({ message: 'stopping device', device: this.getName() });
             this.internalEmitter.emit('stop');
+            if (this.stopped)
+                return;
+            this.logger.logEvent({ message: 'stopping device', device: this.getName() });
             this.promiseWaitForData = null;
             if (this.startStatus) {
                 this.startStatus.interrupted = true;
@@ -461,5 +478,9 @@ class AntAdapter extends adpater_1.default {
             catch (_a) { }
         });
     }
+    setCyclingMode(mode, settings, sendInitCommands) {
+        super.setCyclingMode(mode, settings, sendInitCommands);
+        this.refreshDeviceData();
+    }
 }
 exports.default = AntAdapter;

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

@@ -45,6 +45,8 @@ export default class AntInterface extends EventEmitter implements IncyclistInter
     scannerWaitForConnection(): Promise<void>;
     scan(props?: AntScanProps): Promise<AntDeviceSettings[]>;
     isScanning(): boolean;
+    protected stopAllSensors(sensors: Array<ISensor>): Promise<void>;
+    protected stopDevices(detected: AntDeviceSettings[]): Promise<void>;
     stopScan(): Promise<boolean>;
     startSensor(sensor: ISensor, onDeviceData: (data: any) => void): Promise<boolean>;
     private blockChannel;

package/lib/antv2/base/interface.js

@@ -16,6 +16,7 @@ const events_1 = __importDefault(require("events"));
 const gd_eventlog_1 = require("gd-eventlog");
 const sensor_factory_1 = __importDefault(require("../factories/sensor-factory"));
 const utils_1 = require("../../utils/utils");
+const incyclist_devices_1 = require("incyclist-devices");
 class AntInterface extends events_1.default {
     static getInstance(props = {}) {
         if (AntInterface._instance === undefined)
@@ -237,6 +238,8 @@ class AntInterface extends events_1.default {
                 this.activeScan.emitter.on('stop', () => __awaiter(this, void 0, void 0, function* () {
                     this.activeScan.emitter.removeAllListeners();
                     this.emit('stop-scan');
+                    yield this.stopDevices(detected);
+                    yield this.stopAllSensors(sensors);
                     const stopped = yield this.activeScan.channel.stopScanner();
                     this.logEvent({ message: 'scan stopped' });
                     removeListeners(channel);
@@ -276,6 +279,38 @@ class AntInterface extends events_1.default {
     isScanning() {
         return this.scanPromise !== undefined && this.scanPromise !== null;
     }
+    stopAllSensors(sensors) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'stopping all sensors ' });
+            let promises = [];
+            sensors.forEach((sensor) => {
+                promises.push(this.stopSensor(sensor).catch(err => {
+                    var _a;
+                    this.logger.logEvent({ message: 'could not stop sensor', error: err.message, channel: (_a = sensor.getChannel()) === null || _a === void 0 ? void 0 : _a.getChannelNo(), stack: err.stack });
+                }));
+            });
+            if (promises.length > 0) {
+                yield Promise.allSettled(promises);
+            }
+            this.logger.logEvent({ message: 'sensors stopped' });
+        });
+    }
+    stopDevices(detected) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'stopping devices' });
+            let promises = [];
+            detected.forEach((settings) => {
+                const adapter = incyclist_devices_1.AdapterFactory.create(settings);
+                promises.push(adapter.stop().catch(err => {
+                    this.logger.logEvent({ message: 'could not stop device', error: err.message, deviceID: settings.deviceID, stack: err.stack });
+                }));
+            });
+            if (promises.length > 0) {
+                yield Promise.allSettled(promises);
+            }
+            this.logger.logEvent({ message: 'devices stopped' });
+        });
+    }
     stopScan() {
         return __awaiter(this, void 0, void 0, function* () {
             this.logEvent({ message: 'stopping scan ..' });
@@ -348,7 +383,7 @@ class AntInterface extends events_1.default {
                 return true;
             }
             const channel = sensor.getChannel();
-            if (channel) {
+            if (channel !== undefined) {
                 try {
                     if (!channel.flush) {
                         this.logEvent({ message: 'old version of ant-channel detected' });
@@ -371,8 +406,7 @@ class AntInterface extends events_1.default {
                 }
             }
             else {
-                this.logEvent({ message: 'could not stop sensor', deviceID: sensor.getDeviceID(), error: 'no channel attached' });
-                return false;
+                return true;
             }
         });
     }

package/lib/antv2/fe/adapter.js

@@ -43,7 +43,14 @@ class AntFEAdapter extends adapter_1.default {
             if (this.promiseStop)
                 return;
             if (this.promiseSendUpdate) {
-                this.logEvent({ message: 'send bike update skipped', device: this.getName(), request, reason: 'busy' });
+                let stack;
+                try {
+                    throw new Error();
+                }
+                catch (err) {
+                    stack = err.stack;
+                }
+                this.logEvent({ message: 'send bike update skipped', device: this.getName(), request, reason: 'busy', stack });
                 return;
             }
             let isReset = request.reset && Object.keys(request).length === 1;

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

@@ -5,6 +5,7 @@ import { BleDeviceProperties, BleDeviceSettings, BleStartProperties } from "../t
 import { IAdapter, IncyclistBikeData, IncyclistAdapterData, DeviceProperties } from "../../types";
 import { BleDeviceData } from "./types";
 import { LegacyProfile } from "../../antv2/types";
+import ICyclingMode from "../../modes/types";
 export default class BleAdapter<TDeviceData extends BleDeviceData, TDevice extends BleComms> extends IncyclistDevice<BleDeviceProperties> {
     protected ble: BleInterface;
     protected deviceData: TDeviceData;
@@ -27,6 +28,7 @@ export default class BleAdapter<TDeviceData extends BleDeviceData, TDevice exten
     getProtocolName(): string;
     getID(): string;
     getName(): string;
+    refreshDeviceData(): void;
     onDeviceData(deviceData: TDeviceData): void;
     mapData(deviceData: TDeviceData): IncyclistAdapterData | IncyclistBikeData;
     transformData(data: IncyclistBikeData): IncyclistAdapterData;
@@ -39,4 +41,5 @@ export default class BleAdapter<TDeviceData extends BleDeviceData, TDevice exten
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;
     update(): void;
+    setCyclingMode(mode: string | ICyclingMode, settings?: any, sendInitCommands?: boolean): void;
 }

package/lib/ble/base/adapter.js

@@ -108,6 +108,25 @@ class BleAdapter extends adpater_1.default {
         const settings = this.settings;
         return settings.name || settings.id || settings.address;
     }
+    refreshDeviceData() {
+        if (this.isStopped() || this.isPaused())
+            return;
+        try {
+            this.logEvent({ message: 'refreshDeviceData', data: this.deviceData, isControllable: this.isControllable() });
+            if (this.isControllable()) {
+                const mappedData = this.mapData(this.deviceData);
+                const incyclistData = this.getCyclingMode().updateData(mappedData);
+                this.data = this.transformData(incyclistData);
+            }
+            else {
+                this.data = this.mapData(this.deviceData);
+            }
+            this.emitData(this.data);
+        }
+        catch (err) {
+            this.logEvent({ message: 'error', fn: 'refreshDeviceData', error: err.message, stack: err.stack });
+        }
+    }
     onDeviceData(deviceData) {
         try {
             this.dataMsgCount++;
@@ -231,5 +250,9 @@ class BleAdapter extends adpater_1.default {
     }
     update() {
     }
+    setCyclingMode(mode, settings, sendInitCommands) {
+        super.setCyclingMode(mode, settings, sendInitCommands);
+        this.refreshDeviceData();
+    }
 }
 exports.default = BleAdapter;

package/package.json

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