incyclist-devices 1.5.38 → 2.0.0

package/lib/antv2/adapter.js

@@ -0,0 +1,310 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 });
+exports.ControllableAntAdapter = exports.DEFAULT_UPDATE_FREQUENCY = void 0;
+const ant_interface_1 = __importDefault(require("./ant-interface"));
+const adpater_1 = __importStar(require("../base/adpater"));
+const types_1 = require("./types");
+const utils_1 = require("../utils/utils");
+const capabilities_1 = require("../types/capabilities");
+const adpater_2 = require("../base/adpater");
+const utils_2 = require("./utils");
+exports.DEFAULT_UPDATE_FREQUENCY = 1000;
+const NO_DATA_TIMEOUT = 5000;
+const INTERFACE_NAME = 'ant';
+class AntAdapter extends adpater_1.default {
+    constructor(settings, props) {
+        super(settings, props);
+        this.startupRetryPause = 1000;
+        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.deviceData = {};
+        this.data = {};
+        this.dataMsgCount = 0;
+        this.updateFrequency = exports.DEFAULT_UPDATE_FREQUENCY;
+        this.channel = undefined;
+        this.ant = ant_interface_1.default.getInstance();
+    }
+    createSensor(settings) {
+        throw new Error('Method not implemented.');
+    }
+    isEqual(settings) {
+        const as = this.settings;
+        if (as.interface !== settings.interface)
+            return false;
+        if (as.deviceID !== settings.deviceID || as.profile !== settings.profile)
+            return false;
+        return true;
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connected = yield ant_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.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;
+    }
+    onDeviceData(deviceData) {
+        const { ManId } = this.deviceData;
+        this.deviceData = Object.assign({}, deviceData);
+        if (!ManId && deviceData.ManId) {
+            this.emit('device-info', { device: this.getSettings(), manufacturer: (0, utils_2.getBrand)(deviceData.ManId) });
+        }
+    }
+    waitForData(timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startTs = Date.now();
+            const timeoutTs = startTs + timeout;
+            if (this.hasData())
+                return true;
+            return new Promise((resolve, reject) => {
+                if (this.ivWaitForData)
+                    return reject(new Error('busy'));
+                this.ivWaitForData = setInterval(() => {
+                    const nowTs = Date.now();
+                    const hasData = this.hasData();
+                    if (nowTs > timeoutTs && !hasData) {
+                        clearInterval(this.ivWaitForData);
+                        this.ivWaitForData = undefined;
+                        reject(new Error('No Data Received'));
+                    }
+                    if (hasData) {
+                        clearInterval(this.ivWaitForData);
+                        this.ivWaitForData = undefined;
+                        resolve(true);
+                    }
+                }, 500);
+            });
+        });
+    }
+    getID() {
+        return this.sensor.getDeviceID().toString();
+    }
+    getName() {
+        const deviceID = this.sensor.getDeviceID();
+        const profile = this.sensor.getProfile();
+        return `Ant+${profile} ${deviceID}`;
+    }
+    getInterface() {
+        return INTERFACE_NAME;
+    }
+    getProfile() {
+        const settings = this.settings;
+        if (settings.protocol === undefined)
+            return settings.profile;
+        else {
+            return (0, utils_2.mapLegacyProfile)(settings.profile);
+        }
+    }
+    startDataTimeoutCheck() {
+        if (this.ivDataTimeout)
+            return;
+        this.ivDataTimeout = setInterval(() => {
+            if (!this.lastDataTS)
+                return;
+            if (this.lastDataTS + 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 {
+                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;
+        });
+    }
+    start(props = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.started)
+                return true;
+            const connected = yield this.connect();
+            if (!connected)
+                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;
+                const { startupTimeout = 20000 } = props;
+                let to = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        yield this.stop();
+                    }
+                    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 {
+                    yield this.waitForData(startupTimeout - 100);
+                    yield this.checkCapabilities();
+                    if (this.hasCapability(capabilities_1.IncyclistCapability.Control))
+                        yield this.initControl();
+                    this.started = true;
+                    if (to)
+                        clearTimeout(to);
+                    resolve(true);
+                }
+                catch (err) {
+                }
+            }));
+        });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.stopDataTimeoutCheck();
+            let stopped = yield this.ant.stopSensor(this.sensor);
+            if (!stopped)
+                return false;
+            this.started = false;
+            this.stopped = true;
+            this.removeAllListeners();
+            return true;
+        });
+    }
+}
+exports.default = AntAdapter;
+class ControllableAntAdapter extends AntAdapter {
+    constructor(settings, props) {
+        super(settings, props);
+        this.cyclingMode = this.getDefaultCyclingMode();
+        this.user = {};
+    }
+    isControllable() {
+        return true;
+    }
+    setUser(user) {
+        this.user = user;
+        if (!user.weight)
+            this.user.weight = adpater_2.DEFAULT_USER_WEIGHT;
+    }
+    setBikeProps(props) {
+        const { user, userWeight } = props || {};
+        if (user)
+            this.setUser(user);
+        if (userWeight)
+            this.user.weight = userWeight;
+        const keys = Object.keys(props);
+        keys.forEach(k => {
+            const p = props[k];
+            if (p === null)
+                delete this.props[k];
+            else if (p !== undefined)
+                this.props[k] = p;
+        });
+    }
+    getWeight() {
+        const { user = {}, props = adpater_2.DEFAULT_PROPS } = this;
+        const userWeight = user.weight || props.userWeight || adpater_2.DEFAULT_USER_WEIGHT;
+        const bikeWeight = props.bikeWeight || adpater_1.DEFAULT_BIKE_WEIGHT;
+        return userWeight + bikeWeight;
+    }
+    getSupportedCyclingModes() { throw new Error('not implemented'); }
+    getDefaultCyclingMode() { throw new Error('not implemented'); }
+    setCyclingMode(mode, settings) {
+        let selectedMode;
+        if (typeof mode === 'string') {
+            const supported = this.getSupportedCyclingModes();
+            const CyclingModeClass = supported.find(M => { const m = new M(this); return m.getName() === mode; });
+            if (CyclingModeClass) {
+                this.cyclingMode = new CyclingModeClass(this, settings);
+                return;
+            }
+            selectedMode = this.getDefaultCyclingMode();
+        }
+        else {
+            selectedMode = mode;
+        }
+        this.cyclingMode = selectedMode;
+        this.cyclingMode.setSettings(settings);
+    }
+    getCyclingMode() {
+        if (!this.cyclingMode)
+            this.setCyclingMode(this.getDefaultCyclingMode());
+        return this.cyclingMode;
+    }
+}
+exports.ControllableAntAdapter = ControllableAntAdapter;

