incyclist-devices 1.5.38 → 2.0.0-beta.1

package/lib/antv2/utils.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBrand = void 0;
+const brands = [
+    'Garmin,1',
+    'garmin_fr405_antfs,2',
+    'Zephyr,3',
+    'Dayton,4',
+    'idt,5',
+    'SRM,6',
+    'Quarq,7',
+    'ibike,8',
+    'Saris,9',
+    'spark_hk,10',
+    'Tanita,11',
+    'echowell,12',
+    'Dynastream_oem,13',
+    'Nautilus,14',
+    'Dynastream,15',
+    'Timex,16',
+    'Metrigear,17',
+    'Xelic,18',
+    'Beurer,19',
+    'Cardiosport,20',
+    'A&D,21',
+    'Hmm,22',
+    'Suunto,23',
+    'Thita Elektronik,24',
+    'Gpulse,25',
+    'Clean Mobile,26',
+    'Pedal Brain,27',
+    'Peaksware,28',
+    'Saxonar,29',
+    'Lemond Fitness,30',
+    'Dexcom,31',
+    'Wahoo,32',
+    'Octane,33',
+    'Archinoetics,34',
+    'The Hurt Box,35',
+    'Citizen Systems,36',
+    'Magellan,37',
+    'Osynce,38',
+    'Holux,39',
+    'Concept2,40',
+    'One Giant Leap,42',
+    'Ace Sensor,43',
+    'Brim Brothers,44',
+    'Xplova,45',
+    'Perception Digital,46',
+    'Bf1systems,47',
+    'Pioneer,48',
+    'Spantec,49',
+    'Metalogics,50',
+    '4iiiis,51',
+    'Seiko,52',
+    'Seiko,53',
+    'Ifor Powell,54',
+    'Maxwell Guider,55',
+    'Star rac,56',
+    'Breakaway,57',
+    'Alatech,58',
+    'Mio,59',
+    'Rotor,60',
+    'Geonaute,61',
+    'Id Bike,62',
+    'Specialized,63',
+    'Wtek,64',
+    'Physical Enterprises,65',
+    'North Pole,66',
+    'Bkool,67',
+    'Cateye,68',
+    'Stages,69',
+    'Sigma,70',
+    'Tomtom,71',
+    'Peripedal,72',
+    'Wattbike,73',
+    'Moxy,76',
+    'Ciclosport,77',
+    'Powerbahn,78',
+    'Acorn,79',
+    'Lifebeam,80',
+    'Bontrager,81',
+    'Wellgo,82',
+    'Scosche,83',
+    'Magura,84',
+    'Woodway,85',
+    'Elite,86',
+    'Nielsen Kellerman,87',
+    'DK City,88',
+    'Tacx,89',
+    'Direction,90',
+    'Magtonic,91',
+    '1partcarbon,92',
+    'Inside Ride,93',
+    'Sound Of Motion,94',
+    'Stryd,95',
+    'icg,96',
+    'MiPulse,97',
+    'Bsx Athletics,98',
+    'Look,99',
+    'Campagnolo,100',
+    'Body Bike Smart,101',
+    'Praxisworks,102',
+    'Limits,103',
+    'Topaction,104',
+    'Cosinuss,105',
+    'Fitcare,106',
+    'Magene,107',
+    'Giant,108',
+    'Tigrasport,109',
+    'Salutron,110',
+    'Technogym,111',
+    'Bryton,112',
+    'Latitude,113',
+    'Soaring,114',
+    'Igpsport,115',
+    'Thinkrider,116',
+    'Gopher,117',
+    'Waterrower,118',
+    'Orangetheory,119',
+    'Inpeak,120',
+    'Kinetic,121',
+    'Johnson,122',
+    'Polar,123',
+    'Seesense,124',
+    'NCI,125',
+    'Development,255',
+    'Healthandlife,257',
+    'Lezyne,258',
+    'Scribe,259',
+    'Zwift,260',
+    'Watteam,261',
+    'Recon,262',
+    'Favero,263',
+    'Dynovelo,264',
+    'Strava,265',
+    'Precor,266',
+    'Bryton,267',
+    'Sram,268',
+    'Navman,269',
+    'Cobi,270',
+    'Spivi,271',
+    'Mio Magellan,272',
+    'Evesports,273',
+    'Sensitivus Gauge,274',
+    'Podoon,275',
+    'Life Time Fitness,276',
+    'Falco,277',
+    'Minoura,278',
+    'Cycliq,279',
+    'Luxottica,280',
+    'Trainer Road,281',
+    'The Sufferfest,282',
+    'Fullspeedahead,283',
+    'Virtualtraining,284',
+    'Feedbacksports,285',
+    'Omata,286',
+    'VDO,287',
+    'Magneticdays,288',
+    'Hammerhead,289',
+    'Kinetic By Kurt,290',
+    'Shapelog,291',
+    'Dabuziduo,292',
+    'Jetblack,293',
+    'Coros,294',
+    'Virtugo,295',
+    'Velosense,296',
+    'Cycligentinc,297',
+    'Actigraphcorp,5759'
+];
+const brandLookup = brands.map(str => {
+    const [name, id] = str.split(',');
+    return { name, id: Number(id) };
+});
+const getBrand = (manId) => {
+    const found = brandLookup.find(l => l.id === manId);
+    if (found)
+        return found.name;
+    return;
+};
+exports.getBrand = getBrand;

