incyclist-devices 3.0.25 → 3.0.27

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();
@@ -253,6 +267,8 @@ class BleAdapter extends adpater_js_1.default {
     }
     async initControl(_props) {
     }
+    async initControlBestEffort(_props) {
+    }
     getStartLogProps(props) {
         const capabilities = this.props?.capabilities;
         const { user, userWeight, bikeWeight, timeout, wheelDiameter, restart, scanOnly } = props ?? {};
@@ -288,11 +304,16 @@ class BleAdapter extends adpater_js_1.default {
                 this.stopped = true;
                 return false;
             }
-            await this.waitForInitialData(timeout);
             await this.checkCapabilities();
             const skipControl = this.props.capabilities && !this.props.capabilities.includes(index_js_1.IncyclistCapability.Control);
-            if (this.hasCapability(index_js_1.IncyclistCapability.Control) && !skipControl)
+            const isControllable = this.hasCapability(index_js_1.IncyclistCapability.Control) && !skipControl;
+            if (isControllable) {
                 await this.initControl(startProps);
+            }
+            else {
+                await this.initControlBestEffort(startProps);
+            }
+            await this.waitForInitialData(timeout);
             this.stopped = false;
             this.started = true;
             if (wasPaused)
@@ -372,9 +393,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

@@ -158,8 +158,23 @@ 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);
+        if (!isComplete) {
+            this.logEvent({ message: 'service data incomplete - disconnecting' });
+        }
         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 [];
@@ -436,25 +451,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/fm/adapter.js

@@ -12,6 +12,7 @@ const adapter_js_1 = __importDefault(require("../base/adapter.js"));
 const consts_js_1 = require("./consts.js");
 const index_js_1 = require("../../types/index.js");
 const utils_js_1 = require("../../utils/utils.js");
+const task_js_1 = require("../../utils/task.js");
 const index_js_2 = require("../zwift/play/index.js");
 const index_js_3 = require("../../features/index.js");
 const fm_resistance_js_1 = __importDefault(require("../../modes/fm-resistance.js"));
@@ -21,6 +22,7 @@ class BleFmAdapter extends adapter_js_1.default {
     distanceInternal = 0;
     connectPromise;
     requestControlRetryDelay = 1000;
+    requestControlTimeout = 10000;
     promiseSendUpdate;
     zwiftPlay;
     isHubInitialized = false;
@@ -168,8 +170,36 @@ class BleFmAdapter extends adapter_js_1.default {
         if (!this.hasCapability(index_js_1.IncyclistCapability.Control))
             return;
         await this.establishControl();
+        await this.attemptStartRequest();
         await this.sendInitialRequest();
     }
+    async initControlBestEffort(_startProps) {
+        if (!this.isStarting())
+            return;
+        this.setConstants();
+        try {
+            const hasControl = await this.getSensor().requestControl();
+            if (hasControl) {
+                this.logEvent({ message: 'control granted (downgraded device)', device: this.getName(), interface: this.getInterface() });
+                await this.attemptStartRequest();
+            }
+            else {
+                this.logEvent({ message: 'could not establish control (downgraded device, non-fatal)', device: this.getName(), interface: this.getInterface() });
+            }
+        }
+        catch (err) {
+            this.logEvent({ message: 'could not establish control (downgraded device, non-fatal)', device: this.getName(), interface: this.getInterface(), error: err.message });
+        }
+    }
+    async attemptStartRequest() {
+        try {
+            const started = await this.getSensor().startRequest();
+            this.logEvent({ message: started ? 'start request acknowledged' : 'start request not acknowledged (non-fatal)', device: this.getName(), interface: this.getInterface() });
+        }
+        catch (err) {
+            this.logEvent({ message: 'start request failed (non-fatal)', device: this.getName(), interface: this.getInterface(), error: err.message });
+        }
+    }
     setConstants() {
         const mode = this.getCyclingMode();
         const sensor = this.getSensor();
@@ -195,30 +225,53 @@ class BleFmAdapter extends adapter_js_1.default {
         let hasControl = false;
         let tryCnt = 0;
         const sensor = this.getSensor();
-        return new Promise((resolve) => {
+        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);
                     }
                 }
             };
             waitUntilControl();
         });
