incyclist-devices 1.5.38 → 2.0.0-beta.1

package/lib/ble/adapter.js

@@ -0,0 +1,188 @@
+"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) {
+        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 });
+exports.BleControllableAdapter = void 0;
+const adpater_1 = __importStar(require("../base/adpater"));
+const ble_interface_1 = __importDefault(require("./ble-interface"));
+const INTERFACE_NAME = 'ble';
+class BleAdapter extends adpater_1.default {
+    constructor(settings, props) {
+        super(settings, props);
+        if (this.settings.interface !== INTERFACE_NAME)
+            throw new Error('Incorrect interface');
+        this.deviceData = {};
+        this.data = {};
+        this.dataMsgCount = 0;
+        this.updateFrequency = 1000;
+        this.ble = ble_interface_1.default.getInstance();
+    }
+    isEqual(settings) {
+        const as = this.settings;
+        if (as.interface !== settings.interface)
+            return false;
+        if (as.protocol === 'BLE' || settings.protocol === 'BLE') {
+            return (as.protocol === settings.protocol && as.profile === settings.profile && as.name === settings.name);
+        }
+        else {
+            return (as.protocol === settings.protocol && (as.name === settings.name || as.address === settings.address || as.id === settings.id));
+        }
+    }
+    resetData() {
+        this.dataMsgCount = 0;
+        this.deviceData = {};
+        this.data = {};
+        this.lastDataTS = undefined;
+    }
+    getInterface() {
+        return INTERFACE_NAME;
+    }
+    getProtocolName() {
+        const settings = this.settings;
+        return settings.protocol;
+    }
+    getID() {
+        const settings = this.settings;
+        return settings.id;
+    }
+    getName() {
+        const settings = this.settings;
+        return settings.name || settings.id || settings.address;
+    }
+    onDeviceData(deviceData) {
+        this.dataMsgCount++;
+        this.lastDataTS = Date.now();
+        this.deviceData = Object.assign({}, deviceData);
+    }
+    start(props = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.started)
+                return true;
+            this.logger.logEvent({ message: 'start requested', protocol: this.getProtocolName(), props });
+            try {
+                const bleDevice = yield this.ble.connectDevice(this.device);
+                if (bleDevice) {
+                    this.device = bleDevice;
+                    bleDevice.on('data', (data) => {
+                        this.onDeviceData(data);
+                    });
+                    this.resetData();
+                    this.stopped = false;
+                    this.started = true;
+                    this.paused = false;
+                    return true;
+                }
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'start result: error', error: err.message, protocol: this.getProtocolName() });
+                throw new Error(`could not start device, reason:${err.message}`);
+            }
+        });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'stop requested', protocol: this.getProtocolName() });
+            this.device.reset();
+            const stopped = this.device.disconnect();
+            if (stopped) {
+                this.stopped = true;
+                this.started = false;
+                this.paused = false;
+                return true;
+            }
+            return false;
+        });
+    }
+}
+exports.default = BleAdapter;
+class BleControllableAdapter extends BleAdapter {
+    constructor(settings, props) {
+        super(settings, props);
+        this.cyclingMode = this.getDefaultCyclingMode();
+        this.user = {};
+    }
+    setUser(user) {
+        this.user = user;
+        if (!user.weight)
+            this.user.weight = adpater_1.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 = adpater_1.DEFAULT_PROPS } = this;
+        const userWeight = user.weight || props.userWeight || adpater_1.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);
+    }
+    getCyclingMode() {
+        if (!this.cyclingMode)
+            this.setCyclingMode(this.getDefaultCyclingMode());
+        return this.cyclingMode;
+    }
+}
+exports.BleControllableAdapter = BleControllableAdapter;

package/lib/ble/{ble-device.d.ts → ble-comms.d.ts}

@@ -1,12 +1,15 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { EventLogger } from "gd-eventlog";
-import { BleInterfaceClass, BleDeviceClass, BlePeripheral, BleDeviceProps, ConnectProps, BleDeviceInfo, BleWriteProps } from "./ble";
+import { BleInterfaceClass } from "./ble";
 import BlePeripheralConnector from "./ble-peripheral";
+import { BleDeviceCommsClass, ConnectProps, BleDeviceInfo, BlePeripheral, BleDeviceProps, BleWriteProps } from './types';
 interface BleDeviceConstructProps extends BleDeviceProps {
     log?: boolean;
     logger?: EventLogger;
+    peripheral?: BlePeripheral;
 }
