incyclist-services 1.0.45 → 1.0.47

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

@@ -19,11 +19,15 @@ export declare class DeviceConfigurationService extends EventEmitter {
     userSettings: UserSettingsService;
     adapters: DeviceAdapterList;
     protected logger: EventLogger;
+    protected features: {
+        [index: string]: boolean;
+    };
     constructor();
     protected logEvent(e: any): void;
     protected logError(err: Error, fn: string): void;
     init(): Promise<void>;
-    protected isNewUi(): any;
+    setFeature(name: string, enabled: boolean): void;
+    protected isNewUi(): boolean;
     protected verifyCapabilitySettings(): void;
     protected initCapabilties(): void;
     protected initInterfaces(): void;

package/lib/devices/configuration/service.js

@@ -31,6 +31,7 @@ class DeviceConfigurationService extends events_1.default {
         this.adapters = {};
         this.userSettings = (0, settings_1.useUserSettings)();
         this.logger = new gd_eventlog_1.EventLogger('DeviceConfig');
+        this.features = {};
     }
     logEvent(e) {
         var _a;
@@ -99,8 +100,11 @@ class DeviceConfigurationService extends events_1.default {
             this.emitInitialized();
         });
     }
+    setFeature(name, enabled) {
+        this.features[name] = enabled;
+    }
     isNewUi() {
-        return (this.userSettings.isInitialized && this.userSettings.get('NEW_UI', false));
+        return this.features['NEW_UI'] === true;
     }
     verifyCapabilitySettings() {
         const { capabilities } = this.settings;

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

@@ -4,6 +4,7 @@ import { CapabilityData, DevicePairingData, DevicePairingStatus, DeviceSelectSta
 import { DeviceData, IncyclistCapability, IncyclistDeviceAdapter } from "incyclist-devices";
 import { AdapterStateInfo, DeviceRideService } from "../ride";
 import { IncyclistService } from "../../base/service";
+import { EnrichedInterfaceSetting } from "../access";
 export declare const mappedCapability: (c: CapabilityInformation) => CapabilityData;
 export declare const mappedCapabilities: (capabilities: DeviceConfigurationInfo) => Array<CapabilityData>;
 export interface Services {
@@ -38,10 +39,12 @@ export declare class DevicePairingService extends IncyclistService {
     stopDeviceSelection(): Promise<void>;
     selectDevice(capability: IncyclistCapability, udid: string, addAll?: boolean): Promise<void>;
     deleteDevice(capability: IncyclistCapability, udid: string, deleteAll?: boolean): Promise<void>;
+    unselectDevices(capability: IncyclistCapability): Promise<void>;
     changeInterfaceSettings(name: string, settings: InterfaceSetting): Promise<void>;
-    private restart;
+    protected restart(): Promise<void>;
     protected _stop(): Promise<void>;
     protected getCapability(capability: IncyclistCapability | CapabilityData): CapabilityData;
+    protected wouldChangeCapability(capability: IncyclistCapability | CapabilityData, udid: string): boolean;
     protected getCapabilityDevice(capability: IncyclistCapability | CapabilityData, udid?: string): DevicePairingData;
     protected onConfigLoaded(capabilitiesLoaded: DeviceConfigurationInfo, interfacesLoaded: Array<InterfaceSetting>): Promise<void>;
     protected waitForInit(): Promise<void>;
@@ -83,9 +86,15 @@ export declare class DevicePairingService extends IncyclistService {
     protected pauseScanDelay(): Promise<boolean>;
     protected getAdaptersOnInterface(ifaceName: string): AdapterInfo[];
     protected stopAdaptersOnInterface(ifaceName: string, maxRetry?: number): Promise<void>;
-    protected disableAdaptersOnInterface(name: string): void;
     protected failAdaptersOnInterface(name: string): void;
+    protected disableAdaptersOnInterface(name: string): void;
     protected enableAdaptersOnInterface(name: string): void;
+    protected unselectDisabledInterfaces(): void;
+    protected unselectOnInterface(name: string): void;
+    protected selectFromInterface(name: string): void;
+    protected getCapabilitiesUsingInterface(name: string): CapabilityData[];
+    protected getEnabedInterfaces(): EnrichedInterfaceSetting[];
+    protected getDisabledInterfaces(): EnrichedInterfaceSetting[];
     protected getDeviceAdapter(udid: string): IncyclistDeviceAdapter;
     protected stopAdaptersWithCapability(capability: IncyclistCapability | CapabilityData, udid?: string): Promise<void>;
     protected pauseAdapters(adapters: AdapterInfo[], enforced?: boolean): void;

package/lib/devices/pairing/service.js

@@ -97,7 +97,7 @@ class DevicePairingService extends service_2.IncyclistService {
                 this.logCapabilities();
                 this.state.interfaces.forEach(i => {
                     if (!this.isInterfaceEnabled(i.name))
-                        this.disableAdaptersOnInterface(i.name);
+                        this.unselectOnInterface(i.name);
                 });
                 this.settings.onStateChanged = onStateChanged;
                 this.emitStateChange(this.state);
@@ -184,7 +184,7 @@ class DevicePairingService extends service_2.IncyclistService {
             try {
                 if (addAll) {
                     const adapter = this.getDeviceAdapter(udid);
-                    const capabilities = adapter.getCapabilities().filter(name => this.getCapability(name));
+                    const capabilities = adapter.getCapabilities().filter(name => this.wouldChangeCapability(name, udid));
                     capabilities.forEach((c, idx) => {
                         const shouldEmit = (idx === capabilities.length - 1);
                         const wasChanged = this.selectCapabilityDevice(c, udid, shouldEmit);
@@ -228,6 +228,16 @@ class DevicePairingService extends service_2.IncyclistService {
             }
         });
     }
+    unselectDevices(capability) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.configuration.unselect(capability, true);
+            }
+            catch (err) {
+                this.logError(err, 'deleteDevice');
+            }
+        });
+    }
     changeInterfaceSettings(name, settings) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -270,6 +280,12 @@ class DevicePairingService extends service_2.IncyclistService {
         const { capabilities = [] } = this.state;
         return capabilities.find(c => c.capability === target);
     }
+    wouldChangeCapability(capability, udid) {
+        const c = this.getCapability(capability);
+        if (!c)
+            return false;
+        return c.selected !== udid;
+    }
     getCapabilityDevice(capability, udid) {
         const c = this.getCapability(capability);
         if (!(c === null || c === void 0 ? void 0 : c.devices))
@@ -343,11 +359,12 @@ class DevicePairingService extends service_2.IncyclistService {
             if (settings.enabled && !current.enabled) {
                 const { port, protocol } = settings;
                 this.access.enableInterface(ifName, undefined, { port: Number(port), protocol });
-                this.enableAdaptersOnInterface(ifName);
+                this.selectFromInterface(ifName);
             }
             else if (!settings.enabled && current.enabled) {
                 this.access.disableInterface(ifName);
-                this.disableAdaptersOnInterface(ifName);
+                this.unselectOnInterface(ifName);
+                this.unselectDisabledInterfaces();
                 this.stopAdaptersOnInterface(ifName).catch(err => {
                     this.logError(err, 'stopAdaptersOnInterface()');
                 });
@@ -415,6 +432,10 @@ class DevicePairingService extends service_2.IncyclistService {
                     }
                     else if (ifDetails.state === 'unavailable' && current.state !== 'unavailable') {
                         this.disableAdaptersOnInterface(ifName);
+                        this.unselectOnInterface(ifName);
+                    }
+                    else if (ifDetails.state !== 'unavailable' && current.state === 'unavailable') {
+                        this.enableAdaptersOnInterface(ifName);
                     }
                     if (changedIdx !== -1) {
                         prev[changedIdx].isScanning = ifDetails.isScanning;
@@ -823,37 +844,31 @@ class DevicePairingService extends service_2.IncyclistService {
             } while (++tryCnt < maxRetry && target && target.length > 0);
         });
     }
-    disableAdaptersOnInterface(name) {
+    failAdaptersOnInterface(name) {
         const target = this.getAdaptersOnInterface(name);
         const { capabilities } = this.state;
         target.forEach(ai => {
             const { udid } = ai;
             capabilities.forEach(c => {
                 const device = this.getCapabilityDevice(c, udid);
-                if (device) {
-                    device.interfaceInactive = true;
+                if (device && !device.interfaceInactive) {
+                    device.connectState = 'failed';
                     if (c.selected === udid) {
-                        this.configuration.unselect(c.capability);
-                        const alternative = c.devices.find(d => !d.interfaceInactive);
-                        if (alternative)
-                            this.configuration.select(alternative.udid, c.capability);
+                        c.connectState = 'failed';
                     }
                 }
             });
         });
     }
-    failAdaptersOnInterface(name) {
+    disableAdaptersOnInterface(name) {
         const target = this.getAdaptersOnInterface(name);
         const { capabilities } = this.state;
         target.forEach(ai => {
             const { udid } = ai;
             capabilities.forEach(c => {
                 const device = this.getCapabilityDevice(c, udid);
-                if (device && !device.interfaceInactive) {
-                    device.connectState = 'failed';
-                    if (c.selected === udid) {
-                        c.connectState = 'failed';
-                    }
+                if (device) {
+                    device.interfaceInactive = true;
                 }
             });
         });
@@ -864,15 +879,51 @@ class DevicePairingService extends service_2.IncyclistService {
         target.forEach(ai => {
             const { udid } = ai;
             capabilities.forEach(c => {
-                const alternative = c.devices.find(d => !d.interfaceInactive);
                 const device = this.getCapabilityDevice(c, udid);
                 if (device)
                     delete device.interfaceInactive;
-                if (!c.selected && alternative)
-                    this.configuration.select(alternative.udid, c.capability);
             });
         });
     }
+    unselectDisabledInterfaces() {
+        const disabled = this.getDisabledInterfaces();
+        disabled.forEach(i => this.unselectOnInterface(i.name));
+    }
+    unselectOnInterface(name) {
+        const impactedCapabilties = this.getCapabilitiesUsingInterface(name);
+        const enabledInterfaces = this.getEnabedInterfaces().filter(i => i.name !== name).map(i => i.name);
+        impactedCapabilties.forEach(c => {
+            const available = c.devices.filter(d => d.interface !== name && enabledInterfaces.includes(d.interface));
+            if (!(available === null || available === void 0 ? void 0 : available.length)) {
+                this.configuration.unselect(c.capability, true);
+            }
+            else {
+                this.configuration.select(available[0].udid, c.capability, { emit: true });
+            }
+        });
+    }
+    selectFromInterface(name) {
+        const impactedCapabilties = this.state.capabilities.filter(c => !c.selected);
+        const enabledInterfaces = this.getEnabedInterfaces().filter(i => i.name !== name).map(i => i.name);
+        impactedCapabilties.forEach(c => {
+            const available = c.devices.filter(d => d.interface === name || enabledInterfaces.includes(d.interface));
+            if ((available === null || available === void 0 ? void 0 : available.length) > 0) {
+                this.configuration.select(available[0].udid, c.capability, { emit: true });
+            }
+        });
+    }
+    getCapabilitiesUsingInterface(name) {
+        return this.state.capabilities.filter(c => {
+            var _a;
+            return ((_a = this.getCapabilityDevice(c)) === null || _a === void 0 ? void 0 : _a.interface) === name;
+        });
+    }
+    getEnabedInterfaces() {
+        return this.state.interfaces.filter(i => i.enabled === true);
+    }
+    getDisabledInterfaces() {
+        return this.state.interfaces.filter(i => !i.enabled);
+    }
     getDeviceAdapter(udid) {
         const { adapters = [] } = this.state;
         const target = adapters.find(ai => ai.udid === udid);
@@ -931,9 +982,9 @@ class DevicePairingService extends service_2.IncyclistService {
         this.checkCanStart();
     }
     selectCapabilityDevice(capability, udid, emitUpdate = true) {
+        if (!this.wouldChangeCapability(capability, udid))
+            return;
         const c = this.getCapability(capability);
-        if (!c || c.selected === udid)
-            return false;
         const device = this.getCapabilityDevice(capability, udid);
         c.value = device === null || device === void 0 ? void 0 : device.value;
         this.configuration.select(udid, capability, { emit: emitUpdate });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-services",
-  "version": "1.0.45",
+  "version": "1.0.47",
   "peerDependencies": {
     "gd-eventlog": "^0.1.24"
   },