incyclist-devices 2.0.0-beta.1 → 2.0.0

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

@@ -0,0 +1,43 @@
+import BleAdapter from "./base/adapter";
+import BlePeripheralConnector from "./ble-peripheral";
+import { BleCharacteristic, BlePeripheral } from "./types";
+export interface PeripheralState {
+    isLoading: boolean;
+    isConfigured: boolean;
+    isInterrupted: boolean;
+}
+export interface PeripheralCacheItem {
+    address: string;
+    name?: string;
+    id?: string;
+    ts: number;
+    peripheral: BlePeripheral;
+    state?: PeripheralState;
+    characteristics?: BleCharacteristic[];
+    connector?: BlePeripheralConnector;
+}
+export default class BlePeripheralCache {
+    peripherals: PeripheralCacheItem[];
+    findAdapter(adapter: BleAdapter): PeripheralCacheItem;
+    getConnector(peripheral: BlePeripheral): BlePeripheralConnector;
+    getPeripheral(query: {
+        id?: string;
+        address?: string;
+        name?: string;
+    }): BlePeripheral;
+    handleStopScan(): void;
+    find(query: {
+        name?: string;
+        id?: string;
+        address?: string;
+        peripheral?: BlePeripheral;
+    }): PeripheralCacheItem;
+    filter(services: string[]): PeripheralCacheItem[];
+    protected _findIndex(query: {
+        name?: string;
+        id?: string;
+        address?: string;
+    }): number;
+    add(item: PeripheralCacheItem): PeripheralCacheItem;
+    remove(query: PeripheralCacheItem | BlePeripheral): void;
+}

package/lib/ble/peripheral-cache.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ble_peripheral_1 = __importDefault(require("./ble-peripheral"));
+class BlePeripheralCache {
+    constructor() {
+        this.peripherals = [];
+    }
+    findAdapter(adapter) {
+        return this.find(adapter.getSettings());
+    }
+    getConnector(peripheral) {
+        const info = this.find({ address: peripheral.address });
+        if (!info) {
+            const item = this.add({ address: peripheral.address, ts: Date.now(), peripheral });
+            return item.connector;
+        }
+        return info.connector;
+    }
+    getPeripheral(query) {
+        const info = this.find(query);
+        return info ? info.peripheral : undefined;
+    }
+    handleStopScan() {
+        const ongoing = this.peripherals.filter(i => i.state && i.state.isLoading);
+        if (ongoing)
+            ongoing.forEach(i => { i.state.isInterrupted = true; });
+    }
+    find(query) {
+        const { peripheral } = query;
+        const { name, address, id } = peripheral ? peripheral : query;
+        if (!name && !address && !id)
+            throw new Error('illegal query, one of <id>,<name>,<address> needs to be provided');
+        if (address)
+            return this.peripherals.find(i => i.address === address);
+        else if (name)
+            return this.peripherals.find(i => i.name === name);
+        else if (id)
+            return this.peripherals.find(i => i.id === id);
+    }
+    filter(services) {
+        if (services.length === 0) {
+            return this.peripherals;
+        }
+        return this.peripherals.filter(i => {
+            const announced = i.peripheral.services.map(s => s.uuid);
+            const requested = services;
+            return (announced.find(s => requested.includes(s)));
+        });
+    }
+    _findIndex(query) {
+        const { name, address, id } = query;
+        if (!name && !address && !id)
+            throw new Error('illegal query, one of <id>,<name>,<address> needs to be provided');
+        if (address)
+            return this.peripherals.findIndex(i => i.address === address);
+        else if (name)
+            return this.peripherals.findIndex(i => i.name === name);
+        else if (id)
+            return this.peripherals.findIndex(i => i.id === id);
+    }
+    add(item) {
+        const { address, name, id } = item;
+        const { ts, peripheral, state, characteristics } = item;
+        const cachedItem = this.find({ address, name, id });
+        if (cachedItem) {
+            cachedItem.ts = ts;
+            cachedItem.peripheral = peripheral;
+            if (state)
+                cachedItem.state = state;
+            if (characteristics) {
+                cachedItem.characteristics = characteristics;
+            }
+            if (!cachedItem.connector) {
+                cachedItem.connector = item.connector || new ble_peripheral_1.default(cachedItem.peripheral);
+            }
+            return cachedItem;
+        }
+        else {
+            const newItem = Object.assign({}, item);
+            if (newItem.peripheral && !newItem.connector)
+                newItem.connector = new ble_peripheral_1.default(item.peripheral);
+            this.peripherals.push(newItem);
+            return newItem;
+        }
+    }
+    remove(query) {
+        const item = query;
+        const isCacheItem = item.peripheral !== undefined;
+        let cachedItemIdx;
+        if (isCacheItem) {
+            const { address, name, id } = item;
+            cachedItemIdx = this._findIndex({ address, name, id });
+        }
+        else {
+            const peripheral = query;
+            const { address } = peripheral;
+            cachedItemIdx = this._findIndex({ address });
+        }
+        if (cachedItemIdx == -1)
+            return;
+        this.peripherals.splice(cachedItemIdx);
+    }
+}
+exports.default = BlePeripheralCache;

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