+        const waitTask = new task_js_1.InteruptableTask(controlPromise, {
+            timeout: this.requestControlTimeout,
+            name: 'establishControl',
+            errorOnTimeout: false,
+            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');
+        }
+        return granted;
     }
     async sendInitialRequest() {
         const startRequest = this.getCyclingMode().getBikeInitRequest();

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

@@ -105,20 +105,17 @@ class BleFitnessMachineDevice extends sensor_js_1.TBleSensor {
         this.hasControl = false;
         this.ftmsServiceDataAttempts = 0;
     }
-    async requestControl() {
+    async requestControl(signal) {
         if (this.hasControl) {
             return true;
         }
         if (!this.isSubscribed())
             return false;
-        if (this.features?.setPower === false && this.features?.setSlope === false && this.features?.setResistance === false) {
-            return true;
-        }
         this.logEvent({ message: 'requestControl' });
         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;
         }
@@ -625,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();
@@ -248,6 +262,8 @@ export default class BleAdapter extends IncyclistDevice {
     }
     async initControl(_props) {
     }
+    async initControlBestEffort(_props) {
+    }
     getStartLogProps(props) {
         const capabilities = this.props?.capabilities;
         const { user, userWeight, bikeWeight, timeout, wheelDiameter, restart, scanOnly } = props ?? {};
@@ -283,11 +299,16 @@ export default class BleAdapter extends IncyclistDevice {
                 this.stopped = true;
                 return false;
             }
-            await this.waitForInitialData(timeout);
             await this.checkCapabilities();
             const skipControl = this.props.capabilities && !this.props.capabilities.includes(IncyclistCapability.Control);
-            if (this.hasCapability(IncyclistCapability.Control) && !skipControl)
+            const isControllable = this.hasCapability(IncyclistCapability.Control) && !skipControl;
+            if (isControllable) {
                 await this.initControl(startProps);
+            }
+            else {
+                await this.initControlBestEffort(startProps);
+            }
+            await this.waitForInitialData(timeout);
             this.stopped = false;
             this.started = true;
             if (wasPaused)
@@ -367,9 +388,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

@@ -155,8 +155,23 @@ export class BlePeripheral {
         const promise = this.discoverServicesPromise;
         const res = await promise;
         sleep(0).then(() => { delete this.discoverServicesPromise; });
+        const isComplete = this.checkAnnouncedServices(res);
+        if (!isComplete) {
+            this.logEvent({ message: 'service data incomplete - disconnecting' });
+        }
         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 [];
@@ -433,25 +448,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/fm/adapter.js

@@ -7,6 +7,7 @@ import BleAdapter from '../base/adapter.js';
 import { cRR, cwABike } from './consts.js';
 import { IncyclistCapability } from '../../types/index.js';
 import { sleep } from '../../utils/utils.js';
+import { InteruptableTask } from '../../utils/task.js';
 import { BleZwiftPlaySensor } from '../zwift/play/index.js';
 import { useFeatureToggle } from '../../features/index.js';
 import FMResistanceMode from '../../modes/fm-resistance.js';
@@ -16,6 +17,7 @@ export default class BleFmAdapter extends BleAdapter {
     distanceInternal = 0;
     connectPromise;
     requestControlRetryDelay = 1000;
+    requestControlTimeout = 10000;
     promiseSendUpdate;
     zwiftPlay;
     isHubInitialized = false;
@@ -163,8 +165,36 @@ export default class BleFmAdapter extends BleAdapter {
         if (!this.hasCapability(IncyclistCapability.Control))
             return;
         await this.establishControl();
+        await this.attemptStartRequest();
         await this.sendInitialRequest();
     }
+    async initControlBestEffort(_startProps) {
+        if (!this.isStarting())
+            return;
+        this.setConstants();
+        try {
+            const hasControl = await this.getSensor().requestControl();
+            if (hasControl) {
+                this.logEvent({ message: 'control granted (downgraded device)', device: this.getName(), interface: this.getInterface() });
+                await this.attemptStartRequest();
+            }
+            else {
+                this.logEvent({ message: 'could not establish control (downgraded device, non-fatal)', device: this.getName(), interface: this.getInterface() });
+            }
+        }
+        catch (err) {
+            this.logEvent({ message: 'could not establish control (downgraded device, non-fatal)', device: this.getName(), interface: this.getInterface(), error: err.message });
+        }
+    }
+    async attemptStartRequest() {
+        try {
+            const started = await this.getSensor().startRequest();
+            this.logEvent({ message: started ? 'start request acknowledged' : 'start request not acknowledged (non-fatal)', device: this.getName(), interface: this.getInterface() });
+        }
+        catch (err) {
+            this.logEvent({ message: 'start request failed (non-fatal)', device: this.getName(), interface: this.getInterface(), error: err.message });
+        }
+    }
     setConstants() {
         const mode = this.getCyclingMode();
         const sensor = this.getSensor();
@@ -190,30 +220,53 @@ export default class BleFmAdapter extends BleAdapter {
         let hasControl = false;
         let tryCnt = 0;
         const sensor = this.getSensor();
-        return new Promise((resolve) => {
+        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);
                     }
                 }
             };
             waitUntilControl();
         });
+        const waitTask = new InteruptableTask(controlPromise, {
+            timeout: this.requestControlTimeout,
+            name: 'establishControl',
+            errorOnTimeout: false,
+            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');
+        }
+        return granted;
     }
     async sendInitialRequest() {
         const startRequest = this.getCyclingMode().getBikeInitRequest();

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

@@ -103,20 +103,17 @@ export default class BleFitnessMachineDevice extends TBleSensor {
         this.hasControl = false;
         this.ftmsServiceDataAttempts = 0;
     }
-    async requestControl() {
+    async requestControl(signal) {
         if (this.hasControl) {
             return true;
         }
         if (!this.isSubscribed())
             return false;
-        if (this.features?.setPower === false && this.features?.setSlope === false && this.features?.setResistance === false) {
-            return true;
-        }
         this.logEvent({ message: 'requestControl' });
         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;
         }
@@ -623,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,17 +45,20 @@ 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>;
     protected checkCapabilities(): Promise<void>;
     protected initControl(_props?: BleStartProperties): Promise<void>;
+    protected initControlBestEffort(_props?: BleStartProperties): Promise<void>;
     protected getStartLogProps(props: BleStartProperties): BleStartProperties;
     protected startAdapter(startProps?: BleStartProperties): Promise<boolean>;
     startSensor(): Promise<boolean>;
     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

@@ -29,15 +29,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/adapter.d.ts

@@ -12,6 +12,7 @@ export default class BleFmAdapter extends BleAdapter<IndoorBikeData, BleFitnessM
     protected distanceInternal: number;
     protected connectPromise: Promise<boolean> | undefined;
     protected requestControlRetryDelay: number;
+    protected requestControlTimeout: number;
     protected promiseSendUpdate: Promise<UpdateRequest | void> | undefined;
     protected zwiftPlay: BleZwiftPlaySensor | undefined;
     protected isHubInitialized: boolean;
@@ -28,6 +29,8 @@ export default class BleFmAdapter extends BleAdapter<IndoorBikeData, BleFitnessM
     protected checkResume(): boolean[];
     protected initVirtualShifting(initHub?: boolean): Promise<void>;
     protected initControl(_startProps?: BleStartProperties): Promise<void>;
+    protected initControlBestEffort(_startProps?: BleStartProperties): Promise<void>;
+    protected attemptStartRequest(): Promise<void>;
     protected setConstants(): void;
     protected establishControl(): Promise<boolean>;
     protected sendInitialRequest(): Promise<void>;

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.25",
+    "version": "3.0.27",
     "scripts": {
         "lint": "eslint . --ext .ts",
         "build": "npm run build:esm && npm run build:cjs",