incyclist-devices 2.1.1 → 2.1.3

package/lib/antv2/base/interface.js

@@ -0,0 +1,343 @@
+"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 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");
+class AntInterface extends events_1.default {
+    static getInstance(props = {}) {
+        if (AntInterface._instance === undefined)
+            AntInterface._instance = new AntInterface(props);
+        return AntInterface._instance;
+    }
+    static hasInstance() {
+        return AntInterface._instance !== undefined;
+    }
+    constructor(props) {
+        super();
+        this.props = props;
+        this.device = undefined;
+        this.connected = false;
+        this.connectPromise = null;
+        this.logEnabled = props.log || true;
+        const { binding, logger } = props;
+        this.setLogger(logger || new gd_eventlog_1.EventLogger('Ant+'));
+        if (binding) {
+            this.setBinding(binding);
+        }
+    }
+    getName() {
+        return AntInterface.INTERFACE_NAME;
+    }
+    getBinding() {
+        return this.Binding;
+    }
+    setBinding(binding) {
+        this.Binding = binding;
+    }
+    getLogger() {
+        return this.logger;
+    }
+    setLogger(logger) {
+        this.logger = logger;
+    }
+    enableLogging() {
+        this.logEnabled = true;
+    }
+    disableLogging() {
+        this.logEnabled = false;
+    }
+    logEvent(event) {
+        if (!this.logEnabled || !this.logger)
+            return;
+        this.logger.logEvent(event);
+        const w = global.window;
+        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || (0, utils_1.isTrue)(process.env.ANT_DEBUG)) {
+            console.log('~~~ ANT', event);
+        }
+    }
+    isConnected() {
+        return this.connected && this.device !== undefined;
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isConnected())
+                return true;
+            if (this.connectPromise) {
+                return yield this.connectPromise;
+            }
+            const _connect = () => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    this.logEvent({ message: 'ANT+ connecting ...' });
+                    const device = new this.Binding(Object.assign(Object.assign({}, this.props), { logger: this.logger }));
+                    const opened = yield device.open();
+                    if (!opened) {
+                        this.logEvent({ message: 'ANT+ not connected' });
+                        return false;
+                    }
+                    this.device = device;
+                    this.connected = true;
+                    this.logEvent({ message: 'ANT+ connected' });
+                    return true;
+                }
+                catch (err) {
+                    this.logEvent({ message: 'error', fn: 'connect', error: err.message, stack: err.stack });
+                    this.connected = false;
+                    return false;
+                }
+            });
+            this.connectPromise = _connect();
+            return yield this.connectPromise;
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'ANT+ disconnecting ...' });
+            let closed = false;
+            if (this.device) {
+                try {
+                    closed = yield this.device.close();
+                }
+                catch (_a) {
+                    closed = false;
+                }
+            }
+            else {
+                closed = true;
+            }
+            this.logEvent({ message: 'ANT+ disconnected' });
+            this.connectPromise = null;
+            this.scanPromise = null;
+            this.connected = false;
+            return closed;
+        });
+    }
+    onError(profile, error) {
+        this.logEvent({ message: 'ANT+ERROR:', profile, error });
+    }
+    onData(profile, id, data, tag) {
+        this.emit('data', profile, id, data, tag);
+    }
+    getReconnectPause() {
+        return 1000;
+    }
+    scannerWaitForConnection() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            let scanFinished = false;
+            let scanStopRequested = false;
+            this.activeScan.emitter.once('timeout', () => {
+                this.activeScan.emitter.removeAllListeners();
+                scanFinished = true;
+            });
+            this.activeScan.emitter.once('stop', () => {
+                scanStopRequested = true;
+                this.activeScan.emitter.removeAllListeners();
+            });
+            while (!this.isConnected() && !scanFinished && !scanStopRequested) {
+                const connected = yield this.connect();
+                if (!connected)
+                    yield (0, utils_1.sleep)(this.getReconnectPause());
+            }
+            if (scanStopRequested)
+                this.emit('scan stopped', true);
+            (_a = this.activeScan) === null || _a === void 0 ? void 0 : _a.emitter.removeAllListeners();
+        });
+    }
+    scan(props = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'starting scan ..' });
+            if (this.isScanning()) {
+                return yield this.scanPromise;
+            }
+            this.activeScan = { emitter: new events_1.default() };
+            const detected = [];
+            const _scan = () => new Promise((done) => __awaiter(this, void 0, void 0, function* () {
+                const onDetected = (profile, deviceID) => {
+                    if (deviceID && detected.find(s => s.deviceID === deviceID && s.profile === profile) === undefined) {
+                        try {
+                            detected.push({ interface: this.getName(), profile, deviceID });
+                            this.emit('device', { interface: 'ant', profile, deviceID });
+                        }
+                        catch (err) {
+                            this.logEvent({ message: 'error', fn: 'onDetected', error: err.message, stack: err.stack });
+                        }
+                    }
+                };
+                const addListeners = (channel) => {
+                    channel.on('detected', onDetected);
+                    channel.on('data', this.onData.bind(this));
+                    channel.on('error', this.onError.bind(this));
+                };
+                const removeListeners = (channel) => {
+                    channel.off('detected', onDetected);
+                    channel.off('data', this.onData.bind(this));
+                    channel.off('error', this.onError.bind(this));
+                };
+                yield this.scannerWaitForConnection();
+                if (!this.isConnected()) {
+                    return done(detected);
+                }
+                let channel;
+                channel = this.device.getChannel();
+                if (!channel)
+                    return done(detected);
+                this.activeScan.channel = channel;
+                channel.setProps({ logger: this.logger });
+                const sensors = sensor_factory_1.default.createAll();
+                sensors.forEach((sensor) => {
+                    channel.attach(sensor);
+                });
+                addListeners(channel);
+                try {
+                    const success = yield channel.startScanner();
+                    this.logEvent({ message: 'scan started', success });
+                }
+                catch (err) {
+                    this.logEvent({ message: 'scan could not be started', error: err.message, stack: err.stack });
+                    removeListeners(channel);
+                    return done(detected);
+                }
+                this.activeScan.emitter.on('stop', () => __awaiter(this, void 0, void 0, function* () {
+                    this.activeScan.emitter.removeAllListeners();
+                    this.emit('stop-scan');
+                    const stopped = yield this.activeScan.channel.stopScanner();
+                    this.logEvent({ message: 'scan stopped' });
+                    removeListeners(channel);
+                    this.activeScan = undefined;
+                    this.scanPromise = null;
+                    this.emit('scan stopped', stopped);
+                    done(detected);
+                }));
+                this.activeScan.emitter.on('timeout', () => __awaiter(this, void 0, void 0, function* () {
+                    this.activeScan.emitter.removeAllListeners();
+                    yield this.activeScan.channel.stopScanner();
+                    this.emit('stop-scan');
+                    removeListeners(channel);
+                    this.logEvent({ message: 'scan finished(timeout) ..' });
+                    done(detected);
+                }));
+            }));
+            const { timeout } = props;
+            this.scanPromise = _scan();
+            if (timeout) {
+                yield (0, utils_1.waitWithTimeout)(this.scanPromise, timeout, () => {
+                    var _a;
+                    (_a = this.activeScan) === null || _a === void 0 ? void 0 : _a.emitter.emit('timeout');
+                });
+                this.scanPromise = null;
+                this.activeScan = null;
+                return detected;
+            }
+            else {
+                const res = yield this.scanPromise;
+                this.scanPromise = null;
+                this.activeScan = null;
+                return res;
+            }
+        });
+    }
+    isScanning() {
+        return this.scanPromise !== undefined && this.scanPromise !== null;
+    }
+    stopScan() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'stopping scan ..' });
+            if (!this.isScanning())
+                return true;
+            return new Promise(done => {
+                this.activeScan.emitter.emit('stop');
+                this.once('scan stopped', (res) => {
+                    this.logEvent({ message: 'stopping scan done ..' });
+                    done(res);
+                });
+            });
+        });
+    }
+    startSensor(sensor, onDeviceData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isConnected()) {
+                const connected = yield this.connect();
+                if (!connected)
+                    return false;
+            }
+            let channel;
+            channel = this.device.getChannel();
+            if (!channel)
+                return false;
+            channel.setProps({ logger: this.logger });
+            const onData = (profile, deviceID, data, tag) => {
+                if (profile === sensor.getProfile() && deviceID === sensor.getDeviceID())
+                    this.onData(profile, deviceID, data, tag);
+                onDeviceData(data);
+            };
+            channel.on('data', onData);
+            sensor.setChannel(channel);
+            try {
+                const started = yield channel.startSensor(sensor);
+                if (!started) {
+                    this.logEvent({ message: 'could not start sensor' });
+                    channel.off('data', onData);
+                }
+                return started;
+            }
+            catch (err) {
+                this.logEvent({ message: 'could not start sensor', error: err.message, stack: err.stack });
+                channel.off('data', onData);
+                try {
+                    yield channel.stopSensor(sensor);
+                }
+                catch (_a) { }
+                return false;
+            }
+        });
+    }
+    stopSensor(sensor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isConnected()) {
+                return true;
+            }
+            const channel = sensor.getChannel();
+            if (channel) {
+                try {
+                    if (!channel.flush) {
+                        this.logEvent({ message: 'old version of ant-channel detected' });
+                        channel.flush = () => {
+                            const c = channel;
+                            c.messageQueue.forEach(msg => { msg.resolve(false); });
+                            c.messageQueue = [];
+                            c.isWriting = false;
+                        };
+                    }
+                    channel.flush();
+                    channel.removeAllListeners('data');
+                    const stopped = yield channel.stopSensor(sensor);
+                    return stopped;
+                }
+                catch (err) {
+                    this.logEvent({ message: 'could not stop sensor', error: err.message, deviceID: sensor.getDeviceID(), stack: err.stack });
+                    return false;
+                }
+            }
+            else {
+                this.logEvent({ message: 'could not stop sensor', deviceID: sensor.getDeviceID(), error: 'no channel attached' });
+                return false;
+            }
+        });
+    }
+}
+AntInterface._instance = undefined;
+AntInterface.INTERFACE_NAME = 'ant';
+exports.default = AntInterface;

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

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

