incyclist-services 1.0.53 → 1.0.55

package/lib/api/repository/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './json';

package/lib/api/repository/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./json"), exports);

package/lib/api/repository/json/index.d.ts

@@ -0,0 +1,19 @@
+import { EventLogger } from "gd-eventlog";
+import { IRepositoryBinding, JSONObject } from "../types";
+export declare class JsonRepository {
+    protected static _instances: {
+        [x: string]: JsonRepository;
+    };
+    protected static _defaultBinding: IRepositoryBinding;
+    static create(repoName: string): JsonRepository;
+    static setBinding(binding: IRepositoryBinding): void;
+    protected binding: IRepositoryBinding;
+    protected name: string;
+    protected db: string;
+    protected logger: EventLogger;
+    constructor(repoName: string, binding?: IRepositoryBinding);
+    protected open(): Promise<boolean>;
+    protected close(): Promise<boolean>;
+    protected write(objectName: string, data: JSONObject): Promise<boolean>;
+    protected read(objectName: string): Promise<JSONObject>;
+}

package/lib/api/repository/json/index.js

@@ -0,0 +1,75 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonRepository = void 0;
+const gd_eventlog_1 = require("gd-eventlog");
+class JsonRepository {
+    static create(repoName) {
+        if (JsonRepository._instances[repoName])
+            return JsonRepository._instances[repoName];
+        JsonRepository._instances[repoName] = new JsonRepository(repoName);
+        return JsonRepository._instances[repoName];
+    }
+    static setBinding(binding) {
+        JsonRepository._defaultBinding = binding;
+    }
+    constructor(repoName, binding) {
+        this.name = repoName;
+        this.binding = binding || JsonRepository._defaultBinding;
+        this.logger = new gd_eventlog_1.EventLogger(`Repo-${this.name}`);
+    }
+    open() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.binding)
+                throw new Error('no binding specified');
+            try {
+                const existing = yield this.binding.get(this.name);
+                if (existing) {
+                    return true;
+                }
+                return yield this.binding.create(this.name);
+            }
+            catch (err) {
+                return false;
+            }
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.binding)
+                throw new Error('no binding specified');
+            this.binding.release(this.name);
+            return true;
+        });
+    }
+    write(objectName, data) {
+        if (!this.binding)
+            throw new Error('no binding specified');
+        const success = this.binding.write(objectName, data);
+        if (!success) {
+        }
+        return success;
+    }
+    read(objectName) {
+        if (!this.binding)
+            throw new Error('no binding specified');
+        try {
+            const data = this.binding.read(objectName);
+            if (!data) {
+            }
+            return data;
+        }
+        catch (err) {
+        }
+    }
+}
+exports.JsonRepository = JsonRepository;
+JsonRepository._instances = {};

package/lib/api/repository/types.d.ts

@@ -0,0 +1,10 @@
+export type JSONObject = string | number | boolean | {
+    [x: string]: JSONObject;
+} | Array<JSONObject>;
+export interface IRepositoryBinding {
+    create(name: string): Promise<boolean>;
+    get(name: string): Promise<boolean>;
+    release(name: string): Promise<boolean>;
+    read(resourceName: string): Promise<JSONObject>;
+    write(resourceName: string, data: JSONObject): Promise<boolean>;
+}

