incyclist-devices 1.5.38 → 2.0.0

package/lib/ble/adapter-factory.js

@@ -0,0 +1,105 @@
+"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;
+    }
+    constructor() {
+        this.implementations = [];
+        this.instances = [];
+    }
+    getAdapterInfo(protocol) {
+        return this.implementations.find(a => a.protocol === protocol);
+    }
+    getAll() {
+        return this.implementations;
+    }
+    createInstance(settings, props) {
+        let { profile, protocol } = settings;
+        const adapterSettings = Object.assign({}, settings);
+        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.getAdapterInfo(protocol);
+        if (!info || !info.Adapter)
+            return;
+        const adapter = new info.Adapter(adapterSettings, props);
+        this.instances.push(adapter);
+        return adapter;
+    }
+    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.implementations.push(info);
+    }
+    getAllInstances() {
+        return this.instances;
+    }
+    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().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);
+                    });
+                }
+            });
+        }
+        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;
+    }
+}
+exports.default = BleAdapterFactory;

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/base/adapter.js

@@ -0,0 +1,290 @@
+"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();
+    }
+    getUniqueName() {
+        const settings = this.settings;
+        if (settings.name.match(/[0-9]/g))
+            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.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.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 = {};
+        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);
+        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 comms = this.device;
+                if (comms) {
+                    comms.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;
+        });
+    }
+    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 {
+    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;
+    }
+    isControllable() {
+        return true;
+    }
+    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_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/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-device.d.ts → base/comms.d.ts}

@@ -1,12 +1,13 @@
 /// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import EventEmitter from "events";
 import { EventLogger } from "gd-eventlog";
-import { BleInterfaceClass, BleDeviceClass, BlePeripheral, BleDeviceProps, ConnectProps, BleDeviceInfo, BleWriteProps } from "./ble";
-import BlePeripheralConnector from "./ble-peripheral";
-interface BleDeviceConstructProps extends BleDeviceProps {
-    log?: boolean;
-    logger?: EventLogger;
-}
-declare type CommandQueueItem = {
+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;
     timeout: number;
@@ -18,14 +19,17 @@ export interface MessageLog {
     timestamp: any;
     data: string;
 }
-export declare abstract class BleDevice extends BleDeviceClass {
+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;
@@ -34,23 +38,34 @@ export declare abstract class BleDevice extends BleDeviceClass {
     writeQueue: CommandQueueItem[];
     workerIv: NodeJS.Timeout;
     prevMessages: MessageLog[];
+    connectState: ConnectState;
     constructor(props?: BleDeviceConstructProps);
+    getConnectState(): ConnectState;
+    isConnected(): boolean;
+    pause(): void;
+    resume(): void;
+    getServiceUUids(): 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>;
-    abstract getProfile(): string;
     checkForDuplicate(characteristic: string, data: Buffer): boolean;
     onData(characteristic: string, _data: Buffer): boolean;
     timeoutCheck(): void;