incyclist-devices 2.0.0-beta.1 → 2.0.1

package/lib/ble/adapter-factory.js

@@ -1,19 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapLegacyProfile = void 0;
+const comms_utils_1 = require("./base/comms-utils");
 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)
@@ -21,44 +9,70 @@ class BleAdapterFactory {
         return BleAdapterFactory._instance;
     }
     constructor() {
-        this.adapters = [];
+        this.implementations = [];
+        this.instances = [];
     }
-    getAdapter(protocol) {
-        return this.adapters.find(a => a.protocol === protocol);
+    getAdapterInfo(protocol) {
+        return this.implementations.find(a => a.protocol === protocol);
     }
-    getAllAdapters() {
-        return this.adapters;
+    getAll() {
+        return this.implementations;
     }
     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;
+        if (profile) {
+            const mapping = (0, utils_1.mapLegacyProfile)(profile);
+            protocol = adapterSettings.protocol = mapping.protocol;
+            delete adapterSettings.profile;
+        }
+        const existing = this.find(adapterSettings);
+        if (existing) {
+            existing.setProperties(props);
+            return existing;
         }
-        const info = this.getAdapter(protocol);
+        const info = this.getAdapterInfo(protocol);
         if (!info || !info.Adapter)
             return;
         const adapter = new info.Adapter(adapterSettings, props);
+        this.instances.push(adapter);
         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;
+    removeInstance(query) {
+        let idx = -1;
+        if (query.settings) {
+            idx = this.instances.findIndex(a => a.isEqual(query.settings));
+        }
+        else if (query.adapter) {
+            idx = this.instances.findIndex(a => a.isEqual(query.adapter.getSettings()));
+        }
+        if (idx !== -1)
+            this.instances.splice(idx);
+    }
+    find(settings) {
+        return this.instances.find(a => a.isEqual(settings));
+    }
+    register(protocol, Adapter, Comm) {
+        const info = Object.assign({}, { protocol, Adapter, Comm });
+        const existing = this.implementations.findIndex(a => a.protocol === protocol);
+        if (existing !== -1)
+            this.implementations[existing] = info;
         else
-            this.adapters.push(info);
+            this.implementations.push(info);
+    }
+    getAllInstances() {
+        return this.instances;
     }
-    getAllSupportedDeviceTypes() {
-        const supported = BleAdapterFactory.getInstance().getAllAdapters();
+    getAllSupportedComms() {
+        const supported = BleAdapterFactory.getInstance().getAll();
         return supported.map(info => info.Comm);
     }
+    getAllSupportedAdapters() {
+        const supported = BleAdapterFactory.getInstance().getAll();
+        return supported.map(info => info.Adapter);
+    }
     getAllSupportedServices() {
-        const supported = BleAdapterFactory.getInstance().getAllAdapters();
+        const supported = BleAdapterFactory.getInstance().getAll();
         const res = [];
         if (supported && supported.length > 0) {
             supported.forEach(info => {
@@ -74,18 +88,13 @@ class BleAdapterFactory {
     }
     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 { 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.getProfile() !== profile)
+                if (device.getProtocol() !== protocol)
                     return false;
                 return true;
             });

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

@@ -0,0 +1,53 @@
+import IncyclistDevice from "../../base/adpater";
+import CyclingMode, { IncyclistBikeData } 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 "./comms";
+import BleInterface from "../ble-interface";
+import { BleDeviceProperties, BleDeviceSettings, BleStartProperties } from "../types";
+export default class BleAdapter extends IncyclistDevice {
+    ble: BleInterface;
+    deviceData: any;
+    data: DeviceData;
+    dataMsgCount: number;
+    lastDataTS: number;
+    device: BleComms;
+    constructor(settings: BleDeviceSettings, props?: DeviceProperties);
+    getUniqueName(): string;
+    connect(): Promise<boolean>;
+    close(): Promise<boolean>;
+    getComms(): BleComms;
+    isEqual(settings: BleDeviceSettings): boolean;
+    isSame(adapter: BleAdapter): boolean;
+    isConnected(): boolean;
+    resetData(): void;
+    getInterface(): string;
+    getProtocolName(): string;
+    getID(): string;
+    getName(): string;
+    onDeviceData(deviceData: any): void;
+    mapData(deviceData: any): DeviceData | IncyclistBikeData;
+    transformData(data: IncyclistBikeData): DeviceData;
+    getSettings(): BleDeviceSettings;
+    setProperties(props: BleDeviceProperties): void;
+    check(): Promise<boolean>;
+    start(props?: BleStartProperties): Promise<any>;
+    stop(): Promise<boolean>;
+    pause(): Promise<boolean>;
+    resume(): Promise<boolean>;
+}
+export declare class BleControllableAdapter extends BleAdapter implements Bike {
+    cyclingMode: CyclingMode;
+    user?: User;
+    constructor(settings: BleDeviceSettings, props?: DeviceProperties);
+    setUser(user: User): void;
+    isControllable(): boolean;
+    setBikeProps(props: DeviceProperties): void;
+    getWeight(): number;
+    getSupportedCyclingModes(): any[];
+    getDefaultCyclingMode(): CyclingMode;
+    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
+    getCyclingMode(): CyclingMode;
+}

package/lib/ble/{adapter.js → base/adapter.js}

@@ -36,8 +36,8 @@ var __importDefault = (this && this.__importDefault) || function (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 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) {
@@ -50,17 +50,65 @@ class BleAdapter extends adpater_1.default {
         this.updateFrequency = 1000;
         this.ble = ble_interface_1.default.getInstance();
     }
+    getUniqueName() {
+        const settings = this.settings;
+        if (settings.name.match(/[0-9]/g) || settings.address === undefined)
+            return this.settings.name;
+        else {
+            const addressHash = settings.address.substring(0, 2) + settings.address.slice(-2);
+            return `${this.getName()} ${addressHash}`;
+        }
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.device) {
+                throw new Error('No Comms');
+            }
+            if (this.isConnected())
+                return true;
+            let connected = false;
+            try {
+                connected = yield this.device.connect();
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'connect()', error: err.message, stack: err.stack });
+            }
+            return connected;
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.device || !this.isConnected())
+                return true;
+            if (this.device) {
+                yield this.device.disconnect();
+                this.ble.removeConnectedDevice(this);
+                return true;
+            }
+        });
+    }
+    getComms() {
+        return this.device;
+    }
     isEqual(settings) {
         const as = this.settings;
         if (as.interface !== settings.interface)
             return false;
-        if (as.protocol === 'BLE' || settings.protocol === 'BLE') {
+        if (as.profile || settings.profile) {
             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));
+            return (as.protocol === settings.protocol && ((as.name && settings.name && as.name === settings.name) ||
+                (as.address && settings.address && as.address === settings.address) ||
+                (as.id && settings.id && as.id === settings.id)));
         }
     }