package/lib/api/repository/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -18,11 +18,12 @@ export declare class DeviceAccessService extends EventEmitter {
     constructor();
     protected logEvent(event: any): void;
     setDefaultInterfaceProperties(props: InterfaceAccessProps): void;
-    enableInterface(ifaceName: string, binding?: any, props?: InterfaceAccessProps): void;
-    disableInterface(ifaceName: string, avalailable?: boolean): void;
+    enableInterface(ifaceName: string, binding?: any, props?: InterfaceAccessProps): Promise<void>;
+    disableInterface(ifaceName: string, avalailable?: boolean): Promise<void>;
     setInterfaceProperties(ifaceName: string, props: InterfaceAccessProps): void;
     getInterfaceInfo(ifaceName: string): InterfaceInfo;
     enrichWithAccessState(interfaces: InterfaceSetting[]): EnrichedInterfaceSetting[];
+    initInterface(ifaceName: string, binding: any, props?: InterfaceAccessProps): void;
     protected getInterface(ifaceName: string): IncyclistInterface;
     connect(ifaceName?: string): Promise<boolean>;
     private getScanTimeout;

package/lib/devices/access/service.js

@@ -44,55 +44,67 @@ class DeviceAccessService extends events_1.default {
         this.defaultProps = props;
     }
     enableInterface(ifaceName, binding, props = {}) {
-        const existing = this.interfaces[ifaceName];
-        if (!binding && !existing) {
-            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);
-            (0, merge_1.merge)(properties, props);
-            const info = { name: ifaceName, interface: incyclist_devices_1.InterfaceFactory.create(ifaceName, { binding }), enabled: true, isScanning: false, properties, state: 'unknown' };
-            this.interfaces[ifaceName] = info;
-            info.interface.setBinding(binding);
-            const keys = Object.keys(this.interfaces);
-            const interfaces = keys.map(name => (Object.assign(Object.assign({}, this.interfaces[name]), { name })));
-            this.emit('interface-changed', ifaceName, this.interfaces[ifaceName], interfaces);
-        }
-        else {
-            if (this.isScanning(ifaceName)) {
-                this.logEvent({ message: 'Illegal State, enable Interface cannot be called during an ongoing scan' });
-                return;
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (binding)
+                    this.initInterface(ifaceName, binding, props);
+                const existing = this.interfaces[ifaceName];
+                if (!binding && !existing) {
+                    this.logEvent({ message: 'Interface has not been initialized with binding', interface: ifaceName });
+                    this.emit('interface-changed', ifaceName, { name: ifaceName, state: 'unavailable', isScanning: false });
+                }
+                if (this.isScanning(ifaceName)) {
+                    this.logEvent({ message: 'Illegal State, enable Interface cannot be called during an ongoing scan' });
+                    return;
+                }
+                if (existing.enabled && ((existing.state === 'connected' && ((_a = existing === null || existing === void 0 ? void 0 : existing.interface) === null || _a === void 0 ? void 0 : _a.isConnected())) || existing.state === 'connecting')) {
+                    return;
+                }
+                existing.enabled = true;
+                const state = existing.interface.isConnected() ? 'connected' : 'disconnected';
+                existing.state = state;
+                (0, merge_1.merge)(existing.properties || this.defaultProps, props);
+                this.emit('interface-changed', ifaceName, Object.assign({}, existing));
+                if (!existing.interface.isConnected()) {
+                    this.emit('interface-changed', ifaceName, Object.assign(Object.assign({}, existing), { state: 'connecting' }));
+                    const conected = yield this.connect(ifaceName);
+                    const state = conected ? 'connected' : 'disconnected';
+                    this.emit('interface-changed', ifaceName, Object.assign(Object.assign({}, existing), { state }));
+                }
             }
-            if (binding)
-                existing.interface.setBinding(binding);
-            existing.enabled = true;
-            (0, merge_1.merge)(existing.properties || this.defaultProps, props);
-            this.emit('interface-changed', ifaceName, this.interfaces[ifaceName]);
-        }
+            catch (err) {
+                this.logEvent({ message: 'Error', fn: 'enableInterface', error: err.message, stack: err.stack });
+            }
+        });
     }
     disableInterface(ifaceName, avalailable = true) {
-        const existing = this.interfaces[ifaceName];
-        if (!existing)
-            return;
-        if (this.isScanning(ifaceName)) {
-            const info = this.interfaces[ifaceName];
-            info.interface.stopScan().then((stopped) => {
-                this.emit('interface-changed', ifaceName, this.interfaces[ifaceName]);
-                info.isScanning = !stopped;
-                if (stopped)
-                    this.disableInterface(ifaceName);
-            });
-            return;
-        }
-        existing.enabled = false;
-        if (!avalailable) {
-            existing.state = 'unavailable';
-            existing.unavailable = true;
-            this.emit('interface-changed', ifaceName, { name: ifaceName, state: 'unavailable', isScanning: false });
-            return;
-        }
-        this.emit('interface-changed', ifaceName, this.interfaces[ifaceName]);
+        return __awaiter(this, void 0, void 0, function* () {
+            const existing = this.interfaces[ifaceName];
+            if (!existing)
+                return;
+            if (this.isScanning(ifaceName)) {
+                try {
+                    const info = this.interfaces[ifaceName];
+                    const stopped = yield info.interface.stopScan();
+                    info.isScanning = !stopped;
+                    this.emit('interface-changed', ifaceName, this.interfaces[ifaceName]);
+                    if (stopped)
+                        this.disableInterface(ifaceName);
+                }
+                catch (err) {
+                    this.logEvent({ message: 'Error', fn: 'disableInterface', error: err.message, stack: err.stack });
+                }
+            }
+            existing.enabled = false;
+            yield this.disconnect(ifaceName);
+            if (!avalailable) {
+                existing.state = 'unavailable';
+                existing.unavailable = true;
+                this.emit('interface-changed', ifaceName, { name: ifaceName, state: 'unavailable', isScanning: false });
+                return;
+            }
+        });
     }
     setInterfaceProperties(ifaceName, props) {
         if (this.isScanning(ifaceName)) {
@@ -132,34 +144,60 @@ class DeviceAccessService extends events_1.default {
             return enriched;
         });
     }
