incyclist-devices 2.1.1 → 2.1.2

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

@@ -1,8 +1,8 @@
 /// <reference types="node" />
 import { IChannel, ISensor, Profile } from 'incyclist-ant-plus';
-import AntInterface from './ant-interface';
+import AntInterface from './interface';
 import IncyclistDevice from '../../base/adpater';
-import { AntDeviceProperties, AntDeviceSettings, LegacyProfile, BaseDeviceData } from '../types';
+import { AntDeviceProperties, AntDeviceSettings, LegacyProfile, BaseDeviceData, AdapterStartStatus } from '../types';
 import { IAdapter, IncyclistAdapterData, IncyclistBikeData } from '../../types';
 export default class AntAdapter<TDeviceData extends BaseDeviceData> extends IncyclistDevice<AntDeviceProperties> {
     sensor: ISensor;
@@ -18,17 +18,20 @@ export default class AntAdapter<TDeviceData extends BaseDeviceData> extends Incy
         weight?: number;
     };
     onDataFn: (data: IncyclistAdapterData) => void;
-    startupRetryPause: number;
     protected ivDataTimeout: NodeJS.Timeout;
     protected lastDataTS: number;
     protected dataMsgCount: number;
     protected ivWaitForData: NodeJS.Timeout;
     protected promiseWaitForData: Promise<boolean>;
+    protected sensorConnected: boolean;
+    protected startStatus: AdapterStartStatus;
+    protected startupRetryPause: number;
     constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
     getProfileName(): Profile;
     getLegacyProfileName(): LegacyProfile;
     createSensor(settings: AntDeviceSettings): ISensor;
     isEqual(settings: AntDeviceSettings): boolean;
+    getDefaultReconnectDelay(): number;
     connect(): Promise<boolean>;
     close(): Promise<boolean>;
     resetData(): void;
@@ -48,15 +51,19 @@ export default class AntAdapter<TDeviceData extends BaseDeviceData> extends Incy
     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>;
     getDefaultStartupTimeout(): number;
     sendUpdate(request: any): void;
+    startPreChecks(props: AntDeviceProperties): Promise<'done' | 'connected' | 'connection-failed'>;
+    resetStartStatus(): void;
+    isStartSuccess(): boolean;
+    reportStartStatus(): boolean;
+    protected waitForInitialData(startupTimeout: any): Promise<void>;
+    protected initSensor(props: any): Promise<boolean>;
     start(props?: AntDeviceProperties): Promise<boolean>;
     stop(): Promise<boolean>;
     startSensor(): Promise<boolean>;
+    stopSensor(): Promise<void>;
 }

package/lib/antv2/base/adapter.js

@@ -12,7 +12,7 @@ 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 interface_1 = __importDefault(require("./interface"));
 const adpater_1 = __importDefault(require("../../base/adpater"));
 const types_1 = require("../types");
 const types_2 = require("../../types");
@@ -22,6 +22,7 @@ const consts_1 = require("../consts");
 const sensor_factory_1 = __importDefault(require("../factories/sensor-factory"));
 const gd_eventlog_1 = require("gd-eventlog");
 const INTERFACE_NAME = 'ant';