package/lib/base/adpater.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="node" />
+import { EventEmitter } from "stream";
+import CyclingMode from "../modes/cycling-mode";
+import { DeviceProperties, DeviceSettings } from "../types/device";
+import { Bike, IncyclistDeviceAdapter, OnDeviceDataCallback } from '../types/adapter';
+import { User } from "../types/user";
+import { IncyclistCapability } from "../types/capabilities";
+import { EventLogger } from "gd-eventlog";
+export declare const DEFAULT_BIKE_WEIGHT = 10;
+export declare const DEFAULT_USER_WEIGHT = 75;
+export declare const DEFAULT_PROPS: DeviceProperties;
+export default class IncyclistDevice extends EventEmitter implements IncyclistDeviceAdapter {
+    onDataFn: OnDeviceDataCallback;
+    settings: DeviceSettings;
+    props: DeviceProperties;
+    capabilities: IncyclistCapability[];
+    protected logger: EventLogger;
+    started: boolean;
+    stopped: boolean;
+    paused: boolean;
+    constructor(settings: DeviceSettings, props?: DeviceProperties);
+    connect(): Promise<boolean>;
+    close(): Promise<boolean>;
+    check(): Promise<boolean>;
+    isEqual(settings: DeviceSettings): void;
+    getCapabilities(): IncyclistCapability[];
+    hasCapability(capability: IncyclistCapability): boolean;
+    update(): void;
+    start(props?: DeviceProperties): Promise<boolean>;
+    stop(): Promise<boolean>;
+    pause(): Promise<boolean>;
+    resume(): Promise<boolean>;
+    logEvent(event: any): void;
+    sendUpdate(request: any): void;
+    getID(): string;
+    getDisplayName(): string;
+    getName(): string;
+    getSettings(): DeviceSettings;
+    getInterface(): string;
+    onData(callback: OnDeviceDataCallback): void;
+    isStopped(): boolean;
+    isStarted(): boolean;
+    isPaused(): boolean;
+}
+export declare class ControllableDevice extends IncyclistDevice implements Bike {
+    cyclingMode: CyclingMode;
+    user?: User;
+    constructor(settings: DeviceSettings, props?: DeviceProperties);
+    setUser(user: User): void;
+    setBikeProps(props: DeviceProperties): void;
+    getWeight(): number;
+    getSupportedCyclingModes(): any[];
+    getDefaultCyclingMode(): CyclingMode;
+    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
+    getCyclingMode(): CyclingMode;
+}

package/lib/base/adpater.js

