incyclist-devices 1.5.38 → 2.0.0-beta.1

package/lib/ble/ble-interface.js

@@ -13,23 +13,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
-const utils_1 = require("../utils");
+const utils_1 = require("../utils/utils");
 const ble_1 = require("./ble");
-const ble_2 = require("./ble");
+const ble_comms_1 = require("./ble-comms");
 const ble_peripheral_1 = __importDefault(require("./ble-peripheral"));
+const adapter_factory_1 = __importDefault(require("./adapter-factory"));
+const utils_2 = require("./utils");
 const CONNECT_TIMEOUT = 5000;
 const DEFAULT_SCAN_TIMEOUT = 20000;
 class BleInterface extends ble_1.BleInterfaceClass {
-    constructor(props = {}) {
-        super(props);
-        this.scanState = { isScanning: false, isConnecting: false, timeout: undefined, isBackgroundScan: false };
-        this.connectState = { isConnecting: false, isConnected: false, isInitSuccess: false };
-        this.devices = [];
-        this.peripheralCache = [];
-        if (props.logger)
-            this.logger = props.logger;
-        this.logger = new gd_eventlog_1.EventLogger('BLE');
-    }
     static getInstance(props = {}) {
         if (!BleInterface._instance) {
             BleInterface._instance = new BleInterface(props);
@@ -47,10 +39,18 @@ class BleInterface extends ble_1.BleInterfaceClass {
         }
         return BleInterface._instance;
     }
-    static register(id, type, Class, services) {
-        if (this.deviceClasses.find(i => i.id === id))
-            return;
-        this.deviceClasses.push({ id, type, Class, services });
+    constructor(props = {}) {
+        super(props);
+        this.scanState = { isScanning: false, isConnecting: false, timeout: undefined, isBackgroundScan: false };
+        this.connectState = { isConnecting: false, isConnected: false, isInitSuccess: false };
+        this.devices = [];
+        this.peripheralCache = [];
+        if (props.logger)
+            this.logger = props.logger;
+        this.logger = new gd_eventlog_1.EventLogger('BLE');
+    }
+    getAdapterFactory() {
+        return adapter_factory_1.default.getInstance();
     }
     logEvent(event) {
         if (this.logger) {
@@ -77,14 +77,14 @@ class BleInterface extends ble_1.BleInterfaceClass {
             if (this.connectState.isConnected) {
                 return resolve(true);
             }
-            this.logEvent({ message: 'connect request', });
+            this.logEvent({ message: 'Ble connect request', });
             if (!this.getBinding())
                 return Promise.reject(new Error('no binding defined'));
             this.connectState.timeout = setTimeout(() => {
                 this.connectState.isConnected = false;
                 this.connectState.isConnecting = false;
                 this.connectState.timeout = null;
-                this.logEvent({ message: 'connect result: timeout' });
+                this.logEvent({ message: 'Ble connect result: timeout' });
                 reject(new Error('timeout'));
             }, timeout);
             try {
@@ -139,7 +139,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
                             this.getBinding().on('stateChange', this.onStateChange.bind(this));
                             this.connectState.isConnected = true;
                             this.connectState.isConnecting = false;
-                            this.logEvent({ message: 'connect result: success' });
+                            this.logEvent({ message: 'Ble connect result: success' });
                             return resolve(true);
                         }
                         else {
@@ -154,7 +154,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
                 if (this.connectState.timeout)
                     clearTimeout(this.connectState.timeout);
                 this.connectState.timeout = null;
-                this.logEvent({ message: 'connect result: error', error: err.message });
+                this.logEvent({ message: 'Ble connect result: error', error: err.message });
                 return reject(new Error('bluetooth unavailable, cause: ' + err.message));
             }
         });
@@ -189,83 +189,6 @@ class BleInterface extends ble_1.BleInterfaceClass {
     isConnected() {
         return this.connectState.isConnected;
     }
-    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, ble_2.matches)(s, services));
-        }
-        if (Array.isArray(services)) {
-            const sids = services.map(ble_1.uuid);
-            return get(deviceTypes, s => {
-                const res = sids.find((service) => (0, ble_2.matches)(s, service));
-                return res !== undefined;
-            });
-        }
-        return [];
-    }
-    getAllSupportedServices() {
-        const supported = BleInterface.deviceClasses;
-        const res = [];
-        if (supported && supported.length > 0) {
-            supported.forEach(dc => {
-                if (dc && dc.services) {
-                    dc.services.forEach(s => {
-                        if (!res.includes(s))
-                            res.push(s);
-                    });
-                }
-            });
-        }
-        return res;
-    }
-    getAllSupportedDeviceTypes() {
-        const supported = BleInterface.deviceClasses;
-        return supported.map(dc => dc.Class);
-    }
-    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;
-    }
-    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;
-    }
     waitForConnectFinished(timeout) {
         const waitStart = Date.now();
         const waitTimeout = waitStart + timeout;
@@ -341,31 +264,11 @@ class BleInterface extends ble_1.BleInterfaceClass {
             return characteristics;
         });
     }
