incyclist-devices 2.2.10-beta.0 → 2.3.0-beta.10

package/lib/antv2/base/interface.js

@@ -16,7 +16,7 @@ const events_1 = __importDefault(require("events"));
 const gd_eventlog_1 = require("gd-eventlog");
 const sensor_factory_1 = __importDefault(require("../factories/sensor-factory"));
 const utils_1 = require("../../utils/utils");
-const incyclist_devices_1 = require("incyclist-devices");
+const adapter_factory_1 = __importDefault(require("../factories/adapter-factory"));
 class AntInterface extends events_1.default {
     static getInstance(props = {}) {
         if (AntInterface._instance === undefined)
@@ -300,7 +300,7 @@ class AntInterface extends events_1.default {
             this.logger.logEvent({ message: 'stopping devices' });
             let promises = [];
             detected.forEach((settings) => {
-                const adapter = incyclist_devices_1.AdapterFactory.create(settings);
+                const adapter = adapter_factory_1.default.getInstance().createInstance(settings);
                 promises.push(adapter.stop().catch(err => {
                     this.logger.logEvent({ message: 'could not stop device', error: err.message, deviceID: settings.deviceID, stack: err.stack });
                 }));

package/lib/antv2/factories/index.d.ts

@@ -0,0 +1 @@
+export * from './adapter-factory';

package/lib/antv2/factories/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./adapter-factory"), exports);

package/lib/antv2/fe/adapter.js

@@ -88,16 +88,17 @@ class AntFEAdapter extends adapter_1.default {
         }
     }
     mapData(deviceData) {
+        var _a, _b, _c, _d;
         const data = {
             isPedalling: false,
             power: 0,
             pedalRpm: 0,
             speed: 0,
         };
-        data.speed = (deviceData.VirtualSpeed !== undefined ? deviceData.VirtualSpeed : (deviceData.RealSpeed || 0)) * 3.6;
-        data.slope = (deviceData.Incline !== undefined ? deviceData.Incline : data.slope);
-        data.power = (deviceData.InstantaneousPower !== undefined ? deviceData.InstantaneousPower : data.power);
-        data.pedalRpm = (deviceData.Cadence !== undefined ? deviceData.Cadence : data.pedalRpm);
+        data.speed = ((_a = deviceData === null || deviceData === void 0 ? void 0 : deviceData.VirtualSpeed) !== null && _a !== void 0 ? _a : (deviceData.RealSpeed || 0)) * 3.6;
+        data.slope = (_b = deviceData === null || deviceData === void 0 ? void 0 : deviceData.Incline) !== null && _b !== void 0 ? _b : data.slope;
+        data.power = (_c = deviceData === null || deviceData === void 0 ? void 0 : deviceData.InstantaneousPower) !== null && _c !== void 0 ? _c : data.power;
+        data.pedalRpm = (_d = deviceData.Cadence) !== null && _d !== void 0 ? _d : data.pedalRpm;
         data.isPedalling = data.pedalRpm > 0 || data.power > 0;
         if (deviceData.HeartRate !== undefined)
             data.heartrate = deviceData.HeartRate;

package/lib/antv2/index.d.ts

@@ -8,4 +8,5 @@ import { AntInterfaceProps } from "./types";
 import AntSpdAdapter from "./spd";
 import AntScAdapter from "./sc";
 export { AntDeviceSettings, AntDeviceProperties, AntScanProps } from "./types";
+export declare const initAntFactory: () => void;
 export { AntAdapterFactory, AntFEAdapter, AntHrAdapter, AntPwrAdapter, AntScAdapter, AntSpdAdapter, AntCadAdapter, AntInterface, AntInterfaceProps };

package/lib/antv2/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AntInterface = exports.AntCadAdapter = exports.AntSpdAdapter = exports.AntScAdapter = exports.AntPwrAdapter = exports.AntHrAdapter = exports.AntFEAdapter = exports.AntAdapterFactory = void 0;
+exports.AntInterface = exports.AntCadAdapter = exports.AntSpdAdapter = exports.AntScAdapter = exports.AntPwrAdapter = exports.AntHrAdapter = exports.AntFEAdapter = exports.AntAdapterFactory = exports.initAntFactory = void 0;
 const pwr_1 = __importDefault(require("./pwr"));
 exports.AntPwrAdapter = pwr_1.default;
 const fe_1 = __importDefault(require("./fe"));
@@ -20,10 +20,14 @@ const spd_1 = __importDefault(require("./spd"));
 exports.AntSpdAdapter = spd_1.default;
 const sc_1 = __importDefault(require("./sc"));
 exports.AntScAdapter = sc_1.default;
-const af = adapter_factory_1.default.getInstance();
-af.register('PWR', 'Power Meter', pwr_1.default);
-af.register('HR', 'Heartrate Monitor', hr_1.default);
-af.register('FE', 'Smart Trainer', fe_1.default);
-af.register('CAD', 'Cadence Sensor', cad_1.default);
-af.register('SPD', 'Speed Sensor', spd_1.default);
-af.register('SC', 'Speed + Cadence Sensor', sc_1.default);
+const initAntFactory = () => {
+    const af = adapter_factory_1.default.getInstance();
+    af.register('PWR', 'Power Meter', pwr_1.default);
+    af.register('HR', 'Heartrate Monitor', hr_1.default);
+    af.register('FE', 'Smart Trainer', fe_1.default);
+    af.register('CAD', 'Cadence Sensor', cad_1.default);
+    af.register('SPD', 'Speed Sensor', spd_1.default);
+    af.register('SC', 'Speed + Cadence Sensor', sc_1.default);
+};
+exports.initAntFactory = initAntFactory;
+(0, exports.initAntFactory)();

package/lib/base/adpater.d.ts

@@ -11,6 +11,7 @@ export default class IncyclistDevice<P extends DeviceProperties> extends EventEm
     started: boolean;
     stopped: boolean;
     paused: boolean;
+    scanning: boolean;
     protected props: P;
     protected cyclingMode: ICyclingMode;
     protected logger: EventLogger;
@@ -37,6 +38,7 @@ export default class IncyclistDevice<P extends DeviceProperties> extends EventEm
     resume(): Promise<boolean>;
     connect(): Promise<boolean>;
     close(): Promise<boolean>;
+    resetData(): void;
     getControllerInfo(): ControllerConfig | undefined;
     isControllable(): boolean;
     getCapabilities(): IncyclistCapability[];
@@ -65,5 +67,7 @@ export default class IncyclistDevice<P extends DeviceProperties> extends EventEm
     getStartProps(startProps?: P): P;
     hasDataListeners(): boolean | OnDeviceDataCallback;
     onData(callback: OnDeviceDataCallback): void;
+    onScanStart(): void;
+    onScanStop(): void;
 }
 export type IncyclistDeviceAdapter = IncyclistDevice<DeviceProperties>;

package/lib/base/adpater.js

@@ -26,6 +26,7 @@ class IncyclistDevice extends events_1.default {
         this.started = false;
         this.stopped = false;
         this.paused = false;
+        this.scanning = false;
         this.user = {};
         this.data = {};
         this.cyclingMode = this.getDefaultCyclingMode();
@@ -100,6 +101,9 @@ class IncyclistDevice extends events_1.default {
     }
     connect() { throw new Error('not implemented'); }
     close() { throw new Error('not implemented'); }
+    resetData() {
+        delete this.lastUpdate;
+    }
     getControllerInfo() {
         const a = this.constructor;
         const config = a.controllers;
@@ -200,7 +204,7 @@ class IncyclistDevice extends events_1.default {
             if (!request.enforced && (this.isPaused() || this.isStopped()))
                 return;
             if (!this.hasCapability(types_1.IncyclistCapability.Control))
-                return yield this.getCyclingMode().sendBikeUpdate(request);
+                return this.getCyclingMode().sendBikeUpdate(request);
             else
                 throw new Error('method not implemented');
         });
@@ -223,11 +227,15 @@ class IncyclistDevice extends events_1.default {
         const updateFrequency = this.getMaxUpdateFrequency();
         if (updateFrequency === -1 || updateFrequency === undefined)
             return true;
-        return (!this.lastUpdate || (Date.now() - this.lastUpdate) > updateFrequency);
+        const ok = (!this.lastUpdate || (Date.now() - this.lastUpdate) > updateFrequency);
+        return ok;
     }
     canEmitData() {
-        if (this.paused || this.stopped)
+        if (this.scanning)
+            return this.isUpdateWithinFrequency();
+        if (this.paused || this.stopped) {
             return false;
+        }
         return this.isUpdateWithinFrequency();
     }
     emitData(data) {
@@ -261,6 +269,12 @@ class IncyclistDevice extends events_1.default {
     onData(callback) {
         this.onDataFn = callback;
     }
+    onScanStart() {
+        this.scanning = true;
+    }
+    onScanStop() {
+        this.scanning = false;
+    }
 }
 IncyclistDevice.controllers = {};
 exports.default = IncyclistDevice;

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

@@ -1,34 +1,30 @@
 import BleAdapter from "./base/adapter";
-import { BleDeviceSettings, BleProtocol } from "./types";
+import { BleDeviceSettings, BleProtocol, TBleSensor } from "./types";
 import { DeviceProperties } from "../types";
-import { BleComms } from "./base/comms";
 import { BleDeviceData } from "./base/types";
-export interface BleAdapterInfo {
+export interface BleAdapterInfo<T extends TBleSensor> {
     protocol: BleProtocol;
-    Adapter: typeof BleAdapter<BleDeviceData, BleComms>;
-    Comm: typeof BleComms;
+    Adapter: typeof BleAdapter<BleDeviceData, T>;
+    Comm: typeof TBleSensor;
 }
-export default class BleAdapterFactory {
-    static _instance: BleAdapterFactory;
-    implementations: BleAdapterInfo[];
-    instances: Array<BleAdapter<BleDeviceData, BleComms>>;
-    static getInstance(): BleAdapterFactory;
-    constructor();
-    getAdapterInfo(protocol: BleProtocol): BleAdapterInfo;
-    getAll(): BleAdapterInfo[];
-    createInstance(settings: BleDeviceSettings, props?: DeviceProperties): BleAdapter<BleDeviceData, BleComms>;
+export default class BleAdapterFactory<T extends TBleSensor> {
+    transport: string;
+    static readonly _instances: Record<string, BleAdapterFactory<any>>;
+    implementations: BleAdapterInfo<any>[];
+    instances: Array<BleAdapter<BleDeviceData, T>>;
+    static getInstance(transport: string): BleAdapterFactory<any>;
+    constructor(transport: string);
+    getAdapterInfo(protocol: BleProtocol): BleAdapterInfo<T>;
+    getAll(): BleAdapterInfo<T>[];
+    createInstance(settings: BleDeviceSettings, props?: DeviceProperties): BleAdapter<BleDeviceData, T>;
     removeInstance(query: {
         settings?: BleDeviceSettings;
-        adapter?: BleAdapter<BleDeviceData, BleComms>;
+        adapter?: BleAdapter<BleDeviceData, T>;
     }): void;
-    find(settings?: BleDeviceSettings): BleAdapter<BleDeviceData, BleComms>;
-    register(protocol: BleProtocol, Adapter: typeof BleAdapter<BleDeviceData, BleComms>, Comm: typeof BleComms): void;
-    getAllInstances(): Array<BleAdapter<BleDeviceData, BleComms>>;
-    getAllSupportedComms(): (typeof BleComms)[];
-    getAllSupportedAdapters(): Array<(typeof BleAdapter<BleDeviceData, BleComms>)>;
+    find(settings?: BleDeviceSettings): BleAdapter<BleDeviceData, T>;
+    register(protocol: BleProtocol, Adapter: typeof BleAdapter<BleDeviceData, T>, Comm: typeof TBleSensor): void;
+    getAllInstances(): Array<BleAdapter<BleDeviceData, T>>;
+    getAllSupportedComms(): (typeof TBleSensor)[];
+    getAllSupportedAdapters(): Array<(typeof BleAdapter<BleDeviceData, T>)>;
     getAllSupportedServices(): string[];
-    getDeviceClasses(peripheral: any, props?: {
-        protocol?: BleProtocol;
-        services?: string[];
-    }): (typeof BleComms)[];
 }

package/lib/ble/adapter-factory.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const comms_utils_1 = require("./base/comms-utils");
 const utils_1 = require("./utils");
 class BleAdapterFactory {
-    static getInstance() {
-        if (!BleAdapterFactory._instance)
-            BleAdapterFactory._instance = new BleAdapterFactory();
-        return BleAdapterFactory._instance;
+    static getInstance(transport) {
+        if (!BleAdapterFactory._instances[transport])
+            BleAdapterFactory._instances[transport] = new BleAdapterFactory(transport);
+        return BleAdapterFactory._instances[transport];
     }
-    constructor() {
+    constructor(transport) {
+        this.transport = transport;
         this.implementations = [];
         this.instances = [];
     }
@@ -37,7 +37,8 @@ class BleAdapterFactory {
             return existing;
         }
         const info = this.getAdapterInfo(protocol);
-        if (!info || !info.Adapter)
+        console.log('~~~~ INFO:', info);
+        if (!(info === null || info === void 0 ? void 0 : info.Adapter))
             return;
         const adapter = new info.Adapter(adapterSettings, props);
         this.instances.push(adapter);
@@ -69,42 +70,18 @@ class BleAdapterFactory {
         return this.instances;
     }
     getAllSupportedComms() {
-        const supported = BleAdapterFactory.getInstance().getAll();
+        const supported = this.getAll();
         return supported.map(info => info.Comm);
     }
     getAllSupportedAdapters() {
-        const supported = BleAdapterFactory.getInstance().getAll();
+        const supported = this.getAll();
         return supported.map(info => info.Adapter);
     }
     getAllSupportedServices() {
-        const supported = BleAdapterFactory.getInstance().getAll();
-        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);
-                    });
-                }
-            });
-        }
+        const supported = this.getAll();
+        const res = ['180d', '1818', '1826', '6e40fec1'];
         return res;
     }
-    getDeviceClasses(peripheral, props = {}) {
-        let DeviceClasses;
-        const { protocol, services = peripheral.advertisement.serviceUuids } = props;
-        const classes = this.getAllSupportedComms();
-        DeviceClasses = (0, comms_utils_1.getDevicesFromServices)(classes, services);
-        if (protocol && DeviceClasses && DeviceClasses.length > 0) {
-            DeviceClasses = DeviceClasses.filter((C) => {
-                const device = new C({ peripheral });
-                if (device.getProtocol() !== protocol)
-                    return false;
-                return true;
-            });
-        }
-        return DeviceClasses;
-    }
 }
+BleAdapterFactory._instances = {};
 exports.default = BleAdapterFactory;

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

@@ -1,22 +1,25 @@
 import IncyclistDevice from "../../base/adpater";
-import { BleComms } from "./comms";
-import BleInterface from "../ble-interface";
-import { BleDeviceProperties, BleDeviceSettings, BleStartProperties } from "../types";
+import { BleDeviceProperties, BleDeviceSettings, BleStartProperties, IBleInterface, IBlePeripheral } from "../types";
 import { IAdapter, IncyclistBikeData, IncyclistAdapterData, DeviceProperties } from "../../types";
 import { BleDeviceData } from "./types";
 import { LegacyProfile } from "../../antv2/types";
 import ICyclingMode from "../../modes/types";
-export default class BleAdapter<TDeviceData extends BleDeviceData, TDevice extends BleComms> extends IncyclistDevice<BleDeviceProperties> {
-    protected ble: BleInterface;
+import { InteruptableTask, TaskState } from "../../utils/task";
+import { TBleSensor } from "./sensor";
+export default class BleAdapter<TDeviceData extends BleDeviceData, TDevice extends TBleSensor> extends IncyclistDevice<BleDeviceProperties> {
     protected deviceData: TDeviceData;
     protected data: IncyclistAdapterData;
     protected dataMsgCount: number;
     protected lastDataTS: number;
     protected device: TDevice;
     protected onDeviceDataHandler: any;
+    protected startTask: InteruptableTask<TaskState, boolean>;
     constructor(settings: BleDeviceSettings, props?: DeviceProperties);
     getUniqueName(): string;
     connect(): Promise<boolean>;
+    getPeripheral(): IBlePeripheral;
+    waitForPeripheral(): Promise<void>;
+    updateSensor(peripheral: IBlePeripheral): void;
     close(): Promise<boolean>;
     getComms(): TDevice;
     isEqual(settings: BleDeviceSettings): boolean;
@@ -35,11 +38,22 @@ export default class BleAdapter<TDeviceData extends BleDeviceData, TDevice exten
     getSettings(): BleDeviceSettings;
     setProperties(props: BleDeviceProperties): void;
     check(): Promise<boolean>;
+    getDefaultStartupTimeout(): number;
     startPreChecks(props: BleStartProperties): Promise<'done' | 'connected' | 'connection-failed'>;
     start(startProps?: BleStartProperties): Promise<boolean>;
+    protected isStarting(): boolean;
+    protected hasData(): boolean;
+    protected waitForInitialData(startupTimeout: any): Promise<void>;
+    protected checkCapabilities(): void;
+    protected initControl(_props?: BleStartProperties): Promise<void>;
+    protected startAdapter(startProps?: BleStartProperties): Promise<boolean>;
+    startSensor(): Promise<boolean>;
+    protected onDisconnectDone(): Promise<void>;
     stop(): Promise<boolean>;
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;
+    protected getBle(): IBleInterface<any>;
     update(): void;
     setCyclingMode(mode: string | ICyclingMode, settings?: any, sendInitCommands?: boolean): void;
+    onScanStart(): void;
 }