+    initInterface(ifaceName, binding, props = {}) {
+        const existing = this.interfaces[ifaceName];
+        if (!existing) {
+            const properties = (0, clone_1.default)(this.defaultProps);
+            (0, merge_1.merge)(properties, props);
+            const info = { name: ifaceName, interface: incyclist_devices_1.InterfaceFactory.create(ifaceName, { binding }), enabled: false, isScanning: false, properties, state: 'unknown' };
+            this.interfaces[ifaceName] = info;
+            info.interface.setBinding(binding);
+            const keys = Object.keys(this.interfaces);
+            const interfaces = keys.map(name => (Object.assign(Object.assign({}, this.interfaces[name]), { name })));
+            this.emit('interface-changed', ifaceName, this.interfaces[ifaceName], interfaces);
+        }
+        else {
+            const info = existing;
+            info.interface.setBinding(binding);
+        }
+    }
     getInterface(ifaceName) {
         const info = this.interfaces[ifaceName];
         return info === null || info === void 0 ? void 0 : info.interface;
     }
     connect(ifaceName) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!ifaceName) {
-                const interfaces = Object.keys(this.interfaces);
-                interfaces.forEach(name => { if (name)
-                    this.connect(name); });
-                return;
+            try {
+                if (!ifaceName) {
+                    const interfaces = Object.keys(this.interfaces);
+                    interfaces.forEach(name => { if (name)
+                        this.connect(name); });
+                    return;
+                }
+                if (((_a = this.interfaces[ifaceName]) === null || _a === void 0 ? void 0 : _a.enabled) === false)
+                    return;
+                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;
+                if (prevState === 'connected')
+                    return true;
+                this.interfaces[ifaceName].state = 'connecting';
+                this.emit('interface-changed', ifaceName, Object.assign(Object.assign({}, this.interfaces[ifaceName]), { state: 'connecting' }));
+                const connected = yield impl.connect();
+                const state = connected ? 'connected' : 'disconnected';
+                this.interfaces[ifaceName].state = state;
+                this.emit('interface-changed', ifaceName, this.interfaces[ifaceName]);
+                return connected;
             }
-            const impl = this.getInterface(ifaceName);
-            if (!impl) {
-                this.emit('interface-changed', ifaceName, { name: ifaceName, state: 'unavailable', isScanning: false });
-                this.interfaces[ifaceName].state = 'unavailable';
+            catch (err) {
+                this.logEvent({ message: 'Error', fn: 'connect', error: err.message, stack: err.stack });
                 return false;
             }
-            const prevState = this.interfaces[ifaceName].state;
-            if (prevState === 'connected')
-                return true;
-            this.interfaces[ifaceName].state = 'connecting';
-            this.emit('interface-changed', ifaceName, this.interfaces[ifaceName]);
-            const connected = yield impl.connect();
-            const state = connected ? 'connected' : 'disconnected';
-            this.interfaces[ifaceName].state = state;
-            this.emit('interface-changed', ifaceName, this.interfaces[ifaceName]);
-            return connected;
         });
     }
     getScanTimeout(propsTimeout, interfaceSettingsTimeout) {
@@ -187,11 +225,11 @@ class DeviceAccessService extends events_1.default {
                 return true;
             const prevState = this.interfaces[ifaceName].state;
             this.interfaces[ifaceName].state = 'disconnecting';
-            this.emit('interface-changed', ifaceName, this.interfaces[ifaceName]);
+            this.emit('interface-changed', ifaceName, Object.assign({}, this.interfaces[ifaceName]));
             const disconnected = yield impl.disconnect();
             const state = disconnected ? 'disconnected' : prevState;
             this.interfaces[ifaceName].state = state;
-            this.emit('interface-changed', ifaceName, this.interfaces[ifaceName]);
+            this.emit('interface-changed', ifaceName, Object.assign({}, this.interfaces[ifaceName]));
             return disconnected;
         });
     }

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

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { DeviceData, DeviceSettings, IncyclistCapability, IncyclistDeviceAdapter } from "incyclist-devices";
 import { EnrichedInterfaceSetting } from "../access";
 import { RideServiceCheckFilter } from "../ride";
