incyclist-devices 2.3.33 → 2.3.35

package/lib/antv2/fe/adapter.js

@@ -48,7 +48,7 @@ class AntFEAdapter extends adapter_1.default {
                 return;
             if (this.promiseStop)
                 return;
-            if (this.promiseSendUpdate) {
+            if (this.promiseSendUpdate !== undefined) {
                 this.logEvent({ message: 'send bike update skipped', device: this.getName(), request, reason: 'busy' });
                 return;
             }

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

@@ -13,10 +13,13 @@ export declare class BlePeripheral implements IBlePeripheral {
     }>;
     protected disconnecting: boolean;
     protected disconnectedSignalled: boolean;
+    protected discoveredServiceUUIds: Array<string>;
     protected onErrorHandler: any;
     constructor(announcement: BlePeripheralAnnouncement);
     get services(): BleService[];
     getPeripheral(): BleRawPeripheral;
+    getAnnouncedServices(): string[];
+    getDiscoveredServices(): string[];
     getInfo(): BleDeviceIdentifier;
     connect(): Promise<boolean>;
     disconnect(connectionLost?: boolean): Promise<boolean>;

package/lib/ble/base/peripheral.js

@@ -29,6 +29,12 @@ class BlePeripheral {
     getPeripheral() {
         return this.announcement.peripheral;
     }
+    getAnnouncedServices() {
+        return this.announcement.serviceUUIDs.map(s => (0, utils_1.beautifyUUID)(s));
+    }
+    getDiscoveredServices() {
+        return this.discoveredServiceUUIds;
+    }
     getInfo() {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         return {
@@ -132,11 +138,13 @@ class BlePeripheral {
             if (this.getPeripheral().discoverServicesAsync) {
                 this.logEvent({ message: 'discover services', address: this.getPeripheral().address });
                 const services = yield this.getPeripheral().discoverServicesAsync([]);
+                this.discoveredServiceUUIds = services.map(s => (0, utils_1.beautifyUUID)(s.uuid));
                 return services.map(s => s.uuid);
             }
             else {
                 this.logEvent({ message: 'discover services and characteristics', address: this.getPeripheral().address });
                 const res = yield this.getPeripheral().discoverSomeServicesAndCharacteristicsAsync([], []);
+                this.discoveredServiceUUIds = res.services.map(s => (0, utils_1.beautifyUUID)(s.uuid));
                 return res.services.map(s => s.uuid);
             }
         });
@@ -246,6 +254,12 @@ class BlePeripheral {
     }
     subscribeSelected(characteristics, callback) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!this.discoveredServiceUUIds) {
+                try {
+                    yield this.discoverServices();
+                }
+                catch (_a) { }
+            }
             try {
                 if (Object.keys(this.characteristics).length === 0) {
                     yield this.discoverAllCharacteristics();
@@ -308,6 +322,12 @@ class BlePeripheral {
     }
     subscribeAll(callback) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!this.discoveredServiceUUIds) {
+                try {
+                    yield this.discoverServices();
+                }
+                catch (_a) { }
+            }
             const characteristics = yield this.discoverAllCharacteristics();
             const success = yield this.subscribeSelected(characteristics, callback);
             return success;

package/lib/ble/base/sensor.d.ts

@@ -12,10 +12,12 @@ export declare class TBleSensor extends EventEmitter implements IBleSensor {
     constructor(peripheral: IBlePeripheral, props?: {
         logger?: EventLogger;
     });
+    getPeripheral(): IBlePeripheral;
     getDetectionPriority(): number;
     getProfile(): LegacyProfile;
     getProtocol(): BleProtocol;
     getServiceUUids(): string[];
+    getSupportedServiceUUids(): string[];
     isMatching(serviceUUIDs: string[]): boolean;
     hasPeripheral(): boolean;
     pair(): Promise<boolean>;

package/lib/ble/base/sensor.js

@@ -28,6 +28,9 @@ class TBleSensor extends events_1.default {
         this.reset();
         this.onDataHandler = this.onData.bind(this);
     }
+    getPeripheral() {
+        return this.peripheral;
+    }
     getDetectionPriority() {
         var _a;
         const C = this.constructor;
@@ -45,6 +48,10 @@ class TBleSensor extends events_1.default {
         const C = this.constructor;
         return C['services'];
     }
+    getSupportedServiceUUids() {
+        var _a;
+        return (_a = this.peripheral) === null || _a === void 0 ? void 0 : _a.getDiscoveredServices();
+    }
     isMatching(serviceUUIDs) {
         const uuids = serviceUUIDs.map(uuid => (0, utils_2.beautifyUUID)(uuid));
         const required = this.getServiceUUids();

package/lib/ble/fm/adapter.d.ts

@@ -1,30 +1,36 @@
 import BleFitnessMachineDevice from './sensor';
 import BleAdapter from '../base/adapter';
-import ICyclingMode, { CyclingMode } from '../../modes/types';
+import ICyclingMode, { CyclingMode, UpdateRequest } from '../../modes/types';
 import { IndoorBikeData, IndoorBikeFeatures } from './types';
 import { BleDeviceProperties, BleDeviceSettings, BleStartProperties, IBlePeripheral } from '../types';
 import { IAdapter, IncyclistAdapterData, IncyclistBikeData } from '../../types';
 import { LegacyProfile } from '../../antv2/types';
+import { BleZwiftPlaySensor } from '../zwift/play';
 export default class BleFmAdapter extends BleAdapter<IndoorBikeData, BleFitnessMachineDevice> {
     protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
     protected distanceInternal: number;
     protected connectPromise: Promise<boolean>;
     protected requestControlRetryDelay: number;
+    protected promiseSendUpdate: Promise<UpdateRequest | void>;
+    protected zwiftPlay: BleZwiftPlaySensor;
+    protected virtualShiftingSupported: undefined;
     constructor(settings: BleDeviceSettings, props?: BleDeviceProperties);
     updateSensor(peripheral: IBlePeripheral): void;
     isSame(device: IAdapter): boolean;
     isControllable(): boolean;
+    supportsVirtualShifting(): boolean;
     getSupportedCyclingModes(): Array<typeof CyclingMode>;
     getDefaultCyclingMode(): ICyclingMode;
     mapData(deviceData: IndoorBikeData): IncyclistBikeData;
     transformData(bikeData: IncyclistBikeData): IncyclistAdapterData;
     protected checkResume(): boolean[];
+    protected initVirtualShifting(): Promise<void>;
     protected initControl(_startProps?: BleStartProperties): Promise<void>;
     protected setConstants(): void;
     protected establishControl(): Promise<boolean>;
     protected sendInitialRequest(): Promise<void>;
     protected checkCapabilities(): Promise<void>;
     protected updateCapabilitiesFromFeatures(features: IndoorBikeFeatures): void;
-    sendUpdate(request: any, enforced?: boolean): Promise<void>;
+    sendUpdate(request: any, enforced?: boolean): Promise<UpdateRequest | void>;
     sendInitCommands(): Promise<boolean>;
 }

package/lib/ble/fm/adapter.js

@@ -21,6 +21,9 @@ const adapter_1 = __importDefault(require("../base/adapter"));
 const consts_1 = require("./consts");
 const types_1 = require("../../types");
 const utils_1 = require("../../utils/utils");
+const utils_2 = require("../utils");
+const play_1 = require("../zwift/play");
+const ZWIFT_PLAY_UUID = '0000000119ca465186e5fa29dcdd09d1';
 class BleFmAdapter extends adapter_1.default {
     constructor(settings, props) {
         super(settings, props);
@@ -44,6 +47,10 @@ class BleFmAdapter extends adapter_1.default {
     isControllable() {
         return true;
     }
+    supportsVirtualShifting() {
+        var _a, _b;
+        return (_b = (_a = this.device) === null || _a === void 0 ? void 0 : _a.getSupportedServiceUUids()) === null || _b === void 0 ? void 0 : _b.some(s => (0, utils_2.matches)(s, ZWIFT_PLAY_UUID));
+    }
     getSupportedCyclingModes() {
         var _a, _b;
         const modes = [power_meter_1.default];
@@ -121,6 +128,18 @@ class BleFmAdapter extends adapter_1.default {
             return [wasPaused, true];
         return [wasPaused, false];
     }
+    initVirtualShifting() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                this.zwiftPlay = (_a = this.zwiftPlay) !== null && _a !== void 0 ? _a : new play_1.BleZwiftPlaySensor(this.device);
+            }
+            catch (err) {
+                this.logEvent({ message: 'could not init virtual shifting', reason: err.message });
+                delete this.zwiftPlay;
+            }
+        });
+    }
     initControl(_startProps) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.isStarting())
@@ -163,6 +182,9 @@ class BleFmAdapter extends adapter_1.default {
                     resolve(false);
                 });
                 const waitUntilControl = () => __awaiter(this, void 0, void 0, function* () {
+                    if (this.supportsVirtualShifting()) {
+                        yield this.initVirtualShifting();
+                    }
                     while (!hasControl && this.isStarting()) {
                         if (tryCnt++ === 0) {
                             this.logEvent({ message: 'requesting control', device: this.getName(), interface: this.getInterface() });
@@ -233,6 +255,10 @@ class BleFmAdapter extends adapter_1.default {
     sendUpdate(request_1) {
         return __awaiter(this, arguments, void 0, function* (request, enforced = false) {
             var _a;
+            if (this.promiseSendUpdate !== undefined) {
+                yield this.promiseSendUpdate;
+                this.promiseSendUpdate = undefined;
+            }
             if (!enforced && (this.paused || !this.device))
                 return;
             if (!enforced && (this.stopped && !this.isStarting()))
@@ -242,16 +268,37 @@ class BleFmAdapter extends adapter_1.default {
                 this.logEvent({ message: 'send bike update requested', profile: this.getProfile(), mode: (_a = this.getCyclingMode()) === null || _a === void 0 ? void 0 : _a.getName(), update, request });
                 const device = this.getSensor();
                 if (this.hasCapability(types_1.IncyclistCapability.Control)) {
-                    if (update.slope !== undefined) {
-                        yield device.setSlope(update.slope);
-                    }
-                    if (update.targetPower !== undefined) {
-                        const tp = update.targetPower > 0 ? update.targetPower : 0;
-                        yield device.setTargetPower(tp);
-                    }
+                    const send = () => __awaiter(this, void 0, void 0, function* () {
+                        const res = {};
+                        if (update.slope !== undefined) {
+                            yield device.setSlope(update.slope);
+                            res.slope = update.slope;
+                        }
+                        if (update.targetPower !== undefined) {
+                            const tp = update.targetPower > 0 ? update.targetPower : 0;
+                            yield device.setTargetPower(tp);
+                            res.targetPower = tp;
+                        }
+                        if (update.gearRatio !== undefined) {
+                            if (!this.zwiftPlay) {
+                                this.initVirtualShifting();
+                            }
+                            if (this.zwiftPlay) {
+                                const gearRatio = yield this.zwiftPlay.setGearRatio(update.gearRatio);
+                                yield this.zwiftPlay.setSimulationData({ inclineX100: update.slope * 100 });
+                                res.gearRatio = gearRatio;
+                            }
+                        }
+                        return res;
+                    });
+                    this.promiseSendUpdate = send();
+                    const confirmed = yield this.promiseSendUpdate;
+                    delete this.promiseSendUpdate;
+                    return confirmed;
                 }
             }
             catch (err) {
+                delete this.promiseSendUpdate;
                 if (err.message === 'not connected') {
                     this.logEvent({ message: 'send bike update failed', reason: 'not connected' });
                 }
@@ -263,12 +310,17 @@ class BleFmAdapter extends adapter_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.started && !this.stopped) {
                 try {
-                    if (this.getCyclingMode() instanceof antble_erg_1.default) {
+                    const mode = this.getCyclingMode();
+                    if (mode.isERG()) {
                         const power = this.data.power;
                         const request = power ? { targetPower: power } : this.getCyclingMode().getBikeInitRequest();
                         yield this.sendUpdate(request, true);
                         return true;
                     }
+                    else if (mode.isSIM() && this.supportsVirtualShifting()) {
+                        yield this.sendInitialRequest();
+                        return true;
+                    }
                 }
                 catch (_a) {
                     return false;

package/lib/ble/fm/sensor.js

@@ -13,6 +13,8 @@ const consts_1 = require("../consts");
 const sensor_1 = require("../base/sensor");
 const utils_1 = require("../utils");
 const consts_2 = require("./consts");
+const task_1 = require("../../utils/task");
+const BLE_COMMAND_TIMEOUT = 800;
 class BleFitnessMachineDevice extends sensor_1.TBleSensor {
     constructor(peripheral, props) {
         super(peripheral, props);
@@ -145,70 +147,72 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
     parseIndoorBikeData(_data) {
         const data = Buffer.from(_data);
         let offset = 2;
-        try {
-            const flags = data.readUInt16LE(0);
-            if ((flags & consts_2.IndoorBikeDataFlag.MoreData) === 0) {
-                this.data.speed = data.readUInt16LE(offset) / 100;
-                offset += 2;
-            }
-            if (flags & consts_2.IndoorBikeDataFlag.AverageSpeedPresent) {
-                this.data.averageSpeed = data.readUInt16LE(offset) / 100;
-                offset += 2;
-            }
-            if (flags & consts_2.IndoorBikeDataFlag.InstantaneousCadence) {
-                this.data.cadence = data.readUInt16LE(offset) / 2;
-                offset += 2;
-            }
-            if (flags & consts_2.IndoorBikeDataFlag.AverageCadencePresent) {
-                this.data.averageCadence = data.readUInt16LE(offset) / 2;
-                offset += 2;
-            }
-            if (flags & consts_2.IndoorBikeDataFlag.TotalDistancePresent) {
-                const dvLow = data.readUInt8(offset);
-                offset += 1;
-                const dvHigh = data.readUInt16LE(offset);
-                offset += 2;
-                this.data.totalDistance = (dvHigh << 8) + dvLow;
-            }
-            if (flags & consts_2.IndoorBikeDataFlag.ResistanceLevelPresent) {
-                this.data.resistanceLevel = data.readInt16LE(offset);
-                offset += 2;
-            }
-            if (flags & consts_2.IndoorBikeDataFlag.InstantaneousPowerPresent) {
-                this.data.instantaneousPower = data.readInt16LE(offset);
-                offset += 2;
-            }
-            if (flags & consts_2.IndoorBikeDataFlag.AveragePowerPresent) {
-                this.data.averagePower = data.readInt16LE(offset);
-                offset += 2;
-            }
-            if (flags & consts_2.IndoorBikeDataFlag.ExpendedEnergyPresent) {
-                this.data.totalEnergy = data.readUInt16LE(offset);
-                offset += 2;
-                this.data.energyPerHour = data.readUInt16LE(offset);
-                offset += 2;
-                this.data.energyPerMinute = data.readUInt8(offset);
-                offset += 1;
-            }
-            if (flags & consts_2.IndoorBikeDataFlag.HeartRatePresent) {
-                this.data.heartrate = data.readUInt8(offset);
-                offset += 1;
-            }
-            if (flags & consts_2.IndoorBikeDataFlag.MetabolicEquivalentPresent) {
-                this.data.metabolicEquivalent = data.readUInt8(offset) / 10;
-                offset += 1;
-            }
-            if (flags & consts_2.IndoorBikeDataFlag.ElapsedTimePresent) {
-                this.data.time = data.readUInt16LE(offset);
-                offset += 2;
+        if (data.length > 2) {
+            try {
+                const flags = data.readUInt16LE(0);
+                if ((flags & consts_2.IndoorBikeDataFlag.MoreData) === 0) {
+                    this.data.speed = data.readUInt16LE(offset) / 100;
+                    offset += 2;
+                }
+                if (flags & consts_2.IndoorBikeDataFlag.AverageSpeedPresent) {
+                    this.data.averageSpeed = data.readUInt16LE(offset) / 100;
+                    offset += 2;
+                }
+                if (flags & consts_2.IndoorBikeDataFlag.InstantaneousCadence) {
+                    this.data.cadence = data.readUInt16LE(offset) / 2;
+                    offset += 2;
+                }
+                if (flags & consts_2.IndoorBikeDataFlag.AverageCadencePresent) {
+                    this.data.averageCadence = data.readUInt16LE(offset) / 2;
+                    offset += 2;
+                }
+                if (flags & consts_2.IndoorBikeDataFlag.TotalDistancePresent) {
+                    const dvLow = data.readUInt8(offset);
+                    offset += 1;
+                    const dvHigh = data.readUInt16LE(offset);
+                    offset += 2;
+                    this.data.totalDistance = (dvHigh << 8) + dvLow;
+                }
+                if (flags & consts_2.IndoorBikeDataFlag.ResistanceLevelPresent) {
+                    this.data.resistanceLevel = data.readInt16LE(offset);
+                    offset += 2;
+                }
+                if (flags & consts_2.IndoorBikeDataFlag.InstantaneousPowerPresent) {
+                    this.data.instantaneousPower = data.readInt16LE(offset);
+                    offset += 2;
+                }
+                if (flags & consts_2.IndoorBikeDataFlag.AveragePowerPresent) {
+                    this.data.averagePower = data.readInt16LE(offset);
+                    offset += 2;
+                }
+                if (flags & consts_2.IndoorBikeDataFlag.ExpendedEnergyPresent) {
+                    this.data.totalEnergy = data.readUInt16LE(offset);
+                    offset += 2;
+                    this.data.energyPerHour = data.readUInt16LE(offset);
+                    offset += 2;
+                    this.data.energyPerMinute = data.readUInt8(offset);
+                    offset += 1;
+                }
+                if (flags & consts_2.IndoorBikeDataFlag.HeartRatePresent) {
+                    this.data.heartrate = data.readUInt8(offset);
+                    offset += 1;
+                }
+                if (flags & consts_2.IndoorBikeDataFlag.MetabolicEquivalentPresent) {
+                    this.data.metabolicEquivalent = data.readUInt8(offset) / 10;
+                    offset += 1;
+                }
+                if (flags & consts_2.IndoorBikeDataFlag.ElapsedTimePresent) {
+                    this.data.time = data.readUInt16LE(offset);
+                    offset += 2;
+                }
+                if (flags & consts_2.IndoorBikeDataFlag.RemainingTimePresent) {
+                    this.data.remainingTime = data.readUInt16LE(offset);
+                }
             }
-            if (flags & consts_2.IndoorBikeDataFlag.RemainingTimePresent) {
-                this.data.remainingTime = data.readUInt16LE(offset);
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'parseIndoorBikeData()', data: data.toString('hex'), offset, error: err.message, stack: err.stack });
             }
         }
-        catch (err) {
-            this.logEvent({ message: 'error', fn: 'parseIndoorBikeData()', data: data.toString('hex'), offset, error: err.message, stack: err.stack });
-        }
         return Object.assign(Object.assign({}, this.data), { raw: `2ad2:${data.toString('hex')}` });
     }
     parseFitnessMachineStatus(_data) {
@@ -276,7 +280,7 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
                 const services = ((_a = this.peripheral) === null || _a === void 0 ? void 0 : _a.services) || [];
                 let power = services.some(s => (0, utils_1.matches)(s.uuid, '1818'));
                 let heartrate = services.some(s => (0, utils_1.matches)(s.uuid, '180d'));
-                if (buffer) {
+                if ((buffer === null || buffer === void 0 ? void 0 : buffer.length) >= 8) {
                     const fitnessMachine = buffer.readUInt32LE(0);
                     const targetSettings = buffer.readUInt32LE(4);
                     power = power || (fitnessMachine & consts_2.FitnessMachineFeatureFlag.PowerMeasurementSupported) !== 0;
@@ -287,6 +291,10 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
                     const setPower = (targetSettings & consts_2.TargetSettingFeatureFlag.PowerTargetSettingSupported) !== 0;
                     this._features = { fitnessMachine, targetSettings, power, heartrate, cadence, setPower, setSlope };
                     this.logEvent({ message: 'supported Features: ', fatures: this._features, power, heartrate, cadence });
+                    return this._features;
+                }
+                else {
+                    return { fitnessMachine: undefined, targetSettings: undefined, power, heartrate };
                 }
             }
             catch (err) {
@@ -299,14 +307,25 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 this.logEvent({ message: 'fmts:write', data: data.toString('hex') });
-                const res = yield this.write(consts_1.FTMS_CP, data, props);
+                let res;
+                let tsStart = Date.now();
+                if (props === null || props === void 0 ? void 0 : props.timeout) {
+                    res = yield new task_1.InteruptableTask(this.write(consts_1.FTMS_CP, data, props), {
+                        timeout: 800,
+                        errorOnTimeout: true
+                    }).run();
+                }
+                else {
+                    res = yield this.write(consts_1.FTMS_CP, data, props);
+                }
                 const responseData = Buffer.from(res);
                 const opCode = responseData.readUInt8(0);
                 const request = responseData.readUInt8(1);
                 const result = responseData.readUInt8(2);
                 if (opCode !== 128 || request !== requestedOpCode)
                     throw new Error('Illegal response ');
-                this.logEvent({ message: 'fmts:write result', res, result });
+                const duration = Date.now() - tsStart;
+                this.logEvent({ message: 'fmts:write result', res: responseData.toString('hex'), result, duration });
                 return result;
             }
             catch (err) {
@@ -330,7 +349,7 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
             const data = Buffer.alloc(3);
             data.writeUInt8(3, 0);
             data.writeInt16LE(Math.round(inclination * 10), 1);
-            const res = yield this.writeFtmsMessage(3, data);
+            const res = yield this.writeFtmsMessage(3, data, { timeout: BLE_COMMAND_TIMEOUT });
             return (res === 1);
         });
     }
@@ -350,7 +369,7 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
             data.writeInt16LE(Math.round(gradient * 100), 3);
             data.writeUInt8(Math.round(crr * 10000), 5);
             data.writeUInt8(Math.round(cw * 100), 6);
-            const res = yield this.writeFtmsMessage(17, data);
+            const res = yield this.writeFtmsMessage(17, data, { timeout: BLE_COMMAND_TIMEOUT });
             if (res === 5) {
                 this.hasControl = false;
             }

package/lib/ble/types.d.ts

@@ -160,6 +160,8 @@ export interface IBlePeripheral {
     write(characteristicUUID: string, data: Buffer, options?: BleWriteProps): Promise<Buffer>;
     getManufacturerData?(): Buffer;
     getInfo(): BleDeviceIdentifier;
+    getAnnouncedServices(): string[];
+    getDiscoveredServices(): string[];
 }
 export interface IBleSensor extends EventEmitter {
     startSensor(): Promise<boolean>;

package/lib/ble/zwift/play/helperfactory.d.ts

@@ -0,0 +1,7 @@
+import { IHubHelper } from "./types";
+export declare class HubHelperFactory {
+    private static instance;
+    private constructor();
+    static getInstance(): HubHelperFactory;
+    create(): IHubHelper;
+}

package/lib/ble/zwift/play/helperfactory.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HubHelperFactory = void 0;
+const protohelper_1 = require("./protohelper");
+class HubHelperFactory {
+    constructor() { }
+    static getInstance() {
+        if (!HubHelperFactory.instance) {
+            HubHelperFactory.instance = new HubHelperFactory();
+        }
+        return HubHelperFactory.instance;
+    }
+    create() {
+        return new protohelper_1.HubProtoHelper();
+    }
+}
+exports.HubHelperFactory = HubHelperFactory;

package/lib/ble/zwift/play/protohelper.d.ts

@@ -0,0 +1,4 @@
+import { HubRequest, IHubHelper } from "./types";
+export declare class HubProtoHelper implements IHubHelper {
+    createHubRequest(request: HubRequest): Buffer<ArrayBuffer>;
+}

package/lib/ble/zwift/play/protohelper.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HubProtoHelper = void 0;
+const zwift_hub_pb_js_1 = require("../../../proto/org/cagnulen/qdomyoszwift/zwift_hub_pb.js");
+const protobuf_1 = require("@bufbuild/protobuf");
+class HubProtoHelper {
+    createHubRequest(request) {
+        return Buffer.from((0, protobuf_1.toBinary)(zwift_hub_pb_js_1.HubRequestSchema, (0, protobuf_1.fromJson)(zwift_hub_pb_js_1.HubRequestSchema, request)));
+    }
+}
+exports.HubProtoHelper = HubProtoHelper;

package/lib/ble/zwift/play/sensor.d.ts

@@ -1,6 +1,7 @@
 import { LegacyProfile } from "../../../antv2/types";
+import { HubCommand, HubRequest, SimulationParam } from "../../../proto/zwift_hub";
 import { TBleSensor } from "../../base/sensor";
-import { BleProtocol } from "../../types";
+import { BleProtocol, IBlePeripheral } from "../../types";
 import { EventEmitter } from "events";
 type ButtonState = {
     pressed: boolean;
@@ -23,15 +24,29 @@ export declare class BleZwiftPlaySensor extends TBleSensor {
     protected deviceType: DeviceType;
     protected publicKey: Buffer;
     protected privateKey: Buffer;
-    constructor(peripheral: any, props?: any);
+    protected isFM: boolean;
+    protected tsLastRidingData: number;
+    protected isHubServiceActive: boolean;
+    protected isPaired: boolean;
+    protected isSubscribed: boolean;
+    constructor(peripheral: IBlePeripheral | TBleSensor, props?: any);
     reconnectSensor(): Promise<void>;
     stopSensor(): Promise<boolean>;
     protected getRequiredCharacteristics(): Array<string>;
     onData(characteristic: string, data: Buffer, isNotify?: boolean): boolean;
-    onPlayMeasurement(d: Buffer): boolean;
-    onButtonMessage(d: Buffer): void;
-    onPingMessage(d: Buffer): void;
-    onPairResponse(d: Buffer): boolean;
+    requestDataUpdate(dataId: number): Promise<void>;
+    setSimulationData(data?: SimulationParam): Promise<void>;
+    setGearRatio(gearRatio: number): Promise<number>;
+    protected sendPlayCommand(id: number, command: Buffer): Promise<Buffer<ArrayBufferLike>>;
+    protected onMeasurement(d: Buffer): boolean;
+    initHubService(setSimulation?: boolean): Promise<boolean>;
+    sendHubRequest(request: HubRequest): Promise<Buffer<ArrayBufferLike>>;
+    sendHubCommand(command: HubCommand): Promise<Buffer<ArrayBufferLike>>;
+    protected onRidingData(m: Buffer): void;
+    protected onDeviceInformation(m: Buffer): void;
+    onClickButtonMessage(d: Buffer): void;
+    onPingMessage(message: Buffer): void;
+    onResponse(d: Buffer): boolean;
     read(characteristic: string, ignoreErrors?: boolean): Promise<Buffer | null>;
     pair(): Promise<boolean>;
     reset(): void;