incyclist-devices 1.4.102 → 1.5.1

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

@@ -0,0 +1,51 @@
+import { Device } from '../protocol';
+import { IChannel, ISensor } from 'incyclist-ant-plus';
+import AntProtocol from './incyclist-protocol';
+import AntInterface from './ant-interface';
+import IncyclistDevice, { DeviceAdapter, OnDeviceDataCallback } from '../device';
+export declare const DEFAULT_UPDATE_FREQUENCY = 1000;
+export default class AntAdapter extends IncyclistDevice implements Device {
+    sensor: ISensor;
+    protocol: AntProtocol;
+    ignoreHrm: boolean;
+    ignoreBike: boolean;
+    ignorePower: boolean;
+    lastUpdate?: number;
+    data: any;
+    deviceData: any;
+    updateFrequency: number;
+    channel: IChannel;
+    ant: AntInterface;
+    stopped: boolean;
+    paused: boolean;
+    userSettings: {
+        weight?: number;
+    };
+    bikeSettings: {
+        weight?: number;
+    };
+    detected: boolean;
+    selected: boolean;
+    settings: any;
+    onDataFn: OnDeviceDataCallback;
+    constructor(sensor: ISensor, protocol: AntProtocol, settings?: any);
+    isBike(): boolean;
+    isPower(): boolean;
+    isHrm(): boolean;
+    getDisplayName(): string;
+    isSame(device: DeviceAdapter): boolean;
+    getID(): string;
+    getName(): string;
+    getProfile(): string;
+    getPort(): string;
+    getProtocol(): AntProtocol;
+    getProtocolName(): string;
+    setIgnoreHrm(ignore: any): void;
+    setIgnoreBike(ignore: any): void;
+    setIgnorePower(ignore: any): void;
+    pause(): Promise<boolean>;
+    resume(): Promise<boolean>;
+    start(props?: any): Promise<any>;
+    stop(): Promise<boolean>;
+    isStopped(): boolean;
+}

package/lib/antv2/ant-device.js