+const MAX_RETRIES = 3;
 class AntAdapter extends adpater_1.default {
     constructor(settings, props) {
         super(settings, props);
@@ -37,6 +38,7 @@ class AntAdapter extends adpater_1.default {
         if (this.settings.interface !== 'ant')
             throw new Error('Incorrect interface');
         this.sensor = this.createSensor(settings);
+        this.sensorConnected = false;
         this.deviceData = {
             DeviceID: Number(settings.deviceID)
         };
@@ -45,7 +47,7 @@ class AntAdapter extends adpater_1.default {
         this.logger = new gd_eventlog_1.EventLogger(`Ant+${profile}`);
         this.updateFrequency = consts_1.DEFAULT_UPDATE_FREQUENCY;
         this.channel = undefined;
-        this.ant = ant_interface_1.default.getInstance();
+        this.ant = interface_1.default.getInstance();
     }
     getProfileName() {
         const C = this.constructor;
@@ -66,9 +68,12 @@ class AntAdapter extends adpater_1.default {
             return false;
         return true;
     }
+    getDefaultReconnectDelay() {
+        return this.startupRetryPause;
+    }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
-            const connected = yield ant_interface_1.default.getInstance().connect();
+            const connected = yield interface_1.default.getInstance().connect();
             return connected;
         });
     }
@@ -113,7 +118,6 @@ class AntAdapter extends adpater_1.default {
             }
             if (!this.started || this.isStopped())
                 return;
-            this.triggerTimeoutCheck();
             if (!this.canEmitData())
                 return;
             const logData = this.getLogData(deviceData, ['PairedDevices', 'RawData']);
@@ -158,16 +162,13 @@ class AntAdapter extends adpater_1.default {
             }
             const tsStart = Date.now();
             if (this.promiseWaitForData) {
+                let hasData = false;
                 try {
-                    const hasData = yield (0, utils_1.runWithTimeout)(this.promiseWaitForData, timeout);
-                    if (hasData || Date.now() - tsStart > timeout)
-                        return hasData;
-                }
-                catch (_a) {
-                    timeout -= (Date.now() - tsStart);
-                    if (timeout < 0)
-                        return false;
+                    hasData = yield this.promiseWaitForData;
                 }
+                catch (_a) { }
+                if (hasData || Date.now() > tsStart + timeout)
+                    return hasData;
             }
             try {
                 this.promiseWaitForData = (0, utils_1.runWithTimeout)(this._wait(), timeout);
@@ -226,30 +227,6 @@ class AntAdapter extends adpater_1.default {
         });
         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 {
@@ -283,67 +260,158 @@ class AntAdapter extends adpater_1.default {
         else
             throw new Error('method not implemented');
     }
-    start(props = {}) {
+    startPreChecks(props) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.started && !this.stopped) {
-                if (this.paused)
-                    this.resume();
-                return true;
-            }
+            const wasPaused = this.paused;
+            const wasStopped = this.stopped;
             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';
+        });
+    }
+    resetStartStatus() {
+        this.startStatus = { timeout: false, hasData: false, sensorStarted: false };
+    }
+    isStartSuccess() {
+        const { timeout, hasData, sensorStarted, controlInitialized, userInitialized, interrupted } = this.startStatus;
+        if (interrupted)
+            return false;
+        if (this.hasCapability(types_2.IncyclistCapability.Control))
+            return sensorStarted && hasData && userInitialized && controlInitialized && !timeout;
+        else
+            return sensorStarted && hasData && !timeout;
+    }
+    reportStartStatus() {
+        const success = this.isStartSuccess();
+        if (success) {
+            this.logEvent({ message: 'start device success' });
+            this.started = true;
+            this.paused = false;
+            return true;
+        }
+        else {
+            this.started = false;
+            const { sensorStarted, hasData, interrupted } = this.startStatus;
+            if (interrupted)
+                return;
+            if (!sensorStarted) {
+                this.logEvent({ message: 'start device failed', reason: 'could not connect' });
+                throw new Error('could not start device, reason:could not connect');
+            }
+            else if (!hasData) {
+                this.logEvent({ message: 'start device failed', reason: 'no data received' });
+                throw new Error('could not start device, reason:no data received');
+            }
+            else {
+                this.logEvent({ message: 'start device failed', reason: 'could not send FE commands' });
+                throw new Error('could not start device, reason:could not send FE commands');
+            }
+        }
+    }
+    waitForInitialData(startupTimeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { sensorStarted, hasData, timeout } = this.startStatus;
+            if ((sensorStarted && hasData) || !sensorStarted || timeout)
+                return;
+            this.logEvent({ message: 'wait for sensor data', });
+            this.startStatus.hasData = yield this.waitForData(startupTimeout);
+            if (this.startStatus.hasData)
+                this.logEvent({ message: 'sensor data received', });
+        });
+    }
+    initSensor(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.startStatus.sensorStarted = this.sensorConnected;
+            if (this.startStatus.sensorStarted || this.startStatus.sensorStarted)
+                return;
+            this.logEvent({ message: 'start sensor', props });
+            try {
+                this.sensorConnected = yield this.startSensor();
+                if (this.sensorConnected) {
+                    this.logEvent({ message: 'sensor started', props });
+                    this.startStatus.sensorStarted = true;
+                }
+            }
+            catch (err) {
+                this.logEvent({ message: 'start sensor failed', reason: err.message, props });
+            }
+        });
+    }
+    start(props = {}) {
+        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`);
-            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                this.resetData();
-                this.stopped = false;
-                this.resume();
-                const { startupTimeout = this.getDefaultStartupTimeout() } = props;
-                let to = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'starting device', props, isStarted: this.started });
+            this.resetStartStatus();
+            this.resetData();
+            const { startupTimeout = this.getDefaultStartupTimeout() } = props || {};
+            const retryDelay = this.getDefaultReconnectDelay();
+            const totalTimeout = Math.min(startupTimeout + 10000, (startupTimeout + retryDelay) * MAX_RETRIES);
+            const doStart = () => __awaiter(this, void 0, void 0, function* () {
+                let success = false;
+                let retry = 0;
+                while (!success && retry < MAX_RETRIES && !this.startStatus.timeout && !this.startStatus.interrupted) {
                     try {
-                        yield this.stop();
+                        retry++;
+                        yield this.initSensor(props);
+                        yield this.waitForInitialData(startupTimeout);
+                        yield this.checkCapabilities();
+                        if (this.hasCapability(types_2.IncyclistCapability.Control))
+                            yield this.initControl();
+                        if (!this.startStatus.hasData) {
+                            yield this.stopSensor();
+                            yield (0, utils_1.sleep)(retryDelay);
+                            continue;
+                        }
+                        success = this.isStartSuccess();
+                    }
+                    catch (err) {
+                        this.logEvent({ message: 'error', fn: 'start#doStart', error: err.message, stack: err.stack });
                     }
-                    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 {
-                    this.logEvent({ message: 'wait for sensor data', });
-                    const hasData = yield this.waitForData(startupTimeout - 100);
-                    if (!hasData)
-                        throw new Error('timeout');
-                    this.logEvent({ message: 'sensor data received', });
-                    yield this.checkCapabilities();
-                    if (this.hasCapability(types_2.IncyclistCapability.Control))
-                        yield this.initControl();
-                    this.started = true;
-                    if (to)
-                        clearTimeout(to);
-                    resolve(true);
                 }
-                catch (err) {
+                this.reportStartStatus();
+                return this.started;
+            });
+            try {
+                yield (0, utils_1.runWithTimeout)(doStart(), totalTimeout);
+            }
+            catch (err) {
+                if (err.message === 'Timeout') {
+                    this.started = false;
+                    this.startStatus.timeout = true;
+                    throw new Error(`could not start device, reason:timeout`);
                 }
-            }));
+                throw err;
+            }
+            return true;
         });
     }
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
             let stopped;
+            this.promiseWaitForData = null;
+            if (this.startStatus)
+                this.startStatus.interrupted = true;
             try {
-                this.stopDataTimeoutCheck();
                 stopped = yield this.ant.stopSensor(this.sensor);
             }
             catch (err) {
                 this.logEvent({ message: 'stop sensor failed', reason: err.message });
             }
+            this.sensorConnected = false;
             this.started = false;
             this.stopped = true;
             this.paused = false;
@@ -356,5 +424,16 @@ class AntAdapter extends adpater_1.default {
             return this.ant.startSensor(this.sensor, this.onDeviceData.bind(this));
         });
     }
+    stopSensor() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.sensorConnected)
+                return;
+            try {
+                yield yield this.ant.stopSensor(this.sensor);
+                this.sensorConnected = false;
+            }
+            catch (_a) { }
+        });
+    }
 }
 exports.default = AntAdapter;

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

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+import EventEmitter from "events";
+import { EventLogger } from "gd-eventlog";
+import { IAntDevice, IChannel, ISensor } from "incyclist-ant-plus";
+import { AntDeviceSettings, AntScanProps, AntInterfaceProps } from "../types";
+import { IncyclistInterface } from "../../types";
+import AntDeviceBinding from "./binding";
+export default class AntInterface extends EventEmitter implements IncyclistInterface {
+    static _instance: AntInterface;
+    static INTERFACE_NAME: string;
+    static getInstance(props?: AntInterfaceProps): AntInterface;
+    static hasInstance(): boolean;
+    protected logger: EventLogger;
+    protected device: IAntDevice;
+    protected Binding: typeof AntDeviceBinding;
+    protected connected: boolean;
+    protected connectPromise: Promise<boolean>;
+    protected scanPromise: Promise<AntDeviceSettings[]>;
+    protected activeScan: {
+        emitter: EventEmitter;
+        channel?: IChannel;
+    };
+    protected props: AntInterfaceProps;
+    protected logEnabled: boolean;
+    constructor(props: AntInterfaceProps);
+    getName(): string;
+    getBinding(): typeof AntDeviceBinding;
+    setBinding(binding: typeof AntDeviceBinding): void;
+    getLogger(): EventLogger;
+    setLogger(logger: EventLogger): void;
+    enableLogging(): void;
+    disableLogging(): void;
+    logEvent(event: any): void;
+    isConnected(): boolean;
+    connect(): Promise<boolean>;
+    disconnect(): Promise<boolean>;
+    onError(profile: any, error: any): void;
+    onData(profile: any, id: any, data: any, tag: any): void;
+    getReconnectPause(): number;
+    scannerWaitForConnection(): Promise<void>;
+    scan(props?: AntScanProps): Promise<AntDeviceSettings[]>;
+    isScanning(): boolean;
+    stopScan(): Promise<boolean>;
+    startSensor(sensor: ISensor, onDeviceData: (data: any) => void): Promise<boolean>;
+    stopSensor(sensor: ISensor): Promise<boolean>;
+}