incyclist-devices 2.1.32 → 2.1.33

package/lib/serial/daum/DaumAdapter.d.ts

@@ -24,6 +24,7 @@ export default class DaumAdapter<S extends SerialDeviceSettings, P extends Devic
     updateBusy: boolean;
     startPromise: Promise<boolean>;
     checkPromise: Promise<boolean>;
+    internalEmitter: EventEmitter;
     constructor(settings: S, props?: P);
     getPort(): string;
     getSerialInterface(): SerialInterface;

package/lib/serial/daum/DaumAdapter.js

@@ -26,6 +26,7 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
         this.adapterTime = 0;
         this.requestBusy = false;
         this.updateBusy = false;
+        this.internalEmitter = new events_1.default();
         this.iv = undefined;
         this.deviceData = {
             isPedalling: false,
@@ -216,7 +217,9 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
                     this.started = true;
                     return true;
                 }));
+                this.internalEmitter.emit('start');
                 const started = yield this.startPromise;
+                this.internalEmitter.emit('started', started);
                 this.startPromise = undefined;
                 return started;
             }
@@ -340,8 +343,11 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
     }
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.stopped)
+            console.log('~~~ STOP', this.stopped);
+            if (this.stopped) {
                 return true;
+            }
+            this.internalEmitter.emit('stop');
             this.logEvent({ message: 'stop request', port: this.getPort() });
             if (this.paused)
                 this.resume();
@@ -355,6 +361,7 @@ class DaumAdapter extends adapter_1.SerialIncyclistDevice {
                 this.logEvent({ message: 'stop request failed', port: this.getPort(), reason: err.message });
                 throw (err);
             }
+            this.internalEmitter.emit('stopped', this.stopped);
             return this.stopped;
         });
     }

package/lib/serial/daum/classic/adapter.js

@@ -99,9 +99,14 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
         const user = this.getUser();
         const { gear = consts_1.DEFAULT_GEAR } = props;
         this.initData();
+        let stopped = false;
         let startState = {};