@@ -0,0 +1,115 @@
+"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 });
+exports.DEFAULT_UPDATE_FREQUENCY = void 0;
+const incyclist_protocol_1 = require("./incyclist-protocol");
+const ant_interface_1 = __importDefault(require("./ant-interface"));
+const device_1 = __importDefault(require("../device"));
+exports.DEFAULT_UPDATE_FREQUENCY = 1000;
+class AntAdapter extends device_1.default {
+    constructor(sensor, protocol, settings) {
+        super(protocol, settings);
+        this.sensor = sensor;
+        this.protocol = protocol;
+        this.ignoreHrm = false;
+        this.ignoreBike = false;
+        this.ignorePower = false;
+        this.deviceData = {};
+        this.data = {};
+        this.updateFrequency = exports.DEFAULT_UPDATE_FREQUENCY;
+        this.channel = undefined;
+        this.paused = false;
+        this.stopped = false;
+        this.ant = ant_interface_1.default.getInstance();
+    }
+    isBike() {
+        throw new Error('Method not implemented.');
+    }
+    isPower() {
+        throw new Error('Method not implemented.');
+    }
+    isHrm() {
+        throw new Error('Method not implemented.');
+    }
+    getDisplayName() {
+        throw new Error('Method not implemented.');
+    }
+    isSame(device) {
+        if (!(device instanceof AntAdapter))
+            return false;
+        const adapter = device;
+        return (adapter.getID() === this.getID() && adapter.getProfile() === this.getProfile());
+    }
+    getID() {
+        return this.sensor.getDeviceID().toString();
+    }
+    getName() {
+        const deviceID = this.sensor.getDeviceID();
+        const profile = this.sensor.getProfile();
+        return `Ant+${profile} ${deviceID}`;
+    }
+    getProfile() {
+        return (0, incyclist_protocol_1.mapAntProfile)(this.sensor.getProfile());
+    }
+    getPort() {
+        return this.sensor.getChannel().getChannelNo().toString();
+    }
+    getProtocol() {
+        return this.protocol;
+    }
+    getProtocolName() {
+        return this.protocol.getName();
+    }
+    setIgnoreHrm(ignore) {
+        this.ignoreHrm = ignore;
+    }
+    setIgnoreBike(ignore) {
+        this.ignoreBike = ignore;
+    }
+    setIgnorePower(ignore) {
+        this.ignorePower = ignore;
+    }
+    pause() {
+        return new Promise(resolve => {
+            this.paused = true;
+            resolve(true);
+        });
+    }
+    resume() {
+        return new Promise(resolve => {
+            this.paused = false;
+            resolve(true);
+        });
+    }
+    start(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (props && props.user)
+                this.userSettings = props.user;
+            if (props && props.bikeSettings)
+                this.bikeSettings = props.bikeSettings;
+            this.stopped = false;
+            return true;
+        });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.stopped = true;
+            return true;
+        });
+    }
+    isStopped() {
+        return this.stopped;
+    }
+}
+exports.default = AntAdapter;

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

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+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;
+    startupTimeout?: number;
+};
+export default class AntInterface extends EventEmitter {
+    static _instance: AntInterface;
+    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 props: AntInterfaceProps;
+    protected activeScan: IChannel;
+    constructor(props: AntInterfaceProps);
+    getBinding(): typeof AntDeviceBinding;
+    setBinding(binding: typeof AntDeviceBinding): void;
+    setLogger(logger: EventLogger): void;
+    logEvent(event: any): void;
+    connect(): Promise<unknown>;
+    disconnect(): Promise<boolean>;
+    onError(profile: any, error: any): void;
+    onData(profile: any, id: any, data: any, tag: any): void;
+    scan(props?: AntScannerProps): Promise<unknown>;
+    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

@@ -0,0 +1,239 @@
+"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("./sensor-factory"));
+class AntInterface extends events_1.default {
+    constructor(props) {
+        super();
+        this.props = props;
+        this.device = undefined;
+        this.isConnected = false;
+        this.isConnecting = false;
+        const { binding, logger } = props;
+        if (logger)
+            this.logger = logger;
+        else {
+            this.logger = new gd_eventlog_1.EventLogger('Ant+');
+        }
+        if (binding) {
+            this.Binding = binding;
+        }
+    }
+    static getInstance(props = {}) {
+        if (AntInterface._instance === undefined)
+            AntInterface._instance = new AntInterface(props);
+        return AntInterface._instance;
+    }
+    static hasInstance() {
+        return AntInterface._instance !== undefined;
+    }
+    getBinding() {
+        return this.Binding;
+    }
+    setBinding(binding) {
+        this.Binding = binding;
+    }
+    setLogger(logger) {
+        this.logger = logger;
+    }
+    logEvent(event) {
+        if (this.logger)
+            this.logger.logEvent(event);
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isConnected)
+                return true;
+            if (!this.isConnecting) {
+                this.isConnecting = 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: 'could not connect' });
+                        this.isConnecting = false;
+                        return false;
+                    }
+                    this.device = device;
+                    this.isConnected = true;
+                    this.isConnecting = false;
+                    this.logEvent({ message: 'ANT+ connected' });
+                    return true;
+                }
+                catch (err) {
+                    this.isConnected = false;
+                    this.isConnecting = false;
+                    return false;
+                }
+            }
+            else {
+                return new Promise(resolve => {
+                    setInterval(() => {
+                        if (!this.isConnecting)
+                            resolve(this.isConnected);
+                    }, 500);
+                });
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.device)
+                return true;
+            this.logEvent({ message: 'disconnecting ...' });
+            const closed = yield this.device.close();
+            this.isConnected = !closed;
+            this.logEvent({ message: '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 = [];
+            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);
+                    }
+                    catch (err) {
+                        this.logEvent({ message: 'error', fn: 'onDerected', error: err.message, stack: err.stack });
+                    }
+                }
+            };
+            let channel;
+            if (!this.activeScan) {
+                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));
+                const success = yield channel.startScanner();
+                this.logEvent({ message: 'scan started', success });
+                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) {
+                console.log('ERROR', err);
+                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) {
+                try {
+                    yield channel.stopSensor(sensor);
+                }
+                catch (_a) { }
+                throw err;
+            }
+        });
+    }
+    stopSensor(sensor) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isConnected || !this.device)
+                return true;
+            const channel = sensor.getChannel();
+            this.removeAllListeners('data');
+            if (channel)
+                return yield channel.stopSensor(sensor);
+        });
+    }
+    isScanning() {
+        return (this.activeScan === undefined || this.activeScan === null);
+    }
+}
+exports.default = AntInterface;
+AntInterface._instance = undefined;

package/lib/antv2/fe.d.ts

@@ -0,0 +1,29 @@
+import { ISensor } from "incyclist-ant-plus";
+import AntAdapter from "./ant-device";
+import AntProtocol from "./incyclist-protocol";
+import { EventLogger } from "gd-eventlog";
+import CyclingMode, { IncyclistBikeData } from '../cycling-mode';
+export default class AntFEAdapter extends AntAdapter {
+    protected started: boolean;
+    protected logger: EventLogger;
+    protected cyclingMode: CyclingMode;
+    protected distanceInternal?: number;
+    protected msgCount: number;
+    constructor(sensor: ISensor, protocol: AntProtocol);
+    isBike(): boolean;
+    isHrm(): boolean;
+    isPower(): boolean;
+    getName(): string;
+    getDisplayName(): string;
+    getSupportedCyclingModes(): Array<any>;
+    setCyclingMode(mode: string | CyclingMode, settings?: any): void;
+    getCyclingMode(): CyclingMode;
+    getDefaultCyclingMode(): CyclingMode;
+    getLogData(data: any, excludeList: any): any;
+    sendUpdate(request: any): Promise<void>;
+    onDeviceData(deviceData: any): void;
+    mapData(deviceData: any): IncyclistBikeData;
+    transformData(bikeData: any): any;
+    start(props?: any): Promise<any>;
+    stop(): Promise<boolean>;
+}