incyclist-devices 1.4.58 → 1.4.61

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

@@ -61,6 +61,8 @@ export default class BleInterface extends BleInterfaceClass {
     disconnect(): Promise<boolean>;
     isConnected(): boolean;
     getDevicesFromServices(deviceTypes: (typeof BleDeviceClass)[], services: string | string[]): (typeof BleDeviceClass)[];
+    getAllSupportedServices(): any[];
+    getAllSupportedDeviceTypes(): (typeof BleDeviceClass)[];
     getServicesFromDeviceTypes(deviceTypes: (typeof BleDeviceClass)[]): string[];
     getServicesFromDevice(device: BleDeviceClass): string[];
     waitForConnectFinished(timeout: any): Promise<unknown>;

package/lib/ble/ble-interface.js

@@ -18,8 +18,6 @@ const ble_1 = require("./ble");
 const ble_peripheral_1 = __importDefault(require("./ble-peripheral"));
 const CONNECT_TIMEOUT = 5000;
 const DEFAULT_SCAN_TIMEOUT = 20000;
-const BACKGROUND_SCAN_TIMEOUT = 30000;
-const DEFAULT_SERVICES = ['1818', '180d', '1826'];
 class BleInterface extends ble_1.BleInterfaceClass {
     constructor(props = {}) {
         super(props);
@@ -76,14 +74,6 @@ class BleInterface extends ble_1.BleInterfaceClass {
         const timeout = props.timeout || 2000;
         const runBackgroundScan = () => {
             return;
-            this.scanState.isBackgroundScan = true;
-            this.scan({ timeout: BACKGROUND_SCAN_TIMEOUT, isBackgroundScan: true })
-                .then(() => {
-                this.scanState.isBackgroundScan = false;
-            })
-                .catch(() => {
-                this.scanState.isBackgroundScan = false;
-            });
         };
         return new Promise((resolve, reject) => {
             if (this.connectState.isConnected) {
@@ -223,6 +213,25 @@ class BleInterface extends ble_1.BleInterfaceClass {
         }
         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 {
@@ -369,7 +378,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
             this.scanState.isConnecting = true;
             const existing = this.devices.find(i => (!profile || i.device.getProfile() === profile) && (i.device.address === requested.address || i.device.id === requested.id || i.device.name === requested.name));
             if (existing) {
-                const connected = yield existing.device.connect();
+                yield existing.device.connect();
                 this.scanState.isConnecting = false;
                 return existing.device;
             }
@@ -453,7 +462,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
     }
     scan(props) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { timeout = DEFAULT_SCAN_TIMEOUT, deviceTypes = [], requested } = props;
+            const { timeout = DEFAULT_SCAN_TIMEOUT, deviceTypes = [], requested, isBackgroundScan } = props;
             let profile;
             if (requested)
                 profile = requested instanceof ble_1.BleDeviceClass ?
@@ -461,7 +470,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
                     requested.profile;
             const { id, address, name } = requested || {};
             const scanForDevice = (requested !== null && requested !== undefined);
-            const services = (props.isBackgroundScan || !deviceTypes || deviceTypes.length === 0) ? DEFAULT_SERVICES : this.getServicesFromDeviceTypes(deviceTypes);
+            const services = (props.isBackgroundScan || !deviceTypes || deviceTypes.length === 0) ? this.getAllSupportedServices() : this.getServicesFromDeviceTypes(deviceTypes);
             const bleBinding = this.getBinding();
             if (!bleBinding)
                 return Promise.reject(new Error('no binding defined'));
@@ -470,7 +479,7 @@ class BleInterface extends ble_1.BleInterfaceClass {
             }
             const peripheralsProcessed = [];
             const devicesProcessed = [];
-            this.logEvent({ message: 'scan()', props, scanState: this.scanState,
+            this.logEvent({ message: 'scan()', props: { timeout, isBackgroundScan }, scanState: this.scanState,
                 peripheralCache: this.peripheralCache.map(i => ({ address: i.address, ts: i.ts, name: i.peripheral ? i.peripheral.advertisement.localName : '' })),
                 deviceCache: this.devices.map(i => ({ address: i.device.address, profile: i.device.getProfile(), isConnected: i.isConnected }))
             });
@@ -485,7 +494,8 @@ class BleInterface extends ble_1.BleInterfaceClass {
             }
             else {
                 opStr = 'scan';
-                this.logEvent({ message: 'scan start', services });
+                const supported = BleInterface.deviceClasses.map(dc => ({ id: dc.id, type: dc.type, services: dc.services }));
+                this.logEvent({ message: 'scan start', services, supported });
             }
             if (this.scanState.isScanning) {
                 try {
@@ -506,6 +516,8 @@ class BleInterface extends ble_1.BleInterfaceClass {
                         const knownDevices = this.devices.map(i => ({ name: i.device.name, address: i.device.address, isConnected: i.isConnected, connectState: i.device.getConnectState() }));
                         this.logEvent({ message: `${opStr}: check if already registered`, device: { name, address }, knownDevices });
                         const existing = this.devices.find(i => (i.device.address === address || i.device.name === name || i.device.id === id));
+                        if (existing)
+                            this.logEvent({ message: `${opStr}: device already registered`, device: { name, address } });
                     }
                 }
                 const onTimeout = () => {
@@ -539,8 +551,6 @@ class BleInterface extends ble_1.BleInterfaceClass {
                     if (isPeripheralProcessed)
                         return;
                     peripheralsProcessed.push(peripheral.address);
-                    let chachedPeripheralInfo = this.peripheralCache.find(i => i.address === peripheral.address);
-                    const str = fromCache ? 'added' : 'detected';
                     const characteristics = yield this.getCharacteristics(peripheral);
                     const DeviceClasses = this.getDeviceClasses(peripheral, { profile });
                     let cntFound = 0;

package/lib/ble/incyclist-protocol.js

@@ -39,7 +39,7 @@ const ble_interface_1 = __importDefault(require("./ble-interface"));
 const fm_1 = __importStar(require("./fm"));
 const hrm_1 = __importStar(require("./hrm"));
 const pwr_1 = __importStar(require("./pwr"));
-const supportedDeviceTypes = [hrm_1.default, pwr_1.default, fm_1.default];
+const wahoo_kickr_1 = __importDefault(require("./wahoo-kickr"));
 class BleProtocol extends DeviceProtocol_1.default {
     constructor(binding) {
         super();
@@ -79,9 +79,13 @@ class BleProtocol extends DeviceProtocol_1.default {
                 if (fromDevice)
                     device = bleDevice;
                 else {
-                    device = this.ble.findDeviceInCache(Object.assign(Object.assign({}, props()), { profile: 'Smart Trainer' }));
-                    if (!device)
-                        device = new fm_1.default(props());
+                    device = this.ble.findDeviceInCache(Object.assign(Object.assign({}, props()), { profile }));
+                    if (!device) {
+                        if (profile.toLocaleLowerCase() === 'wahoo smart trainer')
+                            device = new wahoo_kickr_1.default(props());
+                        else
+                            device = new fm_1.default(props());
+                    }
                 }
                 return new fm_1.FmAdapter(device, this);
             case 'cp':
@@ -109,6 +113,7 @@ class BleProtocol extends DeviceProtocol_1.default {
                     }
                 });
                 this.logger.logEvent({ message: 'scan started' });
+                const supportedDeviceTypes = this.ble.getAllSupportedDeviceTypes();
                 yield this.ble.scan({ deviceTypes: supportedDeviceTypes, timeout: 20000 });
                 if (props && props.onScanFinished) {
                     props.onScanFinished(props.id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "1.4.58",
+  "version": "1.4.61",
   "dependencies": {
     "@serialport/parser-byte-length": "^9.0.1",
     "@serialport/parser-delimiter": "^9.0.1",