+    isSame(adapter) {
+        return this.isEqual(adapter.getSettings());
+    }
+    isConnected() {
+        return this.device && this.device.isConnected();
+    }
     resetData() {
         this.dataMsgCount = 0;
         this.deviceData = {};
@@ -86,17 +134,46 @@ class BleAdapter extends adpater_1.default {
         this.dataMsgCount++;
         this.lastDataTS = Date.now();
         this.deviceData = Object.assign({}, deviceData);
+        if (!this.started || !this.canSendUpdate())
+            return;
+        this.logEvent({ message: 'onDeviceData', data: deviceData, isControllable: (this instanceof BleControllableAdapter) });
+        if (this instanceof BleControllableAdapter) {
+            const mappedData = this.mapData(deviceData);
+            const incyclistData = this.getCyclingMode().updateData(mappedData);
+            this.data = this.transformData(incyclistData);
+        }
+        else {
+            this.data = this.mapData(this.deviceData);
+        }
+        this.emitData(this.data);
+    }
+    mapData(deviceData) {
+        throw new Error('message not implemented');
+    }
+    transformData(data) {
+        throw new Error('message not implemented');
+    }
+    getSettings() {
+        return this.settings;
+    }
+    setProperties(props) {
+        this.props = props;
+    }
+    check() {
+        return this.start({ scanOnly: true });
     }
     start(props = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.started)
                 return true;
+            const connected = yield this.connect();
+            if (!connected)
+                throw new Error(`could not start device, reason:could not connect`);
             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) => {
+                const comms = this.device;
+                if (comms) {
+                    comms.on('data', (data) => {
                         this.onDeviceData(data);
                     });
                     this.resetData();
@@ -126,6 +203,28 @@ class BleAdapter extends adpater_1.default {
             return false;
         });
     }
