incyclist-devices 1.2.0 → 1.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Incyclist
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/CyclingMode.d.ts

@@ -0,0 +1,72 @@
+import { Device } from "./DeviceProtocol";
+export declare type UpdateRequest = {
+    slope?: number;
+    minPower?: number;
+    maxPower?: number;
+    targetPower?: number;
+    reset?: boolean;
+    refresh?: boolean;
+};
+export declare enum CyclingModeProperyType {
+    Integer = "Integer",
+    Boolean = "Boolean",
+    Float = "Float",
+    String = "String",
+    SingleSelect = "SingleSelect",
+    MultiSelect = "MultiSelect"
+}
+export declare type CyclingModeProperty = {
+    key: string;
+    name: string;
+    description: string;
+    type: CyclingModeProperyType;
+    min?: number;
+    max?: number;
+    default?: any;
+    options?: any[];
+};
+export declare type IncyclistBikeData = {
+    isPedalling: boolean;
+    power: number;
+    pedalRpm: number;
+    speed: number;
+    heartrate: number;
+    distance: number;
+    distanceInternal: number;
+    time?: number;
+    gear?: number;
+    slope?: number;
+};
+export declare type Settings = {
+    [key: string]: any;
+};
+export default interface CyclingMode {
+    getName(): string;
+    getDescription(): string;
+    getBikeInitRequest(): UpdateRequest;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+    updateData(data: IncyclistBikeData): IncyclistBikeData;
+    getProperties(): CyclingModeProperty[];
+    getProperty(name: string): CyclingModeProperty;
+    setSettings(settings: any): any;
+    setSetting(name: string, value: any): void;
+    getSetting(name: string): any;
+    getSettings(): Settings;
+}
+export declare class CyclingModeBase implements CyclingMode {
+    adapter: Device;
+    settings: Settings;
+    constructor(adapter: Device, props?: any);
+    setAdapter(adapter: Device): void;
+    getBikeInitRequest(): UpdateRequest;
+    getName(): string;
+    getDescription(): string;
+    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
+    updateData(data: IncyclistBikeData): IncyclistBikeData;
+    getProperties(): CyclingModeProperty[];
+    getProperty(name: string): CyclingModeProperty;
+    setSettings(settings?: any): void;
+    setSetting(name: string, value: any): void;
+    getSetting(name: string): any;
+    getSettings(): Settings;
+}

package/lib/CyclingMode.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CyclingModeBase = exports.CyclingModeProperyType = void 0;
+var CyclingModeProperyType;
+(function (CyclingModeProperyType) {
+    CyclingModeProperyType["Integer"] = "Integer";
+    CyclingModeProperyType["Boolean"] = "Boolean";
+    CyclingModeProperyType["Float"] = "Float";
+    CyclingModeProperyType["String"] = "String";
+    CyclingModeProperyType["SingleSelect"] = "SingleSelect";
+    CyclingModeProperyType["MultiSelect"] = "MultiSelect";
+})(CyclingModeProperyType = exports.CyclingModeProperyType || (exports.CyclingModeProperyType = {}));
+class CyclingModeBase {
+    constructor(adapter, props) {
+        this.settings = {};
+        if (!adapter)
+            throw new Error('IllegalArgument: adapter is null');
+        this.setAdapter(adapter);
+        this.setSettings(props);
+    }
+    setAdapter(adapter) {
+        this.adapter = adapter;
+    }
+    getBikeInitRequest() {
+        return {};
+    }
+    getName() {
+        throw new Error("Method not implemented.");
+    }
+    getDescription() {
+        throw new Error("Method not implemented.");
+    }
+    sendBikeUpdate(request) {
+        throw new Error("Method not implemented.");
+    }
+    updateData(data) {
+        throw new Error("Method not implemented.");
+    }
+    getProperties() {
+        throw new Error("Method not implemented.");
+    }
+    getProperty(name) {
+        throw new Error("Method not implemented.");
+    }
+    setSettings(settings) {
+        if (settings) {
+            this.settings = settings;
+        }
+    }
+    setSetting(name, value) {
+        this.settings[name] = value;
+    }
+    getSetting(name) {
+        const res = this.settings[name];
+        if (res !== undefined)
+            return res;
+        const prop = this.getProperties().find(p => p.key === name);
+        if (prop && prop.default !== undefined)
+            return prop.default;
+        return undefined;
+    }
+    getSettings() {
+        return this.settings;
+    }
+}
+exports.CyclingModeBase = CyclingModeBase;

