incyclist-devices 2.1.0 → 2.1.2

package/lib/antv2/base/adapter.js

@@ -0,0 +1,439 @@
+"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 interface_1 = __importDefault(require("./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 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);
+        this.startupRetryPause = 1000;
+        const profile = this.getProfileName();
+        if (settings.protocol && settings.profile !== this.getLegacyProfileName())
+            throw new Error('Incorrect Profile');
+        if (!settings.protocol && settings.profile !== this.getProfileName())
+            throw new Error('Incorrect Profile');
+        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.sensorConnected = false;
+        this.deviceData = {
+            DeviceID: Number(settings.deviceID)
+        };
+        this.data = {};
+        this.dataMsgCount = 0;
+        this.logger = new gd_eventlog_1.EventLogger(`Ant+${profile}`);
+        this.updateFrequency = consts_1.DEFAULT_UPDATE_FREQUENCY;
+        this.channel = undefined;
+        this.ant = interface_1.default.getInstance();
+    }
+    getProfileName() {
+        const C = this.constructor;
+        return C['ANT_PROFILE_NAME'];
+    }
+    getLegacyProfileName() {
+        const C = this.constructor;
+        return C['INCYCLIST_PROFILE_NAME'];
+    }
+    createSensor(settings) {
+        return sensor_factory_1.default.create(this.getProfileName(), Number(settings.deviceID));
+    }
+    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;
+    }
+    getDefaultReconnectDelay() {
+        return this.startupRetryPause;
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connected = yield 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.data = {};
+        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, deviceData) {
+        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', 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.isControllable()) {
+                let incyclistData = this.mapData(deviceData);
+                incyclistData = this.getCyclingMode().updateData(incyclistData);
+                this.transformData(incyclistData, deviceData);
+            }
+            else {
+                this.mapToAdapterData(deviceData);
+            }
+            this.emitData(this.data);
+        }
+        catch (err) {
+            this.logEvent({ message: 'error', fn: 'onDeviceData()', error: err.message || err, stack: err.stack });
+        }
+    }
+    isWaitingForData() {
+        return this.promiseWaitForData !== undefined && this.promiseWaitForData !== null;
+    }
+    _wait() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = new Promise((resolve) => {
+                const iv = setInterval(() => {
+                    if (this.hasData()) {
+                        clearInterval(iv);
+                        resolve(true);
+                    }
+                    if (!this.promiseWaitForData) {
+                        clearInterval(iv);
+                    }
+                }, 10);
+            });
+            return res;
+        });
+    }
+    waitForData(timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.hasData()) {
+                return true;
+            }
+            const tsStart = Date.now();
+            if (this.promiseWaitForData) {
+                let hasData = false;
+                try {
+                    hasData = yield this.promiseWaitForData;
+                }
+                catch (_a) { }
+                if (hasData || Date.now() > tsStart + timeout)
+                    return hasData;
+            }
+            try {
+                this.promiseWaitForData = (0, utils_1.runWithTimeout)(this._wait(), timeout);
+                yield this.promiseWaitForData;
+                this.promiseWaitForData = null;
+                return true;
+            }
+            catch (err) {
+                this.promiseWaitForData = null;
+                return false;
+            }
+        });
+    }
+    getID() {
+        var _a;
+        const id = this.deviceData.DeviceID || ((_a = this.sensor) === null || _a === void 0 ? void 0 : _a.getDeviceID());
+        return id.toString();
+    }
+    getName() {
+        if (this.settings.name)
+            return this.settings.name;
+        const deviceID = this.sensor.getDeviceID();
+        const profile = this.sensor.getProfile();
+        return `Ant+${profile} ${deviceID}`;
+    }
+    getUniqueName() {
+        if (this.settings.name)
+            return this.settings.name;
+        const { ManId } = this.deviceData;
+        const profile = this.getProfileName();
+        const brand = (0, utils_2.getBrand)(ManId);
+        const id = this.getID();
+        if (brand)
+            return `${brand} ${profile} ${id}`;
+        else
+            return `${this.getName()}`;
+    }
+    getDisplayName() {
+        return this.getUniqueName();
+    }
+    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;
+    }
+    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;
+        });
+    }
+    getDefaultStartupTimeout() {
+        return 20000;
+    }
+    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');
+    }
+    startPreChecks(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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`);
+            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 {
+                        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 });
+                    }
+                }
+                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 {
+                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;
+            this.removeAllListeners();
+            return stopped;
+        });
+    }
+    startSensor() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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/ant-interface.d.ts

@@ -0,0 +1,35 @@
+/// <reference types="node" />
+import EventEmitter from "events";
+import { EventLogger } from "gd-eventlog";
+import { IAntDevice, IChannel, ISensor } from "incyclist-ant-plus";
+import { AntDeviceSettings, AntScanProps, AntInterfaceProps, ConnectState } 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 connectState: ConnectState;
+    protected props: AntInterfaceProps;
+    protected activeScan: IChannel;
+    constructor(props: AntInterfaceProps);
+    getName(): string;
+    getBinding(): typeof AntDeviceBinding;
+    setBinding(binding: typeof AntDeviceBinding): void;
+    setLogger(logger: EventLogger): 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;
+    scan(props?: AntScanProps): Promise<AntDeviceSettings[]>;
+    stopScan(): Promise<boolean>;
+    startSensor(sensor: ISensor, onDeviceData: (data: any) => void): Promise<boolean>;
+    stopSensor(sensor: ISensor): Promise<boolean>;
+    isScanning(): boolean;
+}