incyclist-devices 3.0.26 → 3.0.28

package/lib/cjs/ble/base/adapter.js

@@ -17,6 +17,8 @@ class BleAdapter extends adpater_js_1.default {
     onDeviceDisconnectHandler = this.emit.bind(this);
     onDisconnectDoneHandler = this.onDisconnectDone.bind(this);
     startTask;
+    startPromise;
+    stopPromise;
     constructor(settings, props) {
         super(settings, props);
         this.deviceData = {};
@@ -198,8 +200,11 @@ class BleAdapter extends adpater_js_1.default {
         return 'connected';
     }
     async start(startProps) {
-        if (this.isStarting()) {
-            await this.stop();
+        while (this.stopPromise !== undefined) {
+            await this.stopPromise;
+        }
+        if (this.isStarting() && this.startPromise !== undefined) {
+            return this.startPromise;
         }
         const ble = this.getBle();
         ble.once('disconnect-done', this.onDisconnectDoneHandler);
@@ -209,11 +214,20 @@ class BleAdapter extends adpater_js_1.default {
             errorOnTimeout: false,
             log: this.logEvent.bind(this)
         });
-        const res = await this.startTask.run();
-        if (!res) {
-            ble.removeListener('disconnect-done', this.onDisconnectDoneHandler);
+        this.startPromise = this.runStartTask(ble);
+        return this.startPromise;
+    }
+    async runStartTask(ble) {
+        try {
+            const res = await this.startTask.run();
+            if (!res) {
+                ble.removeListener('disconnect-done', this.onDisconnectDoneHandler);
+            }
+            return res;
+        }
+        finally {
+            this.startPromise = undefined;
         }
-        return res;
     }
     isStarting() {
         return this.startTask?.isRunning();
@@ -331,7 +345,10 @@ class BleAdapter extends adpater_js_1.default {
         }
         const sensor = this.getSensor();
         let connected = await sensor.startSensor();
-        await sensor.subscribe();
+        const subscribed = await sensor.subscribe();
+        if (connected && !subscribed) {
+            connected = false;
+        }
         if (connected) {
             sensor.on('data', this.onDeviceDataHandler);
             sensor.on('disconnected', this.onDeviceDisconnectHandler);
@@ -379,9 +396,23 @@ class BleAdapter extends adpater_js_1.default {
         return success;
     }
     async stop() {
+        if (this.stopPromise !== undefined) {
+            return this.stopPromise;
+        }
+        this.stopPromise = this.runStop();
+        try {
+            return await this.stopPromise;
+        }
+        finally {
+            this.stopPromise = undefined;
+        }
+    }
+    async runStop() {
         this.logEvent({ message: 'stopping device', device: this.getName(), interface: this.getInterface() });
         if (this.isStarting()) {
-            await this.startTask.stop();
+            const task = this.startTask;
+            await task.stop();
+            await task.getUnderlyingPromise()?.catch(() => { });
         }
         this.started = false;
         this.resetData();

package/lib/cjs/ble/base/peripheral.js

@@ -15,6 +15,7 @@ class BlePeripheral {
     disconnecting = false;
     disconnectedSignalled = false;
     discoveredServiceUUIds;
+    serviceDiscoveryIncomplete = false;
     discoverServicesPromise;
     discoverCharacteristicsPromise = {};
     onErrorHandler = this.onPeripheralError.bind(this);
@@ -158,8 +159,26 @@ class BlePeripheral {
         const promise = this.discoverServicesPromise;
         const res = await promise;
         (0, utils_js_1.sleep)(0).then(() => { delete this.discoverServicesPromise; });
+        const isComplete = this.checkAnnouncedServices(res);
+        this.serviceDiscoveryIncomplete = !isComplete;
+        if (!isComplete) {
+            const { name, address } = this.getInfo();
+            this.logEvent({ message: 'service data incomplete - disconnecting', name, address,
+                announced: this.getAnnouncedServices(), discovered: this.getDiscoveredServices() });
+        }
         return res;
     }
+    checkAnnouncedServices(discovered) {
+        const announced = this.getAnnouncedServices().map(x => (0, utils_js_2.beautifyUUID)(x));
+        const toBeChecked = discovered.map(x => (0, utils_js_2.beautifyUUID)(x));
+        const cntAnnounced = announced.length;
+        let cntVerified = 0;
+        for (const s of announced) {
+            if (toBeChecked.includes(s))
+                cntVerified++;
+        }
+        return cntAnnounced === cntVerified;
+    }
     async _discoverServices() {
         if (!this.getPeripheral())
             return [];
@@ -309,6 +328,14 @@ class BlePeripheral {
             }
             catch { }
         }
+        if (this.serviceDiscoveryIncomplete) {
+            this.logEvent({ message: 'peripheral subscribe selected failed', uuids, reason: 'service discovery incomplete',
+                announced: this.getAnnouncedServices(), discovered: this.getDiscoveredServices() });
+            this.discoveredServiceUUIds = undefined;
+            this.serviceDiscoveryIncomplete = false;
+            await this.disconnect().catch(() => { });
+            return false;
+        }
         try {
             if (Object.keys(this.characteristics).length === 0) {
                 await this.discoverAllCharacteristics();
@@ -349,6 +376,11 @@ class BlePeripheral {
             const res = await this.getPeripheral().discoverSomeServicesAndCharacteristicsAsync([], []);
             const found = [];
             const uuids = [];
+            const freshUuids = new Set(res.characteristics.map(c => (0, utils_js_2.beautifyUUID)(c.uuid)));
+            Object.keys(this.characteristics).forEach(existing => {
+                if (!freshUuids.has(existing))
+                    delete this.characteristics[existing];
+            });
             res.characteristics.forEach(c => {
                 this.characteristics[(0, utils_js_2.beautifyUUID)(c.uuid)] = c;
                 found.push(c.uuid);
@@ -367,6 +399,12 @@ class BlePeripheral {
             const target = characteristics.map(c => (0, utils_js_2.fullUUID)(c));
             const res = await this.getPeripheral().discoverSomeServicesAndCharacteristicsAsync([], target);
             const found = [];
+            const freshUuids = new Set(res.characteristics.map(c => (0, utils_js_2.beautifyUUID)(c.uuid)));
+            characteristics.forEach(requested => {
+                const requestedUuid = (0, utils_js_2.beautifyUUID)(requested);
+                if (!freshUuids.has(requestedUuid))
+                    delete this.characteristics[requestedUuid];
+            });
             res.characteristics.forEach(c => {
                 this.characteristics[(0, utils_js_2.beautifyUUID)(c.uuid)] = c;
                 found.push(c.uuid);
@@ -436,25 +474,61 @@ class BlePeripheral {
                 return Promise.reject(new Error('characteristic not found: ' + characteristicUUID));
             }
         }
+        const signal = options?.signal;
         return new Promise((resolve, reject) => {
+            let settled = false;
+            let onData;
+            const cleanup = () => {
+                if (onData) {
+                    c.off('data', onData);
+                    onData = undefined;
+                }
+                signal?.removeEventListener('abort', onAbort);
+            };
+            const settleResolve = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve(result);
+            };
+            const settleReject = (err) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                reject(err);
+            };
+            const onAbort = () => {
+                settleReject(new Error('aborted'));
+            };
+            if (signal) {
+                if (signal.aborted) {
+                    settleReject(new Error('aborted'));
+                    return;
+                }
+                signal.addEventListener('abort', onAbort, { once: true });
+            }
             const write = () => {
-                if (this.disconnecting || !this.connected)
-                    return Promise.resolve(Buffer.from([]));
-                c.on('data', (data) => {
-                    c.removeAllListeners('data');
-                    resolve(data);
-                });
+                if (this.disconnecting || !this.connected) {
+                    settleResolve(Buffer.from([]));
+                    return;
+                }
+                onData = (responseData) => {
+                    settleResolve(responseData);
+                };
+                c.on('data', onData);
                 this.logEvent({ message: 'write request', characteristic: uuid, data: data.toString('hex'), withoutResponse: options?.withoutResponse === true });
                 c.write(data, options?.withoutResponse === true, (err) => {
                     if (err)
-                        reject(err);
+                        settleReject(err);
                 });
                 if (options?.withoutResponse) {
-                    resolve(Buffer.from([]));
+                    settleResolve(Buffer.from([]));
                 }
             };
             if (!options?.withoutResponse) {
-                this.subscribe(characteristicUUID, null).then(success => {
+                this.subscribe(characteristicUUID, null).then(() => {
                     write();
                 });
             }

package/lib/cjs/ble/base/sensor.js

@@ -79,6 +79,7 @@ class TBleSensor extends node_events_1.EventEmitter {
         }
         this.connectPromise = this.connectPromise ?? this.peripheral.connect();
         const connected = await this.connectPromise;
+        delete this.connectPromise;
         if (!connected)
             return false;
         if (!reconnect)

package/lib/cjs/ble/fm/adapter.js

@@ -225,24 +225,33 @@ class BleFmAdapter extends adapter_js_1.default {
         let hasControl = false;
         let tryCnt = 0;
         const sensor = this.getSensor();
+        let cancelled = false;
+        const controlAbort = new AbortController();
+        const abandon = () => {
+            if (cancelled)
+                return;
+            cancelled = true;
+            controlAbort.abort();
+        };
         const controlPromise = new Promise((resolve) => {
             this.startTask.notifyOnStop(() => {
+                abandon();
                 resolve(false);
             });
             const waitUntilControl = async () => {
                 if (this.supportsVirtualShifting()) {
                     await this.initVirtualShifting();
                 }
-                while (!hasControl && this.isStarting()) {
+                while (!hasControl && !cancelled && this.isStarting()) {
                     if (tryCnt++ === 0) {
                         this.logEvent({ message: 'requesting control', device: this.getName(), interface: this.getInterface() });
                     }
-                    hasControl = await sensor.requestControl();
+                    hasControl = await sensor.requestControl(controlAbort.signal);
                     if (hasControl) {
                         this.logEvent({ message: 'control granted', device: this.getName(), interface: this.getInterface() });
                         resolve(this.isStarting());
                     }
-                    else {
+                    else if (!cancelled) {
                         await (0, utils_js_1.sleep)(this.requestControlRetryDelay);
                     }
                 }
@@ -253,10 +262,12 @@ class BleFmAdapter extends adapter_js_1.default {
             timeout: this.requestControlTimeout,
             name: 'establishControl',
             errorOnTimeout: false,
-            log: this.logEvent.bind(this)
+            log: this.logEvent.bind(this),
+            onCancel: abandon
         });
         const granted = await waitTask.run();
         if (!granted && this.isStarting()) {
+            abandon();
             this.logEvent({ message: 'could not establish control', device: this.getName(), interface: this.getInterface() });
             throw new Error('could not establish control');
         }

package/lib/cjs/ble/fm/sensor.js

@@ -105,7 +105,7 @@ class BleFitnessMachineDevice extends sensor_js_1.TBleSensor {
         this.hasControl = false;
         this.ftmsServiceDataAttempts = 0;
     }
-    async requestControl() {
+    async requestControl(signal) {
         if (this.hasControl) {
             return true;
         }
@@ -115,7 +115,7 @@ class BleFitnessMachineDevice extends sensor_js_1.TBleSensor {
         this.isCheckingControl = true;
         const data = Buffer.alloc(1);
         data.writeUInt8(0, 0);
-        const res = await this.writeFtmsMessage(0, data, { timeout: 5000 });
+        const res = await this.writeFtmsMessage(0, data, { timeout: 5000, signal });
         if (res === 1) {
             this.hasControl = true;
         }
@@ -622,9 +622,15 @@ class BleFitnessMachineDevice extends sensor_js_1.TBleSensor {
             let res;
             let tsStart = Date.now();
             if (props?.timeout) {
-                res = await new task_js_1.InteruptableTask(this.write(consts_js_1.FTMS_CP, data, props), {
+                const internalAbort = new AbortController();
+                const combined = new AbortController();
+                props.signal?.addEventListener('abort', () => combined.abort(), { once: true });
+                internalAbort.signal.addEventListener('abort', () => combined.abort(), { once: true });
+                const signal = combined.signal;
+                res = await new task_js_1.InteruptableTask(this.write(consts_js_1.FTMS_CP, data, { ...props, signal }), {
                     timeout: props.timeout ?? 800,
-                    errorOnTimeout: true
+                    errorOnTimeout: true,
+                    onCancel: () => internalAbort.abort()
                 }).run();
             }
             else {

package/lib/cjs/utils/task.js

@@ -10,6 +10,7 @@ class InteruptableTask {
     internalEvents = new node_events_1.EventEmitter();
     promise;
     onStopNotifiers = [];
+    cancelNotified = false;
     constructor(promise, props) {
         this.state = (props?.state ?? {});
         this.props = props;
@@ -20,6 +21,9 @@ class InteruptableTask {
     getPromise() {
         return this.internalState.promise;
     }
+    getUnderlyingPromise() {
+        return this.promise;
+    }
     getState() {
         return this.state;
     }
@@ -40,6 +44,7 @@ class InteruptableTask {
             const { timeout } = this.props;
             if (timeout) {
                 this.internalState.tsTimeout = this.internalState.tsStart + timeout;
+                this.internalState.timeoutDuration = timeout;
                 this.internalState.onTimeout = this.onTimeout.bind(this);
                 this.internalState.timeout = setTimeout(() => { this.internalEvents.emit('timeout'); }, timeout);
                 this.internalEvents.on('timeout', this.internalState.onTimeout);
@@ -53,6 +58,7 @@ class InteruptableTask {
                 this.sendStopNotification();
                 if (this.getState().result === 'completed' || this.getState().result === 'error')
                     return;
+                this.notifyCancel();
                 this.getState().result = 'stopped';
                 if (this.props.onDone)
                     resolve(this.props.onDone(this.getState()));
@@ -97,8 +103,9 @@ class InteruptableTask {
         if (!this.internalState.timeout)
             return;
         const message = this.props.name ? `${this.props.name} timeout` : 'timeout';
-        this.logEvent({ message, active: this.isRunning() });
+        this.logEvent({ message, active: this.isRunning(), duration: this.internalState?.timeoutDuration });
         this.clearTimeout();
+        this.notifyCancel();
         this.getState().result = 'timeout';
         const resolve = this.internalState.onDone;
         const reject = this.internalState.onError;
@@ -111,6 +118,12 @@ class InteruptableTask {
         else
             resolve(null);
     }
+    notifyCancel() {
+        if (this.cancelNotified)
+            return;
+        this.cancelNotified = true;
+        this.props.onCancel?.();
+    }
     sendStopNotification() {
         this.onStopNotifiers.forEach((cb) => {
             if (typeof cb === 'function')

package/lib/esm/ble/base/adapter.js

@@ -12,6 +12,8 @@ export default class BleAdapter extends IncyclistDevice {
     onDeviceDisconnectHandler = this.emit.bind(this);
     onDisconnectDoneHandler = this.onDisconnectDone.bind(this);
     startTask;
+    startPromise;
+    stopPromise;
     constructor(settings, props) {
         super(settings, props);
         this.deviceData = {};
@@ -193,8 +195,11 @@ export default class BleAdapter extends IncyclistDevice {
         return 'connected';
     }
     async start(startProps) {
-        if (this.isStarting()) {
-            await this.stop();
+        while (this.stopPromise !== undefined) {
+            await this.stopPromise;
+        }
+        if (this.isStarting() && this.startPromise !== undefined) {
+            return this.startPromise;
         }
         const ble = this.getBle();
         ble.once('disconnect-done', this.onDisconnectDoneHandler);
@@ -204,11 +209,20 @@ export default class BleAdapter extends IncyclistDevice {
             errorOnTimeout: false,
             log: this.logEvent.bind(this)
         });
-        const res = await this.startTask.run();
-        if (!res) {
-            ble.removeListener('disconnect-done', this.onDisconnectDoneHandler);
+        this.startPromise = this.runStartTask(ble);
+        return this.startPromise;
+    }
+    async runStartTask(ble) {
+        try {
+            const res = await this.startTask.run();
+            if (!res) {
+                ble.removeListener('disconnect-done', this.onDisconnectDoneHandler);
+            }
+            return res;
+        }
+        finally {
+            this.startPromise = undefined;
         }
-        return res;
     }
     isStarting() {
         return this.startTask?.isRunning();
@@ -326,7 +340,10 @@ export default class BleAdapter extends IncyclistDevice {
         }
         const sensor = this.getSensor();
         let connected = await sensor.startSensor();
-        await sensor.subscribe();
+        const subscribed = await sensor.subscribe();
+        if (connected && !subscribed) {
+            connected = false;
+        }
         if (connected) {
             sensor.on('data', this.onDeviceDataHandler);
             sensor.on('disconnected', this.onDeviceDisconnectHandler);
@@ -374,9 +391,23 @@ export default class BleAdapter extends IncyclistDevice {
         return success;
     }
     async stop() {
+        if (this.stopPromise !== undefined) {
+            return this.stopPromise;
+        }
+        this.stopPromise = this.runStop();
+        try {
+            return await this.stopPromise;
+        }
+        finally {
+            this.stopPromise = undefined;
+        }
+    }
+    async runStop() {
         this.logEvent({ message: 'stopping device', device: this.getName(), interface: this.getInterface() });
         if (this.isStarting()) {
-            await this.startTask.stop();
+            const task = this.startTask;
+            await task.stop();
+            await task.getUnderlyingPromise()?.catch(() => { });
         }
         this.started = false;
         this.resetData();

package/lib/esm/ble/base/peripheral.js

@@ -12,6 +12,7 @@ export class BlePeripheral {
     disconnecting = false;
     disconnectedSignalled = false;
     discoveredServiceUUIds;
+    serviceDiscoveryIncomplete = false;
     discoverServicesPromise;
     discoverCharacteristicsPromise = {};
     onErrorHandler = this.onPeripheralError.bind(this);
@@ -155,8 +156,26 @@ export class BlePeripheral {
         const promise = this.discoverServicesPromise;
         const res = await promise;
         sleep(0).then(() => { delete this.discoverServicesPromise; });
+        const isComplete = this.checkAnnouncedServices(res);
+        this.serviceDiscoveryIncomplete = !isComplete;
+        if (!isComplete) {
+            const { name, address } = this.getInfo();
+            this.logEvent({ message: 'service data incomplete - disconnecting', name, address,
+                announced: this.getAnnouncedServices(), discovered: this.getDiscoveredServices() });
+        }
         return res;
     }
+    checkAnnouncedServices(discovered) {
+        const announced = this.getAnnouncedServices().map(x => beautifyUUID(x));
+        const toBeChecked = discovered.map(x => beautifyUUID(x));
+        const cntAnnounced = announced.length;
+        let cntVerified = 0;
+        for (const s of announced) {
+            if (toBeChecked.includes(s))
+                cntVerified++;
+        }
+        return cntAnnounced === cntVerified;
+    }
     async _discoverServices() {
         if (!this.getPeripheral())
             return [];
@@ -306,6 +325,14 @@ export class BlePeripheral {
             }
             catch { }
         }
+        if (this.serviceDiscoveryIncomplete) {
+            this.logEvent({ message: 'peripheral subscribe selected failed', uuids, reason: 'service discovery incomplete',
+                announced: this.getAnnouncedServices(), discovered: this.getDiscoveredServices() });
+            this.discoveredServiceUUIds = undefined;
+            this.serviceDiscoveryIncomplete = false;
+            await this.disconnect().catch(() => { });
+            return false;
+        }
         try {
             if (Object.keys(this.characteristics).length === 0) {
                 await this.discoverAllCharacteristics();
@@ -346,6 +373,11 @@ export class BlePeripheral {
             const res = await this.getPeripheral().discoverSomeServicesAndCharacteristicsAsync([], []);
             const found = [];
             const uuids = [];
+            const freshUuids = new Set(res.characteristics.map(c => beautifyUUID(c.uuid)));
+            Object.keys(this.characteristics).forEach(existing => {
+                if (!freshUuids.has(existing))
+                    delete this.characteristics[existing];
+            });
             res.characteristics.forEach(c => {
                 this.characteristics[beautifyUUID(c.uuid)] = c;
                 found.push(c.uuid);
@@ -364,6 +396,12 @@ export class BlePeripheral {
             const target = characteristics.map(c => fullUUID(c));
             const res = await this.getPeripheral().discoverSomeServicesAndCharacteristicsAsync([], target);
             const found = [];
+            const freshUuids = new Set(res.characteristics.map(c => beautifyUUID(c.uuid)));
+            characteristics.forEach(requested => {
+                const requestedUuid = beautifyUUID(requested);
+                if (!freshUuids.has(requestedUuid))
+                    delete this.characteristics[requestedUuid];
+            });
             res.characteristics.forEach(c => {
                 this.characteristics[beautifyUUID(c.uuid)] = c;
                 found.push(c.uuid);
@@ -433,25 +471,61 @@ export class BlePeripheral {
                 return Promise.reject(new Error('characteristic not found: ' + characteristicUUID));
             }
         }
+        const signal = options?.signal;
         return new Promise((resolve, reject) => {
+            let settled = false;
+            let onData;
+            const cleanup = () => {
+                if (onData) {
+                    c.off('data', onData);
+                    onData = undefined;
+                }
+                signal?.removeEventListener('abort', onAbort);
+            };
+            const settleResolve = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve(result);
+            };
+            const settleReject = (err) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                reject(err);
+            };
+            const onAbort = () => {
+                settleReject(new Error('aborted'));
+            };
+            if (signal) {
+                if (signal.aborted) {
+                    settleReject(new Error('aborted'));
+                    return;
+                }
+                signal.addEventListener('abort', onAbort, { once: true });
+            }
             const write = () => {
-                if (this.disconnecting || !this.connected)
-                    return Promise.resolve(Buffer.from([]));
-                c.on('data', (data) => {
-                    c.removeAllListeners('data');
-                    resolve(data);
-                });
+                if (this.disconnecting || !this.connected) {
+                    settleResolve(Buffer.from([]));
+                    return;
+                }
+                onData = (responseData) => {
+                    settleResolve(responseData);
+                };
+                c.on('data', onData);
                 this.logEvent({ message: 'write request', characteristic: uuid, data: data.toString('hex'), withoutResponse: options?.withoutResponse === true });
                 c.write(data, options?.withoutResponse === true, (err) => {
                     if (err)
-                        reject(err);
+                        settleReject(err);
                 });
                 if (options?.withoutResponse) {
-                    resolve(Buffer.from([]));
+                    settleResolve(Buffer.from([]));
                 }
             };
             if (!options?.withoutResponse) {
-                this.subscribe(characteristicUUID, null).then(success => {
+                this.subscribe(characteristicUUID, null).then(() => {
                     write();
                 });
             }

package/lib/esm/ble/base/sensor.js

@@ -76,6 +76,7 @@ export class TBleSensor extends EventEmitter {
         }
         this.connectPromise = this.connectPromise ?? this.peripheral.connect();
         const connected = await this.connectPromise;
+        delete this.connectPromise;
         if (!connected)
             return false;
         if (!reconnect)

package/lib/esm/ble/fm/adapter.js

@@ -220,24 +220,33 @@ export default class BleFmAdapter extends BleAdapter {
         let hasControl = false;
         let tryCnt = 0;
         const sensor = this.getSensor();
+        let cancelled = false;
+        const controlAbort = new AbortController();
+        const abandon = () => {
+            if (cancelled)
+                return;
+            cancelled = true;
+            controlAbort.abort();
+        };
         const controlPromise = new Promise((resolve) => {
             this.startTask.notifyOnStop(() => {
+                abandon();
                 resolve(false);
             });
             const waitUntilControl = async () => {
                 if (this.supportsVirtualShifting()) {
                     await this.initVirtualShifting();
                 }
-                while (!hasControl && this.isStarting()) {
+                while (!hasControl && !cancelled && this.isStarting()) {
                     if (tryCnt++ === 0) {
                         this.logEvent({ message: 'requesting control', device: this.getName(), interface: this.getInterface() });
                     }
-                    hasControl = await sensor.requestControl();
+                    hasControl = await sensor.requestControl(controlAbort.signal);
                     if (hasControl) {
                         this.logEvent({ message: 'control granted', device: this.getName(), interface: this.getInterface() });
                         resolve(this.isStarting());
                     }
-                    else {
+                    else if (!cancelled) {
                         await sleep(this.requestControlRetryDelay);
                     }
                 }
@@ -248,10 +257,12 @@ export default class BleFmAdapter extends BleAdapter {
             timeout: this.requestControlTimeout,
             name: 'establishControl',
             errorOnTimeout: false,
-            log: this.logEvent.bind(this)
+            log: this.logEvent.bind(this),
+            onCancel: abandon
         });
         const granted = await waitTask.run();
         if (!granted && this.isStarting()) {
+            abandon();
             this.logEvent({ message: 'could not establish control', device: this.getName(), interface: this.getInterface() });
             throw new Error('could not establish control');
         }

package/lib/esm/ble/fm/sensor.js

@@ -103,7 +103,7 @@ export default class BleFitnessMachineDevice extends TBleSensor {
         this.hasControl = false;
         this.ftmsServiceDataAttempts = 0;
     }
-    async requestControl() {
+    async requestControl(signal) {
         if (this.hasControl) {
             return true;
         }
@@ -113,7 +113,7 @@ export default class BleFitnessMachineDevice extends TBleSensor {
         this.isCheckingControl = true;
         const data = Buffer.alloc(1);
         data.writeUInt8(0, 0);
-        const res = await this.writeFtmsMessage(0, data, { timeout: 5000 });
+        const res = await this.writeFtmsMessage(0, data, { timeout: 5000, signal });
         if (res === 1) {
             this.hasControl = true;
         }
@@ -620,9 +620,15 @@ export default class BleFitnessMachineDevice extends TBleSensor {
             let res;
             let tsStart = Date.now();
             if (props?.timeout) {
-                res = await new InteruptableTask(this.write(FTMS_CP, data, props), {
+                const internalAbort = new AbortController();
+                const combined = new AbortController();
+                props.signal?.addEventListener('abort', () => combined.abort(), { once: true });
+                internalAbort.signal.addEventListener('abort', () => combined.abort(), { once: true });
+                const signal = combined.signal;
+                res = await new InteruptableTask(this.write(FTMS_CP, data, { ...props, signal }), {
                     timeout: props.timeout ?? 800,
-                    errorOnTimeout: true
+                    errorOnTimeout: true,
+                    onCancel: () => internalAbort.abort()
                 }).run();
             }
             else {

package/lib/esm/utils/task.js

@@ -7,6 +7,7 @@ export class InteruptableTask {
     internalEvents = new EventEmitter();
     promise;
     onStopNotifiers = [];
+    cancelNotified = false;
     constructor(promise, props) {
         this.state = (props?.state ?? {});
         this.props = props;
@@ -17,6 +18,9 @@ export class InteruptableTask {
     getPromise() {
         return this.internalState.promise;
     }
+    getUnderlyingPromise() {
+        return this.promise;
+    }
     getState() {
         return this.state;
     }
@@ -37,6 +41,7 @@ export class InteruptableTask {
             const { timeout } = this.props;
             if (timeout) {
                 this.internalState.tsTimeout = this.internalState.tsStart + timeout;
+                this.internalState.timeoutDuration = timeout;
                 this.internalState.onTimeout = this.onTimeout.bind(this);
                 this.internalState.timeout = setTimeout(() => { this.internalEvents.emit('timeout'); }, timeout);
                 this.internalEvents.on('timeout', this.internalState.onTimeout);
@@ -50,6 +55,7 @@ export class InteruptableTask {
                 this.sendStopNotification();
                 if (this.getState().result === 'completed' || this.getState().result === 'error')
                     return;
+                this.notifyCancel();
                 this.getState().result = 'stopped';
                 if (this.props.onDone)
                     resolve(this.props.onDone(this.getState()));
@@ -94,8 +100,9 @@ export class InteruptableTask {
         if (!this.internalState.timeout)
             return;
         const message = this.props.name ? `${this.props.name} timeout` : 'timeout';
-        this.logEvent({ message, active: this.isRunning() });
+        this.logEvent({ message, active: this.isRunning(), duration: this.internalState?.timeoutDuration });
         this.clearTimeout();
+        this.notifyCancel();
         this.getState().result = 'timeout';
         const resolve = this.internalState.onDone;
         const reject = this.internalState.onError;
@@ -108,6 +115,12 @@ export class InteruptableTask {
         else
             resolve(null);
     }
+    notifyCancel() {
+        if (this.cancelNotified)
+            return;
+        this.cancelNotified = true;
+        this.props.onCancel?.();
+    }
     sendStopNotification() {
         this.onStopNotifiers.forEach((cb) => {
             if (typeof cb === 'function')

package/lib/types/ble/base/adapter.d.ts

@@ -15,6 +15,8 @@ export default class BleAdapter<TDeviceData extends BleDeviceData, TDevice exten
     protected onDeviceDisconnectHandler: any;
     protected onDisconnectDoneHandler: any;
     protected startTask: InteruptableTask<TaskState, boolean>;
+    protected startPromise?: Promise<boolean>;
+    protected stopPromise?: Promise<boolean>;
     constructor(settings: BleDeviceSettings, props?: DeviceProperties);
     getUniqueName(): string;
     connect(): Promise<boolean>;
@@ -43,6 +45,7 @@ export default class BleAdapter<TDeviceData extends BleDeviceData, TDevice exten
     getDefaultStartupTimeout(): number;
     startPreChecks(props: BleStartProperties): Promise<'done' | 'connected' | 'connection-failed'>;
     start(startProps?: BleStartProperties): Promise<boolean>;
+    protected runStartTask(ble: IBleInterface<any>): Promise<boolean>;
     protected isStarting(): boolean;
     protected hasData(): boolean;
     protected waitForInitialData(startupTimeout: any): Promise<void>;
@@ -55,6 +58,7 @@ export default class BleAdapter<TDeviceData extends BleDeviceData, TDevice exten
     protected onDisconnectDone(): Promise<void>;
     restart(pause?: number): Promise<boolean>;
     stop(): Promise<boolean>;
+    protected runStop(): Promise<boolean>;
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;
     protected getBle(): IBleInterface<any>;

package/lib/types/ble/base/peripheral.d.ts

@@ -14,6 +14,7 @@ export declare class BlePeripheral implements IBlePeripheral {
     protected disconnecting: boolean;
     protected disconnectedSignalled: boolean;
     protected discoveredServiceUUIds: Array<string> | undefined;
+    protected serviceDiscoveryIncomplete: boolean;
     protected discoverServicesPromise: Promise<string[]> | undefined;
     protected discoverCharacteristicsPromise: Record<string, Promise<BleCharacteristic[]> | undefined>;
     protected onErrorHandler: any;
@@ -29,15 +30,16 @@ export declare class BlePeripheral implements IBlePeripheral {
     isConnected(): boolean;
     isConnecting(): boolean;
     onDisconnect(callback: () => void): void;
-    getManufacturerData(): Buffer<ArrayBufferLike>;
+    getManufacturerData(): Buffer;
     getServiceData(uuid: string): Buffer | undefined;
     protected onPeripheralDisconnect(): Promise<void>;
     protected onPeripheralError(err: Error): void;
     discoverServices(): Promise<string[]>;
+    protected checkAnnouncedServices(discovered: string[]): boolean;
     protected _discoverServices(): Promise<string[]>;
     discoverCharacteristics(serviceUUID: string): Promise<BleCharacteristic[]>;
     protected _discoverCharacteristics(serviceUUID: string): Promise<BleCharacteristic[]>;
-    subscribe(characteristicUUID: string, callback: (characteristicUuid: string, data: Buffer, isNotify?: any) => void): Promise<boolean>;
+    subscribe(characteristicUUID: string, callback: (characteristicUuid: string, data: Buffer, isNotify?: boolean) => void): Promise<boolean>;
     unsubscribe(characteristicUUID: string): Promise<boolean>;
     subscribeSelected(characteristics: string[], callback: (characteristicUuid: string, data: Buffer, isNotify?: boolean) => void): Promise<boolean>;
     discoverAllCharacteristics(): Promise<string[]>;

package/lib/types/ble/fm/sensor.d.ts

@@ -35,7 +35,7 @@ export default class BleFitnessMachineDevice extends TBleSensor {
     getWindSpeed(): number;
     getSupportedSports(): Array<Sport>;
     protected onDisconnect(): void;
-    requestControl(): Promise<boolean>;
+    requestControl(signal?: AbortSignal): Promise<boolean>;
     setTargetPower(power: number): Promise<boolean>;
     setTargetResistanceLevel(resistanceLevel: number): Promise<boolean>;
     setSlope(slope: number): Promise<boolean>;

package/lib/types/ble/types.d.ts

@@ -123,6 +123,7 @@ export type BleCommsConnectProps = {
 export interface BleWriteProps {
     withoutResponse?: boolean;
     timeout?: number;
+    signal?: AbortSignal;
 }
 export interface ConnectState {
     isConnecting: boolean;

package/lib/types/utils/task.d.ts

@@ -13,10 +13,12 @@ export interface TaskProps<T, P> {
     errorOnTimeout?: boolean;
     log?: (event: any) => void;
     onDone?: (state: T) => P;
+    onCancel?: () => void;
 }
 interface InternalTaskState<P> {
     tsStart?: number;
     tsTimeout?: number;
+    timeoutDuration?: number;
     isRunning: boolean;
     timeout?: NodeJS.Timeout;
     promise?: Promise<P>;
@@ -31,8 +33,10 @@ export declare class InteruptableTask<T extends TaskState, P> {
     protected internalEvents: EventEmitter<any>;
     protected promise?: Promise<P>;
     protected onStopNotifiers: Array<() => void>;
+    protected cancelNotified: boolean;
     constructor(promise: Promise<any>, props?: TaskProps<T, P>);
     getPromise(): Promise<P>;
+    getUnderlyingPromise(): Promise<any> | undefined;
     getState(): T;
     run(): Promise<P>;
     notifyOnStop(cb: () => void): void;
@@ -41,6 +45,7 @@ export declare class InteruptableTask<T extends TaskState, P> {
     isRunning(): boolean;
     protected clearTimeout(): void;
     protected onTimeout(): void;
+    protected notifyCancel(): void;
     protected sendStopNotification(): void;
     protected logEvent(event: any): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "incyclist-devices",
-    "version": "3.0.26",
+    "version": "3.0.28",
     "scripts": {
         "lint": "eslint . --ext .ts",
         "build": "npm run build:esm && npm run build:cjs",