@@ -1,5 +1,5 @@
 import { BleFmAdapter } from '../fm';
-import BleAdapter from '../adapter';
+import BleAdapter from '../base/adapter';
 import { DeviceProperties } from '../../types/device';
 import { BleDeviceSettings, BleStartProperties } from '../types';
 export default class BleTacxFEAdapter extends BleFmAdapter {

package/lib/ble/tacx/adapter.js

@@ -40,44 +40,50 @@ class BleTacxFEAdapter extends fm_1.BleFmAdapter {
     }
     start(props = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'start requested', protocol: this.getProtocolName(), props });
-            if (this.ble.isScanning())
+            if (this.started)
+                return true;
+            if (this.ble.isScanning()) {
+                this.logger.logEvent({ message: 'stop previous scan', isScanning: this.ble.isScanning() });
                 yield this.ble.stopScan();
+            }
+            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);
-                bleDevice.setLogger(this.logger);
-                if (bleDevice) {
-                    this.device = bleDevice;
+                const comms = this.device;
+                if (comms) {
+                    this.device = comms;
                     const mode = this.getCyclingMode();
                     if (mode && mode.getSetting('bikeType')) {
                         const bikeType = mode.getSetting('bikeType').toLowerCase();
-                        bleDevice.setCrr(fm_1.cRR);
+                        comms.setCrr(fm_1.cRR);
                         switch (bikeType) {
                             case 'race':
-                                bleDevice.setCw(fm_1.cwABike.race);
+                                comms.setCw(fm_1.cwABike.race);
                                 break;
                             case 'triathlon':
-                                bleDevice.setCw(fm_1.cwABike.triathlon);
+                                comms.setCw(fm_1.cwABike.triathlon);
                                 break;
                             case 'mountain':
-                                bleDevice.setCw(fm_1.cwABike.mountain);
+                                comms.setCw(fm_1.cwABike.mountain);
                                 break;
                         }
                     }
                     const { user, wheelDiameter, gearRatio, bikeWeight = adpater_1.DEFAULT_BIKE_WEIGHT } = props || {};
                     const userWeight = (user && user.weight ? user.weight : adpater_1.DEFAULT_USER_WEIGHT);
-                    bleDevice.sendTrackResistance(0.0);
-                    bleDevice.sendUserConfiguration(userWeight, bikeWeight, wheelDiameter, gearRatio);
+                    comms.sendTrackResistance(0.0);
+                    comms.sendUserConfiguration(userWeight, bikeWeight, wheelDiameter, gearRatio);
                     const startRequest = this.getCyclingMode().getBikeInitRequest();
                     yield this.sendUpdate(startRequest);
-                    bleDevice.on('data', (data) => {
+                    comms.on('data', (data) => {
                         this.onDeviceData(data);
                     });
                     this.resetData();
                     this.stopped = false;
                     this.started = true;
                     this.paused = false;
-                    if (bleDevice.isHrm() && !this.hasCapability(capabilities_1.IncyclistCapability.HeartRate)) {
+                    if (comms.features.heartrate && !this.hasCapability(capabilities_1.IncyclistCapability.HeartRate)) {
                         this.capabilities.push(capabilities_1.IncyclistCapability.HeartRate);
                     }
                     return true;

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

@@ -1,10 +1,12 @@
 /// <reference types="node" />
+import { LegacyProfile } from "../../antv2/types";
 import { CrankData } from "../cp";
 import { IndoorBikeData } from "../fm";
 import BleFitnessMachineDevice from "../fm/comms";
-import { IBlePeripheralConnector } from "../types";
+import { BleProtocol, IBlePeripheralConnector } from "../types";
 import { BleFeBikeData } from "./types";
 export default class TacxAdvancedFitnessMachineDevice extends BleFitnessMachineDevice {
+    static protocol: BleProtocol;
     static services: string[];
     static characteristics: string[];
     static PROFILE: string;
@@ -19,15 +21,13 @@ export default class TacxAdvancedFitnessMachineDevice extends BleFitnessMachineD
     tacxRx: string;
     tacxTx: string;
     constructor(props?: any);
-    isMatching(characteristics: string[]): boolean;
+    static isMatching(characteristics: string[]): boolean;
     setCharacteristicUUIDs(uuids: string[]): void;
     subscribeAll(conn?: IBlePeripheralConnector): Promise<void>;
     init(): Promise<boolean>;
-    getProfile(): string;
+    getProfile(): LegacyProfile;
+    getProtocol(): BleProtocol;
     getServiceUUids(): string[];
-    isBike(): boolean;
-    isPower(): boolean;
-    isHrm(): boolean;
     requestControl(): Promise<boolean>;
     parseCrankData(crankData: any): {
         rpm?: undefined;

package/lib/ble/tacx/comms.js

@@ -12,6 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = require(".");
 const consts_1 = require("../consts");
 const comms_1 = __importDefault(require("../fm/comms"));
 const utils_1 = require("../utils");
@@ -50,7 +51,7 @@ class TacxAdvancedFitnessMachineDevice extends comms_1.default {
         this.tacxRx = consts_1.TACX_FE_C_RX;
         this.tacxTx = consts_1.TACX_FE_C_TX;
     }
-    isMatching(characteristics) {
+    static isMatching(characteristics) {
         if (!characteristics)
             return false;
         const hasTacxCP = characteristics.find(c => (0, utils_1.matches)(c, consts_1.TACX_FE_C_RX)) !== undefined &&
@@ -66,36 +67,8 @@ class TacxAdvancedFitnessMachineDevice extends comms_1.default {
         });
     }
     subscribeAll(conn) {
-        return new Promise(resolve => {
-            const characteristics = [consts_1.CSC_MEASUREMENT, consts_1.CSP_MEASUREMENT, consts_1.INDOOR_BIKE_DATA, consts_1.FTMS_STATUS, consts_1.FTMS_CP];
-            const timeout = Date.now() + 5500;
-            const iv = setInterval(() => {
-                const subscriptionStatus = characteristics.map(c => this.subscribedCharacteristics.find(s => s === c) !== undefined);
-                const done = subscriptionStatus.filter(s => s === true).length === characteristics.length;
-                if (done || Date.now() > timeout) {
-                    clearInterval(iv);
-                    resolve();
-                }
-            }, 100);
-            try {
-                const connector = conn || this.ble.getConnector(this.peripheral);
-                for (let i = 0; i < characteristics.length; i++) {
-                    const c = characteristics[i];
-                    const isAlreadySubscribed = connector.isSubscribed(c);
-                    if (!isAlreadySubscribed) {
-                        connector.removeAllListeners(c);
-                        connector.on(c, (uuid, data) => {
-                            this.onData(uuid, data);
-                        });
-                        connector.subscribe(c);
-                        this.subscribedCharacteristics.push(c);
-                    }
-                }
-            }
-            catch (err) {
-                this.logEvent({ message: 'Error', fn: 'subscribeAll()', error: err.message, stack: err.stack });
-            }
-        });
+        const characteristics = [consts_1.CSC_MEASUREMENT, consts_1.CSP_MEASUREMENT, consts_1.INDOOR_BIKE_DATA, consts_1.FTMS_STATUS, consts_1.FTMS_CP, consts_1.TACX_FE_C_RX];
+        return this.subscribeMultiple(characteristics, conn);
     }
     init() {
         const _super = Object.create(null, {
@@ -103,8 +76,7 @@ class TacxAdvancedFitnessMachineDevice extends comms_1.default {
         });
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                yield _super.initDevice.call(this);
-                return true;
+                return yield _super.initDevice.call(this);
             }
             catch (err) {
                 this.logEvent({ message: 'error', fn: 'TacxAdvancedFitnessMachineDevice.init()', error: err.message || err, stack: err.stack });
@@ -113,20 +85,14 @@ class TacxAdvancedFitnessMachineDevice extends comms_1.default {
         });
     }
     getProfile() {
-        return TacxAdvancedFitnessMachineDevice.PROFILE;
+        return 'Smart Trainer';
+    }
+    getProtocol() {
+        return _1.BleTacxComms.protocol;
     }
     getServiceUUids() {
         return TacxAdvancedFitnessMachineDevice.services;
     }
-    isBike() {
-        return true;
-    }
-    isPower() {
-        return true;
-    }
-    isHrm() {
-        return this.hasService('180d');
-    }
     requestControl() {
         return __awaiter(this, void 0, void 0, function* () {
             return true;
@@ -660,6 +626,7 @@ class TacxAdvancedFitnessMachineDevice extends comms_1.default {
     }
 }
 exports.default = TacxAdvancedFitnessMachineDevice;
+TacxAdvancedFitnessMachineDevice.protocol = 'tacx';
 TacxAdvancedFitnessMachineDevice.services = [consts_1.TACX_FE_C_BLE];
 TacxAdvancedFitnessMachineDevice.characteristics = ['2acc', '2ad2', '2ad6', '2ad8', '2ad9', '2ada', consts_1.TACX_FE_C_RX, consts_1.TACX_FE_C_TX];
 TacxAdvancedFitnessMachineDevice.PROFILE = PROFILE_ID;

package/lib/ble/types.d.ts

@@ -1,27 +1,67 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { EventEmitter } from "stream";
-import { DeviceProperties, DeviceSettings } from "../types/device";
+import EventEmitter from "events";
+import { EventLogger } from "gd-eventlog";
+import { DeviceProperties, DeviceSettings, DeviceStartProperties, IncyclistScanProps } from "../types/device";
+import { InterfaceProps } from "../types/interface";
+export type BleProtocol = 'hr' | 'fm' | 'cp' | 'tacx' | 'wahoo' | 'elite';
+export type BleInterfaceState = 'unknown' | 'resetting' | 'unsupported' | 'unauthorized' | 'poweredOff' | 'poweredOn';
+export interface BleBinding extends EventEmitter {
+    startScanning(serviceUUIDs?: string[], allowDuplicates?: boolean, callback?: (error?: Error) => void): void;
+    stopScanning(callback?: () => void): void;
+    _bindings: any;
+    state: BleInterfaceState;
+    on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+}
+export interface BleScanProps extends IncyclistScanProps {
+    protocol?: BleProtocol;
+    protocols?: BleProtocol[];
+    isBackgroundScan?: boolean;
+}
+export interface BleDeviceConstructProps extends BleDeviceProps {
+    log?: boolean;
+    logger?: EventLogger;
+    peripheral?: BlePeripheral;
+}
 export interface BleDeviceSettings extends DeviceSettings {
     id?: string;
-    profile: string;
-    protocol: string;
+    protocol: BleProtocol;
+    profile?: string;
     address?: string;
+    name?: string;
+}
+export interface BleDetectedDevice extends BleDeviceSettings {
+    peripheral: BlePeripheral;
 }
 export interface BleDeviceProperties extends DeviceProperties {
     wheelDiameter?: number;
     gearRatio?: number;
 }
-export interface BleStartProperties extends BleDeviceProperties {
+export interface BleStartProperties extends DeviceStartProperties {
+    wheelDiameter?: number;
+    gearRatio?: number;
     restart?: boolean;
+    scanOnly?: boolean;
+}
+export interface BleInterfaceProps extends InterfaceProps {
+    binding?: BleBinding;
+    timeout?: number;
+    reconnect?: boolean;
 }
+export type BleService = {
+    uuid: string;
+};
+export type DiscoverResult = {
+    services: BleService[];
+    characteristics: BleCharacteristic[];
+};
 export interface BlePeripheral extends EventEmitter, BlePeripheralIdentifier {
-    services: string[];
+    services: [];
     advertisement: any;
     state: string;
     connectAsync(): Promise<void>;
     disconnect(cb: (err?: Error) => void): Promise<void>;
-    discoverSomeServicesAndCharacteristicsAsync(serviceUUIDs: string[], characteristicUUIDs: string[]): Promise<any>;
+    discoverSomeServicesAndCharacteristicsAsync(serviceUUIDs: string[], characteristicUUIDs: string[]): Promise<DiscoverResult>;
 }
 export interface IBlePeripheralConnector {
     connect(): Promise<void>;
@@ -43,9 +83,12 @@ export interface IBlePeripheralConnector {
 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;
+    _serviceUuid?: string;
+    name?: string;
+    subscribe(callback: (err: Error | undefined) => void): void;
+    unsubscribe(callback: (err: Error | undefined) => void): void;
+    read(callback: (err: Error | undefined, data: Buffer) => void): void;
+    write(data: Buffer, withoutResponse: boolean, callback?: (err: Error | undefined) => void): void;
 }
 export type BleDeviceProps = {
     id?: string;
@@ -54,7 +97,7 @@ export type BleDeviceProps = {
     services?: string[];
     peripheral?: BlePeripheral;
 };
-export type ConnectProps = {
+export type BleCommsConnectProps = {
     timeout?: number;
     reconnect?: boolean;
 };
@@ -83,19 +126,3 @@ export type BleDeviceInfo = {
     model?: string;
     serialNo?: string;
 };
-export declare abstract class BleDeviceCommsClass extends EventEmitter {
-    static services: string[];
-    id?: string;
-    address?: string;
-    name?: string;
-    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;
-}

package/lib/ble/types.js

@@ -1,19 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BleDeviceCommsClass = void 0;
-const stream_1 = require("stream");
-class BleDeviceCommsClass extends stream_1.EventEmitter {
-    constructor() {
-        super(...arguments);
-        this.connectState = { isConnecting: false, isConnected: false, isDisconnecting: false };
-    }
-    getConnectState() {
-        return this.connectState;
-    }
-    isConnected() {
-        return this.connectState.isConnected;
-    }
-    setCharacteristicUUIDs(uuids) { }
-}
-exports.BleDeviceCommsClass = BleDeviceCommsClass;
-BleDeviceCommsClass.services = [];

package/lib/ble/utils.d.ts

@@ -1,7 +1,17 @@
-import { BleComms } from "./ble-comms";
+import { LegacyProfile } from "../antv2/types";
+import { BleCharacteristic, BlePeripheral, BleProtocol } from "./types";
+type MappingRecord = {
+    profile: LegacyProfile;
+    protocol: BleProtocol;
+};
+export declare function mapLegacyProfile(profile: string): MappingRecord;
 export declare function uuid(s: string): string;
 export declare function matches(uuid1: string, uuid2: string): boolean;
-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 getServicesFromDevice(device: BleComms): string[];
+export declare function getPeripheralInfo(p: BlePeripheral): {
+    id: string;
+    name: any;
+    address: string;
+    services: any;
+};
+export declare function getCharachteristicsInfo(c: BleCharacteristic): string;
+export {};

package/lib/ble/utils.js

@@ -1,6 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getServicesFromDevice = exports.getServicesFromDeviceTypes = exports.getDevicesFromServices = exports.getBestDeviceMatch = exports.matches = exports.uuid = void 0;
+exports.getCharachteristicsInfo = exports.getPeripheralInfo = exports.matches = exports.uuid = exports.mapLegacyProfile = void 0;
+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' };
+    }
+}
+exports.mapLegacyProfile = mapLegacyProfile;
 function uuid(s) {
     if (s) {
         if (s.includes('-')) {
@@ -24,72 +35,20 @@ function matches(uuid1, uuid2) {
     return false;
 }
 exports.matches = matches;
-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) => matches(s, services));
-    }
-    if (Array.isArray(services)) {
-        const sids = services.map(uuid);
-        return get(deviceTypes, s => {
-            const res = sids.find((service) => 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);
-                });
-            }
-        });
+function getPeripheralInfo(p) {
+    const { id, name, address, advertisement, services } = p;
+    if (advertisement) {
+        return { id, name: advertisement.localName, address, services: advertisement.serviceUuids };
     }
-    catch (err) {
-        console.log(err);
+    else {
+        return { id, name, address, services };
     }
-    return services;
 }
-exports.getServicesFromDeviceTypes = getServicesFromDeviceTypes;
-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.getPeripheralInfo = getPeripheralInfo;
+function getCharachteristicsInfo(c) {
+    const { uuid, properties, name, _serviceUuid } = c;
+    const nameStr = name ? ` (${name})` : '';
+    const serviceStr = _serviceUuid ? `${_serviceUuid}:` : '';
+    return `${serviceStr}${uuid}${nameStr} ${properties}`;
 }
-exports.getServicesFromDevice = getServicesFromDevice;
+exports.getCharachteristicsInfo = getCharachteristicsInfo;

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

@@ -1,5 +1,5 @@
 import { BleFmAdapter } from '../fm';
-import BleAdapter from '../adapter';
+import BleAdapter from '../base/adapter';
 import { BleDeviceProperties, BleDeviceSettings, BleStartProperties } from '../types';
 export default class BleWahooAdapter extends BleFmAdapter {
     constructor(settings: BleDeviceSettings, props?: BleDeviceProperties);