incyclist-devices 2.1.0 → 2.1.2

package/lib/antv2/base/interface.js

@@ -0,0 +1,337 @@
+"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() {
+        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);
+            this.activeScan.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 _scan = () => new Promise((done) => __awaiter(this, void 0, void 0, function* () {
+                const detected = [];
+                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();
+                    this.emit('stop-scan');
+                    removeListeners(channel);
+                    done(detected);
+                }));
+            }));
+            const { timeout } = props;
+            this.scanPromise = _scan();
+            if (timeout) {
+                const res = yield (0, utils_1.waitWithTimeout)(this.scanPromise, timeout, () => {
+                    var _a;
+                    (_a = this.activeScan) === null || _a === void 0 ? void 0 : _a.emitter.emit('timeout');
+                });
+                return res || [];
+            }
+            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) => {
+                    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/cad/adapter.d.ts

@@ -0,0 +1,10 @@
+import { CadenceSensorState, Profile } from "incyclist-ant-plus";
+import AntAdapter from "../base/adapter";
+import { AntDeviceProperties, AntDeviceSettings, LegacyProfile } from "../types";
+export default class AntHrAdapter extends AntAdapter<CadenceSensorState> {
+    protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
+    protected static ANT_PROFILE_NAME: Profile;
+    constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
+    mapToAdapterData(deviceData: CadenceSensorState): void;
+    hasData(): boolean;
+}

package/lib/antv2/cad/adapter.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const adapter_1 = __importDefault(require("../base/adapter"));
+const types_1 = require("../../types");
+class AntHrAdapter extends adapter_1.default {
+    constructor(settings, props) {
+        super(settings, props);
+        this.capabilities = [types_1.IncyclistCapability.Cadence];
+    }
+    mapToAdapterData(deviceData) {
+        if (deviceData.CalculatedCadence) {
+            this.data.cadence = deviceData.CalculatedCadence;
+            this.data.timestamp = Date.now();
+        }
+    }
+    hasData() {
+        return this.deviceData.CalculatedCadence !== undefined && this.deviceData.CalculatedCadence !== null;
+    }
+}
+AntHrAdapter.INCYCLIST_PROFILE_NAME = 'Cadence Sensor';
+AntHrAdapter.ANT_PROFILE_NAME = 'CAD';
+exports.default = AntHrAdapter;

package/lib/antv2/cad/index.d.ts

@@ -0,0 +1,2 @@
+import AntHrAdapter from './adapter';
+export default AntHrAdapter;

package/lib/antv2/cad/index.js

@@ -0,0 +1,7 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const adapter_1 = __importDefault(require("./adapter"));
+exports.default = adapter_1.default;

package/lib/antv2/consts.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_UPDATE_FREQUENCY = 1000;
+export declare const NO_DATA_TIMEOUT = 5000;

package/lib/antv2/consts.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NO_DATA_TIMEOUT = exports.DEFAULT_UPDATE_FREQUENCY = void 0;
+exports.DEFAULT_UPDATE_FREQUENCY = 1000;
+exports.NO_DATA_TIMEOUT = 5000;

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

@@ -0,0 +1,14 @@
+import { Profile } from "incyclist-ant-plus";
+import AntAdapter from "../base/adapter";
+import { AntDeviceProperties, AntDeviceSettings, LegacyProfile, BaseDeviceData, AntAdapterInfo, AdapterQuery } from "../types";
+export default class AntAdapterFactory {
+    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

@@ -0,0 +1,73 @@
+"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);
+    }
+    _getAll() {
+        return this.adapters;
+    }
+    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 (!found && 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 = (info !== undefined && info !== null);
+            }
+            catch (_a) {
+                return;
+            }
+        }
+        if (!isLegacy) {
+            const antProfile = profile;
+            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);
+        }
+    }
+    createFromDetected(profile, deviceID, props) {
+        const info = this.getAdapter({ antProfile: profile });
+        if (!info || !info.Adapter)
+            return;
+        const settings = Object.assign({}, {
+            profile: info.antProfile,
+            deviceID: deviceID.toString(),
+            interface: 'ant'
+        });
+        return new info.Adapter(settings, props);
+    }
+}
+exports.default = AntAdapterFactory;

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

