incyclist-devices 2.0.38 → 2.1.1

package/lib/adapters.d.ts

@@ -1,4 +1,4 @@
-import { IncyclistDeviceAdapter } from "./types/adapter";
+import { IncyclistDeviceAdapter } from "./base/adpater";
 import { DeviceProperties, DeviceSettings } from "./types/device";
 export default class AdapterFactory {
     static adapters: IncyclistDeviceAdapter[];

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

@@ -1,22 +1,13 @@
 import { Profile } from "incyclist-ant-plus";
-import { DeviceData } from "../types/data";
-import AntAdapter, { BaseDeviceData } from "./adapter";
-import { AntDeviceProperties, AntDeviceSettings, LegacyProfile } from "./types";
-export type AntAdapterInfo = {
-    antProfile: Profile;
-    incyclistProfile: LegacyProfile;
-    Adapter: typeof AntAdapter<BaseDeviceData, DeviceData>;
-};
-export type AdapterQuery = {
-    antProfile?: Profile;
-    incyclistProfile?: LegacyProfile;
-};
+import AntAdapter from "./base/adapter";
+import { AntDeviceProperties, AntDeviceSettings, LegacyProfile, BaseDeviceData } from "./types";
+import { AntAdapterInfo, AdapterQuery } from "./types";
 export default class AntAdapterFactory {
     static _instance: AntAdapterFactory;
     adapters: AntAdapterInfo[];
     static getInstance(): AntAdapterFactory;
     constructor();
-    register<TDeviceData extends BaseDeviceData, TData>(antProfile: Profile, incyclistProfile: LegacyProfile, Adapter: typeof AntAdapter<TDeviceData, TData>): void;
+    register<TDeviceData extends BaseDeviceData>(antProfile: Profile, incyclistProfile: LegacyProfile, Adapter: typeof AntAdapter<TDeviceData>): void;
     getAdapter(query?: AdapterQuery): any;
     createInstance(settings: AntDeviceSettings, props?: AntDeviceProperties): any;
     createFromDetected(profile: Profile, deviceID: number, props?: AntDeviceProperties): any;

package/lib/antv2/adapter.d.ts

@@ -2,20 +2,11 @@
 import { IChannel, ISensor, Profile } from 'incyclist-ant-plus';
 import AntInterface from './ant-interface';
 import IncyclistDevice from '../base/adpater';
-import { AntDeviceProperties, AntDeviceSettings } from './types';
-import { DeviceProperties } from '../types/device';
-import { Bike, IncyclistDeviceAdapter } from '../types/adapter';
-import CyclingMode from '../modes/cycling-mode';
-import { User } from '../types/user';
-export declare const DEFAULT_UPDATE_FREQUENCY = 1000;
-export type BaseDeviceData = {
-    DeviceID: number;
-    ManId?: number;
-};
-export default class AntAdapter<TDeviceData extends BaseDeviceData, TData> extends IncyclistDevice {
+import { AntDeviceProperties, AntDeviceSettings, BaseDeviceData } from './types';
+import { IAdapter, IncyclistAdapterData, IncyclistBikeData } from '../types';
+export default class AntAdapter<TDeviceData extends BaseDeviceData> extends IncyclistDevice<AntDeviceProperties> {
     sensor: ISensor;
-    lastUpdate?: number;
-    data: TData;
+    data: IncyclistAdapterData;
     deviceData: TDeviceData;
     updateFrequency: number;
     channel: IChannel;
@@ -26,46 +17,38 @@ export default class AntAdapter<TDeviceData extends BaseDeviceData, TData> exten
     bikeSettings: {
         weight?: number;
     };
-    onDataFn: (data: TData) => void;
+    onDataFn: (data: IncyclistAdapterData) => void;
     startupRetryPause: number;
     protected ivDataTimeout: NodeJS.Timeout;
     protected lastDataTS: number;
     protected dataMsgCount: number;
     protected ivWaitForData: NodeJS.Timeout;
-    constructor(settings: AntDeviceSettings, props?: DeviceProperties);
-    logEvent(event: any): void;
+    constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
     createSensor(settings: AntDeviceSettings): ISensor;
     isEqual(settings: AntDeviceSettings): boolean;
     connect(): Promise<boolean>;
     close(): Promise<boolean>;
     resetData(): void;
-    isSame(device: IncyclistDeviceAdapter): boolean;
+    isSame(device: IAdapter): boolean;
     hasData(): boolean;
-    onDeviceData(deviceData: any): void;
-    waitForData(timeout: number): Promise<unknown>;
+    mapData(deviceData: TDeviceData): IncyclistBikeData;
+    transformData(data: IncyclistBikeData): void;
+    mapToAdapterData(deviceData: any): void;
+    onDeviceData(deviceData: TDeviceData): void;
+    isWaitingForData(): boolean;
+    waitForData(timeout: number): Promise<boolean>;
     getID(): string;
     getName(): string;
     getInterface(): string;
     getProfile(): Profile;
+    getLogData(data: any, excludeList: any): any;
+    triggerTimeoutCheck(): void;
     startDataTimeoutCheck(): void;
     stopDataTimeoutCheck(): void;
     check(): Promise<boolean>;
     checkCapabilities(): Promise<void>;
     initControl(): Promise<void>;
+    sendUpdate(request: any): void;
     start(props?: AntDeviceProperties): Promise<boolean>;
     stop(): Promise<boolean>;
 }
-export declare class ControllableAntAdapter<TDeviceData extends BaseDeviceData, TData> extends AntAdapter<TDeviceData, TData> implements Bike {
-    cyclingMode: CyclingMode;
-    user?: User;
-    constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
-    isControllable(): boolean;
-    setUser(user: User): void;
-    setBikeProps(props: DeviceProperties): void;
-    getWeight(): number;
-    getSupportedCyclingModes(): any[];
-    getDefaultCyclingMode(): CyclingMode;
-    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
-    sendInitCommands(): Promise<boolean>;
-    getCyclingMode(): CyclingMode;
-}

package/lib/antv2/adapter.js

@@ -1,27 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (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 __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) {
@@ -35,16 +12,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ControllableAntAdapter = exports.DEFAULT_UPDATE_FREQUENCY = void 0;
 const ant_interface_1 = __importDefault(require("./ant-interface"));
-const adpater_1 = __importStar(require("../base/adpater"));
+const adpater_1 = __importDefault(require("../base/adpater"));
 const types_1 = require("./types");
+const types_2 = require("../types");
 const utils_1 = require("../utils/utils");
-const capabilities_1 = require("../types/capabilities");
-const adpater_2 = require("../base/adpater");
 const utils_2 = require("./utils");
-exports.DEFAULT_UPDATE_FREQUENCY = 1000;
-const NO_DATA_TIMEOUT = 5000;
+const consts_1 = require("./consts");
 const INTERFACE_NAME = 'ant';
 class AntAdapter extends adpater_1.default {
     constructor(settings, props) {
@@ -59,20 +33,10 @@ class AntAdapter extends adpater_1.default {
         this.deviceData = {};
         this.data = {};
         this.dataMsgCount = 0;
-        this.updateFrequency = exports.DEFAULT_UPDATE_FREQUENCY;
+        this.updateFrequency = consts_1.DEFAULT_UPDATE_FREQUENCY;
         this.channel = undefined;
         this.ant = ant_interface_1.default.getInstance();
     }
-    logEvent(event) {
-        if (!this.logger || this.paused)
-            return;
-        this.logger.logEvent(event);
-        const w = global.window;
-        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG || process.env.ANT_DEBUG) {
-            const logText = '~~~ ANT:' + this.logger.getName();
-            console.log(logText, event);
-        }
-    }
     createSensor(settings) {
         throw new Error('Method not implemented.');
     }
@@ -110,13 +74,49 @@ class AntAdapter extends adpater_1.default {
     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) {
-        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) });
+        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();
@@ -162,13 +162,25 @@ class AntAdapter extends adpater_1.default {
             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 + NO_DATA_TIMEOUT < Date.now()) {
+            if (this.lastDataTS + consts_1.NO_DATA_TIMEOUT < Date.now()) {
                 this.emit('disconnected', Date.now() - this.lastDataTS);
             }
         }, 1000);
@@ -201,6 +213,16 @@ class AntAdapter extends adpater_1.default {
             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) {
@@ -236,7 +258,7 @@ class AntAdapter extends adpater_1.default {
                 try {
                     yield this.waitForData(startupTimeout - 100);
                     yield this.checkCapabilities();
-                    if (this.hasCapability(capabilities_1.IncyclistCapability.Control))
+                    if (this.hasCapability(types_2.IncyclistCapability.Control))
                         yield this.initControl();
                     this.started = true;
                     if (to)
@@ -267,69 +289,3 @@ class AntAdapter extends adpater_1.default {
     }
 }
 exports.default = AntAdapter;
-class ControllableAntAdapter extends AntAdapter {
-    constructor(settings, props) {
-        super(settings, props);
-        this.cyclingMode = this.getDefaultCyclingMode();
-        this.user = {};
-    }
-    isControllable() {
-        return true;
-    }
-    setUser(user) {
-        this.user = user;
-        if (!user.weight)
-            this.user.weight = adpater_2.DEFAULT_USER_WEIGHT;
-    }
-    setBikeProps(props) {
-        const { user, userWeight } = 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 = adpater_2.DEFAULT_PROPS } = this;
-        const userWeight = user.weight || props.userWeight || adpater_2.DEFAULT_USER_WEIGHT;
-        const bikeWeight = props.bikeWeight || adpater_1.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);
-    }
-    sendInitCommands() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return true;
-        });
-    }
-    getCyclingMode() {
-        if (!this.cyclingMode)
-            this.setCyclingMode(this.getDefaultCyclingMode());
-        return this.cyclingMode;
-    }
-}
-exports.ControllableAntAdapter = ControllableAntAdapter;

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