@@ -0,0 +1,144 @@
+"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 });
+exports.ControllableDevice = exports.DEFAULT_PROPS = exports.DEFAULT_USER_WEIGHT = exports.DEFAULT_BIKE_WEIGHT = void 0;
+const stream_1 = require("stream");
+exports.DEFAULT_BIKE_WEIGHT = 10;
+exports.DEFAULT_USER_WEIGHT = 75;
+exports.DEFAULT_PROPS = {
+    userWeight: exports.DEFAULT_USER_WEIGHT,
+    bikeWeight: exports.DEFAULT_BIKE_WEIGHT
+};
+class IncyclistDevice extends stream_1.EventEmitter {
+    constructor(settings, props) {
+        super();
+        this.onDataFn = undefined;
+        this.settings = settings;
+        this.props = props || {};
+        this.capabilities = [];
+        this.started = false;
+        this.stopped = false;
+        this.paused = false;
+    }
+    connect() { throw new Error('not implemented'); }
+    close() { throw new Error('not implemented'); }
+    check() { throw new Error("Method not implemented."); }
+    isEqual(settings) { throw new Error("Method not implemented."); }
+    getCapabilities() { return this.capabilities; }
+    hasCapability(capability) {
+        return this.capabilities.find(c => c === capability) !== undefined;
+    }
+    update() { throw new Error("Method not implemented."); }
+    start(props) { throw new Error("Method not implemented."); }
+    stop() { throw new Error("Method not implemented."); }
+    pause() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.paused = true;
+            return true;
+        });
+    }
+    resume() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.paused = false;
+            return true;
+        });
+    }
+    logEvent(event) {
+        if (!this.logger)
+            return;
+        this.logger.logEvent(event);
+    }
+    sendUpdate(request) { throw new Error("Method not implemented."); }
+    getID() { throw new Error('not implemented'); }
+    getDisplayName() {
+        return this.getName();
+    }
+    getName() {
+        return this.settings.name;
+    }
+    getSettings() {
+        return this.settings;
+    }
+    getInterface() {
+        return typeof this.settings.interface === 'string' ? this.settings.interface : this.settings.interface.getName();
+    }
+    onData(callback) {
+        this.onDataFn = callback;
+    }
+    isStopped() {
+        return this.stopped;
+    }
+    isStarted() {
+        return this.started;
+    }
+    isPaused() {
+        return this.paused;
+    }
+}
+exports.default = IncyclistDevice;
+class ControllableDevice extends IncyclistDevice {
+    constructor(settings, props) {
+        super(settings, props);
+        this.cyclingMode = this.getDefaultCyclingMode();
+        this.user = {};
+    }
+    setUser(user) {
+        this.user = user;
+        if (!user.weight)
+            this.user.weight = exports.DEFAULT_USER_WEIGHT;
+    }
+    setBikeProps(props) {
+        const { user, userWeight, bikeWeight } = 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 = exports.DEFAULT_PROPS } = this;
+        const userWeight = user.weight || props.userWeight || exports.DEFAULT_USER_WEIGHT;
+        const bikeWeight = props.bikeWeight || exports.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.ControllableDevice = ControllableDevice;

package/lib/ble/adapter-factory.d.ts

@@ -0,0 +1,31 @@
+import { DeviceProperties } from "../types/device";
+import { BleComms } from "./ble-comms";
+import BleAdapter from "./adapter";
+import { BleDeviceSettings } from "./types";
+export interface BleAdapterInfo {
+    protocol: string;
+    profile: string;
+    Adapter: typeof BleAdapter;
+    Comm: typeof BleComms;
+}
+export declare function mapLegacyProfile(profile: any): {
+    profile: any;
+    protocol: string;
+};
+export default class BleAdapterFactory {
+    static _instance: BleAdapterFactory;
+    adapters: BleAdapterInfo[];
+    static getInstance(): BleAdapterFactory;
+    constructor();
+    getAdapter(protocol: string): BleAdapterInfo;
+    getAllAdapters(): BleAdapterInfo[];
+    createInstance(settings: BleDeviceSettings, props?: DeviceProperties): BleAdapter;
+    register(protocol: string, profile: string, Adapter: typeof BleAdapter, Comm: typeof BleComms): void;
+    getAllSupportedDeviceTypes(): (typeof BleComms)[];
+    getAllSupportedServices(): string[];
+    getDeviceClasses(peripheral: any, props?: {
+        deviceTypes?: (typeof BleComms)[];
+        profile?: string;
+        services?: string[];
+    }): (typeof BleComms)[];
+}

package/lib/ble/adapter-factory.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapLegacyProfile = void 0;
+const utils_1 = require("./utils");
+function mapLegacyProfile(profile) {
+    switch (profile) {
+        case 'Smart Trainer': return { profile: 'Smart Trainer', protocol: 'fm' };
+        case 'Elite Smart Trainer': return { profile: 'Smart Trainer', protocol: 'elite' };
+        case 'Heartrate Monitor': return { profile: 'Heartrate Monitor', protocol: 'hr' };
+        case 'Power Meter': return { profile: 'Power Meter', protocol: 'cp' };
+        case 'Tacx Smart Trainer': return { profile: 'Smart Trainer', protocol: 'tacx' };
+        case 'Wahoo Smart Trainer': return { profile: 'Smart Trainer', protocol: 'wahoo' };
+    }
+    return { profile, protocol: 'Ble' };
+}
+exports.mapLegacyProfile = mapLegacyProfile;
+class BleAdapterFactory {
+    static getInstance() {
+        if (!BleAdapterFactory._instance)
+            BleAdapterFactory._instance = new BleAdapterFactory();
+        return BleAdapterFactory._instance;
+    }
+    constructor() {
+        this.adapters = [];
+    }
+    getAdapter(protocol) {
+        return this.adapters.find(a => a.protocol === protocol);
+    }
+    getAllAdapters() {
+        return this.adapters;
+    }
+    createInstance(settings, props) {
+        let { profile, protocol } = settings;
+        const adapterSettings = Object.assign({}, settings);
+        if (protocol === 'BLE') {
+            const mapping = mapLegacyProfile(profile);
+            protocol = mapping.protocol;
+            profile = mapping.profile;
+            adapterSettings.protocol = protocol;
+            adapterSettings.profile = profile;
+        }
+        const info = this.getAdapter(protocol);
+        if (!info || !info.Adapter)
+            return;
+        const adapter = new info.Adapter(adapterSettings, props);
+        return adapter;
+    }
+    register(protocol, profile, Adapter, Comm) {
+        const info = Object.assign({}, { protocol, profile, Adapter, Comm });
+        const existing = this.adapters.findIndex(a => a.protocol === protocol);
+        if (existing)
+            this.adapters[existing] = info;
+        else
+            this.adapters.push(info);
+    }
+    getAllSupportedDeviceTypes() {
+        const supported = BleAdapterFactory.getInstance().getAllAdapters();
+        return supported.map(info => info.Comm);
+    }
+    getAllSupportedServices() {
+        const supported = BleAdapterFactory.getInstance().getAllAdapters();
+        const res = [];
+        if (supported && supported.length > 0) {
+            supported.forEach(info => {
+                if (info && info.Comm && info.Comm.services) {
+                    info.Comm.services.forEach(s => {
+                        if (!res.includes(s))
+                            res.push(s);
+                    });
+                }
+            });
+        }
+        return res;
+    }
+    getDeviceClasses(peripheral, props = {}) {
+        let DeviceClasses;
+        const { deviceTypes, profile, services = peripheral.advertisement.serviceUuids } = props;
+        if ((!deviceTypes || deviceTypes.length === 0)) {
+            const classes = this.getAllSupportedDeviceTypes();
+            DeviceClasses = (0, utils_1.getDevicesFromServices)(classes, services);
+        }
+        else {
+            DeviceClasses = (0, utils_1.getDevicesFromServices)(deviceTypes, services);
+        }
+        if (profile && DeviceClasses && DeviceClasses.length > 0) {
+            DeviceClasses = DeviceClasses.filter(C => {
+                const device = new C({ peripheral });
+                if (device.getProfile() !== profile)
+                    return false;
+                return true;
+            });
+        }
+        return DeviceClasses;
+    }
+}
+exports.default = BleAdapterFactory;

package/lib/ble/adapter.d.ts

@@ -0,0 +1,41 @@
+import IncyclistDevice from "../base/adpater";
+import CyclingMode from "../modes/cycling-mode";
+import { Bike } from "../types/adapter";
+import { DeviceData } from "../types/data";
+import { DeviceProperties } from "../types/device";
+import { User } from "../types/user";
+import { BleComms } from "./ble-comms";
+import BleInterface from "./ble-interface";
+import { BleDeviceSettings } from "./types";
+export default class BleAdapter extends IncyclistDevice {
+    ble: BleInterface;
+    deviceData: any;
+    data: DeviceData;
+    dataMsgCount: number;
+    lastUpdate?: number;
+    lastDataTS: number;
+    updateFrequency: number;
+    device: BleComms;
+    constructor(settings: BleDeviceSettings, props?: DeviceProperties);
+    isEqual(settings: BleDeviceSettings): boolean;
+    resetData(): void;
+    getInterface(): string;
+    getProtocolName(): string;
+    getID(): string;
+    getName(): string;
+    onDeviceData(deviceData: any): void;
+    start(props?: DeviceProperties): Promise<any>;
+    stop(): Promise<boolean>;
+}
+export declare class BleControllableAdapter extends BleAdapter implements Bike {
+    cyclingMode: CyclingMode;
+    user?: User;
+    constructor(settings: BleDeviceSettings, props?: DeviceProperties);
+    setUser(user: User): void;
+    setBikeProps(props: DeviceProperties): void;
+    getWeight(): number;
+    getSupportedCyclingModes(): any[];
+    getDefaultCyclingMode(): CyclingMode;
+    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
+    getCyclingMode(): CyclingMode;
+}