package/lib/antv2/factories/adapter-factory.js

@@ -17,6 +17,9 @@ class AntAdapterFactory {
         else
             this.adapters.push(info);
     }
+    _getAll() {
+        return this.adapters;
+    }
     getAdapter(query) {
         const { antProfile, incyclistProfile } = query;
         if (!antProfile && !incyclistProfile)
@@ -24,7 +27,7 @@ class AntAdapterFactory {
         let found;
         if (antProfile)
             found = this.adapters.find(a => a.antProfile === antProfile);
-        if (incyclistProfile)
+        if (!found && incyclistProfile)
             found = this.adapters.find(a => a.incyclistProfile === incyclistProfile);
         return found;
     }
@@ -36,28 +39,33 @@ class AntAdapterFactory {
             try {
                 const incyclistProfile = profile;
                 info = this.getAdapter({ incyclistProfile });
-                isLegacy = true;
+                isLegacy = (info !== undefined && info !== null);
             }
             catch (_a) {
-                isLegacy = false;
+                return;
             }
         }
         if (!isLegacy) {
             const antProfile = profile;
-            info = this.getAdapter({ antProfile });
+            try {
+                info = this.getAdapter({ antProfile });
+            }
+            catch (_b) { }
+        }
+        if (info && info.Adapter) {
+            const { deviceID, interface: ifName } = settings;
+            const { antProfile } = info;
+            return new info.Adapter({ profile: antProfile, interface: ifName, deviceID }, props);
         }
-        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,
+            profile: info.antProfile,
             deviceID: deviceID.toString(),
-            interface: 'ant',
-            protocol: 'Ant'
+            interface: 'ant'
         });
         return new info.Adapter(settings, props);
     }

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