-        return (0, utils_1.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
+        const start = () => __awaiter(this, void 0, void 0, function* () {
             try {
+                if (stopped) {
+                    this.started = false;
+                    return false;
+                }
                 this.logEvent({ message: 'start attempt', isRelaunch, isConnected: this.getComms().isConnected() });
                 if (!isRelaunch && !this.getComms().isConnected()) {
                     yield this.verifyConnection();
@@ -136,13 +141,15 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
                 startState.checkRunData = true;
                 const data = yield this.getComms().runData();
                 if (startRequest.targetPower && startRequest.targetPower !== 25 && data.power === 25) {
-                    throw new Error('invalid device response: runData');
+                    throw (new Error('invalid device response: runData'));
                 }
                 this.started = true;
                 this.startUpdatePull();
-                return true;
+                return (true);
             }
             catch (err) {
+                if (stopped)
+                    return false;
                 this.logEvent({ message: 'start attempt failed', error: err.message });
                 this.started = false;
                 if (startState.checkRunData) {
@@ -150,7 +157,15 @@ class DaumClassicAdapter extends DaumAdapter_1.default {
                 }
                 throw (new Error(`could not start device, reason:${err.message}`));
             }
-        }), 5, 1000);
+        });
+        const checkInterrupt = () => new Promise(done => {
+            this.internalEmitter.on('stop', () => {
+                stopped = true;
+                this.started = false;
+                done(false);
+            });
+        });
+        return (0, utils_1.runWithRetries)(() => Promise.race([start(), checkInterrupt()]), 5, 1000);
     }
     getCurrentBikeData() {
         return __awaiter(this, void 0, void 0, function* () {

package/lib/serial/daum/premium/adapter.d.ts

@@ -21,7 +21,7 @@ export default class DaumPremiumAdapter extends DaumAdapter<SerialDeviceSettings
     getStartRetries(): number;
     getStartRetryTimeout(): number;
     restart(pause?: number): Promise<boolean>;
-    performStart(props?: DaumPremiumDeviceProperties, _isRelaunch?: boolean, wasPaused?: boolean): Promise<boolean>;
+    performStart(props?: DaumPremiumDeviceProperties, _isRelaunch?: boolean, wasPaused?: boolean): Promise<any>;
     requiresProgramUpload(): boolean;
     getCurrentBikeData(): Promise<IncyclistBikeData>;
     getDeviceInfo(): Promise<any>;

package/lib/serial/daum/premium/adapter.js

@@ -139,8 +139,12 @@ class DaumPremiumAdapter extends DaumAdapter_1.default {
             if (!wasPaused)
                 yield this.stop();
             var info = {};
-            yield (0, utils_1.runWithRetries)(() => __awaiter(this, void 0, void 0, function* () {
+            let stopped = false;
+            this.stopped = false;
+            const start = () => __awaiter(this, void 0, void 0, function* () {
                 try {
+                    if (stopped)
+                        return false;
                     if (wasPaused) {
                         info.deviceType = 'Resumed';
                         info.version = "Resumed";
@@ -177,21 +181,33 @@ class DaumPremiumAdapter extends DaumAdapter_1.default {
                     if (!this.getCyclingMode().getModeProperty('eppSupport')) {
                         info.gear = yield this.getComms().setGear(this.deviceData.gear || gear || DEFAULT_GEAR);
                     }
-                    return;
+                    return true;
                 }
                 catch (err) {
+                    if (stopped)
+                        return false;
                     if (info.connected && !info.deviceType) {
                         yield (0, utils_1.sleep)(500);
                         yield this.reconnect();
                     }
                     throw (err);
                 }
-            }), this.getStartRetries(), this.getStartRetryTimeout());
-            this.stopped = false;
-            this.paused = false;
-            this.started = true;
-            this.startUpdatePull();
-            return true;
+            });
+            const checkInterrupt = () => new Promise(done => {
+                this.internalEmitter.on('stop', () => {
+                    stopped = true;
+                    this.started = false;
+                    done(false);
+                });
+            });
+            const started = yield (0, utils_1.runWithRetries)(() => Promise.race([start(), checkInterrupt()]), this.getStartRetries(), this.getStartRetryTimeout());
+            if (started) {
+                this.stopped = false;
+                this.paused = false;
+                this.started = true;
+                this.startUpdatePull();
+            }
+            return started;
         });
     }
     requiresProgramUpload() {

package/package.json

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

package/lib/adapters.d.ts

@@ -1,7 +0,0 @@
-import { IncyclistDeviceAdapter } from "./base/adpater";
-import { DeviceProperties, DeviceSettings } from "./types/device";
-export default class AdapterFactory {
-    static adapters: IncyclistDeviceAdapter[];
-    static reset(): void;
-    static create(settings: DeviceSettings, props?: DeviceProperties): any;
-}

package/lib/adapters.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const antv2_1 = require("./antv2");
-const ble_1 = require("./ble");
-const serial_1 = require("./serial");
-const Simulator_1 = require("./simulator/Simulator");
-const device_1 = require("./types/device");
-class AdapterFactory {
-    static reset() {
-        AdapterFactory.adapters = [];
-        ble_1.BleAdapterFactory.getInstance().instances = [];
-    }
-    static create(settings, props) {
-        const adapters = AdapterFactory.adapters;
-        if (!settings.interface && settings.protocol === 'Simulator') {
-            const adapter = new Simulator_1.Simulator(settings);
-            if (adapter) {
-                adapters.push(adapter);
-            }
-            return adapter;
-        }
-        const existing = adapters.find(a => a.isEqual(settings));
-        if (existing)
-            return existing;
-        const ifaceName = typeof settings.interface === 'string' ? settings.interface : settings.interface.getName();
-        let adapter;
-        switch (ifaceName) {
-            case device_1.INTERFACE.SERIAL:
-            case device_1.INTERFACE.TCPIP:
-                adapter = serial_1.SerialAdapterFactory.getInstance().createInstance(settings, props);
-                break;
-            case device_1.INTERFACE.ANT:
-                adapter = antv2_1.AntAdapterFactory.getInstance().createInstance(settings, props);
-                break;
-            case device_1.INTERFACE.BLE:
-                adapter = ble_1.BleAdapterFactory.getInstance().createInstance(settings, props);
-                break;
-            case device_1.INTERFACE.SIMULATOR:
-                adapter = new Simulator_1.Simulator(settings, props);
-                break;
-        }
-        if (adapter) {
-            adapters.push(adapter);
-        }
-        return adapter;
-    }
-}
-AdapterFactory.adapters = [];
-exports.default = AdapterFactory;

package/lib/antv2/adapter-factory.d.ts

@@ -1,14 +0,0 @@
-import { Profile } from "incyclist-ant-plus";
-import AntAdapter from "./base/adapter";
-import { AntDeviceProperties, AntDeviceSettings, LegacyProfile, BaseDeviceData } from "./types";
-import { AntAdapterInfo, AdapterQuery } from "./types";
-export default class AntAdapterFactory {
-    static _instance: AntAdapterFactory;
-    adapters: AntAdapterInfo[];
-    static getInstance(): AntAdapterFactory;
-    constructor();
-    register<TDeviceData extends BaseDeviceData>(antProfile: Profile, incyclistProfile: LegacyProfile, Adapter: typeof AntAdapter<TDeviceData>): void;
-    getAdapter(query?: AdapterQuery): any;
-    createInstance(settings: AntDeviceSettings, props?: AntDeviceProperties): any;
-    createFromDetected(profile: Profile, deviceID: number, props?: AntDeviceProperties): any;
-}

package/lib/antv2/adapter-factory.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class AntAdapterFactory {
-    static getInstance() {
-        if (!AntAdapterFactory._instance)
-            AntAdapterFactory._instance = new AntAdapterFactory();
-        return AntAdapterFactory._instance;
-    }
-    constructor() {
-        this.adapters = [];
-    }
-    register(antProfile, incyclistProfile, Adapter) {
-        const info = Object.assign({}, { antProfile, incyclistProfile, Adapter });
-        const existing = this.adapters.findIndex(a => a.antProfile === antProfile);
-        if (existing !== -1)
-            this.adapters[existing] = info;
-        else
-            this.adapters.push(info);
-    }
-    getAdapter(query) {
-        const { antProfile, incyclistProfile } = query;
-        if (!antProfile && !incyclistProfile)
-            throw new Error('Illegal arguments: either "antProfile" or "incyclistProfile" must be set');
-        let found;
-        if (antProfile)
-            found = this.adapters.find(a => a.antProfile === antProfile);
-        if (incyclistProfile)
-            found = this.adapters.find(a => a.incyclistProfile === incyclistProfile);
-        return found;
-    }
-    createInstance(settings, props) {
-        let info;
-        const { profile, protocol } = settings;
-        let isLegacy = false;
-        if (protocol) {
-            try {
-                const incyclistProfile = profile;
-                info = this.getAdapter({ incyclistProfile });
-                isLegacy = true;
-            }
-            catch (_a) {
-                isLegacy = false;
-            }
-        }
-        if (!isLegacy) {
-            const antProfile = profile;
-            info = this.getAdapter({ antProfile });
-        }
-        if (info && info.Adapter)
-            return new info.Adapter(settings, props);
-    }
-    createFromDetected(profile, deviceID, props) {
-        const info = this.getAdapter({ antProfile: profile });
-        if (!info || !info.Adapter)
-            return;
-        const settings = Object.assign({}, {
-            profile: info.incyclistProfile,
-            deviceID: deviceID.toString(),
-            interface: 'ant',
-            protocol: 'Ant'
-        });
-        return new info.Adapter(settings, props);
-    }
-}
-exports.default = AntAdapterFactory;

package/lib/antv2/adapter.d.ts

@@ -1,54 +0,0 @@
-/// <reference types="node" />
-import { IChannel, ISensor, Profile } from 'incyclist-ant-plus';
-import AntInterface from './ant-interface';
-import IncyclistDevice from '../base/adpater';
-import { AntDeviceProperties, AntDeviceSettings, BaseDeviceData } from './types';
-import { IAdapter, IncyclistAdapterData, IncyclistBikeData } from '../types';
-export default class AntAdapter<TDeviceData extends BaseDeviceData> extends IncyclistDevice<AntDeviceProperties> {
-    sensor: ISensor;
-    data: IncyclistAdapterData;
-    deviceData: TDeviceData;
-    updateFrequency: number;
-    channel: IChannel;
-    ant: AntInterface;
-    userSettings: {
-        weight?: number;
-    };
-    bikeSettings: {
-        weight?: number;
-    };
-    onDataFn: (data: IncyclistAdapterData) => void;
-    startupRetryPause: number;
-    protected ivDataTimeout: NodeJS.Timeout;
-    protected lastDataTS: number;
-    protected dataMsgCount: number;
-    protected ivWaitForData: NodeJS.Timeout;
-    constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
-    createSensor(settings: AntDeviceSettings): ISensor;
-    isEqual(settings: AntDeviceSettings): boolean;
-    connect(): Promise<boolean>;
-    close(): Promise<boolean>;
-    resetData(): void;
-    isSame(device: IAdapter): boolean;
-    hasData(): boolean;
-    mapData(deviceData: TDeviceData): IncyclistBikeData;
-    transformData(data: IncyclistBikeData): void;
-    mapToAdapterData(deviceData: any): void;
-    onDeviceData(deviceData: TDeviceData): void;
-    isWaitingForData(): boolean;
-    waitForData(timeout: number): Promise<boolean>;
-    getID(): string;
-    getName(): string;
-    getInterface(): string;
-    getProfile(): Profile;
-    getLogData(data: any, excludeList: any): any;
-    triggerTimeoutCheck(): void;
-    startDataTimeoutCheck(): void;
-    stopDataTimeoutCheck(): void;
-    check(): Promise<boolean>;
-    checkCapabilities(): Promise<void>;
-    initControl(): Promise<void>;
-    sendUpdate(request: any): void;
-    start(props?: AntDeviceProperties): Promise<boolean>;
-    stop(): Promise<boolean>;
-}

package/lib/antv2/adapter.js

@@ -1,291 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const ant_interface_1 = __importDefault(require("./ant-interface"));
-const adpater_1 = __importDefault(require("../base/adpater"));
-const types_1 = require("./types");
-const types_2 = require("../types");
-const utils_1 = require("../utils/utils");
-const utils_2 = require("./utils");
-const consts_1 = require("./consts");
-const INTERFACE_NAME = 'ant';
-class AntAdapter extends adpater_1.default {
-    constructor(settings, props) {
-        super(settings, props);
-        this.startupRetryPause = 1000;
-        const antSettings = this.settings;
-        if ((0, types_1.isLegacyProfile)(antSettings.profile))
-            antSettings.profile = (0, utils_2.mapLegacyProfile)(antSettings.profile);
-        if (this.settings.interface !== 'ant')
-            throw new Error('Incorrect interface');
-        this.sensor = this.createSensor(settings);
-        this.deviceData = {};
-        this.data = {};
-        this.dataMsgCount = 0;
-        this.updateFrequency = consts_1.DEFAULT_UPDATE_FREQUENCY;
-        this.channel = undefined;
-        this.ant = ant_interface_1.default.getInstance();
-    }
-    createSensor(settings) {
-        throw new Error('Method not implemented.');
-    }
-    isEqual(settings) {
-        const as = this.settings;
-        if (as.interface !== settings.interface)
-            return false;
-        if (Number(as.deviceID) !== Number(settings.deviceID) || as.profile !== settings.profile)
-            return false;
-        return true;
-    }
-    connect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const connected = yield ant_interface_1.default.getInstance().connect();
-            return connected;
-        });
-    }
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return true;
-        });
-    }
-    resetData() {
-        this.dataMsgCount = 0;
-        const { DeviceID } = this.deviceData;
-        this.deviceData = { DeviceID };
-        this.lastDataTS = undefined;
-    }
-    isSame(device) {
-        if (!(device instanceof AntAdapter))
-            return false;
-        const adapter = device;
-        return (adapter.getID() === this.getID() && adapter.getProfile() === this.getProfile());
-    }
-    hasData() {
-        return this.dataMsgCount > 0;
-    }
-    mapData(deviceData) {
-        throw new Error('message not implemented');
-    }
-    transformData(data) {
-        throw new Error('message not implemented');
-    }
-    mapToAdapterData(deviceData) {
-        throw new Error('message not implemented');
-    }
-    onDeviceData(deviceData) {
-        this.dataMsgCount++;
-        this.lastDataTS = Date.now();
-        try {
-            const { ManId } = this.deviceData;
-            this.deviceData = Object.assign({}, deviceData);
-            if (!ManId && deviceData.ManId) {
-                this.emit('device-info', { device: this.getSettings(), manufacturer: (0, utils_2.getBrand)(deviceData.ManId) });
-            }
-            if (!this.started || this.isStopped())
-                return;
-            this.triggerTimeoutCheck();
-            if (!this.canEmitData())
-                return;
-            const logData = this.getLogData(deviceData, ['PairedDevices', 'RawData']);
-            this.logEvent({ message: 'onDeviceData', data: logData, paused: this.paused });
-            if (this.isControllable()) {
-                let incyclistData = this.mapData(deviceData);
-                incyclistData = this.getCyclingMode().updateData(incyclistData);
-                this.transformData(incyclistData);
-            }
-            else {
-                this.mapToAdapterData(deviceData);
-            }
-            this.emitData(this.data);
-        }
-        catch (err) {
-            console.log('~~~ERROR', err);
-            this.logEvent({ message: 'error', fn: 'onDeviceData()', error: err.message || err, stack: err.stack });
-        }
-    }
-    isWaitingForData() {
-        return this.ivWaitForData !== undefined && this.ivWaitForData !== null;
-    }
-    waitForData(timeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const startTs = Date.now();
-            const timeoutTs = startTs + timeout;
-            if (this.hasData())
-                return true;
-            return new Promise((resolve, reject) => {
-                if (this.ivWaitForData)
-                    return reject(new Error('busy'));
-                this.ivWaitForData = setInterval(() => {
-                    const nowTs = Date.now();
-                    const hasData = this.hasData();
-                    if (nowTs > timeoutTs && !hasData) {
-                        clearInterval(this.ivWaitForData);
-                        this.ivWaitForData = undefined;
-                        reject(new Error('No Data Received'));
-                    }
-                    if (hasData) {
-                        clearInterval(this.ivWaitForData);
-                        this.ivWaitForData = undefined;
-                        resolve(true);
-                    }
-                }, 500);
-            });
-        });
-    }
-    getID() {
-        return this.sensor.getDeviceID().toString();
-    }
-    getName() {
-        const deviceID = this.sensor.getDeviceID();
-        const profile = this.sensor.getProfile();
-        return `Ant+${profile} ${deviceID}`;
-    }
-    getInterface() {
-        return INTERFACE_NAME;
-    }
-    getProfile() {
-        const settings = this.settings;
-        if (settings.protocol === undefined)
-            return settings.profile;
-        else {
-            return (0, utils_2.mapLegacyProfile)(settings.profile);
-        }
-    }
-    getLogData(data, excludeList) {
-        const logData = JSON.parse(JSON.stringify(data));
-        excludeList.forEach((key) => {
-            delete logData[key];
-        });
-        return logData;
-    }
-    triggerTimeoutCheck() {
-        if (!this.ivDataTimeout && this.dataMsgCount > 0) {
-            this.startDataTimeoutCheck();
-        }
-    }
-    startDataTimeoutCheck() {
-        if (this.ivDataTimeout)
-            return;
-        this.ivDataTimeout = setInterval(() => {
-            if (!this.lastDataTS)
-                return;
-            if (this.lastDataTS + consts_1.NO_DATA_TIMEOUT < Date.now()) {
-                this.emit('disconnected', Date.now() - this.lastDataTS);
-            }
-        }, 1000);
-    }
-    stopDataTimeoutCheck() {
-        if (!this.ivDataTimeout)
-            return;
-        clearInterval(this.ivDataTimeout);
-        this.ivDataTimeout = undefined;
-        this.lastDataTS = undefined;
-        this.dataMsgCount = 0;
-    }
-    check() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield this.start();
-            }
-            catch (error) {
-                return false;
-            }
-        });
-    }
-    checkCapabilities() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return;
-        });
-    }
-    initControl() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return;
-        });
-    }
-    sendUpdate(request) {
-        if (!this.isControllable())
-            return;
-        if (this.isPaused() || this.isStopped())
-            return;
-        if (!this.hasCapability(types_2.IncyclistCapability.Control))
-            this.getCyclingMode().sendBikeUpdate(request);
-        else
-            throw new Error('method not implemented');
-    }
-    start(props = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.started && !this.stopped) {
-                if (this.paused)
-                    this.resume();
-                return true;
-            }
-            this.stopped = false;
-            const connected = yield this.connect();
-            if (!connected)
-                throw new Error(`could not start device, reason:could not connect`);
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                this.resetData();
-                this.stopped = false;
-                this.resume();
-                const { startupTimeout = 20000 } = props;
-                let to = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-                    try {
-                        yield this.stop();
-                    }
-                    catch (_a) { }
-                    this.started = false;
-                    reject(new Error(`could not start device, reason:timeout`));
-                }), startupTimeout);
-                let started = false;
-                do {
-                    started = yield this.ant.startSensor(this.sensor, (data) => {
-                        this.onDeviceData(data);
-                    });
-                    if (!started)
-                        yield (0, utils_1.sleep)(this.startupRetryPause);
-                } while (!started);
-                try {
-                    yield this.waitForData(startupTimeout - 100);
-                    yield this.checkCapabilities();
-                    if (this.hasCapability(types_2.IncyclistCapability.Control))
-                        yield this.initControl();
-                    this.started = true;
-                    if (to)
-                        clearTimeout(to);
-                    resolve(true);
-                }
-                catch (err) {
-                }
-            }));
-        });
-    }
-    stop() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let stopped;
-            try {
-                this.stopDataTimeoutCheck();
-                stopped = yield this.ant.stopSensor(this.sensor);
-            }
-            catch (err) {
-                this.logEvent({ message: 'stop sensor failed', reason: err.message });
-            }
-            this.started = false;
-            this.stopped = true;
-            this.paused = false;
-            this.removeAllListeners();
-            return stopped;
-        });
-    }
-}
-exports.default = AntAdapter;