-declare type CommandQueueItem = {
+type CommandQueueItem = {
     uuid: string;
     data: Buffer;
     timeout: number;
@@ -18,7 +21,7 @@ export interface MessageLog {
     timestamp: any;
     data: string;
 }
-export declare abstract class BleDevice extends BleDeviceClass {
+export declare class BleComms extends BleDeviceCommsClass {
     id: string;
     address: string;
     name: string;
@@ -35,11 +38,14 @@ export declare abstract class BleDevice extends BleDeviceClass {
     workerIv: NodeJS.Timeout;
     prevMessages: MessageLog[];
     constructor(props?: BleDeviceConstructProps);
+    getServiceUUids(): string[];
+    getProfile(): string;
     getServices(): string[];
     logEvent(event: any): void;
     setLogger(logger: EventLogger): void;
     setInterface(ble: BleInterfaceClass): void;
     isMatching(characteristics: string[]): boolean;
+    reset(): void;
     cleanupListeners(): void;
     onDisconnect(): void;
     waitForConnectFinished(timeout: any): Promise<unknown>;
@@ -50,7 +56,6 @@ export declare abstract class BleDevice extends BleDeviceClass {
     subscribeAll(conn?: BlePeripheralConnector): Promise<void>;
     connect(props?: ConnectProps): Promise<boolean>;
     disconnect(): Promise<boolean>;
-    abstract getProfile(): string;
     checkForDuplicate(characteristic: string, data: Buffer): boolean;
     onData(characteristic: string, _data: Buffer): boolean;
     timeoutCheck(): void;

package/lib/ble/{ble-device.js → ble-comms.js}

@@ -8,14 +8,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 });
-exports.BleDevice = void 0;
+exports.BleComms = void 0;
 const gd_eventlog_1 = require("gd-eventlog");
-const ble_1 = require("./ble");
-const ble_2 = require("./ble");
+const utils_1 = require("./utils");
+const types_1 = require("./types");
+const ble_interface_1 = __importDefault(require("./ble-interface"));
 const CONNECT_WAIT_TIMEOUT = 10000;
 const BLE_TIMEOUT = 1000;
-class BleDevice extends ble_1.BleDeviceClass {
+class BleComms extends types_1.BleDeviceCommsClass {
     constructor(props) {
         super();
         this.characteristics = [];
@@ -24,7 +28,7 @@ class BleDevice extends ble_1.BleDeviceClass {
         this.address = props.address;
         this.name = props.name;
         this.services = props.services;
-        this.ble = props.ble;
+        this.ble = ble_interface_1.default.getInstance();
         this.characteristics = [];
         this.subscribedCharacteristics = [];
         this.isInitialized = false;
@@ -47,6 +51,12 @@ class BleDevice extends ble_1.BleDeviceClass {
             this.logger = new gd_eventlog_1.EventLogger('BleDevice');
         }
     }
+    getServiceUUids() {
+        throw new Error("Method not implemented.");
+    }
+    getProfile() {
+        throw new Error("Method not implemented.");
+    }
     getServices() {
         return this.services;
     }
@@ -67,6 +77,8 @@ class BleDevice extends ble_1.BleDeviceClass {
     isMatching(characteristics) {
         return true;
     }
+    reset() {
+    }
     cleanupListeners() {
         if (this.characteristics === undefined) {
             this.characteristics = [];
@@ -74,7 +86,7 @@ class BleDevice extends ble_1.BleDeviceClass {
         else {
             const connector = this.ble.getConnector(this.peripheral);
             this.characteristics.forEach(c => {
-                connector.removeAllListeners((0, ble_1.uuid)(c.uuid));
+                connector.removeAllListeners((0, utils_1.uuid)(c.uuid));
             });
         }
     }
@@ -114,7 +126,7 @@ class BleDevice extends ble_1.BleDeviceClass {
         });
     }
     hasService(serviceUuid) {
-        return this.services && this.services.find(s => s === serviceUuid || (0, ble_1.uuid)(serviceUuid)) !== undefined;
+        return this.services && this.services.find(s => s === serviceUuid || (0, utils_1.uuid)(serviceUuid)) !== undefined;
     }
     init() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -296,7 +308,7 @@ class BleDevice extends ble_1.BleDeviceClass {
         }
         this.logEvent({ message: 'got data', characteristic, data: data.toString('hex'), writeQueue: this.writeQueue.length });
         if (this.writeQueue.length > 0) {
-            const writeIdx = this.writeQueue.findIndex(i => (0, ble_2.matches)(i.uuid, characteristic));
+            const writeIdx = this.writeQueue.findIndex(i => (0, utils_1.matches)(i.uuid, characteristic));
             if (writeIdx !== -1) {
                 const writeItem = this.writeQueue[writeIdx];
                 this.writeQueue.splice(writeIdx, 1);
@@ -358,7 +370,7 @@ class BleDevice extends ble_1.BleDeviceClass {
                     this.subscribedCharacteristics.push(characteristicUuid);
                 }
                 return new Promise((resolve, reject) => {
-                    const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, ble_1.uuid)(c.uuid) === characteristicUuid);
+                    const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, utils_1.uuid)(c.uuid) === characteristicUuid);
                     if (!characteristic) {
                         reject(new Error('Characteristic not found'));
                         return;
@@ -402,7 +414,7 @@ class BleDevice extends ble_1.BleDeviceClass {
         return new Promise((resolve, reject) => {
             if (!this.isConnected())
                 return reject(new Error('not connected'));
-            const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, ble_1.uuid)(c.uuid) === characteristicUuid);
+            const characteristic = this.characteristics.find(c => c.uuid === characteristicUuid || (0, utils_1.uuid)(c.uuid) === characteristicUuid);
             if (!characteristic) {
                 reject(new Error('Characteristic not found'));
                 return;
@@ -441,4 +453,4 @@ class BleDevice extends ble_1.BleDeviceClass {
         });
     }
 }
-exports.BleDevice = BleDevice;
+exports.BleComms = BleComms;

package/lib/ble/ble-interface.d.ts

@@ -1,6 +1,9 @@
 /// <reference types="node" />
 import { EventLogger } from 'gd-eventlog';
-import { BleInterfaceClass, ConnectProps, ScanProps, BleDeviceClass, BlePeripheral, BleBinding, BleCharacteristic, BleDeviceDescription } from './ble';
+import { BleInterfaceClass, BleScanProps, BleBinding } from './ble';
+import { BleComms } from './ble-comms';
+import BleAdapterFactory from './adapter-factory';
+import { ConnectProps, BlePeripheral, BleCharacteristic, BleDeviceSettings } from './types';
 export interface ScanState {
     isScanning: boolean;
     isConnecting: boolean;
@@ -19,11 +22,11 @@ export interface PeripheralState {
     isInterrupted: boolean;
 }
 export interface BleDeviceInfo {
-    device: BleDeviceClass;
+    device: BleComms;
     isConnected: boolean;
 }
 export interface BleDeviceClassInfo {
-    Class: typeof BleDeviceClass;
+    Class: typeof BleComms;
     type: string;
     services: string[];
     id: string;
@@ -41,7 +44,6 @@ export default class BleInterface extends BleInterfaceClass {
     devices: BleDeviceInfo[];
     peripheralCache: any[];
     logger: EventLogger;
-    static deviceClasses: BleDeviceClassInfo[];
     static _instance: BleInterface;
     static getInstance(props?: {
         binding?: BleBinding;
@@ -53,18 +55,13 @@ export default class BleInterface extends BleInterfaceClass {
         log?: boolean;
         logger?: EventLogger;
     });
-    static register(id: string, type: string, Class: typeof BleDeviceClass, services: string[]): void;
+    getAdapterFactory(): BleAdapterFactory;
     logEvent(event: any): void;
     onStateChange(state: any): void;
     onError(err: any): void;
     connect(props?: ConnectProps): Promise<boolean>;
     disconnect(): Promise<boolean>;
     isConnected(): boolean;
-    getDevicesFromServices(deviceTypes: (typeof BleDeviceClass)[], services: string | string[]): (typeof BleDeviceClass)[];
-    getAllSupportedServices(): any[];
-    getAllSupportedDeviceTypes(): (typeof BleDeviceClass)[];
-    getServicesFromDeviceTypes(deviceTypes: (typeof BleDeviceClass)[]): string[];
-    getServicesFromDevice(device: BleDeviceClass): string[];
     waitForConnectFinished(timeout: any): Promise<unknown>;
     addPeripheralToCache(peripheral: any, props?: {}): void;
     onDisconnect(peripheral: any): void;
@@ -75,26 +72,20 @@ export default class BleInterface extends BleInterfaceClass {
         name?: string;
     }): BlePeripheral;
     getCharacteristics(peripheral: any): Promise<any>;
-    getDeviceClasses(peripheral: any, props?: {
-        deviceTypes?: (typeof BleDeviceClass)[];
-        profile?: string;
-        services?: string[];
-    }): (typeof BleDeviceClass)[];
-    createDevice(DeviceClass: (typeof BleDeviceClass), peripheral: BlePeripheral, characteristics?: BleCharacteristic[]): BleDeviceClass;
-    connectDevice(requested: BleDeviceClass | BleDeviceDescription, timeout?: number): Promise<BleDeviceClass>;
+    createDeviceComms(DeviceClass: (typeof BleComms), peripheral: BlePeripheral, characteristics?: BleCharacteristic[]): any;
+    connectDevice(requested: BleComms | BleDeviceSettings, timeout?: number): Promise<BleComms>;
     waitForScanFinished(timeout: any): Promise<unknown>;
-    getBestDeviceMatch(DeviceClasses: (typeof BleDeviceClass)[]): typeof BleDeviceClass;
-    scan(props: ScanProps): Promise<BleDeviceClass[]>;
+    scan(props: BleScanProps): Promise<BleComms[]>;
     stopScan(): Promise<boolean>;
     isScanning(): boolean;
-    addConnectedDevice(device: BleDeviceClass): void;
-    addDeviceToCache(device: BleDeviceClass, isConnected: boolean): void;
-    findConnected(device: BleDeviceClass | BlePeripheral): BleDeviceClass;
+    addConnectedDevice(device: BleComms): void;
+    addDeviceToCache(device: BleComms, isConnected: boolean): void;
+    findConnected(device: BleComms | BlePeripheral): BleComms;
     findDeviceInCache(device: {
         id?: string;
         address?: string;
         name?: string;
         profile: string;
-    }): BleDeviceClass;
-    removeConnectedDevice(device: BleDeviceClass): void;
+    }): BleComms;
+    removeConnectedDevice(device: BleComms): void;
 }