incyclist-devices 2.3.12 → 2.3.14

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

@@ -0,0 +1,34 @@
+import BleAdapter from "./base/adapter";
+import { BleDeviceSettings, BleProtocol } from "./types";
+import { DeviceProperties } from "../types";
+import { BleComms } from "./base/comms";
+import { BleDeviceData } from "./base/types";
+export interface BleAdapterInfo {
+    protocol: BleProtocol;
+    Adapter: typeof BleAdapter<BleDeviceData, BleComms>;
+    Comm: typeof BleComms;
+}
+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>;
+    removeInstance(query: {
+        settings?: BleDeviceSettings;
+        adapter?: BleAdapter<BleDeviceData, BleComms>;
+    }): 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>)>;
+    getAllSupportedServices(): string[];
+    getDeviceClasses(peripheral: any, props?: {
+        protocol?: BleProtocol;
+        services?: string[];
+    }): (typeof BleComms)[];
+}

package/lib/ble/adapter-factory.js

@@ -0,0 +1,110 @@
+"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) {
+            try {
+                const mapping = (0, utils_1.mapLegacyProfile)(profile);
+                protocol = adapterSettings.protocol = mapping.protocol;
+                delete adapterSettings.profile;
+            }
+            catch (_a) {
+                delete settings.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/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,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBestDeviceMatch = getBestDeviceMatch;
+exports.getDevicesFromServices = getDevicesFromServices;
+exports.getServicesFromDeviceTypes = getServicesFromDeviceTypes;
+exports.getServicesFromProtocols = getServicesFromProtocols;
+exports.getServicesFromDevice = getServicesFromDevice;
+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;
+}
+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 [];
+}
+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;
+}
+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;
+}
+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;
+}

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

@@ -0,0 +1,75 @@
+import EventEmitter from "events";
+import { EventLogger } from "gd-eventlog";
+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;
+    resolve: any;
+    reject: any;
+};
+export interface MessageLog {
+    uuid: string;
+    timestamp: any;
+    data: string;
+}
+export declare class BleComms extends EventEmitter {
+    static services: string[];
+    static protocol: BleProtocol;
+    id: string;
+    paused: boolean;
+    address: string;
+    name: string;
+    services: string[];
+    ble: BleInterface;
+    peripheral?: BlePeripheral;
+    characteristics: BleCharacteristic[];
+    state?: string;
+    logger?: EventLogger;
+    deviceInfo: BleDeviceInfo;
+    isInitialized: boolean;
+    subscribedCharacteristics: string[];
+    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: BleInterface): void;
+    static isMatching(characteristics: string[]): boolean;
+    reset(): void;
+    cleanupListeners(): void;
+    onDisconnect(): Promise<void>;
+    waitForConnectFinished(timeout: any): Promise<unknown>;
+    hasService(serviceUuid: any): boolean;
+    init(): Promise<boolean>;
+    initDevice(): Promise<boolean>;
+    connectPeripheral(peripheral: BlePeripheral): Promise<boolean>;
+    subscribeMultiple(characteristics: string[], conn?: IBlePeripheralConnector): Promise<void>;
+    subscribeAll(conn?: BlePeripheralConnector): Promise<void>;
+    unsubscribeAll(conn?: BlePeripheralConnector): void;
+    connect(props?: BleCommsConnectProps): Promise<boolean>;
+    disconnect(): Promise<boolean>;
+    checkForDuplicate(characteristic: string, data: Buffer): boolean;
+    onData(characteristic: string, _data: Buffer): boolean;
+    timeoutCheck(): void;
+    startWorker(): void;
+    stopWorker(): void;
+    write(characteristicUuid: string, data: Buffer, props?: BleWriteProps): Promise<ArrayBuffer>;
+    read(characteristicUuid: string): Promise<Uint8Array>;
+    getDeviceInfo(): Promise<BleDeviceInfo>;
+}
+export {};