incyclist-devices 1.3.0 → 1.4.1

package/lib/ant/antfe/AntFEProcessor.js

@@ -1,238 +0,0 @@
-"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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const processor_1 = require("../../processor");
-function floatVal(d) {
-    if (d === undefined)
-        return d;
-    return parseFloat(d);
-}
-function intVal(d) {
-    if (d === undefined)
-        return d;
-    return parseInt(d);
-}
-class AntFEProcessor extends processor_1.default {
-    constructor(controller, bikeInfo) {
-        super(controller, AntFEProcessor.NAME);
-        this.bikeInfo = bikeInfo;
-        this.ignoreHrm = false;
-        this.instance = undefined;
-        this.paused = undefined;
-        this.started = undefined;
-        this.time = undefined;
-        this.iv = undefined;
-        this.state = AntFEProcessor.STATE.INITIALIZED;
-        this.logger.set({ processor: AntFEProcessor.NAME, state: this.state });
-        this.data = {};
-        this.request = undefined;
-    }
-    setState(newState) {
-        this.state = newState;
-        this.logger.set({ bikeState: this.state });
-    }
-    static isBike() {
-        return true;
-    }
-    static isHrm() {
-        return true;
-    }
-    toggle() {
-    }
-    pause() {
-        this.paused = true;
-    }
-    setIgnoreHrm(ignore) {
-        this.ignoreHrm = ignore;
-    }
-    checkBikeStatus() {
-        this.logger.log('checkBikeStatus request');
-        return new Promise((resolve, reject) => {
-            try {
-                this.instance.checkBikeStatus((status, data) => {
-                    if (status !== 200)
-                        return reject(status);
-                    this.logger.logEvent({ message: 'checkBikeStatus request', status: 'OK' });
-                    resolve(data);
-                });
-            }
-            catch (error) {
-                this.logger.logEvent({ message: 'checkBikeStatus request', status: 'Error', error });
-                reject(error);
-            }
-        });
-    }
-    startTraining() {
-        this.logger.logEvent({ message: 'startTraining request' });
-        return new Promise((resolve, reject) => {
-            try {
-                this.instance.startTraining((status, data) => {
-                    if (status !== 200)
-                        return reject(status);
-                    this.logger.logEvent({ message: 'startTraining request', status: 'started' });
-                    resolve(data);
-                });
-            }
-            catch (error) {
-                this.logger.logEvent({ message: 'startTraining request', status: 'Error', error });
-                reject(error);
-            }
-        });
-    }
-    getBikeData() {
-        this.logger.logEvent({ message: 'bike data request' });
-        return new Promise((resolve, reject) => {
-            try {
-                this.instance.getBikeData((status, data) => {
-                    if (status !== 200)
-                        return reject(status);
-                    this.logger.logEvent({ message: 'bike data response', data });
-                    resolve(data);
-                });
-            }
-            catch (error) {
-                this.logger.logEvent({ message: 'bike data error', error });
-                reject(error);
-            }
-        });
-    }
-    sendBikeUpdate(request) {
-        this.logger.logEvent({ message: 'bike update request', request });
-        return new Promise((resolve, reject) => {
-            try {
-                this.instance.sendBikeUpdate(request, (status, data) => {
-                    if (status !== 200)
-                        return reject(status);
-                    this.logger.logEvent({ message: 'bike update success', data });
-                    resolve(data);
-                });
-            }
-            catch (error) {
-                this.logger.logEvent({ message: 'bike update error', error });
-                reject(error);
-            }
-        });
-    }
-    onStarted() {
-        this.controller.start();
-        this.time = Date.now();
-        if (this.iv !== undefined) {
-            clearInterval(this.iv);
-            this.iv = undefined;
-        }
-        this.data = {};
-        this.data.distanceInternal = undefined;
-        this.iv = setInterval(this.update.bind(this), 1000);
-        this.setState(AntFEProcessor.STATE.START_OK);
-        this.logger.logEvent({ message: 'start request completed' });
-        this.controller.emit({ component: 'BikeProcessor', event: { started: { success: true } } });
-    }
-    start(user) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'start request' });
-            if (this.state !== AntFEProcessor.STATE.INITIALIZED && this.state !== AntFEProcessor.STATE.FINISH_OK)
-                return;
-            this.setState(AntFEProcessor.STATE.STARTING);
-            if (this.bikeInfo.instantiate !== undefined) {
-                let options = {
-                    settings: {
-                        simulate: false,
-                        ignoreHrm: this.ignoreHrm,
-                        user
-                    }
-                };
-                this.instance = this.bikeInfo.instantiate(this.bikeInfo, { options });
-                try {
-                    yield this.checkBikeStatus();
-                    yield this.startTraining();
-                    this.onStarted();
-                }
-                catch (error) {
-                    this.setState(AntFEProcessor.STATE.START_FAILED);
-                    this.logger.logEvent({ message: 'start request failed', error });
-                    this.controller.emit({ component: 'BikeProcessor', event: { started: { success: false } } });
-                }
-            }
-        });
-    }
-    stop() {
-        this.logger.logEvent({ message: 'stop request' });
-        this.setState(AntFEProcessor.STATE.FINISHING);
-        try {
-            if (this.instance !== undefined)
-                this.instance.disconnect();
-            clearInterval(this.iv);
-            this.iv = undefined;
-            this.setState(AntFEProcessor.STATE.FINISH_OK);
-            this.logger.logEvent({ message: 'stop request completed' });
-        }
-        catch (error) {
-            this.setState(AntFEProcessor.STATE.FINISH_FAILED);
-            this.logger.logEvent({ message: 'stop error', error });
-        }
-        this.paused = undefined;
-        this.started = false;
-    }
-    update() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.request !== undefined) {
-                yield this.sendBikeUpdate(this.request);
-                this.request = undefined;
-            }
-            let bikeData = yield this.getBikeData();
-            let distance = bikeData.distanceInternal;
-            if (this.data.distanceInternal !== undefined && this.data.distanceInternal > 0) {
-                distance = bikeData.distanceInternal - this.data.distanceInternal;
-            }
-            this.data.distanceInternal = bikeData.distanceInternal;
-            let data = {
-                speed: floatVal(bikeData.speed),
-                slope: floatVal(bikeData.slope),
-                power: intVal(bikeData.power),
-                cadence: intVal(bikeData.pedalRpm),
-                heartrate: intVal(bikeData.heartrate),
-                distance,
-                timestamp: Date.now()
-            };
-            if (this.ignoreHrm)
-                delete data.heartrate;
-            this.controller.update(data);
-        });
-    }
-    sendUpdate(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'update request', data });
-            this.request = data;
-        });
-    }
-    onEvent(event) {
-        if (event === 'start')
-            return this.start();
-        if (event === 'stop')
-            return this.stop();
-        if (event === 'pause')
-            return this.pause();
-        if (event === 'toggle')
-            return this.toggle();
-    }
-}
-exports.default = AntFEProcessor;
-AntFEProcessor.NAME = 'Ant+FE';
-AntFEProcessor.STATE = {
-    INITIALIZED: 'initialized',
-    STARTING: 'starting',
-    START_OK: 'start:ok',
-    START_FAILED: 'start:failed',
-    ERROR: 'error',
-    FINISHING: 'finishing',
-    FINISH_OK: 'finish:ok',
-    FINISH_FAILED: 'finish:failed',
-};

