incyclist-devices 2.3.0-beta.9 → 2.3.1

package/README.MD

@@ -19,6 +19,11 @@ __BLE__
 - Wahoo Smart Trainers (Wahoo specific service)
 - Tacx FE-C over BLE
 
+__Direct Connect (Wifi)__
+- Smart Trainers (FTMS)
+- Power Meters (CP)
+- Heartrate Monitors (HR)
+
 __Serial__
 - Daum Classic Ergo Bikes
 - Daum Premium Ergo Bikes  (also over TCP/IP)
@@ -41,6 +46,7 @@ As this library supports various OS( Linux, Windows, Mac) and Incyclist is based
 - Ant: specified by the [incyclist-ant-plus](https://github.com/incyclist/ant-plus) library
 - Serial: specified by the [serialport](https://serialport.io/) library
 - BLE: specified by the [noble](https://github.com/noble/noble) library
+- Wifi: a combination of Multicast DNS as provided by the [Bonjour](https://github.com/onlxltd/bonjour-service) library and createSocket() wich creates a Socket class from NodeJS net module
 
 __Ant Example__
 
@@ -76,6 +82,55 @@ const logger = new EventLogger('BLESample')
 const ble = InterfaceFactory.create('ble',{logger, log:true, binding:noble})
 ```
 
+__Direct Connect Example__
+```
+const { Bonjour } = require('bonjour-service')
+const net = require('net');
+
+const createBinding = ()=>{
+    return {
+        mdns: new MDNSBinding(),
+        net: {
+            createSocket: ()=>new net.Socket()
+        } 
+    }
+}
+
+class MDNSBinding {
+    
+    connect() {
+        this.bonjour = new Bonjour()
+        
+    }
+
+    disconnect() {
+        if (this.bonjour) {
+            this.bonjour.destroy()
+            this.bonjour = null
+        }
+    }
+
+    find(opts , onUp) {
+        this.bonjour.find(opts, (s)=>{ 
+            this.handleAnnouncement(s,onUp) 
+        })
+    }       
+
+    handleAnnouncement(service,callback) {
+        const {name,txt,port,referer,protocol} = service
+        const announcement = {
+            name,address:referer?.address,protocol,port,
+            serialNo:txt?.['serial-number'], 
+            serviceUUIDs:txt?.['ble-service-uuids']?.split(',')
+        }
+        if (callback)
+            callback(announcement)
+    }
+        
+}
+```
+
+
 ### Check availability of interface
 
 For some interfaces (ANT and BLE) it cannot be guaranteed that the underlying hardware supports the interface ( e.g. a USB stick might be required). Therefore this library offers a `connect` method, that allows to check if the interface is availabe

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

@@ -56,8 +56,8 @@ export default class AntAdapter<TDeviceData extends BaseDeviceData> extends Incy
     getProfile(): Profile;
     getLogData(data: any, excludeList: any): any;
     check(): Promise<boolean>;
-    checkCapabilities(): Promise<void>;
-    initControl(): Promise<void>;
+    protected checkCapabilities(): Promise<void>;
+    protected initControl(): Promise<void>;
     getDefaultStartupTimeout(): number;
     startPreChecks(props: AntDeviceProperties): Promise<'done' | 'connected' | 'connection-failed'>;
     resetStartStatus(): void;

package/lib/base/adpater.d.ts

@@ -11,6 +11,7 @@ export default class IncyclistDevice<P extends DeviceProperties> extends EventEm
     started: boolean;
     stopped: boolean;
     paused: boolean;
+    scanning: boolean;
     protected props: P;
     protected cyclingMode: ICyclingMode;
     protected logger: EventLogger;
@@ -66,5 +67,7 @@ export default class IncyclistDevice<P extends DeviceProperties> extends EventEm
     getStartProps(startProps?: P): P;
     hasDataListeners(): boolean | OnDeviceDataCallback;
     onData(callback: OnDeviceDataCallback): void;
+    onScanStart(): void;
+    onScanStop(): void;
 }
 export type IncyclistDeviceAdapter = IncyclistDevice<DeviceProperties>;

package/lib/base/adpater.js

@@ -26,6 +26,7 @@ class IncyclistDevice extends events_1.default {
         this.started = false;
         this.stopped = false;
         this.paused = false;
+        this.scanning = false;
         this.user = {};
         this.data = {};
         this.cyclingMode = this.getDefaultCyclingMode();
@@ -226,11 +227,15 @@ class IncyclistDevice extends events_1.default {
         const updateFrequency = this.getMaxUpdateFrequency();
         if (updateFrequency === -1 || updateFrequency === undefined)
             return true;
-        return (!this.lastUpdate || (Date.now() - this.lastUpdate) > updateFrequency);
+        const ok = (!this.lastUpdate || (Date.now() - this.lastUpdate) > updateFrequency);
+        return ok;
     }
     canEmitData() {
-        if (this.paused || this.stopped)
+        if (this.scanning)
+            return this.isUpdateWithinFrequency();
+        if (this.paused || this.stopped) {
             return false;
+        }
         return this.isUpdateWithinFrequency();
     }
     emitData(data) {
@@ -264,6 +269,12 @@ class IncyclistDevice extends events_1.default {
     onData(callback) {
         this.onDataFn = callback;
     }
+    onScanStart() {
+        this.scanning = true;
+    }
+    onScanStop() {
+        this.scanning = false;
+    }
 }
 IncyclistDevice.controllers = {};
 exports.default = IncyclistDevice;

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

@@ -1,30 +1,34 @@
 import BleAdapter from "./base/adapter";
-import { BleDeviceSettings, BleProtocol, TBleSensor } from "./types";
+import { BleDeviceSettings, BleProtocol } from "./types";
 import { DeviceProperties } from "../types";
+import { BleComms } from "./base/comms";
 import { BleDeviceData } from "./base/types";
-export interface BleAdapterInfo<T extends TBleSensor> {
+export interface BleAdapterInfo {
     protocol: BleProtocol;
-    Adapter: typeof BleAdapter<BleDeviceData, T>;
-    Comm: typeof TBleSensor;
+    Adapter: typeof BleAdapter<BleDeviceData, BleComms>;
+    Comm: typeof BleComms;
 }
-export default class BleAdapterFactory<T extends TBleSensor> {
-    transport: string;
-    static readonly _instances: Record<string, BleAdapterFactory<any>>;
-    implementations: BleAdapterInfo<any>[];
-    instances: Array<BleAdapter<BleDeviceData, T>>;
-    static getInstance(transport: string): BleAdapterFactory<any>;
-    constructor(transport: string);
-    getAdapterInfo(protocol: BleProtocol): BleAdapterInfo<T>;
-    getAll(): BleAdapterInfo<T>[];
-    createInstance(settings: BleDeviceSettings, props?: DeviceProperties): BleAdapter<BleDeviceData, T>;
+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, T>;
+        adapter?: BleAdapter<BleDeviceData, BleComms>;
     }): void;
-    find(settings?: BleDeviceSettings): BleAdapter<BleDeviceData, T>;
-    register(protocol: BleProtocol, Adapter: typeof BleAdapter<BleDeviceData, T>, Comm: typeof TBleSensor): void;
-    getAllInstances(): Array<BleAdapter<BleDeviceData, T>>;
-    getAllSupportedComms(): (typeof TBleSensor)[];
-    getAllSupportedAdapters(): Array<(typeof BleAdapter<BleDeviceData, T>)>;
+    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

@@ -1,14 +1,14 @@
 "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(transport) {
-        if (!BleAdapterFactory._instances[transport])
-            BleAdapterFactory._instances[transport] = new BleAdapterFactory(transport);
-        return BleAdapterFactory._instances[transport];
+    static getInstance() {
+        if (!BleAdapterFactory._instance)
+            BleAdapterFactory._instance = new BleAdapterFactory();
+        return BleAdapterFactory._instance;
     }
-    constructor(transport) {
-        this.transport = transport;
+    constructor() {
         this.implementations = [];
         this.instances = [];
     }
@@ -37,8 +37,7 @@ class BleAdapterFactory {
             return existing;
         }
         const info = this.getAdapterInfo(protocol);
-        console.log('~~~~ INFO:', info);
-        if (!(info === null || info === void 0 ? void 0 : info.Adapter))
+        if (!info || !info.Adapter)
             return;
         const adapter = new info.Adapter(adapterSettings, props);
         this.instances.push(adapter);
@@ -70,18 +69,42 @@ class BleAdapterFactory {
         return this.instances;
     }
     getAllSupportedComms() {
-        const supported = this.getAll();
+        const supported = BleAdapterFactory.getInstance().getAll();
         return supported.map(info => info.Comm);
     }
     getAllSupportedAdapters() {
-        const supported = this.getAll();
+        const supported = BleAdapterFactory.getInstance().getAll();
         return supported.map(info => info.Adapter);
     }
     getAllSupportedServices() {
-        const supported = this.getAll();
-        const res = ['180d', '1818', '1826', '6e40fec1'];
+        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;
+    }
 }
-BleAdapterFactory._instances = {};
 exports.default = BleAdapterFactory;

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

@@ -21,7 +21,7 @@ export default class BleAdapter<TDeviceData extends BleDeviceData, TDevice exten
     waitForPeripheral(): Promise<void>;
     updateSensor(peripheral: IBlePeripheral): void;
     close(): Promise<boolean>;
-    getComms(): TDevice;
+    getSensor(): TDevice;
     isEqual(settings: BleDeviceSettings): boolean;
     isSame(adapter: IAdapter): boolean;
     isConnected(): boolean;
@@ -44,14 +44,16 @@ export default class BleAdapter<TDeviceData extends BleDeviceData, TDevice exten
     protected isStarting(): boolean;
     protected hasData(): boolean;
     protected waitForInitialData(startupTimeout: any): Promise<void>;
-    protected checkCapabilities(): void;
+    protected checkCapabilities(): Promise<void>;
     protected initControl(_props?: BleStartProperties): Promise<void>;
     protected startAdapter(startProps?: BleStartProperties): Promise<boolean>;
     startSensor(): Promise<boolean>;
+    protected onDisconnectDone(): Promise<void>;
     stop(): Promise<boolean>;
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;
     protected getBle(): IBleInterface<any>;
     update(): void;
     setCyclingMode(mode: string | ICyclingMode, settings?: any, sendInitCommands?: boolean): void;
+    onScanStart(): void;
 }

package/lib/ble/base/adapter.js

@@ -63,7 +63,7 @@ class BleAdapter extends adpater_1.default {
             return true;
         });
     }
-    getComms() {
+    getSensor() {
         return this.device;
     }
     isEqual(settings) {
@@ -142,8 +142,9 @@ class BleAdapter extends adpater_1.default {
             this.dataMsgCount++;
             this.lastDataTS = Date.now();
             this.deviceData = Object.assign({}, deviceData);
-            if (!this.canEmitData())
+            if (!this.canEmitData()) {
                 return;
+            }
             this.logEvent({ message: 'onDeviceData', device: this.getName(), interface: this.getInterface(), data: deviceData, isControllable: this.isControllable() });
             if (this.isControllable()) {
                 const mappedData = this.mapData(deviceData);
@@ -198,6 +199,8 @@ class BleAdapter extends adpater_1.default {
             if (this.isStarting()) {
                 yield this.stop();
             }
+            const ble = this.getBle();
+            ble.once('disconnect-done', this.onDisconnectDone.bind(this));
             this.startTask = new task_1.InteruptableTask(this.startAdapter(startProps), {
                 timeout: startProps === null || startProps === void 0 ? void 0 : startProps.timeout,
                 name: 'start',
@@ -246,6 +249,8 @@ class BleAdapter extends adpater_1.default {
         });
     }
     checkCapabilities() {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
     }
     initControl(_props) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -281,7 +286,7 @@ class BleAdapter extends adpater_1.default {
                     return false;
                 }
                 yield this.waitForInitialData(timeout);
-                this.checkCapabilities();
+                yield this.checkCapabilities();
                 if (this.hasCapability(types_1.IncyclistCapability.Control))
                     yield this.initControl(startProps);
                 this.stopped = false;
@@ -307,52 +312,62 @@ class BleAdapter extends adpater_1.default {
     startSensor() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            if (!((_a = this.getComms()) === null || _a === void 0 ? void 0 : _a.hasPeripheral())) {
+            if (!((_a = this.getSensor()) === null || _a === void 0 ? void 0 : _a.hasPeripheral())) {
                 yield this.waitForPeripheral();
             }
-            if (!this.getComms()) {
+            if (!this.getSensor()) {
                 return false;
             }
-            const connected = yield this.getComms().startSensor();
+            const sensor = this.getSensor();
+            const connected = yield sensor.startSensor();
+            yield sensor.subscribe();
             if (connected) {
-                this.getComms().on('data', this.onDeviceDataHandler);
-                this.getComms().on('disconnected', this.emit.bind(this));
-                this.getComms().on('error', console.log);
+                sensor.on('data', this.onDeviceDataHandler);
+                sensor.on('disconnected', this.emit.bind(this));
+                sensor.on('error', console.log);
             }
             return connected;
         });
     }
-    stop() {
+    onDisconnectDone() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'stopping device', device: this.getName(), interface: this.getInterface() });
+            this.logEvent({ message: 'disconnecting device', device: this.getName(), interface: this.getInterface() });
             if (this.isStarting()) {
                 yield this.startTask.stop();
             }
-            this.started = false;
-            this.resetData();
             let reason = 'unknown';
             let stopped = false;
-            if (!this.getComms()) {
-                this.logEvent({ message: 'device stopped - not started yet', device: this.getName(), interface: this.getInterface() });
-                return true;
-            }
-            this.getComms().reset();
+            const sensor = this.getSensor();
             try {
-                stopped = yield this.getComms().stopSensor();
+                stopped = yield sensor.stopSensor();
             }
             catch (err) {
                 reason = err.message;
             }
-            if (stopped) {
-                this.logEvent({ message: 'device stopped', device: this.getName(), interface: this.getInterface() });
+            if (!stopped) {
+                this.logEvent({ message: 'disconnecting device failed', device: this.getName(), interface: this.getInterface(), reason });
             }
-            else {
-                this.logEvent({ message: 'stopping device failed', device: this.getName(), interface: this.getInterface(), reason });
+        });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'stopping device', device: this.getName(), interface: this.getInterface() });
+            if (this.isStarting()) {
+                yield this.startTask.stop();
             }
+            this.started = false;
+            this.resetData();
+            if (!this.getSensor()) {
+                this.logEvent({ message: 'device stopped - not started yet', device: this.getName(), interface: this.getInterface() });
+                return true;
+            }
+            const sensor = this.getSensor();
+            sensor.reset();
             this.resetData();
             this.stopped = true;
             this.started = false;
-            return stopped;
+            this.logEvent({ message: 'device stopped', device: this.getName(), interface: this.getInterface() });
+            return this.stopped;
         });
     }
     pause() {
@@ -386,5 +401,9 @@ class BleAdapter extends adpater_1.default {
         super.setCyclingMode(mode, settings, sendInitCommands);
         this.refreshDeviceData();
     }
+    onScanStart() {
+        if (!this.isStarted())
+            this.start();
+    }
 }
 exports.default = BleAdapter;

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

@@ -1,3 +1,75 @@
-import { IBleSensor } from "../types";
-export declare class BleSensor implements IBleSensor {
+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 {};