package/lib/Device.d.ts

@@ -1,16 +1,54 @@
-import DeviceProtocol from './DeviceProtocol';
-export default class Device {
+import { DeviceProtocol, Device } from './DeviceProtocol';
+import CyclingMode from './CyclingMode';
+export declare type OnDeviceDataCallback = (data: any) => void;
+export interface Bike {
+    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
+    getSupportedCyclingModes(): Array<any>;
+    getCyclingMode(): CyclingMode;
+    getDefaultCyclingMode(): CyclingMode;
+    setUserSettings(userSettings: any): void;
+    setBikeSettings(bikeSettings: any): void;
+}
+export interface DeviceAdapter extends Device {
+    isBike(): boolean;
+    isPower(): boolean;
+    isHrm(): boolean;
+    getID(): string;
+    getDisplayName(): string;
+    getName(): string;
+    getPort(): string;
+    getProtocol(): DeviceProtocol;
+    getProtocolName(): string;
+    setIgnoreHrm(ignore: boolean): void;
+    setIgnorePower(ignore: boolean): void;
+    setIgnoreBike(ignore: boolean): void;
+    select(): void;
+    unselect(): void;
+    isSelected(): boolean;
+    setDetected(detected?: boolean): void;
+    isDetected(): boolean;
+    start(props?: any): Promise<any>;
+    stop(): Promise<boolean>;
+    pause(): Promise<boolean>;
+    resume(): Promise<boolean>;
+    sendUpdate(request: any): void;
+    onData(callback: OnDeviceDataCallback): void;
+}
+export default class DeviceAdapterBase implements DeviceAdapter {
     protocol: DeviceProtocol;
     detected: boolean;
     selected: boolean;
-    onDataFn: any;
-    constructor(proto: any);
-    getID(): void;
-    getDisplayName(): void;
-    getName(): void;
-    getPort(): void;
+    onDataFn: OnDeviceDataCallback;
+    constructor(proto: DeviceProtocol);
+    isBike(): boolean;
+    isPower(): boolean;
+    isHrm(): boolean;
+    getID(): string;
+    getDisplayName(): string;
+    getName(): string;
+    getPort(): string;
     getProtocol(): DeviceProtocol;
-    getProtocolName(): void;
+    getProtocolName(): string | undefined;
     setIgnoreHrm(ignore: any): void;
     setIgnorePower(ignore: any): void;
     setIgnoreBike(ignore: any): void;
@@ -28,5 +66,5 @@ export default class Device {
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;
     sendUpdate(request: any): void;
-    onData(callback: any): void;
+    onData(callback: OnDeviceDataCallback): void;
 }

package/lib/Device.js

@@ -1,19 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-class Device {
+class DeviceAdapterBase {
     constructor(proto) {
         this.protocol = proto;
         this.detected = false;
         this.selected = false;
         this.onDataFn = undefined;
     }
-    getID() { }
+    isBike() { throw new Error('not implemented'); }
+    isPower() { throw new Error('not implemented'); }
+    isHrm() { throw new Error('not implemented'); }
+    getID() { throw new Error('not implemented'); }
     getDisplayName() { return this.getName(); }
-    getName() { }
-    getPort() { }
-    getProtocol() {
-        return this.protocol;
-    }
+    getName() { throw new Error('not implemented'); }
+    getPort() { throw new Error('not implemented'); }
+    getProtocol() { return this.protocol; }
     getProtocolName() {
         return this.protocol ? this.protocol.getName() : undefined;
     }
@@ -38,4 +39,4 @@ class Device {
         this.onDataFn = callback;
     }
 }
-exports.default = Device;
+exports.default = DeviceAdapterBase;

package/lib/DeviceProtocol.d.ts

@@ -6,25 +6,54 @@ export declare const INTERFACE: {
     TCPIP: string;
     SIMULATOR: string;
 };
-declare type DeviceFoundCallback = (device: any, protocol: DeviceProtocol) => void;
-declare type ScanFinishedCallback = (id: number) => void;
+export declare type Device = {
+    getID(): string;
+    getName(): string;
+    getPort(): string;
+    getProtocol(): DeviceProtocol;
+    getProtocolName(): string;
+};
+export interface DeviceSettings {
+    name: string;
+    port: string;
+}
+export declare type DeviceFoundCallback = (device: Device, protocol: DeviceProtocolBase) => void;
+export declare type ScanFinishedCallback = (id: number) => void;
 export declare type ScanProps = {
     id: number;
     onDeviceFound?: DeviceFoundCallback;
     onScanFinished?: ScanFinishedCallback;
 };
-export default class DeviceProtocol {
-    devices: Array<any>;
+export interface DeviceProtocol {
+    add(props: DeviceSettings): any;
+    getName(): string;
+    getInterfaces(): Array<string>;
+    isBike(): boolean;
+    isHrm(): boolean;
+    isPower(): boolean;
+    scan(props: ScanProps): void;
+    stopScan(): void;
+    isScanning(): boolean;
+    getDevices(): Array<any>;
+    setAnt(antClass: any): void;
+    getAnt(): any;
+    setSerialPort(serialClass: any): void;
+    getSerialPort(): any;
+    setNetImpl(netClass: any): void;
+    getNetImpl(): any;
+}
+export default class DeviceProtocolBase {
+    devices: Array<Device>;
     constructor();
-    getName(): void;
-    getInterfaces(): void;
-    isBike(): void;
-    isHrm(): void;
-    isPower(): void;
+    getName(): string;
+    getInterfaces(): Array<string>;
+    isBike(): boolean;
+    isHrm(): boolean;
+    isPower(): boolean;
     scan(props: ScanProps): void;
     stopScan(): void;
-    isScanning(): void;
-    getDevices(): any[];
+    isScanning(): boolean;
+    getDevices(): Array<Device>;
     setAnt(antClass: any): void;
     getAnt(): any;
     setSerialPort(serialClass: any): void;
@@ -38,4 +67,3 @@ export default class DeviceProtocol {
     static setNetImpl(netClass: any): void;
     static getNetImpl(): any;
 }
-export {};

package/lib/DeviceProtocol.js

@@ -10,25 +10,25 @@ exports.INTERFACE = {
     SIMULATOR: 'simulator'
 };
 let _ant, _serial, _net;
-class DeviceProtocol {
+class DeviceProtocolBase {
     constructor() {
         this.devices = [];
     }
-    getName() { }
-    getInterfaces() { }
-    isBike() { }
-    isHrm() { }
-    isPower() { }
-    scan(props) { }
-    stopScan() { }
-    isScanning() { }
+    getName() { throw new Error('not implemented'); }
+    getInterfaces() { throw new Error('not implemented'); }
+    isBike() { throw new Error('not implemented'); }
+    isHrm() { throw new Error('not implemented'); }
+    isPower() { throw new Error('not implemented'); }
+    scan(props) { throw new Error('not implemented'); }
+    stopScan() { throw new Error('not implemented'); }
+    isScanning() { throw new Error('not implemented'); }
     getDevices() { return this.devices; }
-    setAnt(antClass) { DeviceProtocol.setAnt(antClass); }
-    getAnt() { return DeviceProtocol.getAnt(); }
-    setSerialPort(serialClass) { DeviceProtocol.setSerialPort(serialClass); }
-    getSerialPort() { DeviceProtocol.getSerialPort(); }
-    setNetImpl(netClass) { DeviceProtocol.setNetImpl(netClass); }
-    getNetImpl() { return DeviceProtocol.getNetImpl(); }
+    setAnt(antClass) { DeviceProtocolBase.setAnt(antClass); }
+    getAnt() { return DeviceProtocolBase.getAnt(); }
+    setSerialPort(serialClass) { DeviceProtocolBase.setSerialPort(serialClass); }
+    getSerialPort() { DeviceProtocolBase.getSerialPort(); }
+    setNetImpl(netClass) { DeviceProtocolBase.setNetImpl(netClass); }
+    getNetImpl() { return DeviceProtocolBase.getNetImpl(); }
     static setAnt(antClass) { _ant = antClass; }
     static getAnt() { return _ant; }
     static setSerialPort(serialClass) { _serial = serialClass; }
@@ -36,4 +36,4 @@ class DeviceProtocol {
     static setNetImpl(netClass) { _net = netClass; }
     static getNetImpl() { return _net; }
 }
-exports.default = DeviceProtocol;
+exports.default = DeviceProtocolBase;

package/lib/DeviceRegistry.d.ts

@@ -1,8 +1,8 @@
-import DeviceProtocol from './DeviceProtocol';
+import { DeviceProtocol } from './DeviceProtocol';
 export default class DeviceRegistry {
     static _reset(): void;
     static _get(): any[];
-    static register(device: any): void;
-    static findByName(name: any): DeviceProtocol;
-    static findByInterface(interf: any): Array<DeviceProtocol>;
+    static register(protocol: DeviceProtocol): void;
+    static findByName(name: string): DeviceProtocol;
+    static findByInterface(interf: string): Array<DeviceProtocol>;
 }

package/lib/DeviceRegistry.js

@@ -1,33 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-let _devices = [];
+let _protocols = [];
 class DeviceRegistry {
     static _reset() {
-        _devices = [];
+        _protocols = [];
     }
     static _get() {
-        return _devices;
+        return _protocols;
     }
-    static register(device) {
-        if (!device)
+    static register(protocol) {
+        if (!protocol)
             return;
-        const idx = _devices.findIndex(d => d.getName() === device.getName());
+        const idx = _protocols.findIndex(d => d.getName() === protocol.getName());
         if (idx !== -1) {
-            _devices[idx] = device;
+            _protocols[idx] = protocol;
         }
         else {
-            _devices.push(device);
+            _protocols.push(protocol);
         }
     }
     static findByName(name) {
         if (!name)
             return;
-        return _devices.find(d => d.getName() === name);
+        return _protocols.find(d => d.getName() === name);
     }
     static findByInterface(interf) {
         if (!interf)
             return;
-        return _devices.filter(d => d.getInterfaces().findIndex(i => i === interf) !== -1);
+        return _protocols.filter(d => d.getInterfaces().findIndex(i => i === interf) !== -1);
     }
 }
 exports.default = DeviceRegistry;

package/lib/DeviceSupport.d.ts

@@ -1,13 +1,14 @@
 import DeviceRegistry from './DeviceRegistry';
-import Device from './Device';
-import DeviceProtocol, { INTERFACE } from './DeviceProtocol';
+import DeviceAdapter from './Device';
+import DeviceProtocolBase, { INTERFACE, DeviceProtocol } from './DeviceProtocol';
 import SimulatorProtocol from './simulator/Simulator';
 import DaumPremiumProtocol from './daum/premium/DaumPremiumProtocol';
 import DaumClassicProtocol from './daum/classic/DaumClassicProtocol';
 import { AntScanner } from './ant/AntScanner';
+import { CyclingModeProperyType } from './CyclingMode';
 declare const Protocols: {
     SimulatorProtocol: typeof SimulatorProtocol;
     DaumClassicProtocol: typeof DaumClassicProtocol;
     DaumPremiumProtocol: typeof DaumPremiumProtocol;
 };
-export { DeviceProtocol, DeviceRegistry, INTERFACE, Device, Protocols, AntScanner, };
+export { DeviceProtocolBase, DeviceProtocol, DeviceRegistry, INTERFACE, DeviceAdapter as Device, Protocols, AntScanner, CyclingModeProperyType };

package/lib/DeviceSupport.js

@@ -1,18 +1,42 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AntScanner = exports.Protocols = exports.Device = exports.INTERFACE = exports.DeviceRegistry = exports.DeviceProtocol = void 0;
-const DeviceRegistry_1 = require("./DeviceRegistry");
+exports.CyclingModeProperyType = exports.AntScanner = exports.Protocols = exports.Device = exports.INTERFACE = exports.DeviceRegistry = exports.DeviceProtocolBase = void 0;
+const DeviceRegistry_1 = __importDefault(require("./DeviceRegistry"));
 exports.DeviceRegistry = DeviceRegistry_1.default;
-const Device_1 = require("./Device");
+const Device_1 = __importDefault(require("./Device"));
 exports.Device = Device_1.default;
-const DeviceProtocol_1 = require("./DeviceProtocol");
-exports.DeviceProtocol = DeviceProtocol_1.default;
+const DeviceProtocol_1 = __importStar(require("./DeviceProtocol"));
+exports.DeviceProtocolBase = DeviceProtocol_1.default;
 Object.defineProperty(exports, "INTERFACE", { enumerable: true, get: function () { return DeviceProtocol_1.INTERFACE; } });
-const Simulator_1 = require("./simulator/Simulator");
-const DaumPremiumProtocol_1 = require("./daum/premium/DaumPremiumProtocol");
-const DaumClassicProtocol_1 = require("./daum/classic/DaumClassicProtocol");
+const Simulator_1 = __importDefault(require("./simulator/Simulator"));
+const DaumPremiumProtocol_1 = __importDefault(require("./daum/premium/DaumPremiumProtocol"));
+const DaumClassicProtocol_1 = __importDefault(require("./daum/classic/DaumClassicProtocol"));
 const AntScanner_1 = require("./ant/AntScanner");
 Object.defineProperty(exports, "AntScanner", { enumerable: true, get: function () { return AntScanner_1.AntScanner; } });
+const CyclingMode_1 = require("./CyclingMode");
+Object.defineProperty(exports, "CyclingModeProperyType", { enumerable: true, get: function () { return CyclingMode_1.CyclingModeProperyType; } });
 const Protocols = {
     SimulatorProtocol: Simulator_1.default,
     DaumClassicProtocol: DaumClassicProtocol_1.default,

package/lib/ant/AntAdapter.d.ts

@@ -1,8 +1,9 @@
-import Device from "../Device";
+import DeviceAdapter from "../Device";
 import { EventLogger } from 'gd-eventlog';
 export declare const DEFAULT_UPDATE_FREQUENCY = 1000;
-export default class AntAdapter extends Device {
+export default class AntAdapter extends DeviceAdapter {
     paused: boolean;
+    stopped: boolean;
     ignoreHrm: boolean;
     ignoreBike: boolean;
     ignorePower: boolean;
@@ -10,19 +11,23 @@ export default class AntAdapter extends Device {
     port: string;
     stick: any;
     channel: number;
+    sensor: any;
     deviceData: any;
     data: any;
     logger: EventLogger;
     lastUpdate?: number;
     updateFrequency: number;
     constructor(protocol: any);
+    setSensor(sensor: any): void;
     getID(): string;
     setIgnoreHrm(ignore: any): void;
     setIgnoreBike(ignore: any): void;
     setIgnorePower(ignore: any): void;
+    getProfile(): string;
     getPort(): string;
     setChannel(channel: any): void;
     setStick(stick: any): void;
+    isStopped(): boolean;
     onDeviceData(data: any): void;
     onDeviceEvent(data: any): void;
     onAttached(): void;
@@ -32,4 +37,6 @@ export default class AntAdapter extends Device {
     close(): void;
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;
+    start(props?: any): Promise<any>;
+    stop(): Promise<boolean>;
 }

package/lib/ant/AntAdapter.js

@@ -1,12 +1,16 @@
 "use strict";
+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 Device_1 = require("../Device");
+const Device_1 = __importDefault(require("../Device"));
 exports.DEFAULT_UPDATE_FREQUENCY = 1000;
 class AntAdapter extends Device_1.default {
     constructor(protocol) {
         super(protocol);
         this.paused = false;
+        this.stopped = false;
         this.ignoreHrm = false;
         this.ignoreBike = false;
         this.ignorePower = false;
@@ -18,6 +22,9 @@ class AntAdapter extends Device_1.default {
         this.data = {};
         this.updateFrequency = exports.DEFAULT_UPDATE_FREQUENCY;
     }
+    setSensor(sensor) {
+        this.sensor = sensor;
+    }
     getID() {
         return this.deviceID;
     }
@@ -30,16 +37,21 @@ class AntAdapter extends Device_1.default {
     setIgnorePower(ignore) {
         this.ignorePower = ignore;
     }
+    getProfile() {
+        return "unknown";
+    }
     getPort() {
         return this.port;
     }
     setChannel(channel) {
-        console.log('~~setChannel', this.getName(), channel);
         this.channel = channel;
     }
     setStick(stick) {
         this.stick = stick;
     }
+    isStopped() {
+        return this.stopped;
+    }
     onDeviceData(data) { }
     onDeviceEvent(data) { }
     onAttached() { }
@@ -59,5 +71,17 @@ class AntAdapter extends Device_1.default {
             resolve(true);
         });
     }
+    start(props) {
+        return new Promise(resolve => {
+            this.stopped = false;
+            resolve(true);
+        });
+    }
+    stop() {
+        return new Promise(resolve => {
+            this.stopped = true;
+            resolve(true);
+        });
+    }
 }
 exports.default = AntAdapter;