incyclist-services 1.0.36 → 1.0.38

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2023 Incyclist
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2023 Incyclist
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.MD

@@ -1,28 +1,29 @@
-# incyclist-services
-
-This Library contains the business logic used by the React components of the [Incyclist](https://incyclist.com) Indoor Cycling App. 
-
-Incyclist uses React to render the App Front-End for PC platforms ( Windows, Mac. Linux). It is planned that in the future, React Native will be used to render the Front-Ends for other platforms ( Android, IOS, AppleTV,...)
-
-All Services will be accessed by the Front-End using 
-
-```
-import {useXXX, initXXX} from {incyclist-devices}
-
-```
-
-- useXXX  can be used to consume a Service (e.g. `useDeviceConfiguration()` ) 
-- initXXX can be used to perform a lazy initialization of the Service (e.g. `initUserSettings(binding)` ) 
-
-where XXX represents the Service name
-
-The following Services are currently implemented in this library:
-
-## Settings
-- [UserSettings](./doc/classes/UserSettingsService.md): manages the user settings 
-
-
-## Devices
-- [DeviceConfiguration](./doc/classes/DeviceConfigurationService.md): manages the user configuration of scanned/added/selected devices
-- [DeviceAccess](./doc/classes/DeviceAccessService.md): manages the basic communication to the device (setting up interfacs, scanning,... )
-- [Device](./src/devices/device/README.MD): allows the Front-End to communicate with a device (reading, writing data)
+# incyclist-services
+
+This Library contains the business logic used by the React components of the [Incyclist](https://incyclist.com) Indoor Cycling App. 
+
+Incyclist uses React to render the App Front-End for PC platforms ( Windows, Mac. Linux). It is planned that in the future, React Native will be used to render the Front-Ends for other platforms ( Android, IOS, AppleTV,...)
+
+All Services will be accessed by the Front-End using 
+
+```
+import {useXXX, initXXX} from {incyclist-devices}
+
+```
+
+- useXXX  can be used to consume a Service (e.g. `useDeviceConfiguration()` ) 
+- initXXX can be used to perform a lazy initialization of the Service (e.g. `initUserSettings(binding)` ) 
+
+where XXX represents the Service name
+
+The following Services are currently implemented in this library:
+
+## Settings
+- [UserSettings](./doc/classes/UserSettingsService.md): manages the user settings 
+
+
+## Devices
+- [DeviceConfiguration](./doc/classes/DeviceConfigurationService.md): manages the user configuration of scanned/added/selected devices
+- [DeviceAccess](./doc/classes/DeviceAccessService.md): manages the basic communication to the device (setting up interfacs, scanning,... )
+- [Device](./src/devices/device/README.MD): allows the Front-End to communicate with a device (reading, writing data)
+- [DevicePairing](./doc/classes/DevicePairingService.md): implements the business logic og the DevicePairing screens

package/lib/devices/access/mock.d.ts

@@ -0,0 +1,4 @@
+import { DeviceAccessService } from "./service";
+export default class DeviceAccessMock extends DeviceAccessService {
+    constructor();
+}

package/lib/devices/access/mock.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const service_1 = require("./service");
+class DeviceAccessMock extends service_1.DeviceAccessService {
+    constructor() {
+        super();
+        service_1.DeviceAccessService._instance = this;
+    }
+}
+exports.default = DeviceAccessMock;

package/lib/devices/access/model.d.ts

@@ -1,4 +1,5 @@
 import { DeviceSettings, IncyclistCapability } from "incyclist-devices";
+import { InterfaceSetting } from "../configuration";
 export type InterfaceState = 'connected' | 'disconnected' | 'unknown' | 'connecting' | 'disconnecting' | 'unavailable';
 export type ScanState = 'start-requested' | 'started' | 'stop-requested' | 'stopped' | 'idle';
 export interface InterfaceInfo {
@@ -18,6 +19,10 @@ export interface InterfaceAccessProps {
 export interface InterfaceList {
     [index: string]: InterfaceInfo;
 }
+export interface EnrichedInterfaceSetting extends InterfaceSetting {
+    state: InterfaceState;
+    isScanning: boolean;
+}
 export interface ScanFilter {
     interfaces?: string[];
     capabilities?: (IncyclistCapability | 'bike')[];

package/lib/devices/access/service.d.ts

@@ -2,7 +2,8 @@
 import EventEmitter from "events";
 import { EventLogger } from "gd-eventlog";
 import { DeviceSettings, IncyclistInterface } from "incyclist-devices";
-import { InterfaceList, ScanFilter, InterfaceInfo, InterfaceAccessProps, ScanState, ScanForNewFilter } from "./model";
+import { InterfaceSetting } from "../configuration";
+import { InterfaceList, ScanFilter, InterfaceInfo, InterfaceAccessProps, ScanState, ScanForNewFilter, EnrichedInterfaceSetting } from "./model";
 interface InternalScanState {
     promises: (Promise<DeviceSettings[]>)[];
     interfaces: IncyclistInterface[];
@@ -21,10 +22,15 @@ export declare class DeviceAccessService extends EventEmitter {
     disableInterface(ifaceName: string, avalailable?: boolean): void;
     setInterfaceProperties(ifaceName: string, props: InterfaceAccessProps): void;
     getInterfaceInfo(ifaceName: string): InterfaceInfo;
+    enrichWithAccessState(interfaces: InterfaceSetting[]): EnrichedInterfaceSetting[];
     protected getInterface(ifaceName: string): IncyclistInterface;
     connect(ifaceName?: string): Promise<boolean>;
+    private getScanTimeout;
     disconnect(ifaceName?: string): Promise<boolean>;
-    scan(filter?: ScanFilter): Promise<DeviceSettings[]>;
+    scan(filter?: ScanFilter, props?: {
+        timeout?: number;
+        includeKnown?: boolean;
+    }): Promise<DeviceSettings[]>;
     scanForNew(filter?: ScanForNewFilter, maxDevices?: number, timeout?: number): Promise<DeviceSettings[] | DeviceSettings>;
     getPaths(ifaceName: string): Promise<string[]>;
     getProtocols(ifaceName: string): string[];

package/lib/devices/access/service.js

@@ -46,7 +46,8 @@ class DeviceAccessService extends events_1.default {
     enableInterface(ifaceName, binding, props = {}) {
         const existing = this.interfaces[ifaceName];
         if (!binding && !existing) {
-            throw new Error('Interface has not been initialized with binding');
+            this.logEvent({ message: 'Interface has not been initialized with binding', interface: ifaceName });
+            this.emit('interface-changed', ifaceName, { name: ifaceName, state: 'unavailable', isScanning: false });
         }
         if (!existing) {
             const properties = (0, clone_1.default)(this.defaultProps);
@@ -60,7 +61,8 @@ class DeviceAccessService extends events_1.default {
         }
         else {
             if (this.isScanning(ifaceName)) {
-                throw new Error('Illegal State, enable Interface cannot be called during an ongoing scan');
+                this.logEvent({ message: 'Illegal State, enable Interface cannot be called during an ongoing scan' });
+                return;
             }
             if (binding)
                 existing.interface.setBinding(binding);
@@ -115,6 +117,21 @@ class DeviceAccessService extends events_1.default {
     getInterfaceInfo(ifaceName) {
         return this.interfaces[ifaceName];
     }
+    enrichWithAccessState(interfaces) {
+        return interfaces.map(i => {
+            const info = this.interfaces[i.name];
+            const enriched = Object.assign({}, i);
+            if (!info) {
+                enriched.state = 'unavailable';
+                enriched.isScanning = false;
+            }
+            else {
+                enriched.state = info.state;
+                enriched.isScanning = info.isScanning;
+            }
+            return enriched;
+        });
+    }
     getInterface(ifaceName) {
         const info = this.interfaces[ifaceName];
         return info === null || info === void 0 ? void 0 : info.interface;
@@ -130,6 +147,7 @@ class DeviceAccessService extends events_1.default {
             const impl = this.getInterface(ifaceName);
             if (!impl) {
                 this.emit('interface-changed', ifaceName, { name: ifaceName, state: 'unavailable', isScanning: false });
+                this.interfaces[ifaceName].state = 'unavailable';
                 return false;
             }
             const prevState = this.interfaces[ifaceName].state;
@@ -144,6 +162,17 @@ class DeviceAccessService extends events_1.default {
             return connected;
         });
     }
+    getScanTimeout(propsTimeout, interfaceSettingsTimeout) {
+        if (propsTimeout) {
+            if (propsTimeout === -1)
+                return undefined;
+            else
+                return propsTimeout;
+        }
+        else {
+            return interfaceSettingsTimeout;
+        }
+    }
     disconnect(ifaceName) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!ifaceName) {
@@ -166,11 +195,13 @@ class DeviceAccessService extends events_1.default {
             return disconnected;
         });
     }
-    scan(filter = {}) {
+    scan(filter = {}, props = {}) {
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'device scan start', filter });
+            this.logEvent({ message: 'device scan start', filter, props });
             const detected = [];
             const onDataHandlers = {};
+            const { includeKnown = false } = props;
             if (!this.isScanning()) {
                 this.emitScanStateChange('start-requested');
                 this.scanState = {
@@ -192,17 +223,19 @@ class DeviceAccessService extends events_1.default {
                         }
                     };
                     const onDevice = (deviceSettings) => __awaiter(this, void 0, void 0, function* () {
-                        if (adapters.find(a => a.isEqual(deviceSettings))) {
-                            return;
-                        }
-                        if (filter.profile && deviceSettings.profile !== filter.profile) {
-                            return;
-                        }
-                        if (filter.protocol && deviceSettings.protocol !== filter.protocol) {
-                            return;
-                        }
-                        if (filter.protocols && !filter.protocols.includes(deviceSettings.protocol)) {
-                            return;
+                        if (!includeKnown) {
+                            if (adapters.find(a => a.isEqual(deviceSettings))) {
+                                return;
+                            }
+                            if (filter.profile && deviceSettings.profile !== filter.profile) {
+                                return;
+                            }
+                            if (filter.protocol && deviceSettings.protocol !== filter.protocol) {
+                                return;
+                            }
+                            if (filter.protocols && !filter.protocols.includes(deviceSettings.protocol)) {
+                                return;
+                            }
                         }
                         const adapter = incyclist_devices_1.AdapterFactory.create(deviceSettings);
                         if (filter.capabilities) {
@@ -227,17 +260,18 @@ class DeviceAccessService extends events_1.default {
                     const ifaceName = i.getName();
                     const info = this.interfaces[ifaceName];
                     info.isScanning = true;
-                    const props = info.properties || this.defaultProps;
-                    const { scanTimeout, port, protocol } = props;
-                    const properties = ifaceName === 'tcpip' || ifaceName === 'serial' ? { timeout: scanTimeout, port: port === null || port === void 0 ? void 0 : port.toString(), protocol } : { timeout: scanTimeout };
+                    const scanProps = info.properties || this.defaultProps;
+                    const { scanTimeout, port, protocol } = scanProps;
+                    const timeout = this.getScanTimeout(props.timeout, scanTimeout);
+                    const properties = ifaceName === 'tcpip' || ifaceName === 'serial' ? { timeout, port: port === null || port === void 0 ? void 0 : port.toString(), protocol } : { timeout: scanTimeout };
                     this.scanState.promises.push(i.scan(properties));
                 });
                 this.emitScanStateChange('started');
                 try {
-                    if (this.scanState.promises.length === 0) {
-                        this.scanState.promises.push(this.dummyScan());
+                    if (((_a = this.scanState) === null || _a === void 0 ? void 0 : _a.promises.length) === 0) {
+                        (_b = this.scanState) === null || _b === void 0 ? void 0 : _b.promises.push(this.dummyScan());
                     }
-                    yield Promise.allSettled(this.scanState.promises);
+                    yield Promise.allSettled((_c = this.scanState) === null || _c === void 0 ? void 0 : _c.promises);
                 }
                 catch (err) {
                     this.logEvent({ message: 'device scan finished with errors', filter, error: err.message, stack: err.stack });
@@ -250,6 +284,7 @@ class DeviceAccessService extends events_1.default {
                     if (i.getName() === 'tcpip')
                         this.interfaces[i.getName()];
                 });
+                adapters.forEach(adapter => adapter.removeAllListeners('data'));
                 this.emitScanStateChange('stopped');
                 this.logEvent({ message: 'device scan finished', filter, detected });
                 return detected;
@@ -355,13 +390,15 @@ class DeviceAccessService extends events_1.default {
                 this.logEvent({ message: 'stop device scan finished with errors', error: err.message, stack: err.stack });
                 return false;
             }
-            this.scanState.promises = [];
+            this.scanState = null;
             this.emitScanStateChange('stopped');
             this.logEvent({ message: 'stop device scan finished', stopScanresult: result });
             return true;
         });
     }
     isScanning(ifaceName) {
+        if (!this.scanState)
+            return false;
         if (!ifaceName)
             return this.scanState !== null && this.scanState.promises !== null && this.scanState.promises.length > 0;
         else

package/lib/devices/configuration/mock.d.ts

@@ -0,0 +1,4 @@
+import { DeviceConfigurationService } from "./service";
+export default class DeviceConfigurationMock extends DeviceConfigurationService {
+    constructor(settings: any);
+}

package/lib/devices/configuration/mock.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mock_1 = __importDefault(require("../../settings/user/mock"));
+const service_1 = require("./service");
+class DeviceConfigurationMock extends service_1.DeviceConfigurationService {
+    constructor(settings) {
+        const svc = new mock_1.default(settings);
+        super();
+        this.userSettings = svc;
+        service_1.DeviceConfigurationService._instance = this;
+    }
+}
+exports.default = DeviceConfigurationMock;

package/lib/devices/configuration/model/app/index.d.ts

@@ -3,6 +3,7 @@ export type ExtendedIncyclistCapability = IncyclistCapability | 'bike';
 export interface DeviceInformation {
     udid: string;
     name: string;
+    interface: string;
     selected: boolean;
     mode?: string;
     modeSetting?: any;

package/lib/devices/configuration/service.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 import { IncyclistCapability, IncyclistDeviceAdapter } from "incyclist-devices";
+import { UserSettingsService } from "../../settings";
 import { AdapterInfo, DeviceConfigurationInfo, DeviceConfigurationSettings, DeviceModeInfo, ExtendedIncyclistCapability, IncyclistDeviceSettings, InterfaceSetting, LegacySettings } from "./model";
 import EventEmitter from "events";
 import { EventLogger } from "gd-eventlog";
@@ -15,7 +16,7 @@ export declare class DeviceConfigurationService extends EventEmitter {
     protected static _instance: DeviceConfigurationService;
     static getInstance(): DeviceConfigurationService;
     settings: DeviceConfigurationSettings;
-    userSettings: any;
+    userSettings: UserSettingsService;
     adapters: DeviceAdapterList;
     protected logger: EventLogger;
     constructor();
@@ -31,6 +32,10 @@ export declare class DeviceConfigurationService extends EventEmitter {
     protected getDeviceConfigurationInfo(): DeviceConfigurationInfo;
     protected emitCapabiltyChanged(capability?: ExtendedIncyclistCapability): void;
     protected emitInitialized(): void;
+    load(): {
+        capabilities: DeviceConfigurationInfo;
+        interfaces: Array<InterfaceSetting>;
+    };
     disableCapability(cability: ExtendedIncyclistCapability, disabled?: boolean): void;
     select(udid: string, capability: ExtendedIncyclistCapability, props?: {
         noRecursive?: boolean;