@@ -1,9 +1,8 @@
 import { FitnessEquipmentSensorState, Profile } from "incyclist-ant-plus";
 import AntAdapter from "../base/adapter";
 import { UpdateRequest } from '../../modes/types';
-import { IncyclistBikeData } from "../../types/data";
 import { AntDeviceProperties, AntDeviceSettings, LegacyProfile } from "../types";
-import { ControllerConfig } from "../../types/adapter";
+import { IncyclistBikeData, ControllerConfig } from "../../types";
 interface AntFEStartDeviceProperties extends AntDeviceProperties {
     reconnect?: boolean;
     reconnectTimeout?: number;
@@ -15,22 +14,19 @@ export default class AntFEAdapter extends AntAdapter<FitnessEquipmentSensorState
     protected distanceInternal?: number;
     protected startProps: AntDeviceProperties;
     protected promiseReconnect: Promise<boolean>;
-    protected sensorConnected: boolean;
     constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
     getDisplayName(): string;
-    getDefaultReconnectDelay(): number;
     isReconnecting(): boolean;
     sendUpdate(request: UpdateRequest, forced?: boolean): Promise<void>;
     onDeviceData(deviceData: FitnessEquipmentSensorState): void;
     mapData(deviceData: FitnessEquipmentSensorState): IncyclistBikeData;
     transformData(adapterData: IncyclistBikeData, deviceData: FitnessEquipmentSensorState): void;
-    start(props?: AntFEStartDeviceProperties): Promise<any>;
-    performStart(props: AntFEStartDeviceProperties, isReconnect: boolean): Promise<any>;
-    private waitForInitialData;
-    stopSensor(): Promise<void>;
-    initSensor(status: any, props: any): Promise<boolean>;
-    sendInititalUserMessage(status: any, props: any): Promise<void>;
-    sendInitialRequest(status: any, props: any): Promise<void>;
+    start(props?: AntFEStartDeviceProperties): Promise<boolean>;
+    resetStartStatus(): void;
+    startPreChecks(props: AntFEStartDeviceProperties): Promise<'done' | 'connected' | 'connection-failed'>;
+    initControl(): Promise<void>;
+    sendInititalUserMessage(): Promise<void>;
+    sendInitialRequest(): Promise<void>;
     setFEDefaultTimeout(): void;
     stop(): Promise<boolean>;
     reconnect(): Promise<boolean>;