incyclist-devices 2.1.31 → 2.1.33

package/lib/antv2/adapter.js

@@ -1,291 +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());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const ant_interface_1 = __importDefault(require("./ant-interface"));
-const adpater_1 = __importDefault(require("../base/adpater"));
-const types_1 = require("./types");
-const types_2 = require("../types");
-const utils_1 = require("../utils/utils");
-const utils_2 = require("./utils");
-const consts_1 = require("./consts");
-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 = consts_1.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 (Number(as.deviceID) !== Number(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;
-    }
-    mapData(deviceData) {
-        throw new Error('message not implemented');
-    }
-    transformData(data) {
-        throw new Error('message not implemented');
-    }
-    mapToAdapterData(deviceData) {
-        throw new Error('message not implemented');
-    }
-    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', { device: this.getSettings(), manufacturer: (0, utils_2.getBrand)(deviceData.ManId) });
-            }
-            if (!this.started || this.isStopped())
-                return;
-            this.triggerTimeoutCheck();
-            if (!this.canEmitData())
-                return;
-            const logData = this.getLogData(deviceData, ['PairedDevices', 'RawData']);
-            this.logEvent({ message: 'onDeviceData', data: logData, paused: this.paused });
-            if (this.isControllable()) {
-                let incyclistData = this.mapData(deviceData);
-                incyclistData = this.getCyclingMode().updateData(incyclistData);
-                this.transformData(incyclistData);
-            }
-            else {
-                this.mapToAdapterData(deviceData);
-            }
-            this.emitData(this.data);
-        }
-        catch (err) {
-            console.log('~~~ERROR', err);
-            this.logEvent({ message: 'error', fn: 'onDeviceData()', error: err.message || err, stack: err.stack });
-        }
-    }
-    isWaitingForData() {
-        return this.ivWaitForData !== undefined && this.ivWaitForData !== null;
-    }
-    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);
-        }
-    }
-    getLogData(data, excludeList) {
-        const logData = JSON.parse(JSON.stringify(data));
-        excludeList.forEach((key) => {
-            delete logData[key];
-        });
-        return logData;
-    }
-    triggerTimeoutCheck() {
-        if (!this.ivDataTimeout && this.dataMsgCount > 0) {
-            this.startDataTimeoutCheck();
-        }
-    }
-    startDataTimeoutCheck() {
-        if (this.ivDataTimeout)
-            return;
-        this.ivDataTimeout = setInterval(() => {
-            if (!this.lastDataTS)
-                return;
-            if (this.lastDataTS + consts_1.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;
-        });
-    }
-    sendUpdate(request) {
-        if (!this.isControllable())
-            return;
-        if (this.isPaused() || this.isStopped())
-            return;
-        if (!this.hasCapability(types_2.IncyclistCapability.Control))
-            this.getCyclingMode().sendBikeUpdate(request);
-        else
-            throw new Error('method not implemented');
-    }
-    start(props = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.started && !this.stopped) {
-                if (this.paused)
-                    this.resume();
-                return true;
-            }
-            this.stopped = false;
-            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;
-                this.resume();
-                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(types_2.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* () {
-            let stopped;
-            try {
-                this.stopDataTimeoutCheck();
-                stopped = yield this.ant.stopSensor(this.sensor);
-            }
-            catch (err) {
-                this.logEvent({ message: 'stop sensor failed', reason: err.message });
-            }
-            this.started = false;
-            this.stopped = true;
-            this.paused = false;
-            this.removeAllListeners();
-            return stopped;
-        });
-    }
-}
-exports.default = AntAdapter;

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

@@ -1,35 +0,0 @@
-/// <reference types="node" />
-import EventEmitter from "events";
-import { EventLogger } from "gd-eventlog";
-import { IAntDevice, IChannel, ISensor } from "incyclist-ant-plus";
-import { AntDeviceSettings, AntScanProps, AntInterfaceProps, ConnectState } from "./types";
-import { IncyclistInterface } from "../types";
-import AntDeviceBinding from "./base/binding";
-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 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;
-    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?: AntScanProps): Promise<AntDeviceSettings[]>;
-    stopScan(): Promise<boolean>;
-    startSensor(sensor: ISensor, onDeviceData: (data: any) => void): Promise<boolean>;
-    stopSensor(sensor: ISensor): Promise<boolean>;
-    isScanning(): boolean;
-}

package/lib/antv2/ant-interface.js