@@ -38,10 +39,18 @@ export interface PairingState {
     canStartRide?: boolean;
     adapters?: Array<AdapterInfo>;
 }
+export interface DeleteListEntry {
+    capability: IncyclistCapability;
+    udid: string;
+}
 export interface InternalPairingState extends PairingState {
     initialized: boolean;
     stopRequested?: boolean;
     stopped?: boolean;
+    waiting?: boolean;
+    deleted: Array<DeleteListEntry>;
+    scanTo?: NodeJS.Timeout;
+    tsPrevStart?: number;
     check?: {
         promise: Promise<boolean>;
     };

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

@@ -5,8 +5,6 @@ import { DeviceData, IncyclistCapability, IncyclistDeviceAdapter } from "incycli
 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 {
     configuration?: DeviceConfigurationService;
     access?: DeviceAccessService;
@@ -95,6 +93,7 @@ export declare class DevicePairingService extends IncyclistService {
     protected getCapabilitiesUsingInterface(name: string): CapabilityData[];
     protected getEnabedInterfaces(): EnrichedInterfaceSetting[];
     protected getDisabledInterfaces(): EnrichedInterfaceSetting[];
+    protected getPairingInterfaces(): Array<string>;
     protected getDeviceAdapter(udid: string): IncyclistDeviceAdapter;
     protected stopAdaptersWithCapability(capability: IncyclistCapability | CapabilityData, udid?: string): Promise<void>;
     protected pauseAdapters(adapters: AdapterInfo[], enforced?: boolean): void;
@@ -106,5 +105,10 @@ export declare class DevicePairingService extends IncyclistService {
     protected isPairing(): boolean;
     protected _stopDeviceSelection(changed: boolean): Promise<void>;
     private numberOfSelectedCababilities;
+    protected addToDeletedList(capability: IncyclistCapability | CapabilityData, udid: string): void;
+    protected removeFromDeletedList(capability: IncyclistCapability | CapabilityData, udid: string): void;
+    protected isOnDeletedList(c: IncyclistCapability | CapabilityData, udid: string): boolean;
+    mappedCapability(c: CapabilityInformation): CapabilityData;
+    protected mappedCapabilities(capabilities: DeviceConfigurationInfo): Array<CapabilityData>;
 }
 export declare const useDevicePairing: () => DevicePairingService;

package/lib/devices/pairing/service.js

@@ -12,7 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useDevicePairing = exports.DevicePairingService = exports.mappedCapabilities = exports.mappedCapability = void 0;
+exports.useDevicePairing = exports.DevicePairingService = void 0;
 const service_1 = require("../access/service");
 const configuration_1 = require("../configuration");
 const incyclist_devices_1 = require("incyclist-devices");
@@ -26,28 +26,6 @@ const Units = [
     { capability: incyclist_devices_1.IncyclistCapability.Speed, unit: 'km/h', value: 'speed', decimals: 1 },
     { capability: incyclist_devices_1.IncyclistCapability.Cadence, unit: 'rpm', value: 'cadence', decimals: 0 },
 ];
-const mappedCapability = (c) => {
-    var _a, _b, _c;
-    const { devices } = c;
-    const mapped = Object.assign({}, c);
-    mapped.deviceNames = devices.map(d => d.name).join(';');
-    mapped.selected = (_a = devices.find(d => d.selected)) === null || _a === void 0 ? void 0 : _a.udid;
-    mapped.deviceName = (_b = devices.find(d => d.selected)) === null || _b === void 0 ? void 0 : _b.name;
-    mapped.interface = (_c = devices.find(d => d.selected)) === null || _c === void 0 ? void 0 : _c.interface;
-    mapped.devices = devices;
-    return mapped;
-};
-exports.mappedCapability = mappedCapability;
-const mappedCapabilities = (capabilities) => {
-    const caps = [];
-    const ci = capabilities ? Object.keys(capabilities) || [] : [];
-    ci.forEach(name => {
-        const c = capabilities[name];
-        caps.push((0, exports.mappedCapability)(c));
-    });
-    return caps;
-};
-exports.mappedCapabilities = mappedCapabilities;
 const getInterfaceSettings = (ifName, v) => {
     if (!v)
         return {};
@@ -62,7 +40,7 @@ class DevicePairingService extends service_2.IncyclistService {
     constructor(services) {
         super('Pairing');
         this.settings = {};
-        this.state = { initialized: false };
+        this.state = { initialized: false, deleted: [] };
         this.deviceSelectState = null;
         this.onPairingStartedHandler = this.onPairingStarted.bind(this);
         this.onPairingSuccessHandler = this.onPairingSuccess.bind(this);
@@ -81,6 +59,10 @@ class DevicePairingService extends service_2.IncyclistService {
     }
     start(onStateChanged) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.state.stopped) {
+                this.state.stopped = false;
+                this.state.deleted = [];
+            }
             try {
                 if (this.settings.onStateChanged) {
                     this.settings.onStateChanged = onStateChanged;
@@ -89,7 +71,9 @@ class DevicePairingService extends service_2.IncyclistService {
                 }
                 yield this.waitForInit();
                 const { capabilities, interfaces } = this.configuration.load();
-                this.state.capabilities = (0, exports.mappedCapabilities)(capabilities);
+                const state = Object.assign({}, this.state);
+                delete state.adapters;
+                this.state.capabilities = this.mappedCapabilities(capabilities);
                 this.state.interfaces = this.access.enrichWithAccessState(interfaces);
                 this.state.canStartRide = this.configuration.canStartRide();
                 this.state.stopRequested = false;
@@ -129,6 +113,11 @@ class DevicePairingService extends service_2.IncyclistService {
                 this.removeConfigHandlers();
                 this.settings = {};
                 this.state.initialized = false;
+                this.state.waiting = false;
+                this.state.check = null;
+                this.state.scan = null;
+                this.state.stopRequested = false;
+                this.state.stopped = true;
             }
             catch (err) {
                 this.logError(err, 'stop');
@@ -140,7 +129,7 @@ class DevicePairingService extends service_2.IncyclistService {
             const capabilityData = this.getCapability(capability);
             this.settings = Object.assign(this.settings || {}, { onDeviceSelectStateChanged, capabilityForScan: capability });
             const devices = (capabilityData === null || capabilityData === void 0 ? void 0 : capabilityData.devices) || [];
-            const available = devices.filter(d => this.isInterfaceEnabled(d.interface));
+            const available = devices.filter(d => this.isInterfaceEnabled(d.interface)).filter(d => !this.isOnDeletedList(capability, d.udid));
             const startScan = () => __awaiter(this, void 0, void 0, function* () {
                 if (devices.length > 0)
                     yield this.stopAdaptersWithCapability(capability);
@@ -246,15 +235,6 @@ class DevicePairingService extends service_2.IncyclistService {
                 if (!changed)
                     return;
                 this.configuration.setInterfaceSettings(name, settings);
-                if (settings.enabled) {
-                    this.connectInterface(name);
-                }
-                else {
-                    this.stopAdaptersOnInterface(name);
-                    this.disconnectInterface(name);
-                }
-                this.emitStateChange();
-                yield this.restart();
             }
             catch (err) {
                 this.logError(err, 'changeInterfaceSettings');
@@ -263,8 +243,34 @@ class DevicePairingService extends service_2.IncyclistService {
     }
     restart() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this._stop();
-            this.run();
+            const wasActive = this.isPairing() || this.isScanning();
+            if (this.state.scanTo) {
+                clearTimeout(this.state.scanTo);
+                delete this.state.scanTo;
+                this.state.waiting = true;
+            }
+            else {
+                yield this._stop();
+            }
+            if (this.state.tsPrevStart) {
+                if (this.state.tsPrevStart === -1) {
+                    return;
+                }
+                const timeSincePrev = Date.now() - this.state.tsPrevStart;
+                if (timeSincePrev < 3000) {
+                    this.state.tsPrevStart = -1;
+                    yield (0, utils_1.sleep)(3000 - timeSincePrev);
+                }
+            }
+            if (wasActive) {
+                yield this.rideService.stop();
+                yield (0, utils_1.sleep)(500);
+                this.run();
+            }
+            if (this.state.waiting) {
+                this.state.waiting = false;
+                this.run();
+            }
         });
     }
     _stop() {
@@ -273,6 +279,8 @@ class DevicePairingService extends service_2.IncyclistService {
                 yield this.stopPairing();
             if (this.isScanning())
                 yield this.stopScanning();
+            this.state.capabilities.forEach(c => c.connectState = 'waiting');
+            this.state.waiting = true;
         });
     }
     getCapability(capability) {
@@ -284,14 +292,14 @@ class DevicePairingService extends service_2.IncyclistService {
         const c = this.getCapability(capability);
         if (!c)
             return false;
-        return c.selected !== udid;
+        return c.selected !== udid && !this.isOnDeletedList(capability, udid);
     }
     getCapabilityDevice(capability, udid) {
         const c = this.getCapability(capability);
         if (!(c === null || c === void 0 ? void 0 : c.devices))
             return;
         if (udid) {
-            return c.devices.find(d => d.udid === udid);
+            return c.devices.find(d => d.udid === udid && !this.isOnDeletedList(capability, udid));
         }
         else {
             return c.devices.find(d => d.selected);
@@ -301,7 +309,7 @@ class DevicePairingService extends service_2.IncyclistService {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.state.initialized)
                 return;
-            this.state.capabilities = (0, exports.mappedCapabilities)(capabilitiesLoaded);
+            this.state.capabilities = this.mappedCapabilities(capabilitiesLoaded);
             this.state.canStartRide = this.configuration.canStartRide();
             this.state.interfaces = this.access.enrichWithAccessState(interfacesLoaded);
             this.state.initialized = true;
@@ -337,6 +345,8 @@ class DevicePairingService extends service_2.IncyclistService {
         delete state.scan;
         delete state.initialized;
         delete state.props;
+        delete state.deleted;
+        delete state.waiting;
         return state;
     }
     emitStateChange(newState) {
@@ -378,6 +388,7 @@ class DevicePairingService extends service_2.IncyclistService {
             current.port = settings.port;
             current.protocol = settings.protocol;
             this.emitStateChange();
+            this.restart();
         }
         catch (err) {
             this.logError(err, 'onInterfaceConfigChanged()');
@@ -404,7 +415,7 @@ class DevicePairingService extends service_2.IncyclistService {
             keys.forEach(key => {
                 const newCap = newCapabilities[key];
                 const current = capabilities.find(c => c.capability === key);
-                this.mergeState(current, (0, exports.mappedCapability)(newCap));
+                this.mergeState(current, this.mappedCapability(newCap));
             });
             this.checkCanStart();
         }
@@ -420,9 +431,12 @@ class DevicePairingService extends service_2.IncyclistService {
             const current = getInterfaceSettings(ifName, prev);
             const changed = (current.state !== ifDetails.state || current.isScanning !== ifDetails.isScanning || current.enabled !== ifDetails.enabled);
             if (!changed) {
+                console.log('~~~ DEUBUG: if change, no change', ifName, ifDetails);
                 return;
             }
+            this.logEvent({ message: 'interface state changed', interface: ifName, state: ifDetails.state });
             try {
+                let restartScan = false;
                 if (interfacesNew) {
                     const getData = (i) => ({ name: i.name, enabled: i.enabled, state: i.state });
                     if (!prev)
@@ -443,10 +457,15 @@ class DevicePairingService extends service_2.IncyclistService {
                     else if (ifDetails.state !== 'unavailable' && current.state === 'unavailable') {
                         this.enableAdaptersOnInterface(ifName);
                     }
+                    else if (ifDetails.state === 'connected' && current.state !== 'connected' && !this.isPairing()) {
+                        restartScan = true;
+                    }
                     if (changedIdx !== -1) {
                         prev[changedIdx].isScanning = ifDetails.isScanning;
                         prev[changedIdx].state = ifDetails.state;
                     }
+                    if (restartScan)
+                        this.restart();
                     this.emitStateChange({ interfaces: this.state.interfaces });
                 }
             }
@@ -467,7 +486,7 @@ class DevicePairingService extends service_2.IncyclistService {
         ci.forEach(c => {
             var _a;
             const { devices = [], disabled } = c;
-            const deviceNames = devices.map(d => d.name).join(';');
+            const deviceNames = devices.filter(d => !this.isOnDeletedList(c.capability, d.udid)).map(d => d.name).join(';');
             const selected = (_a = devices.find(d => d.selected)) === null || _a === void 0 ? void 0 : _a.name;
             this.logEvent({ message: 'capability info', capability: c.capability, devices: deviceNames, selected, disabled });
         });
@@ -577,6 +596,8 @@ class DevicePairingService extends service_2.IncyclistService {
             return;
         capabilities.forEach(c => {
             var _a;
+            if (this.isOnDeletedList(c, udid))
+                return;
             const unitInfo = Units.find(ui => ui.capability === c.capability);
             const device = this.getCapabilityDevice(c, udid);
             if (unitInfo) {
@@ -619,6 +640,8 @@ class DevicePairingService extends service_2.IncyclistService {
     markConnected(adapter, udid) {
         const capabilites = adapter.getCapabilities();
         capabilites.forEach(c => {
+            if (this.isOnDeletedList(c, udid))
+                return;
             const info = this.getCapability(c);
             if (!info) {
                 this.logEvent({ message: 'warning: capabability not found', c, caps: this.state.capabilities });
@@ -710,7 +733,7 @@ class DevicePairingService extends service_2.IncyclistService {
     run(props = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             this.emit('run');
-            if (this.isPairing() || this.isScanning()) {
+            if (this.isPairing() || this.isScanning() || !this.state.waiting) {
                 yield this._stop();
             }
             if (this.state.stopRequested || this.state.stopped) {
@@ -743,14 +766,19 @@ class DevicePairingService extends service_2.IncyclistService {
     startPairing(adapters, props) {
         return __awaiter(this, void 0, void 0, function* () {
             this.emit('pairing-start');
-            const isReady = !this.state.interfaces.find(i => i.enabled && i.state === 'connecting');
+            const requiredInterfaces = this.getPairingInterfaces();
+            const busyRequired = this.state.interfaces
+                .filter(i => requiredInterfaces.includes(i.name))
+                .find(i => i.enabled && i.state !== 'connected' && i.state !== 'unavailable');
+            const isReady = busyRequired === undefined;
             if (!isReady) {
                 setTimeout(() => {
-                    this.run();
+                    if (!this.isPairing() && !this.isScanning())
+                        this.run();
                 }, 1000);
                 return;
             }
-            this.logEvent({ message: 'Start Pairing', adapters, props });
+            this.state.tsPrevStart = Date.now();
             this.processConnectedDevices(adapters);
             const selected = this.state.capabilities.map(c => c.selected);
             const target = adapters.filter(ai => !ai.adapter.isStarted() && selected.includes(ai.udid));
@@ -759,12 +787,14 @@ class DevicePairingService extends service_2.IncyclistService {
             const promise = this.rideService.startAdapters(selectedAdapters, 'pair');
             this.state.check = { promise };
             this.onPairingStarted();
+            this.logEvent({ message: 'Start Pairing', adapters, props });
             yield this.state.check.promise;
             if (this.state.check)
                 delete this.state.check;
             this.emit('pairing-done');
             if (!this.checkPairingSuccess()) {
                 this.logEvent({ message: 'Pairing done', adapters, props });
+                yield this.rideService.stop();
                 yield (0, utils_1.sleep)(this.getPairingRetryDelay());
                 if (!this.state.scan)
                     this.run();
@@ -787,25 +817,24 @@ class DevicePairingService extends service_2.IncyclistService {
     }
     startScanning(adapters, props) {
         return __awaiter(this, void 0, void 0, function* () {
-            const interfaces = this.state.interfaces.filter(i => this.isInterfaceEnabled(i)) || [].map(i => i.name);
+            const interfaces = this.state.interfaces.filter(i => this.isInterfaceEnabled(i) && i.state === 'connected')
+                .map(i => i.name);
             if (interfaces.length === 0) {
-                setTimeout(() => {
-                    this.run();
+                if (this.state.scanTo)
+                    return;
+                this.state.scanTo = setTimeout(() => {
+                    delete this.state.scanTo;
+                    if (!this.isPairing() && !this.isScanning())
+                        this.run();
                 }, 1000);
                 return;
             }
             this.emit('scanning-start');
-            const isReady = !this.state.interfaces.find(i => i.enabled && i.state === 'connecting');
-            if (!isReady) {
-                setTimeout(() => {
-                    this.run();
-                }, 1000);
-                return;
-            }
-            this.logEvent({ message: 'Start Scanning', props });
+            this.state.tsPrevStart = Date.now();
+            this.logEvent({ message: 'Start Scanning', interfaces: interfaces.join(','), props });
             this.initScanningCallbacks();
             const timeout = props.enforcedScan ? 1000 * 60 * 60 : undefined;
-            const promise = this.access.scan({ excludeDisabled: true }, { includeKnown: props.enforcedScan, timeout });
+            const promise = this.access.scan({ interfaces, excludeDisabled: true }, { includeKnown: props.enforcedScan, timeout });
             this.state.scan = { promise, adapters: [] };
             this.onPairingStarted();
             try {
@@ -919,7 +948,9 @@ class DevicePairingService extends service_2.IncyclistService {
         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));
+            const available = c.devices
+                .filter(d => d.interface !== name && enabledInterfaces.includes(d.interface))
+                .filter(d => !this.isOnDeletedList(c, d.udid));
             if (!(available === null || available === void 0 ? void 0 : available.length)) {
                 this.configuration.unselect(c.capability, true);
             }
@@ -932,7 +963,9 @@ class DevicePairingService extends service_2.IncyclistService {
         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));
+            const available = c.devices
+                .filter(d => d.interface === name || enabledInterfaces.includes(d.interface))
+                .filter(d => !this.isOnDeletedList(c, d.udid));
             if ((available === null || available === void 0 ? void 0 : available.length) > 0) {
                 this.configuration.select(available[0].udid, c.capability, { emit: true });
             }
@@ -950,6 +983,15 @@ class DevicePairingService extends service_2.IncyclistService {
     getDisabledInterfaces() {
         return this.state.interfaces.filter(i => !i.enabled);
     }
+    getPairingInterfaces() {
+        const interfaces = this.state.capabilities.map(ci => ci.interface);
+        const selected = [];
+        interfaces.forEach(i => {
+            if (!selected.includes(i))
+                selected.push(i);
+        });
+        return selected;
+    }
     getDeviceAdapter(udid) {
         const { adapters = [] } = this.state;
         const target = adapters.find(ai => ai.udid === udid);
@@ -1029,6 +1071,7 @@ class DevicePairingService extends service_2.IncyclistService {
             c.connectState = undefined;
         }
         this.configuration.delete(udid, capability, shouldEmit);
+        this.addToDeletedList(capability, udid);
         this.emitStateChange({ capabilities: this.state.capabilities });
     }
     isScanning() {
@@ -1056,6 +1099,44 @@ class DevicePairingService extends service_2.IncyclistService {
     numberOfSelectedCababilities(udid) {
         return (this.state.capabilities || []).map(c => c.selected === udid ? 1 : 0).reduce((a, c) => a + c, 0);
     }
+    addToDeletedList(capability, udid) {
+        if (this.isOnDeletedList(capability, udid))
+            return;
+        const c = this.getCapability(capability);
+        this.state.deleted.push({ capability: c.capability, udid });
+    }
+    removeFromDeletedList(capability, udid) {
+        const c = this.getCapability(capability);
+        const idx = this.state.deleted.findIndex(e => e.capability === c.capability && e.udid === udid);
+        if (idx === -1)
+            return;
+        this.state.deleted.splice(idx, 1);
+    }
+    isOnDeletedList(c, udid) {
+        const capability = this.getCapability(c);
+        return this.state.deleted.find(e => e.capability === capability.capability && e.udid === udid) !== undefined;
+    }
+    mappedCapability(c) {
+        var _a, _b, _c;
+        const { devices } = c;
+        const mapped = Object.assign({}, c);
+        const available = devices.filter(d => !this.isOnDeletedList(c.capability, d.udid));
+        mapped.deviceNames = available.map(d => d.name).join(';');
+        mapped.selected = (_a = available.find(d => d.selected)) === null || _a === void 0 ? void 0 : _a.udid;
+        mapped.deviceName = (_b = devices.find(d => d.selected)) === null || _b === void 0 ? void 0 : _b.name;
+        mapped.interface = (_c = devices.find(d => d.selected)) === null || _c === void 0 ? void 0 : _c.interface;
+        mapped.devices = devices;
+        return mapped;
+    }
+    mappedCapabilities(capabilities) {
+        const caps = [];
+        const ci = capabilities ? Object.keys(capabilities) || [] : [];
+        ci.forEach(name => {
+            const c = capabilities[name];
+            caps.push(this.mappedCapability(c));
+        });
+        return caps;
+    }
 }
 exports.DevicePairingService = DevicePairingService;
 const useDevicePairing = () => DevicePairingService.getInstance();

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "incyclist-services",
-  "version": "1.0.53",
+  "version": "1.0.55",
   "peerDependencies": {
-    "gd-eventlog": "^0.1.24"
+    "gd-eventlog": "^0.1.26"
   },
   "devDependencies": {
     "@types/jest": "^29.5.4",
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "axios": "^1.6.1",
-    "incyclist-devices": "^2.1.21",
+    "incyclist-devices": "^2.1.22",
     "uuid": "^9.0.0"
   }
 }