incyclist-devices 2.1.11 → 2.1.13

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;
-}

package/lib/antv2/base/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/binding.d.ts

@@ -1,13 +0,0 @@
-/// <reference types="node" />
-import { IAntDevice, IChannel } from 'incyclist-ant-plus';
-import { AntInterfaceProps } from './ant-interface';
-export default class AntDeviceBinding implements IAntDevice {
-    constructor(_props: AntInterfaceProps);
-    open(): Promise<boolean>;
-    close(): Promise<boolean>;
-    getMaxChannels(): number;
-    getChannel(): IChannel;
-    freeChannel(channel: IChannel): void;
-    getDeviceNumber(): number;
-    write(data: Buffer): void;
-}

package/lib/antv2/binding.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class AntDeviceBinding {
-    constructor(_props) { }
-    open() {
-        throw new Error('Method not implemented.');
-    }
-    close() {
-        throw new Error('Method not implemented.');
-    }
-    getMaxChannels() {
-        throw new Error('Method not implemented.');
-    }
-    getChannel() {
-        throw new Error('Method not implemented.');
-    }
-    freeChannel(channel) {
-        throw new Error('Method not implemented.');
-    }
-    getDeviceNumber() {
-        throw new Error('Method not implemented.');
-    }
-    write(data) {
-        throw new Error('Method not implemented.');
-    }
-}
-exports.default = AntDeviceBinding;

package/lib/antv2/hr copy/adapter.d.ts

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

package/lib/antv2/hr copy/adapter.js

@@ -1,30 +0,0 @@
-"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.HeartRate];
-    }
-    getDisplayName() {
-        const { ComputedHeartRate } = this.deviceData;
-        const hrmStr = ComputedHeartRate ? ` (${ComputedHeartRate})` : '';
-        return `${this.getUniqueName()}${hrmStr}`;
-    }
-    mapToAdapterData(deviceData) {
-        if (deviceData.ComputedHeartRate) {
-            this.data.heartrate = deviceData.ComputedHeartRate;
-            this.data.timestamp = Date.now();
-        }
-    }
-    hasData() {
-        return this.deviceData.ComputedHeartRate !== undefined && this.deviceData.ComputedHeartRate !== null;
-    }
-}
-AntHrAdapter.INCYCLIST_PROFILE_NAME = 'Heartrate Monitor';
-AntHrAdapter.ANT_PROFILE_NAME = 'HR';
-exports.default = AntHrAdapter;