-    getDeviceClasses(peripheral, props = {}) {
-        let DeviceClasses;
-        const { deviceTypes, profile, services = peripheral.advertisement.serviceUuids } = props;
-        if ((!deviceTypes || deviceTypes.length === 0)) {
-            const classes = BleInterface.deviceClasses.map(c => c.Class);
-            DeviceClasses = this.getDevicesFromServices(classes, services);
-        }
-        else {
-            DeviceClasses = this.getDevicesFromServices(deviceTypes, services);
-        }
-        if (profile && DeviceClasses && DeviceClasses.length > 0) {
-            DeviceClasses = DeviceClasses.filter(C => {
-                const device = new C({ peripheral });
-                if (device.getProfile() !== profile)
-                    return false;
-                return true;
-            });
-        }
-        return DeviceClasses;
-    }
-    createDevice(DeviceClass, peripheral, characteristics) {
+    createDeviceComms(DeviceClass, peripheral, characteristics) {
         try {
             const C = DeviceClass;
             const device = new C({ peripheral });
-            const cids = characteristics ? characteristics.map(c => (0, ble_1.uuid)(c.uuid)) : [];
+            const cids = characteristics ? characteristics.map(c => (0, utils_2.uuid)(c.uuid)) : [];
             this.logEvent({ message: 'trying to create device', peripheral: peripheral.address, characteristics: cids, profile: device.getProfile() });
             const existingDevice = this.devices.find(i => i.device.id === device.id && i.device.getProfile() === device.getProfile());
             if (existingDevice)
@@ -387,7 +290,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
     connectDevice(requested, timeout = DEFAULT_SCAN_TIMEOUT + CONNECT_TIMEOUT) {
         return __awaiter(this, void 0, void 0, function* () {
             const { id, name, address } = requested;
-            const profile = requested instanceof ble_1.BleDeviceClass ?
+            const profile = requested instanceof ble_comms_1.BleComms ?
                 (requested.getProfile && typeof (requested.getProfile) === 'function' ? requested.getProfile() : undefined) :
                 requested.profile;
             this.logEvent({ message: 'connectDevice', id, name, address, profile, isbusy: this.scanState.isConnecting });
@@ -406,10 +309,10 @@ class BleInterface extends ble_1.BleInterfaceClass {
             if (peripheralInfo) {
                 if (!peripheralInfo.characteristic) {
                     yield this.getCharacteristics(peripheralInfo.periphal);
-                    const DeviceClasses = this.getDeviceClasses(peripheralInfo.peripheral, { profile });
+                    const DeviceClasses = this.getAdapterFactory().getDeviceClasses(peripheralInfo.peripheral, { profile });
                     if (!DeviceClasses || DeviceClasses.length === 0)
                         return;
-                    const devices = DeviceClasses.map(C => this.createDevice(C, peripheralInfo.periphal, peripheralInfo.characteristics));
+                    const devices = DeviceClasses.map(C => this.createDeviceComms(C, peripheralInfo.periphal, peripheralInfo.characteristics));
                     if (devices && devices.length > 0) {
                         for (let i = 0; i < devices.length; i++) {
                             const idx = this.devices.push({ device: devices[i], isConnected: false }) - 1;
@@ -484,24 +387,17 @@ class BleInterface extends ble_1.BleInterfaceClass {
             }, 100);
         });
     }
-    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;
-    }
     scan(props) {
         return __awaiter(this, void 0, void 0, function* () {
             const { timeout = DEFAULT_SCAN_TIMEOUT, deviceTypes = [], requested } = props;
             let profile;
             if (requested)
-                profile = requested instanceof ble_1.BleDeviceClass ?
+                profile = requested instanceof ble_comms_1.BleComms ?
                     (requested.getProfile && typeof (requested.getProfile) === 'function' ? requested.getProfile() : undefined) :
                     requested.profile;
             const { id, address, name } = requested || {};
             const scanForDevice = (requested !== null && requested !== undefined);
-            const services = (!deviceTypes || deviceTypes.length === 0) ? this.getAllSupportedServices() : this.getServicesFromDeviceTypes(deviceTypes);
+            const services = (!deviceTypes || deviceTypes.length === 0) ? this.getAdapterFactory().getAllSupportedServices() : (0, utils_2.getServicesFromDeviceTypes)(deviceTypes);
             const bleBinding = this.getBinding();
             if (!bleBinding)
                 return Promise.reject(new Error('no binding defined'));
@@ -521,7 +417,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
             }
             else {
                 opStr = 'scan';
-                const supported = BleInterface.deviceClasses.map(dc => ({ id: dc.id, type: dc.type, services: dc.services }));
+                const supported = adapter_factory_1.default.getInstance().getAllAdapters().map(i => i.protocol);
                 this.logEvent({ message: 'scan start', services, supported });
             }
             if (this.scanState.isScanning) {
@@ -585,15 +481,15 @@ class BleInterface extends ble_1.BleInterfaceClass {
                     const services = connectedServices ? connectedServices.map(cs => cs.uuid) : undefined;
                     const connectedPeripheral = connector.getPeripheral();
                     const { id, name, address, advertisement = {} } = connectedPeripheral;
-                    const DeviceClasses = this.getDeviceClasses(connectedPeripheral, { profile, services }) || [];
+                    const DeviceClasses = this.getAdapterFactory().getDeviceClasses(connectedPeripheral, { profile, services }) || [];
                     this.logEvent({ message: 'BLE scan: device connected', peripheral: { id, name, address, services: advertisement.serviceUuids }, services, classes: DeviceClasses.map(c => c.prototype.constructor.name) });
                     let cntFound = 0;
-                    const DeviceClass = this.getBestDeviceMatch(DeviceClasses);
+                    const DeviceClass = (0, utils_2.getBestDeviceMatch)(DeviceClasses);
                     if (!DeviceClass)
                         return;
                     if (scanForDevice && cntFound > 0)
                         return;
-                    const d = this.createDevice(DeviceClass, peripheral, characteristics);
+                    const d = this.createDeviceComms(DeviceClass, peripheral, characteristics);
                     if (!d) {
                         this.logEvent({ message: `${opStr}: could not create device `, DeviceClass });
                         return;
@@ -643,7 +539,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
                 this.logEvent({ message: `${opStr}: start scanning`, requested: scanForDevice ? { name, address, profile } : undefined, timeout });
                 let services = [];
                 if (scanForDevice && name && !name.toLowerCase().startsWith('tacx')) {
-                    if (props.requested instanceof ble_1.BleDeviceClass) {
+                    if (props.requested instanceof ble_comms_1.BleComms) {
                         const device = props.requested;
                         services = (device.getServices()) || [];
                     }
@@ -718,4 +614,3 @@ class BleInterface extends ble_1.BleInterfaceClass {
     }
 }
 exports.default = BleInterface;
-BleInterface.deviceClasses = [];

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

@@ -1,6 +1,6 @@
-import { BleCharacteristic, BlePeripheral } from "./ble";
+import { BleCharacteristic, BlePeripheral, IBlePeripheralConnector } from './types';
 import BleInterface from "./ble-interface";
-export declare type ConnectorState = {
+export type ConnectorState = {
     isConnected: boolean;
     isConnecting: boolean;
     isInitialized: boolean;
@@ -8,7 +8,7 @@ export declare type ConnectorState = {
     isSubscribing: boolean;
     subscribed?: string[];
 };
-export default class BlePeripheralConnector {
+export default class BlePeripheralConnector implements IBlePeripheralConnector {
     private state;
     private services;
     private characteristics;

package/lib/ble/ble-peripheral.js

@@ -12,9 +12,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const ble_1 = require("./ble");
 const gd_eventlog_1 = require("gd-eventlog");
 const events_1 = __importDefault(require("events"));
+const utils_1 = require("./utils");
 class BlePeripheralConnector {
     constructor(ble, peripheral) {
         this.ble = ble;
@@ -42,7 +42,7 @@ class BlePeripheralConnector {
             this.logEvent({ message: 'connect', peripheral: this.peripheral.address, state: this.state });
             this.state.isConnecting = true;
             try {
-                this.peripheral.on('connect', () => { console.log('~~~ peripheral connected', this.peripheral); });
+                this.peripheral.on('connect', () => { });
                 this.peripheral.on('disconnect', () => { this.onDisconnect(); });
                 if (!this.state.isConnected || (this.peripheral && this.peripheral.state !== 'connected')) {
                     yield this.peripheral.connectAsync();
@@ -57,7 +57,7 @@ class BlePeripheralConnector {
     }
     reconnect() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.connect();
+            yield this.connect();
         });
     }
     onDisconnect() {
@@ -91,7 +91,7 @@ class BlePeripheralConnector {
         });
     }
     isSubscribed(characteristicUuid) {
-        return this.state.subscribed.find(c => c === characteristicUuid || (0, ble_1.uuid)(c) === characteristicUuid || c === (0, ble_1.uuid)(characteristicUuid)) !== undefined;
+        return this.state.subscribed.find(c => c === characteristicUuid || (0, utils_1.uuid)(c) === characteristicUuid || c === (0, utils_1.uuid)(characteristicUuid)) !== undefined;
     }
     subscribeAll(callback) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -106,12 +106,12 @@ class BlePeripheralConnector {
                     const isNotify = c.properties.find(p => p === 'notify');
                     if (isNotify && subscribed.find(uuid => uuid === c.uuid) === undefined) {
                         c.on('data', (data, _isNotification) => {
-                            this.onData((0, ble_1.uuid)(c.uuid), data);
+                            this.onData((0, utils_1.uuid)(c.uuid), data);
                         });
                         if (callback) {
-                            this.on((0, ble_1.uuid)(c.uuid), callback);
+                            this.on((0, utils_1.uuid)(c.uuid), callback);
                         }
-                        this.logEvent({ message: 'subscribe', peripheral: this.peripheral.address, characteristic: c.uuid, uuid: (0, ble_1.uuid)(c.uuid) });
+                        this.logEvent({ message: 'subscribe', peripheral: this.peripheral.address, characteristic: c.uuid, uuid: (0, utils_1.uuid)(c.uuid) });
                         if (this.state.subscribed.find(uuid => uuid === c.uuid) === undefined) {
                             try {
                                 yield this.subscribe(c.uuid, 3000);
@@ -133,10 +133,10 @@ class BlePeripheralConnector {
         });
     }
     subscribe(characteristicUuid, timeout) {
-        this.logEvent({ message: 'subscribe attempt', characteristic: characteristicUuid, characteristics: this.characteristics.map(c => ({ characteristic: c.uuid, uuid: (0, ble_1.uuid)(c.uuid) })) });
+        this.logEvent({ message: 'subscribe attempt', characteristic: characteristicUuid, characteristics: this.characteristics.map(c => ({ characteristic: c.uuid, uuid: (0, utils_1.uuid)(c.uuid) })) });
         return new Promise((resolve, reject) => {
             try {
-                const characteristic = this.characteristics.find(c => (0, ble_1.uuid)(c.uuid) === (0, ble_1.uuid)(characteristicUuid) || (0, ble_1.uuid)(c.uuid) === (0, ble_1.uuid)(characteristicUuid));
+                const characteristic = this.characteristics.find(c => (0, utils_1.uuid)(c.uuid) === (0, utils_1.uuid)(characteristicUuid) || (0, utils_1.uuid)(c.uuid) === (0, utils_1.uuid)(characteristicUuid));
                 if (!characteristic) {
                     reject(new Error('Characteristic not found'));
                     return;
@@ -144,7 +144,7 @@ class BlePeripheralConnector {
                 this.logEvent({ message: 'subscribe', peripheral: this.peripheral.address, characteristic: characteristic.uuid });
                 characteristic.removeAllListeners('data');
                 characteristic.on('data', (data, _isNotification) => {
-                    this.onData((0, ble_1.uuid)(characteristicUuid), data);
+                    this.onData((0, utils_1.uuid)(characteristicUuid), data);
                 });
                 let to;
                 if (timeout) {
@@ -171,18 +171,18 @@ class BlePeripheralConnector {
         });
     }
     onData(characteristicUuid, data) {
-        this.emitter.emit((0, ble_1.uuid)(characteristicUuid), characteristicUuid, data);
+        this.emitter.emit((0, utils_1.uuid)(characteristicUuid), characteristicUuid, data);
     }
     on(characteristicUuid, callback) {
         if (callback)
-            this.emitter.on((0, ble_1.uuid)(characteristicUuid), callback);
+            this.emitter.on((0, utils_1.uuid)(characteristicUuid), callback);
     }
     off(characteristicUuid, callback) {
         if (callback)
-            this.emitter.off((0, ble_1.uuid)(characteristicUuid), callback);
+            this.emitter.off((0, utils_1.uuid)(characteristicUuid), callback);
     }
     removeAllListeners(characteristicUuid) {
-        this.emitter.removeAllListeners((0, ble_1.uuid)(characteristicUuid));
+        this.emitter.removeAllListeners((0, utils_1.uuid)(characteristicUuid));
     }
     getState() {
         return this.peripheral.state;

package/lib/ble/ble.d.ts

@@ -1,65 +1,18 @@
 /// <reference types="node" />
 import EventEmitter from "events";
+import { BleComms } from "./ble-comms";
 import BlePeripheralConnector from "./ble-peripheral";
-export declare type ConnectProps = {
-    timeout?: number;
-    reconnect?: boolean;
-};
-export interface BleDeviceIdentifier {
-    id?: string;
-    address?: string;
-    name?: string;
-}
-export interface ConnectState {
-    isConnecting: boolean;
-    isConnected: boolean;
-    isDisconnecting: boolean;
-}
-export declare type BleDeviceInfo = {
-    manufacturer?: string;
-    hwRevision?: string;
-    swRevision?: string;
-    fwRevision?: string;
-    model?: string;
-    serialNo?: string;
-};
-export interface BleDeviceDescription {
-    id?: string;
-    address: string;
-    name?: string;
-    profile: string;
-}
-export declare abstract class BleDeviceClass extends EventEmitter {
-    static services: string[];
-    id?: string;
-    address?: string;
-    name?: string;
-    peripheral?: BlePeripheral;
-    connectState: ConnectState;
-    getConnectState(): ConnectState;
-    isConnected(): boolean;
-    abstract getProfile(): string;
-    abstract getServiceUUids(): string[];
-    abstract connect(props?: ConnectProps): Promise<boolean>;
-    abstract disconnect(): Promise<boolean>;
-    abstract getDeviceInfo(): Promise<BleDeviceInfo>;
-    abstract getServices(): string[];
-    setCharacteristicUUIDs(uuids: string[]): void;
-}
-export interface BleWriteProps {
-    withoutResponse?: boolean;
-    timeout?: number;
-}
+import { BleDeviceCommsClass, BleDeviceSettings, BlePeripheral, ConnectProps } from "./types";
 export interface BleBinding extends EventEmitter {
     startScanning(serviceUUIDs?: string[], allowDuplicates?: boolean, callback?: (error?: Error) => void): void;
     stopScanning(callback?: () => void): void;
     _bindings: any;
     state: string;
 }
-export declare type ScanProps = {
+export type BleScanProps = {
     timeout?: number;
-    deviceTypes?: (typeof BleDeviceClass)[];
-    requested?: BleDeviceClass | BleDeviceDescription;
+    deviceTypes?: (typeof BleComms)[];
+    requested?: BleComms | BleDeviceSettings;
     isBackgroundScan?: boolean;
 };
 export declare class BleBindingWrapper {
@@ -77,14 +30,14 @@ export declare abstract class BleInterfaceClass extends EventEmitter {
         binding?: BleBinding;
     });
     abstract connect(props: ConnectProps): Promise<boolean>;
-    abstract scan(props: ScanProps): Promise<BleDeviceClass[]>;
+    abstract scan(props: BleScanProps): Promise<BleDeviceCommsClass[]>;
     abstract stopScan(): Promise<boolean>;
     abstract disconnect(): Promise<boolean>;
     abstract onDisconnect(peripheral: BlePeripheral): void;
     abstract isScanning(): boolean;
-    abstract addConnectedDevice(device: BleDeviceClass): void;
-    abstract removeConnectedDevice(device: BleDeviceClass): void;
-    abstract findConnected(device: BleDeviceClass | BlePeripheral): BleDeviceClass;
+    abstract addConnectedDevice(device: BleDeviceCommsClass): void;
+    abstract removeConnectedDevice(device: BleDeviceCommsClass): void;
+    abstract findConnected(device: BleDeviceCommsClass | BlePeripheral): BleDeviceCommsClass;
     abstract getConnector(peripheral: BlePeripheral): BlePeripheralConnector;
     abstract findPeripheral(peripheral: BlePeripheral | {
         id?: string;
@@ -94,29 +47,6 @@ export declare abstract class BleInterfaceClass extends EventEmitter {
     getBinding(): BleBinding;
     setBinding(binding: BleBinding): void;
 }
-export interface BlePeripheral extends EventEmitter, BleDeviceIdentifier {
-    services: string[];
-    advertisement: any;
-    state: string;
-    connectAsync(): Promise<void>;
-    disconnect(cb: (err?: Error) => void): Promise<void>;
-    discoverSomeServicesAndCharacteristicsAsync(serviceUUIDs: string[], characteristicUUIDs: string[]): Promise<any>;
-}
-export interface BleCharacteristic extends EventEmitter {
-    uuid: string;
-    properties: string[];
-    subscribe(callback: (err: Error) => void): void;
-    read(callback: (err: Error, data: Buffer) => void): void;
-    write(data: Buffer, withoutResponse: boolean, callback?: (err: Error) => void): void;
-}
-export declare type BleDeviceProps = {
-    id?: string;
-    address?: string;
-    name?: string;
-    services?: string[];
-    ble: BleInterfaceClass;
-    peripheral?: BlePeripheral;
-};
 export declare enum BleState {
     UNKNOWN = "unknown",
     RESETTING = "resetting",
@@ -125,5 +55,3 @@ export declare enum BleState {
     POWERED_OFF = "poweredOff",
     POWERED_ON = "poweredOn"
 }
-export declare const uuid: (s: any) => any;
-export declare const matches: (uuid1: any, uuid2: any) => boolean;

package/lib/ble/ble.js

@@ -3,23 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.matches = exports.uuid = exports.BleState = exports.BleInterfaceClass = exports.BleBindingWrapper = exports.BleDeviceClass = void 0;
+exports.BleState = exports.BleInterfaceClass = exports.BleBindingWrapper = void 0;
 const events_1 = __importDefault(require("events"));
-class BleDeviceClass extends events_1.default {
-    constructor() {
-        super(...arguments);
-        this.connectState = { isConnecting: false, isConnected: false, isDisconnecting: false };
-    }
-    getConnectState() {
-        return this.connectState;
-    }
-    isConnected() {
-        return this.connectState.isConnected;
-    }
-    setCharacteristicUUIDs(uuids) { }
-}
-exports.BleDeviceClass = BleDeviceClass;
-BleDeviceClass.services = [];
 class BleBindingWrapper {
     constructor(binding) {
         this.binding = binding;
@@ -61,26 +46,3 @@ var BleState;
     BleState["POWERED_OFF"] = "poweredOff";
     BleState["POWERED_ON"] = "poweredOn";
 })(BleState = exports.BleState || (exports.BleState = {}));
-const uuid = (s) => {
-    if (s) {
-        if (s.includes('-')) {
-            const parts = s.split('-');
-            const uuidNo = parseInt('0x' + parts[0]);
-            return uuidNo.toString(16).toLowerCase();
-        }
-        return s;
-    }
-};
-exports.uuid = uuid;
-const matches = (uuid1, uuid2) => {
-    const ul1 = uuid1.toLowerCase();
-    const ul2 = uuid2.toLowerCase();
-    if ((0, exports.uuid)(ul1) === (0, exports.uuid)(ul2))
-        return true;
-    if (ul1.length < ul2.length && ul2.startsWith(ul1))
-        return true;
-    if (ul1.length > ul2.length && ul1.startsWith(ul2))
-        return true;
-    return false;
-};
-exports.matches = matches;

package/lib/ble/consts.d.ts

@@ -11,4 +11,6 @@ export declare const CSP_FEATURE = "2a65";
 export declare const CSC = "1816";
 export declare const CSC_MEASUREMENT = "2a5b";
 export declare const WAHOO_ADVANCED_TRAINER_CP = "a026e005";
+export declare const WAHOO_ADVANCED_FTMS = "a026ee0b";
 export declare const WAHOO_ADVANCED_TRAINER_CP_FULL = "A026E005-0A7D-4AB3-97FA-F1500F9FEB8B";
+export declare const ELITE_TRAINER_SVC = "347b0001";

package/lib/ble/consts.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WAHOO_ADVANCED_TRAINER_CP_FULL = exports.WAHOO_ADVANCED_TRAINER_CP = exports.CSC_MEASUREMENT = exports.CSC = exports.CSP_FEATURE = exports.CSP_MEASUREMENT = exports.CSP = exports.INDOOR_BIKE_DATA = exports.FTMS_STATUS = exports.FTMS_CP = exports.FTMS = exports.TACX_FE_C_TX = exports.TACX_FE_C_RX = exports.TACX_FE_C_BLE = void 0;
+exports.ELITE_TRAINER_SVC = exports.WAHOO_ADVANCED_TRAINER_CP_FULL = exports.WAHOO_ADVANCED_FTMS = exports.WAHOO_ADVANCED_TRAINER_CP = exports.CSC_MEASUREMENT = exports.CSC = exports.CSP_FEATURE = exports.CSP_MEASUREMENT = exports.CSP = exports.INDOOR_BIKE_DATA = exports.FTMS_STATUS = exports.FTMS_CP = exports.FTMS = exports.TACX_FE_C_TX = exports.TACX_FE_C_RX = exports.TACX_FE_C_BLE = void 0;
 exports.TACX_FE_C_BLE = '6e40fec1';
 exports.TACX_FE_C_RX = '6e40fec2';
 exports.TACX_FE_C_TX = '6e40fec3';
@@ -14,4 +14,6 @@ exports.CSP_FEATURE = '2a65';
 exports.CSC = '1816';
 exports.CSC_MEASUREMENT = '2a5b';
 exports.WAHOO_ADVANCED_TRAINER_CP = 'a026e005';
+exports.WAHOO_ADVANCED_FTMS = 'a026ee0b';
 exports.WAHOO_ADVANCED_TRAINER_CP_FULL = 'A026E005-0A7D-4AB3-97FA-F1500F9FEB8B';
+exports.ELITE_TRAINER_SVC = '347b0001';

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

@@ -0,0 +1,23 @@
+import CyclingMode from '../../modes/cycling-mode';
+import { IncyclistBikeData } from '../../modes/cycling-mode';
+import { BleControllableAdapter } from '../adapter';
+import { DeviceProperties } from '../../types/device';
+import { PowerData } from './types';
+import { DeviceData } from '../../types/data';
+import { BleDeviceSettings } from '../types';
+import IncyclistDevice from '../../base/adpater';
+export default class PwrAdapter extends BleControllableAdapter {
+    distanceInternal: number;
+    constructor(settings: BleDeviceSettings, props?: DeviceProperties);
+    isSame(device: IncyclistDevice): boolean;
+    getProfile(): string;
+    getName(): string;
+    getDisplayName(): string;
+    getDefaultCyclingMode(): CyclingMode;
+    getSupportedCyclingModes(): any[];
+    onDeviceData(deviceData: PowerData): void;
+    mapData(deviceData: PowerData): IncyclistBikeData;
+    transformData(bikeData: IncyclistBikeData): DeviceData;
+    sendUpdate(request: any): Promise<void>;
+    stop(): Promise<boolean>;
+}