incyclist-devices 3.0.0 → 3.0.1

package/lib/cjs/antv2/base/adapter.js

@@ -0,0 +1,459 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const interface_js_1 = __importDefault(require("./interface.js"));
+const adpater_js_1 = __importDefault(require("../../base/adpater.js"));
+const types_js_1 = require("../types.js");
+const index_js_1 = require("../../types/index.js");
+const utils_js_1 = require("../../utils/utils.js");
+const utils_js_2 = require("../utils.js");
+const consts_js_1 = require("../consts.js");
+const sensor_factory_js_1 = __importDefault(require("../factories/sensor-factory.js"));
+const gd_eventlog_1 = require("gd-eventlog");
+const node_events_1 = __importDefault(require("node:events"));
+const INTERFACE_NAME = 'ant';
+const MAX_RETRIES = 3;
+class AntAdapter extends adpater_js_1.default {
+    sensor;
+    deviceData;
+    channel;
+    ant;
+    userSettings;
+    bikeSettings;
+    ivDataTimeout;
+    lastDataTS;
+    dataMsgCount;
+    ivWaitForData;
+    promiseWaitForData;
+    sensorConnected;
+    startStatus;
+    startupRetryPause = 1000;
+    internalEmitter = new node_events_1.default();
+    constructor(settings, props) {
+        super(settings, props);
+        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_js_1.isLegacyProfile)(antSettings.profile))
+            antSettings.profile = (0, utils_js_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_js_1.DEFAULT_UPDATE_FREQUENCY;
+        this.channel = undefined;
+        this.ant = interface_js_1.default.getInstance();
+        if (this.isDebugEnabled()) {
+            this.ant.setLogger(this);
+        }
+        if (this.getStaticCapabilities())
+            this.capabilities = this.getStaticCapabilities();
+    }
+    getProfileName() {
+        const C = this.constructor;
+        return C['ANT_PROFILE_NAME'];
+    }
+    getLegacyProfileName() {
+        const C = this.constructor;
+        return C['INCYCLIST_PROFILE_NAME'];
+    }
+    getStaticCapabilities() {
+        const C = this.constructor;
+        return C['CAPABILITIES'];
+    }
+    createSensor(settings) {
+        return sensor_factory_js_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;
+    }
+    async connect() {
+        const connected = await interface_js_1.default.getInstance().connect();
+        return connected;
+    }
+    async close() {
+        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');
+    }
+    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();
+        try {
+            const { ManId } = this.deviceData;
+            this.deviceData = Object.assign({}, deviceData);
+            if (!ManId && deviceData.ManId) {
+                this.emit('device-info', this.getSettings(), { manufacturer: (0, utils_js_2.getBrand)(deviceData.ManId) });
+            }
+            const logData = this.getLogData(deviceData, ['PairedDevices', 'RawData', '_RawData']);
+            this.logEvent({ message: 'onDeviceData', device: this.getName(), interface: this.getInterface(), data: logData, paused: this.paused, started: this.started, canEmit: this.canEmitData() });
+            if (this.isStopped() || !this.canEmitData())
+                return;
+            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;
+    }
+    async _wait() {
+        const res = new Promise((resolve) => {
+            const iv = setInterval(() => {
+                if (this.hasData()) {
+                    clearInterval(iv);
+                    resolve(true);
+                }
+                if (this.promiseWaitForData === undefined || this.promiseWaitForData === null || this.stopped) {
+                    resolve(false);
+                    clearInterval(iv);
+                }
+            }, 10);
+        });
+        return res;
+    }
+    async waitForData(timeout) {
+        if (this.hasData()) {
+            return true;
+        }
+        const tsStart = Date.now();
+        if (this.promiseWaitForData !== undefined && this.promiseWaitForData !== null) {
+            let hasData = false;
+            try {
+                hasData = await this.promiseWaitForData;
+            }
+            catch { }
+            if (hasData || Date.now() > tsStart + timeout)
+                return hasData;
+        }
+        try {
+            this.promiseWaitForData = (0, utils_js_1.runWithTimeout)(this._wait(), timeout);
+            const hasData = await this.promiseWaitForData;
+            this.promiseWaitForData = null;
+            return hasData;
+        }
+        catch {
+            this.promiseWaitForData = null;
+            return false;
+        }
+    }
+    getID() {
+        const id = this.deviceData?.DeviceID ?? this.sensor?.getDeviceID();
+        return id?.toString();
+    }
+    getName() {
+        if (this.settings.name)
+            return this.settings.name;
+        const deviceID = this.getID();
+        const profile = this.getProfileName();
+        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_js_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_js_2.mapLegacyProfile)(settings.profile);
+        }
+    }
+    getLogData(data, excludeList) {
+        const logData = JSON.parse(JSON.stringify(data));
+        excludeList.forEach((key) => {
+            delete logData[key];
+        });
+        return logData;
+    }
+    async check() {
+        try {
+            return await this.start();
+        }
+        catch {
+            return false;
+        }
+    }
+    async checkCapabilities() {
+        return;
+    }
+    async initControl() {
+        return;
+    }
+    getDefaultStartupTimeout() {
+        return 20000;
+    }
+    async startPreChecks(props) {
+        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 = await 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(index_js_1.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', device: this.getName() });
+            this.started = true;
+            this.paused = false;
+            return true;
+        }
+        else {
+            this.started = false;
+            const { sensorStarted, hasData, interrupted } = this.startStatus;
+            if (interrupted) {
+                this.logEvent({ message: 'start device interrupted', device: this.getName() });
+                return false;
+            }
+            if (!sensorStarted) {
+                this.logEvent({ message: 'start device failed', device: this.getName(), reason: 'could not connect' });
+                throw new Error('could not start device, reason:could not connect');
+            }
+            else if (!hasData) {
+                this.logEvent({ message: 'start device failed', device: this.getName(), reason: 'no data received' });
+                throw new Error('could not start device, reason:no data received');
+            }
+            else {
+                this.logEvent({ message: 'start device failed', device: this.getName(), reason: 'could not send FE commands' });
+                throw new Error('could not start device, reason:could not send FE commands');
+            }
+        }
+    }
+    async waitForInitialData(startupTimeout) {
+        const { sensorStarted, hasData, timeout } = this.startStatus;
+        if ((sensorStarted && hasData) || !sensorStarted || timeout)
+            return;
+        this.logEvent({ message: 'wait for sensor data', device: this.getName() });
+        this.startStatus.hasData = await this.waitForData(startupTimeout);
+        if (this.startStatus.hasData)
+            this.logEvent({ message: 'sensor data received', device: this.getName() });
+    }
+    async initSensor(props) {
+        this.startStatus.sensorStarted = this.sensorConnected;
+        if (this.startStatus.sensorStarted)
+            return;
+        this.logEvent({ message: 'start sensor', device: this.getName(), props });
+        try {
+            this.sensorConnected = await this.startSensor();
+            if (this.sensorConnected) {
+                this.logEvent({ message: 'sensor started', device: this.getName(), channel: this.sensor?.getChannel()?.getChannelNo(), props });
+                this.startStatus.sensorStarted = true;
+            }
+            else {
+                this.logEvent({ message: 'start sensor failed', device: this.getName(), reason: 'unknown', props });
+            }
+        }
+        catch (err) {
+            this.logEvent({ message: 'start sensor failed', device: this.getName(), reason: err.message, props });
+        }
+    }
+    getLogProps(startProps) {
+        const { user, userWeight, bikeWeight, startupTimeout, automaticReconnect } = startProps ?? {};
+        return { user, userWeight, bikeWeight, startupTimeout, automaticReconnect };
+    }
+    async start(startProps) {
+        const props = this.getStartProps(startProps);
+        const logProps = this.getLogProps(startProps);
+        const preCheckResult = await 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', device: this.getName(), props: logProps, isStarted: this.started, isPaused: this.isPaused, isStopped: this.isStopped });
+        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 = async () => {
+            let success = false;
+            let retry = 0;
+            while (!success && retry < MAX_RETRIES && !this.startStatus.timeout && !this.startStatus.interrupted) {
+                try {
+                    retry++;
+                    await this.initSensor(props);
+                    await this.waitForInitialData(startupTimeout);
+                    await this.checkCapabilities();
+                    if (this.hasCapability(index_js_1.IncyclistCapability.Control))
+                        await this.initControl();
+                    if (!this.startStatus.hasData && !this.startStatus.interrupted) {
+                        await this.stopSensor();
+                        await (0, utils_js_1.sleep)(retryDelay);
+                        continue;
+                    }
+                    success = this.isStartSuccess();
+                }
+                catch (err) {
+                    this.logEvent({ message: 'error', fn: 'start#doStart', device: this.getName(), error: err.message, stack: err.stack });
+                }
+            }
+            this.reportStartStatus();
+            return this.started;
+        };
+        const checkInterrupt = () => new Promise(done => {
+            this.internalEmitter.on('stop', () => {
+                this.started = false;
+                this.startStatus.interrupted = true;
+                done(false);
+            });
+        });
+        try {
+            await (0, utils_js_1.runWithTimeout)(Promise.race([doStart(), checkInterrupt()]), totalTimeout);
+        }
+        catch (err) {
+            if (err.message === 'Timeout') {
+                this.started = false;
+                this.startStatus.timeout = true;
+                this.logEvent({ message: 'start device failed', device: this.getName(), reason: 'timeout' });
+                throw new Error(`could not start device, reason:timeout`);
+            }
+            throw err;
+        }
+        return this.started;
+    }
+    async stop() {
+        let stopped;
+        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;
+            await (0, utils_js_1.sleep)(20);
+        }
+        try {
+            stopped = await (0, utils_js_1.runWithTimeout)(this.ant.stopSensor(this.sensor), 5000);
+        }
+        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();
+        this.logEvent({ message: 'stopping device finished', device: this.getName(), stopped });
+        return stopped;
+    }
+    async startSensor() {
+        return await this.ant.startSensor(this.sensor, this.onDeviceData.bind(this));
+    }
+    async stopSensor() {
+        if (!this.sensorConnected)
+            return;
+        try {
+            await await this.ant.stopSensor(this.sensor);
+            this.sensorConnected = false;
+        }
+        catch { }
+    }
+    setCyclingMode(mode, settings, sendInitCommands) {
+        super.setCyclingMode(mode, settings, sendInitCommands);
+        this.refreshDeviceData();
+    }
+}
+exports.default = AntAdapter;

package/lib/cjs/antv2/base/binding.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class AntDeviceBinding {
+    constructor(_props) { }
+    open() {
+        throw new Error('Method not implemented.');
+    }
+    close() {
+        throw new Error('Method not implemented.');
+    }
+    getMaxChannels() {
+        throw new Error('Method not implemented.');
+    }
+    getChannel() {
+        throw new Error('Method not implemented.');
+    }
+    freeChannel(channel) {
+        throw new Error('Method not implemented.');
+    }
+    getDeviceNumber() {
+        throw new Error('Method not implemented.');
+    }
+    write(data) {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.default = AntDeviceBinding;