package/lib/antv2/ant-interface.d.ts

@@ -2,34 +2,40 @@
 import EventEmitter from "events";
 import { EventLogger } from "gd-eventlog";
 import { IAntDevice, IChannel, ISensor } from "incyclist-ant-plus";
-import AntDeviceBinding from "./ant-binding";
-import { AntScannerProps } from "./incyclist-protocol";
-export declare type AntInterfaceProps = {
-    binding?: typeof AntDeviceBinding;
-    logger?: EventLogger;
+import { InterfaceProps } from "../types/interface";
+import AntDeviceBinding from "./binding";
+import { IncyclistInterface } from "../types/interface";
+import { AntDeviceSettings, AntScanProps } from "./types";
+export interface AntInterfaceProps extends InterfaceProps {
     startupTimeout?: number;
-};
-export default class AntInterface extends EventEmitter {
+}
+export interface ConnectState {
+    connected: boolean;
+    connecting: boolean;
+}
+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 isConnected: boolean;
-    protected isConnecting: boolean;
+    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;
-    connect(): Promise<unknown>;
+    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?: AntScannerProps): Promise<unknown>;
+    scan(props?: AntScanProps): Promise<AntDeviceSettings[]>;
     stopScan(): Promise<boolean>;
     startSensor(sensor: ISensor, onDeviceData: (data: any) => void): Promise<boolean>;
     stopSensor(sensor: ISensor): Promise<boolean>;

package/lib/antv2/ant-interface.js

@@ -16,12 +16,22 @@ const events_1 = __importDefault(require("events"));
 const gd_eventlog_1 = require("gd-eventlog");
 const sensor_factory_1 = __importDefault(require("./sensor-factory"));
 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.isConnected = false;
-        this.isConnecting = false;
+        this.connectState = {
+            connected: false,
+            connecting: false
+        };
         const { binding, logger } = props;
         if (logger)
             this.logger = logger;
@@ -32,13 +42,8 @@ class AntInterface extends events_1.default {
             this.Binding = binding;
         }
     }
-    static getInstance(props = {}) {
-        if (AntInterface._instance === undefined)
-            AntInterface._instance = new AntInterface(props);
-        return AntInterface._instance;
-    }
-    static hasInstance() {
-        return AntInterface._instance !== undefined;
+    getName() {
+        return AntInterface.INTERFACE_NAME;
     }
     getBinding() {
         return this.Binding;
@@ -53,38 +58,42 @@ class AntInterface extends events_1.default {
         if (this.logger)
             this.logger.logEvent(event);
     }
+    isConnected() {
+        return this.connectState.connected;
+    }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.isConnected)
+            if (this.isConnected())
                 return true;
-            if (!this.isConnecting) {
-                this.isConnecting = true;
+            if (!this.connectState.connecting) {
+                this.connectState.connecting = true;
                 this.logEvent({ message: 'ANT+ connecting ...' });
                 try {
                     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' });
-                        this.isConnecting = false;
+                        this.connectState.connecting = false;
                         return false;
                     }
                     this.device = device;
-                    this.isConnected = true;
-                    this.isConnecting = false;
+                    this.connectState.connected = true;
+                    this.connectState.connecting = false;
                     this.logEvent({ message: 'ANT+ connected' });
                     return true;
                 }
                 catch (err) {
-                    this.isConnected = false;
-                    this.isConnecting = false;
+                    this.logEvent({ message: 'error', fn: 'connect', error: err.message, stack: err.stack });
+                    this.connectState.connected = false;
+                    this.connectState.connecting = false;
                     return false;
                 }
             }
             else {
                 return new Promise(resolve => {
                     setInterval(() => {
-                        if (!this.isConnecting)
-                            resolve(this.isConnected);
+                        if (!this.connectState.connecting)
+                            resolve(this.connectState.connected);
                     }, 500);
                 });
             }
@@ -94,10 +103,10 @@ class AntInterface extends events_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.device)
                 return true;