package/lib/ant/antfe/AntHrmProtocol.d.ts

@@ -1,9 +0,0 @@
-export default class AntFEProtocol {
-    logger: EventLogger;
-    getLogger(): EventLogger;
-    getName(): string;
-    isBike(): boolean;
-    isHrm(): boolean;
-    isPower(): boolean;
-}
-import { EventLogger } from "gd-eventlog";

package/lib/ant/antfe/AntHrmProtocol.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const AntProtocol_1 = require("../AntProtocol");
-const DeviceRegistry_1 = require("../../DeviceRegistry");
-const gd_eventlog_1 = require("gd-eventlog");
-const PROTOCOL_NAME = "Smart Trainer";
-const LOGGER_NAME = "Ant+FE";
-class AntFEProtocol extends AntProtocol_1.default {
-    constructor() {
-        super();
-        this.logger = new gd_eventlog_1.EventLogger(LOGGER_NAME);
-    }
-    getLogger() {
-        return this.logger;
-    }
-    getName() {
-        return PROTOCOL_NAME;
-    }
-    isBike() {
-        return true;
-    }
-    isHrm() {
-        return true;
-    }
-    isPower() {
-        return true;
-    }
-}
-exports.default = AntFEProtocol;
-DeviceRegistry_1.default.register(new AntFEProtocol());

package/lib/ant/antfe/FEDevice.d.ts

@@ -1 +0,0 @@
-declare function initDevice(Ant: any): void;

package/lib/ant/antfe/FEDevice.js

@@ -1,7 +0,0 @@
-function initDevice(Ant) {
-    class FEDevice extends Ant.FitnessEquipmentSensor {
-        constructor() {
-            super();
-        }
-    }
-}

package/lib/ant/antfe/bike.d.ts

@@ -1,47 +0,0 @@
-export function sendBasicResistance(stick: any, resistance: any): void;
-export function sendWindResistance(stick: any, windCoeff: any, windSpeed: any, draftFactor: any): void;
-export default class AntFEBike {
-    static setAnt(antClass: any): void;
-    static getClassName(): string;
-    static log(str: any, ...args: any[]): void;
-    static logEvent(event: any): void;
-    static stopScanning(callback: any): void;
-    static getStick(): any;
-    constructor(opts: any);
-    logger: import("gd-eventlog").EventLogger;
-    stick: any;
-    connection: any;
-    scanner: any;
-    sensor: any;
-    connected: boolean;
-    started: boolean;
-    channel: number;
-    pairedDeviceId: any;
-    initDone: boolean;
-    scanMode: boolean;
-    deviceID: any;
-    isScanning: boolean;
-    isAttached: boolean;
-    scanners: any[];
-    sensors: any[];
-    getType(): string;
-    addScanner(scanner: any): void;
-    addSensor(sensor: any): void;
-    setUser(user: any, callback: any): void;
-    checkBikeStatus(callback: any): void;
-    recheckStatus(tsStart: any, timeout: any, bike: any, cb: any): any;
-    getBikeData(callback: any): void;
-    sendBikeUpdate(data: any, callback: any): void;
-    setSlope(slope: any): void;
-    setPower(power: any): void;
-    initSensor(): boolean;
-    attachScanners(): void;
-    attachSensors(): void;
-    startTraining(callback: any, timeout: any): void;
-    stopTraining(callback: any, timeout: any): void;
-    resync(callback: any): void;
-    parseEvent(data: any): void;
-    parseData(data: any): void;
-    antData: any;
-    data: any;
-}