@@ -2,17 +2,9 @@
 import EventEmitter from "events";
 import { EventLogger } from "gd-eventlog";
 import { IAntDevice, IChannel, ISensor } from "incyclist-ant-plus";
-import { InterfaceProps } from "../types/interface";
-import AntDeviceBinding from "./binding";
-import { IncyclistInterface } from "../types/interface";
-import { AntDeviceSettings, AntScanProps } from "./types";
-export interface AntInterfaceProps extends InterfaceProps {
-    startupTimeout?: number;
-}
-export interface ConnectState {
-    connected: boolean;
-    connecting: boolean;
-}
+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;

package/lib/antv2/ant-interface.js

@@ -14,7 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (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"));
+const sensor_factory_1 = __importDefault(require("./factories/sensor-factory"));
 class AntInterface extends events_1.default {
     static getInstance(props = {}) {
         if (AntInterface._instance === undefined)

package/lib/antv2/base/adapter.d.ts

@@ -0,0 +1,62 @@
+/// <reference types="node" />
+import { IChannel, ISensor, Profile } from 'incyclist-ant-plus';
+import AntInterface from './ant-interface';
+import IncyclistDevice from '../../base/adpater';
+import { AntDeviceProperties, AntDeviceSettings, LegacyProfile, BaseDeviceData } from '../types';
+import { IAdapter, IncyclistAdapterData, IncyclistBikeData } from '../../types';
+export default class AntAdapter<TDeviceData extends BaseDeviceData> extends IncyclistDevice<AntDeviceProperties> {
+    sensor: ISensor;
+    data: IncyclistAdapterData;
+    deviceData: TDeviceData;
+    updateFrequency: number;
+    channel: IChannel;
+    ant: AntInterface;
+    userSettings: {
+        weight?: number;
+    };
+    bikeSettings: {
+        weight?: number;
+    };
+    onDataFn: (data: IncyclistAdapterData) => void;
+    startupRetryPause: number;
+    protected ivDataTimeout: NodeJS.Timeout;
+    protected lastDataTS: number;
+    protected dataMsgCount: number;
+    protected ivWaitForData: NodeJS.Timeout;
+    protected promiseWaitForData: Promise<boolean>;
+    constructor(settings: AntDeviceSettings, props?: AntDeviceProperties);
+    getProfileName(): Profile;
+    getLegacyProfileName(): LegacyProfile;
+    createSensor(settings: AntDeviceSettings): ISensor;
+    isEqual(settings: AntDeviceSettings): boolean;
+    connect(): Promise<boolean>;
+    close(): Promise<boolean>;
+    resetData(): void;
+    isSame(device: IAdapter): boolean;
+    hasData(): boolean;
+    mapData(deviceData: TDeviceData): IncyclistBikeData;
+    transformData(data: IncyclistBikeData, deviceData: TDeviceData): void;
+    mapToAdapterData(deviceData: any): void;
+    onDeviceData(deviceData: TDeviceData): void;
+    isWaitingForData(): boolean;
+    _wait(): Promise<boolean>;
+    waitForData(timeout: number): Promise<boolean>;
+    getID(): string;
+    getName(): string;
+    getUniqueName(): string;
+    getDisplayName(): string;
+    getInterface(): string;
+    getProfile(): Profile;
+    getLogData(data: any, excludeList: any): any;
+    triggerTimeoutCheck(): void;
+    startDataTimeoutCheck(): void;
+    stopDataTimeoutCheck(): void;
+    check(): Promise<boolean>;
+    checkCapabilities(): Promise<void>;
+    initControl(): Promise<void>;
+    getDefaultStartupTimeout(): number;
+    sendUpdate(request: any): void;
+    start(props?: AntDeviceProperties): Promise<boolean>;
+    stop(): Promise<boolean>;
+    startSensor(): Promise<boolean>;
+}