-            this.logEvent({ message: 'disconnecting ...' });
+            this.logEvent({ message: 'ANT+ disconnecting ...' });
             const closed = yield this.device.close();
-            this.isConnected = !closed;
-            this.logEvent({ message: 'disconnected' });
+            this.connectState.connected = !closed;
+            this.logEvent({ message: 'ANT+ disconnected' });
             return closed;
         });
     }
@@ -111,16 +120,11 @@ class AntInterface extends events_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             this.logEvent({ message: 'starting scan ..' });
             const detected = [];
-            if (!this.isConnected) {
-                const connected = yield this.connect();
-                if (!connected)
-                    return [];
-            }
             const onDetected = (profile, deviceID) => {
                 if (deviceID && detected.find(s => s.deviceID === deviceID && s.profile === profile) === undefined) {
                     try {
-                        detected.push({ profile, deviceID });
-                        this.emit('detected', profile, deviceID);
+                        detected.push({ interface: this.getName(), profile, deviceID });
+                        this.emit('device', { interface: 'ant', profile, deviceID });
                     }
                     catch (err) {
                         this.logEvent({ message: 'error', fn: 'onDerected', error: err.message, stack: err.stack });
@@ -129,6 +133,11 @@ class AntInterface extends events_1.default {
             };
             let channel;
             if (!this.activeScan) {
+                while (!this.isConnected()) {
+                    const connected = yield this.connect();
+                    if (!connected)
+                        return [];
+                }
                 channel = this.device.getChannel();
                 channel.setProps({ logger: this.logger });
                 if (!channel)
@@ -201,7 +210,7 @@ class AntInterface extends events_1.default {
     }
     startSensor(sensor, onDeviceData) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.isConnected) {
+            if (!this.isConnected()) {
                 const connected = yield this.connect();
                 if (!connected)
                     return false;
@@ -232,7 +241,7 @@ class AntInterface extends events_1.default {
     }
     stopSensor(sensor) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.isConnected || !this.device)
+            if (!this.isConnected() || !this.device)
                 return true;
             const channel = sensor.getChannel();
             if (channel) {
@@ -267,3 +276,4 @@ class AntInterface extends events_1.default {
 }
 exports.default = AntInterface;
 AntInterface._instance = undefined;
+AntInterface.INTERFACE_NAME = 'ant';

package/lib/antv2/{ant-binding.d.ts → binding.d.ts}

@@ -2,7 +2,7 @@
 import { IAntDevice, IChannel } from 'incyclist-ant-plus';
 import { AntInterfaceProps } from './ant-interface';
 export default class AntDeviceBinding implements IAntDevice {
-    constructor(props: AntInterfaceProps);
+    constructor(_props: AntInterfaceProps);
     open(): Promise<boolean>;
     close(): Promise<boolean>;
     getMaxChannels(): number;

package/lib/antv2/{ant-binding.js → binding.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 class AntDeviceBinding {
-    constructor(props) { }
+    constructor(_props) { }
     open() {
         throw new Error('Method not implemented.');
     }

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

@@ -0,0 +1,28 @@
+import { FitnessEquipmentSensorState, ISensor, Profile } from "incyclist-ant-plus";
+import { ControllableAntAdapter } from "../adapter";
+import CyclingMode, { IncyclistBikeData, UpdateRequest } from '../../modes/cycling-mode';
+import { AntDeviceProperties, AntDeviceSettings, LegacyProfile } from "../types";
+export default class AntFEAdapter extends ControllableAntAdapter {
+    static INCYCLIST_PROFILE_NAME: LegacyProfile;
+    static ANT_PROFILE_NAME: Profile;
+    protected distanceInternal?: number;
+    protected startProps: AntDeviceProperties;
+    protected isReconnecting: boolean;
+    constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
+    createSensor(settings: AntDeviceSettings): ISensor;
+    getName(): string;
+    getUniqueName(): string;
+    getDisplayName(): string;
+    getSupportedCyclingModes(): Array<any>;
+    getDefaultCyclingMode(): CyclingMode;
+    getLogData(data: any, excludeList: any): any;
+    sendUpdate(request: UpdateRequest, forced?: boolean): Promise<void>;
+    onDeviceData(deviceData: FitnessEquipmentSensorState): void;
+    canSendUpdate(): boolean;
+    mapToCycleModeData(deviceData: FitnessEquipmentSensorState): IncyclistBikeData;
+    transformData(bikeData: IncyclistBikeData): any;
+    start(props?: any): Promise<any>;
+    setFEDefaultTimeout(): void;
+    reconnect(): Promise<boolean>;
+    setCyclingMode(mode: string | CyclingMode, settings?: any): void;
+}