incyclist-devices 2.3.0-beta.19 → 2.3.0-beta.20

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/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/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 {};