@@ -1,285 +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());
-    });
-};
-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"));
-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.connectState = {
-            connected: false,
-            connecting: false
-        };
-        const { binding, logger } = props;
-        if (logger)
-            this.logger = logger;
-        else {
-            this.logger = new gd_eventlog_1.EventLogger('Ant+');
-        }
-        if (binding) {
-            this.Binding = binding;
-        }
-    }
-    getName() {
-        return AntInterface.INTERFACE_NAME;
-    }
-    getBinding() {
-        return this.Binding;
-    }
-    setBinding(binding) {
-        this.Binding = binding;
-    }
-    setLogger(logger) {
-        this.logger = logger;
-    }
-    logEvent(event) {
-        if (this.logger)
-            this.logger.logEvent(event);
-        const w = global.window;
-        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.ANT_DEBUG) {
-            console.log('~~~ ANT', event);
-        }
-    }
-    isConnected() {
-        return this.connectState.connected;
-    }
-    connect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.isConnected())
-                return 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.connectState.connecting = false;
-                        return false;
-                    }
-                    this.device = device;
-                    this.connectState.connected = true;
-                    this.connectState.connecting = false;
-                    this.logEvent({ message: 'ANT+ connected' });
-                    return true;
-                }
-                catch (err) {
-                    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.connectState.connecting)
-                            resolve(this.connectState.connected);
-                    }, 500);
-                });
-            }
-        });
-    }
-    disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.device)
-                return true;
-            this.logEvent({ message: 'ANT+ disconnecting ...' });
-            const closed = yield this.device.close();
-            this.connectState.connected = !closed;
-            this.logEvent({ message: 'ANT+ disconnected' });
-            return closed;
-        });
-    }
-    onError(profile, error) {
-        this.logEvent({ message: 'ANT+ERROR:', profile, error });
-    }
-    onData(profile, id, data, tag) {
-        this.emit('data', profile, id, data, tag);
-    }
-    scan(props = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'starting scan ..' });
-            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: 'onDerected', error: err.message, stack: err.stack });
-                    }
-                }
-            };
-            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)
-                    return [];
-                const sensors = sensor_factory_1.default.createAll();
-                sensors.forEach((sensor) => {
-                    channel.attach(sensor);
-                });
-                channel.on('detected', onDetected);
-                channel.on('data', this.onData.bind(this));
-                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 });
-                    channel.off('detected', onDetected);
-                    channel.off('data', this.onData.bind(this));
-                    return [];
-                }
-                let iv;
-                return new Promise(resolve => {
-                    this.activeScan = channel;
-                    const start = Date.now();
-                    const timeout = props.timeout ? start + props.timeout : undefined;
-                    iv = setInterval(() => __awaiter(this, void 0, void 0, function* () {
-                        if (this.activeScan && (!timeout || Date.now() < timeout))
-                            return;
-                        clearInterval(iv);
-                        if (this.activeScan)
-                            yield this.stopScan();
-                        this.emit('stop-scan');
-                        channel.off('detected', onDetected);
-                        channel.off('data', this.onData.bind(this));
-                        resolve(detected);
-                    }), 100);
-                });
-            }
-            else {
-                return new Promise(resolve => {
-                    channel = this.activeScan;
-                    channel.on('data', this.onData.bind(this));
-                    channel.on('detected', onDetected);
-                    this.once('stop-scan', () => {
-                        channel.off('detected', onDetected);
-                        channel.off('data', this.onData.bind(this));
-                        resolve(detected);
-                    });
-                });
-            }
-        });
-    }
-    stopScan() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'stopping scan ..' });
-            if (!this.activeScan)
-                return false;
-            const channel = this.activeScan;
-            try {
-                const stopped = yield channel.stopScanner();
-                this.activeScan = undefined;
-                this.logEvent({ message: 'scan stopped' });
-                return stopped;
-            }
-            catch (err) {
-                this.logEvent({ message: 'error', fn: 'stopScan()', error: err.message, stack: err.stack });
-                return false;
-            }
-        });
-    }
-    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();
-            channel.setProps({ logger: this.logger });
-            if (!channel)
-                return false;
-            channel.on('data', this.onData.bind(this));
-            sensor.setChannel(channel);
-            this.on('data', (profile, deviceID, data) => {
-                if (profile === sensor.getProfile() && deviceID === sensor.getDeviceID())
-                    onDeviceData(data);
-            });
-            try {
-                return yield channel.startSensor(sensor);
-            }
-            catch (err) {
-                this.logEvent({ message: 'could not start sensor', error: err.message || err, stack: err.stack });
-                try {
-                    yield channel.stopSensor(sensor);
-                }
-                catch (_a) { }
-                return false;
-            }
-        });
-    }
-    stopSensor(sensor) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.isConnected() || !this.device) {
-                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 || err, 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;
-            }
-        });
-    }
-    isScanning() {
-        return (this.activeScan === undefined || this.activeScan === null);
-    }
-}
-AntInterface._instance = undefined;
-AntInterface.INTERFACE_NAME = 'ant';
-exports.default = AntInterface;

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

@@ -1,35 +0,0 @@
-/// <reference types="node" />
-import EventEmitter from "events";
-import { EventLogger } from "gd-eventlog";
-import { IAntDevice, IChannel, ISensor } from "incyclist-ant-plus";
-import { AntDeviceSettings, AntScanProps, AntInterfaceProps, ConnectState } from "../types";
-import { IncyclistInterface } from "../../types";
-import AntDeviceBinding from "./binding";
-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 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;
-    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?: AntScanProps): Promise<AntDeviceSettings[]>;
-    stopScan(): Promise<boolean>;
-    startSensor(sensor: ISensor, onDeviceData: (data: any) => void): Promise<boolean>;
-    stopSensor(sensor: ISensor): Promise<boolean>;
-    isScanning(): boolean;
-}