+    pause() {
+        const _super = Object.create(null, {
+            pause: { get: () => super.pause }
+        });
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield _super.pause.call(this);
+            (_a = this.getComms()) === null || _a === void 0 ? void 0 : _a.pause();
+            return res;
+        });
+    }
+    resume() {
+        const _super = Object.create(null, {
+            resume: { get: () => super.resume }
+        });
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield _super.resume.call(this);
+            (_a = this.getComms()) === null || _a === void 0 ? void 0 : _a.resume();
+            return res;
+        });
+    }
 }
 exports.default = BleAdapter;
 class BleControllableAdapter extends BleAdapter {
@@ -139,8 +238,11 @@ class BleControllableAdapter extends BleAdapter {
         if (!user.weight)
             this.user.weight = adpater_1.DEFAULT_USER_WEIGHT;
     }
+    isControllable() {
+        return true;
+    }
     setBikeProps(props) {
-        const { user, userWeight, bikeWeight } = props || {};
+        const { user, userWeight } = props || {};
         if (user)
             this.setUser(user);
         if (userWeight)

package/lib/ble/base/comms-utils.d.ts

@@ -0,0 +1,7 @@
+import { BleProtocol } from "../types";
+import { BleComms } from "./comms";
+export declare function getBestDeviceMatch(DeviceClasses: (typeof BleComms)[]): typeof BleComms;
+export declare function getDevicesFromServices(deviceTypes: (typeof BleComms)[], services: string | string[]): (typeof BleComms)[];
+export declare function getServicesFromDeviceTypes(deviceTypes: (typeof BleComms)[]): string[];
+export declare function getServicesFromProtocols(protocols: BleProtocol[]): string[];
+export declare function getServicesFromDevice(device: BleComms): string[];

package/lib/ble/base/comms-utils.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServicesFromDevice = exports.getServicesFromProtocols = exports.getServicesFromDeviceTypes = exports.getDevicesFromServices = exports.getBestDeviceMatch = void 0;
+const adapter_factory_1 = __importDefault(require("../adapter-factory"));
+const utils_1 = require("../utils");
+function getBestDeviceMatch(DeviceClasses) {
+    if (!DeviceClasses || DeviceClasses.length === 0)
+        return;
+    const details = DeviceClasses.map(c => ({ name: c.prototype.constructor.name, priority: c.detectionPriority || 0, class: c }));
+    details.sort((a, b) => b.priority - a.priority);
+    return details[0].class;
+}
+exports.getBestDeviceMatch = getBestDeviceMatch;
+function getDevicesFromServices(deviceTypes, services) {
+    if (!deviceTypes || !Array.isArray(deviceTypes) || deviceTypes.length === 0) {
+        return [];
+    }
+    const get = (deviceTypes, fnCompare) => {
+        const types = deviceTypes.filter(DeviceType => {
+            const C = DeviceType;
+            let found = false;
+            if (C.services)
+                found = C.services.find((s) => fnCompare(s));
+            return found;
+        });
+        return types;
+    };
+    if (typeof services === 'string') {
+        return get(deviceTypes, (s) => (0, utils_1.matches)(s, services));
+    }
+    if (Array.isArray(services)) {
+        const sids = services.map(utils_1.uuid);
+        return get(deviceTypes, s => {
+            const res = sids.find((service) => (0, utils_1.matches)(s, service));
+            return res !== undefined;
+        });
+    }
+    return [];
+}
+exports.getDevicesFromServices = getDevicesFromServices;
+function getServicesFromDeviceTypes(deviceTypes) {
+    let services = [];
+    try {
+        if (!deviceTypes || !Array.isArray(deviceTypes) || deviceTypes.length === 0) {
+            return [];
+        }
+        deviceTypes.forEach(DeviceType => {
+            if (DeviceType.services) {
+                const dtServices = DeviceType.services;
+                dtServices.forEach(s => {
+                    if (!services.find(s2 => s2 === s))
+                        services.push(s);
+                });
+            }
+        });
+    }
+    catch (err) {
+        console.log(err);
+    }
+    return services;
+}
+exports.getServicesFromDeviceTypes = getServicesFromDeviceTypes;
+function getServicesFromProtocols(protocols) {
+    const services = [];
+    const comms = adapter_factory_1.default.getInstance().getAllSupportedComms();
+    comms
+        .filter((C) => protocols.find(p => p === C.protocol) !== undefined)
+        .forEach((C) => {
+        C.services.forEach(s => {
+            if (!services.find(s2 => s2 === s))
+                services.push(s);
+        });
+    });
+    return services;
+}
+exports.getServicesFromProtocols = getServicesFromProtocols;
+function getServicesFromDevice(device) {
+    if (!device)
+        return [];
+    const services = [];
+    const dServices = device.getServiceUUids();
+    dServices.forEach(s => {
+        if (!services.find(s2 => s2 === s))
+            services.push(s);
+    });
+    return services;
+}
+exports.getServicesFromDevice = getServicesFromDevice;

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

@@ -1,14 +1,12 @@
 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
+import EventEmitter from "events";
 import { EventLogger } from "gd-eventlog";
-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;
-}
+import { LegacyProfile } from "../../antv2/types";
+import BleInterface from "../ble-interface";
+import BlePeripheralConnector from "../ble-peripheral";
+import { BleCharacteristic, BleCommsConnectProps, BleDeviceConstructProps, BleDeviceInfo, BleDeviceSettings, BlePeripheral, BleProtocol, BleWriteProps, ConnectState, IBlePeripheralConnector } from "../types";
 type CommandQueueItem = {
     uuid: string;
     data: Buffer;
@@ -21,14 +19,17 @@ export interface MessageLog {
     timestamp: any;
     data: string;
 }
-export declare class BleComms extends BleDeviceCommsClass {
+export declare class BleComms extends EventEmitter {
+    static services: string[];
+    static protocol: BleProtocol;
     id: string;
+    paused: boolean;
     address: string;
     name: string;
     services: string[];
-    ble: BleInterfaceClass;
+    ble: BleInterface;
     peripheral?: BlePeripheral;
-    characteristics: any[];
+    characteristics: BleCharacteristic[];
     state?: string;
     logger?: EventLogger;
     deviceInfo: BleDeviceInfo;
@@ -37,24 +38,33 @@ export declare class BleComms extends BleDeviceCommsClass {
     writeQueue: CommandQueueItem[];
     workerIv: NodeJS.Timeout;
     prevMessages: MessageLog[];
+    connectState: ConnectState;
     constructor(props?: BleDeviceConstructProps);
+    getConnectState(): ConnectState;
+    isConnected(): boolean;
+    pause(): void;
+    resume(): void;
     getServiceUUids(): string[];
-    getProfile(): string;
+    getProfile(): LegacyProfile;
+    getProtocol(): BleProtocol;
+    getSettings(): BleDeviceSettings;
     getServices(): string[];
     logEvent(event: any): void;
     setLogger(logger: EventLogger): void;
-    setInterface(ble: BleInterfaceClass): void;
-    isMatching(characteristics: string[]): boolean;
+    setInterface(ble: BleInterface): void;
+    static isMatching(characteristics: string[]): boolean;
     reset(): void;
     cleanupListeners(): void;
-    onDisconnect(): void;
+    onDisconnect(): Promise<void>;
     waitForConnectFinished(timeout: any): Promise<unknown>;
     hasService(serviceUuid: any): boolean;
     init(): Promise<boolean>;
     initDevice(): Promise<boolean>;
-    connectPeripheral(peripheral: BlePeripheral): Promise<void>;
+    connectPeripheral(peripheral: BlePeripheral): Promise<boolean>;
+    subscribeMultiple(characteristics: string[], conn?: IBlePeripheralConnector): Promise<void>;
     subscribeAll(conn?: BlePeripheralConnector): Promise<void>;
-    connect(props?: ConnectProps): Promise<boolean>;
+    unsubscribeAll(conn?: BlePeripheralConnector): void;
+    connect(props?: BleCommsConnectProps): Promise<boolean>;
     disconnect(): Promise<boolean>;
     checkForDuplicate(characteristic: string, data: Buffer): boolean;
     onData(characteristic: string, _data: Buffer): boolean;