@@ -0,0 +1,5 @@
+import { ISensor, Profile } from "incyclist-ant-plus";
+export default class SensorFactory {
+    static create(profile: Profile, deviceID?: number): ISensor;
+    static createAll(): ISensor[];
+}

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const incyclist_ant_plus_1 = require("incyclist-ant-plus");
+const incyclist_ant_plus_2 = require("incyclist-ant-plus");
+const profiles = [
+    { profile: 'PWR', Class: incyclist_ant_plus_2.BicyclePowerSensor },
+    { profile: 'HR', Class: incyclist_ant_plus_2.HeartRateSensor },
+    { profile: 'FE', Class: incyclist_ant_plus_2.FitnessEquipmentSensor },
+    { profile: 'CAD', Class: incyclist_ant_plus_1.CadenceSensor },
+];
+class SensorFactory {
+    static create(profile, deviceID) {
+        const info = profiles.find(i => i.profile === profile);
+        if (!info)
+            return;
+        return new info.Class(deviceID);
+    }
+    static createAll() {
+        return profiles.map(info => new info.Class());
+    }
+}
+exports.default = SensorFactory;

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

@@ -1,41 +1,32 @@
-import { FitnessEquipmentSensorState, ISensor, Profile } from "incyclist-ant-plus";
-import AntAdapter from "../adapter";
-import ICyclingMode, { CyclingMode, IncyclistBikeData, UpdateRequest } from '../../modes/types';
+import { FitnessEquipmentSensorState, Profile } from "incyclist-ant-plus";
+import AntAdapter from "../base/adapter";
+import { UpdateRequest } from '../../modes/types';
 import { AntDeviceProperties, AntDeviceSettings, LegacyProfile } from "../types";
-import { ControllableDevice } from "../../base/adpater";
-type FitnessEquipmentSensorData = {
-    speed: number;
-    slope: number;
-    power: number;
-    cadence: number;
-    heartrate: number;
-    distance: number;
-    timestamp: number;
-};
-export declare class AntFeControl extends ControllableDevice<AntDeviceProperties> {
-    getSupportedCyclingModes(): Array<typeof CyclingMode>;
-    getDefaultCyclingMode(): ICyclingMode;
-    sendInitCommands(): Promise<boolean>;
+import { IncyclistBikeData, ControllerConfig } from "../../types";
+interface AntFEStartDeviceProperties extends AntDeviceProperties {
+    reconnect?: boolean;
+    reconnectTimeout?: number;
 }
-export default class AntFEAdapter extends AntAdapter<AntFeControl, FitnessEquipmentSensorState, FitnessEquipmentSensorData> {
-    static INCYCLIST_PROFILE_NAME: LegacyProfile;
-    static ANT_PROFILE_NAME: Profile;
+export default class AntFEAdapter extends AntAdapter<FitnessEquipmentSensorState> {
+    protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
+    protected static ANT_PROFILE_NAME: Profile;
+    protected static controllers: ControllerConfig;
     protected distanceInternal?: number;
     protected startProps: AntDeviceProperties;
-    protected isReconnecting: boolean;
-    protected sensorConnected: boolean;
+    protected promiseReconnect: Promise<boolean>;
     constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
-    createSensor(settings: AntDeviceSettings): ISensor;
-    getName(): string;
-    getUniqueName(): string;
     getDisplayName(): string;
-    getLogData(data: any, excludeList: any): any;
+    isReconnecting(): boolean;
     sendUpdate(request: UpdateRequest, forced?: boolean): Promise<void>;
     onDeviceData(deviceData: FitnessEquipmentSensorState): void;
-    canSendUpdate(): boolean;
-    mapToCycleModeData(deviceData: FitnessEquipmentSensorState): IncyclistBikeData;
-    transformData(bikeData: IncyclistBikeData): FitnessEquipmentSensorData;
-    start(props?: any): Promise<any>;
+    mapData(deviceData: FitnessEquipmentSensorState): IncyclistBikeData;
+    transformData(adapterData: IncyclistBikeData, deviceData: FitnessEquipmentSensorState): 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>;