incyclist-devices 2.3.28 → 2.3.29

package/lib/antv2/types.d.ts

@@ -7,7 +7,7 @@ export interface AntDeviceSettings extends DeviceSettings {
     interface: string;
     protocol?: string;
 }
-export type LegacyProfile = 'Heartrate Monitor' | 'Power Meter' | 'Smart Trainer' | 'Speed Sensor' | 'Cadence Sensor' | 'Speed + Cadence Sensor';
+export type LegacyProfile = 'Heartrate Monitor' | 'Power Meter' | 'Smart Trainer' | 'Speed Sensor' | 'Cadence Sensor' | 'Speed + Cadence Sensor' | 'Controller';
 export declare const isLegacyProfile: (o: unknown) => boolean;
 export type DeviceFoundCallback = (device: IAdapter, protocol: string) => void;
 export type ScanFinishedCallback = (id: number) => void;

package/lib/base/adpater.d.ts

@@ -48,6 +48,7 @@ export default class IncyclistDevice<P extends DeviceProperties> extends EventEm
     setMaxUpdateFrequency(value: number): void;
     update(): void;
     setCyclingMode(mode: string | ICyclingMode, settings?: any, sendInitCommands?: boolean): void;
+    protected createOrGetMode(mode: string | ICyclingMode): ICyclingMode;
     getSupportedCyclingModes(): Array<typeof CyclingMode>;
     getCyclingMode(): ICyclingMode;
     getDefaultCyclingMode(): ICyclingMode;

package/lib/base/adpater.js

@@ -139,21 +139,29 @@ class IncyclistDevice extends events_1.default {
     setCyclingMode(mode, settings, sendInitCommands) {
         if (!this.isControllable())
             return;
-        let selectedMode;
+        const selectedMode = this.createOrGetMode(mode);
+        this.cyclingMode = selectedMode;
+        this.cyclingMode.setSettings(settings);
+    }
+    createOrGetMode(mode) {
+        var _a, _b;
         if (typeof mode === 'string') {
+            if (mode === ((_a = this.getCyclingMode()) === null || _a === void 0 ? void 0 : _a.getName())) {
+                return this.cyclingMode;
+            }
             const supported = this.getSupportedCyclingModes();
             const CyclingModeClass = supported.find(M => { const m = new M(this); return m.getName() === mode; });
             if (CyclingModeClass) {
-                this.cyclingMode = new CyclingModeClass(this, settings);
-                return;
+                return new CyclingModeClass(this);
+            }
+            else {
+                return this.getDefaultCyclingMode();
             }
-            selectedMode = this.getDefaultCyclingMode();
         }
-        else {
-            selectedMode = mode;
+        if (mode.getName() === ((_b = this.cyclingMode) === null || _b === void 0 ? void 0 : _b.getName())) {
+            return this.cyclingMode;
         }
-        this.cyclingMode = selectedMode;
-        this.cyclingMode.setSettings(settings);
+        return mode;
     }
     getSupportedCyclingModes() {
         if (!this.isControllable())
@@ -259,9 +267,11 @@ class IncyclistDevice extends events_1.default {
         return this.data;
     }
     getStartProps(startProps) {
-        if (startProps)
-            this.props = startProps;
-        return startProps || {};
+        if (startProps) {
+            const current = this.props || {};
+            this.props = Object.assign(Object.assign({}, current), startProps);
+        }
+        return startProps !== null && startProps !== void 0 ? startProps : {};
     }
     hasDataListeners() {
         return this.onDataFn || this.listenerCount('data') > 0;

package/lib/ble/base/adapter.js

@@ -328,12 +328,13 @@ class BleAdapter extends adpater_1.default {
                 return false;
             }
             const sensor = this.getSensor();
-            const connected = yield sensor.startSensor();
+            let connected = yield sensor.startSensor();
             yield sensor.subscribe();
             if (connected) {
                 sensor.on('data', this.onDeviceDataHandler);
                 sensor.on('disconnected', this.emit.bind(this));
                 sensor.on('error', console.log);
+                connected = yield sensor.pair();
             }
             return connected;
         });

package/lib/ble/base/interface.js

@@ -228,10 +228,16 @@ class BleInterface extends events_1.default {
     pauseLogging() {
         this.logEvent({ message: 'pausing logging' });
         this.logDisabled = true;
-        this.getBinding().pauseLogging();
+        try {
+            this.getBinding().pauseLogging();
+        }
+        catch (_a) { }
     }
     resumeLogging() {
-        this.getBinding().resumeLogging();
+        try {
+            this.getBinding().resumeLogging();
+        }
+        catch (_a) { }
         this.logDisabled = false;
         this.logEvent({ message: 'resuming logging' });
     }
@@ -407,11 +413,12 @@ class BleInterface extends events_1.default {
         });
     }
     buildAnnouncement(peripheral) {
-        var _a;
+        var _a, _b;
         return {
             advertisement: peripheral.advertisement,
             name: peripheral.advertisement.localName,
-            serviceUUIDs: (_a = peripheral.advertisement.serviceUuids) !== null && _a !== void 0 ? _a : [],
+            manufacturerData: ((_a = peripheral.advertisement) === null || _a === void 0 ? void 0 : _a.manufacturerData) ? Buffer.from(peripheral.advertisement.manufacturerData) : undefined,
+            serviceUUIDs: (_b = peripheral.advertisement.serviceUuids) !== null && _b !== void 0 ? _b : [],
             peripheral,
             transport: this.getName()
         };

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

@@ -22,13 +22,14 @@ export declare class BlePeripheral implements IBlePeripheral {
     isConnected(): boolean;
     isConnecting(): boolean;
     onDisconnect(callback: () => void): void;
+    getManufacturerData(): Buffer<ArrayBufferLike>;
     protected onPeripheralDisconnect(): Promise<void>;
     protected onPeripheralError(err: Error): void;
     discoverServices(): Promise<string[]>;
     discoverCharacteristics(serviceUUID: string): Promise<BleCharacteristic[]>;
-    subscribe(characteristicUUID: string, callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
+    subscribe(characteristicUUID: string, callback: (characteristicUuid: string, data: Buffer, isNotify?: any) => void): Promise<boolean>;
     unsubscribe(characteristicUUID: string): Promise<boolean>;
-    subscribeSelected(characteristics: string[], callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
+    subscribeSelected(characteristics: string[], callback: (characteristicUuid: string, data: Buffer, isNotify?: boolean) => void): Promise<boolean>;
     discoverAllCharacteristics(): Promise<string[]>;
     discoverSomeCharacteristics(characteristics: string[]): Promise<string[]>;
     subscribeAll(callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;

package/lib/ble/base/peripheral.js

@@ -93,6 +93,10 @@ class BlePeripheral {
     onDisconnect(callback) {
         this.onDisconnectHandler = callback;
     }
+    getManufacturerData() {
+        var _a;
+        return (_a = this.announcement) === null || _a === void 0 ? void 0 : _a.manufacturerData;
+    }
     onPeripheralDisconnect() {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -148,9 +152,9 @@ class BlePeripheral {
                 if (this.disconnecting || !this.connected)
                     return false;
                 const uuid = (0, utils_1.beautifyUUID)(characteristicUUID);
-                const onData = (data) => {
+                const onData = (data, isNotify) => {
                     try {
-                        callback(characteristicUUID, data);
+                        callback(characteristicUUID, data, isNotify);
                     }
                     catch (_a) { }
                 };
@@ -241,7 +245,7 @@ class BlePeripheral {
                 const retry = [];
                 for (const element of characteristics) {
                     const c = this.getRawCharacteristic(element);
-                    if (c === null || c === void 0 ? void 0 : c.properties.includes('notify')) {
+                    if ((c === null || c === void 0 ? void 0 : c.properties.includes('notify')) || (c === null || c === void 0 ? void 0 : c.properties.includes('indicate'))) {
                         const success = yield this.subscribe(c.uuid, callback);
                         if (!success)
                             retry.push(c);
@@ -315,46 +319,66 @@ class BlePeripheral {
         });
     }
     read(characteristicUUID) {
-        if (this.disconnecting || !this.connected)
-            return Promise.resolve(Buffer.from([]));
-        const c = this.characteristics[(0, utils_1.beautifyUUID)(characteristicUUID)];
-        if (!c) {
-            return Promise.reject(new Error('characteristic not found'));
-        }
-        return new Promise((resolve, reject) => {
-            c.read((err, data) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(data);
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.disconnecting || !this.connected)
+                return Buffer.from([]);
+            let c = this.characteristics[(0, utils_1.beautifyUUID)(characteristicUUID)];
+            if (!c) {
+                yield this.discoverAllCharacteristics();
+                c = this.characteristics[(0, utils_1.beautifyUUID)(characteristicUUID)];
+                if (!c) {
+                    return Promise.reject(new Error('characteristic not found: ' + characteristicUUID));
                 }
+            }
+            return new Promise((resolve, reject) => {
+                c.read((err, data) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(data);
+                    }
+                });
             });
         });
     }
     write(characteristicUUID, data, options) {
-        if (this.disconnecting || !this.connected)
-            return Promise.resolve(Buffer.from([]));
-        const uuid = (0, utils_1.beautifyUUID)(characteristicUUID);
-        const c = this.characteristics[uuid];
-        if (!c) {
-            return Promise.reject(new Error('characteristic not found'));
-        }
-        return new Promise((resolve, reject) => {
-            this.subscribe(characteristicUUID, null).then(success => {
-                if (this.disconnecting || !this.connected)
-                    return Promise.resolve(Buffer.from([]));
-                c.on('data', (data) => {
-                    c.removeAllListeners('data');
-                    resolve(data);
-                });
-                this.logEvent({ message: 'write request', characteristic: uuid, data: data.toString('hex'), withoutResponse: (options === null || options === void 0 ? void 0 : options.withoutResponse) === true });
-                c.write(data, (options === null || options === void 0 ? void 0 : options.withoutResponse) === true, (err) => {
-                    if (err)
-                        reject(err);
-                });
-                if (options === null || options === void 0 ? void 0 : options.withoutResponse) {
-                    resolve(Buffer.from([]));
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.disconnecting || !this.connected)
+                return Buffer.from([]);
+            const uuid = (0, utils_1.beautifyUUID)(characteristicUUID);
+            let c = this.characteristics[uuid];
+            if (!c) {
+                yield this.discoverAllCharacteristics();
+                c = this.characteristics[(0, utils_1.beautifyUUID)(characteristicUUID)];
+                if (!c) {
+                    return Promise.reject(new Error('characteristic not found: ' + characteristicUUID));
+                }
+            }
+            return new Promise((resolve, reject) => {
+                const write = () => {
+                    if (this.disconnecting || !this.connected)
+                        return Promise.resolve(Buffer.from([]));
+                    c.on('data', (data) => {
+                        c.removeAllListeners('data');
+                        resolve(data);
+                    });
+                    this.logEvent({ message: 'write request', characteristic: uuid, data: data.toString('hex'), withoutResponse: (options === null || options === void 0 ? void 0 : options.withoutResponse) === true });
+                    c.write(data, (options === null || options === void 0 ? void 0 : options.withoutResponse) === true, (err) => {
+                        if (err)
+                            reject(err);
+                    });
+                    if (options === null || options === void 0 ? void 0 : options.withoutResponse) {
+                        resolve(Buffer.from([]));
+                    }
+                };
+                if (!(options === null || options === void 0 ? void 0 : options.withoutResponse)) {
+                    this.subscribe(characteristicUUID, null).then(success => {
+                        write();
+                    });
+                }
+                else {
+                    write();
                 }
             });
         });

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

@@ -18,6 +18,7 @@ export declare class TBleSensor extends EventEmitter implements IBleSensor {
     getServiceUUids(): string[];
     isMatching(serviceUUIDs: string[]): boolean;
     hasPeripheral(): boolean;
+    pair(): Promise<boolean>;
     startSensor(reconnect?: boolean): Promise<boolean>;
     protected getRequiredCharacteristics(): Array<string>;
     subscribe(): Promise<boolean>;
@@ -28,5 +29,6 @@ export declare class TBleSensor extends EventEmitter implements IBleSensor {
     read(characteristicUUID: string): Promise<Buffer>;
     write(characteristicUUID: string, data: Buffer, options?: BleWriteProps): Promise<Buffer>;
     onData(characteristic: string, data: Buffer): boolean;
+    getAnnouncement(): IBlePeripheral;
     protected getDefaultLogger(): EventLogger;
 }

package/lib/ble/base/sensor.js

@@ -61,6 +61,11 @@ class TBleSensor extends events_1.default {
     hasPeripheral() {
         return !!this.peripheral;
     }
+    pair() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
+    }
     startSensor(reconnect) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!reconnect)
@@ -83,11 +88,15 @@ class TBleSensor extends events_1.default {
     subscribe() {
         return __awaiter(this, void 0, void 0, function* () {
             const selected = this.getRequiredCharacteristics();
-            if (selected === null)
-                return yield this.peripheral.subscribeAll(this.onDataHandler);
-            if (selected.length === 0)
+            if (selected === null) {
+                const res = yield this.peripheral.subscribeAll(this.onDataHandler);
+                return res;
+            }
+            if (selected.length === 0) {
                 return true;
-            return yield this.peripheral.subscribeSelected(selected, this.onDataHandler);
+            }
+            const res = yield this.peripheral.subscribeSelected(selected, this.onDataHandler);
+            return res;
         });
     }
     stopSensor() {
@@ -142,6 +151,9 @@ class TBleSensor extends events_1.default {
     onData(characteristic, data) {
         return true;
     }
+    getAnnouncement() {
+        return this.peripheral;
+    }
     getDefaultLogger() {
         return new gd_eventlog_1.EventLogger(this.constructor.name);
     }

package/lib/ble/fm/adapter.js

@@ -45,11 +45,11 @@ class BleFmAdapter extends adapter_1.default {
         return true;
     }
     getSupportedCyclingModes() {
-        var _a;
+        var _a, _b;
         const modes = [power_meter_1.default];
-        if (this.props.capabilities && this.props.capabilities.indexOf(types_1.IncyclistCapability.Control) === -1)
+        if (((_a = this.props) === null || _a === void 0 ? void 0 : _a.capabilities) && this.props.capabilities.indexOf(types_1.IncyclistCapability.Control) === -1)
             return modes;
-        const features = (_a = this.getSensor()) === null || _a === void 0 ? void 0 : _a.features;
+        const features = (_b = this.getSensor()) === null || _b === void 0 ? void 0 : _b.features;
         if (!features)
             return [power_meter_1.default, antble_smarttrainer_1.default, antble_erg_1.default];
         if (features.setPower === undefined || features.setPower)
@@ -59,10 +59,10 @@ class BleFmAdapter extends adapter_1.default {
         return modes;
     }
     getDefaultCyclingMode() {
-        var _a;
-        if (this.props.capabilities && this.props.capabilities.indexOf(types_1.IncyclistCapability.Control) === -1)
+        var _a, _b;
+        if (((_a = this.props) === null || _a === void 0 ? void 0 : _a.capabilities) && this.props.capabilities.indexOf(types_1.IncyclistCapability.Control) === -1)
             return new power_meter_1.default(this);
-        const features = (_a = this.getSensor()) === null || _a === void 0 ? void 0 : _a.features;
+        const features = (_b = this.getSensor()) === null || _b === void 0 ? void 0 : _b.features;
         if (!features)
             return new antble_smarttrainer_1.default(this);
         if (features.setSlope === undefined || features.setSlope)
@@ -231,13 +231,14 @@ class BleFmAdapter extends adapter_1.default {
     }
     sendUpdate(request_1) {
         return __awaiter(this, arguments, void 0, function* (request, enforced = false) {
+            var _a;
             if (!enforced && (this.paused || !this.device))
                 return;
             if (!enforced && (this.stopped && !this.isStarting()))
                 return;
             try {
                 const update = this.getCyclingMode().sendBikeUpdate(request);
-                this.logEvent({ message: 'send bike update requested', profile: this.getProfile(), update, request });
+                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) {

package/lib/ble/index.js

@@ -31,6 +31,7 @@ const factories_1 = require("./factories");
 Object.defineProperty(exports, "BleInterfaceFactory", { enumerable: true, get: function () { return factories_1.BleMultiTransportInterfaceFactory; } });
 Object.defineProperty(exports, "BleAdapterFactory", { enumerable: true, get: function () { return factories_1.BleAdapterFactory; } });
 const csc_1 = require("./csc");
+const play_1 = require("./zwift/play");
 ['ble', 'wifi'].forEach(i => {
     const af = factories_1.BleAdapterFactory.getInstance(i);
     af.register('hr', hr_1.BleHrmAdapter, hr_1.BleHrmComms);
@@ -39,6 +40,7 @@ const csc_1 = require("./csc");
     af.register('wahoo', wahoo_1.BleWahooAdapter, wahoo_1.BleWahooComms);
     af.register('tacx', tacx_1.BleTacxAdapter, tacx_1.BleTacxComms);
     af.register('csc', csc_1.BleCSCAdapter, csc_1.BleCyclingSpeedCadenceDevice);
+    af.register('zwift-play', play_1.ZwiftPlayAdapter, play_1.BleZwiftPlaySensor);
 });
 factories_1.BleMultiTransportInterfaceFactory.register('ble', interface_1.BleInterfaceFactory);
 __exportStar(require("./utils"), exports);

package/lib/ble/types.d.ts

@@ -1,7 +1,7 @@
 import EventEmitter from "events";
 import { EventLogger } from "gd-eventlog";
 import { DeviceProperties, DeviceSettings, DeviceStartProperties, IncyclistInterface, IncyclistScanProps, InterfaceProps } from "../types";
-export type BleProtocol = 'hr' | 'fm' | 'cp' | 'tacx' | 'wahoo' | 'elite' | 'csc';
+export type BleProtocol = 'hr' | 'fm' | 'cp' | 'tacx' | 'wahoo' | 'elite' | 'csc' | 'zwift-play';
 export type BleInterfaceState = 'unknown' | 'resetting' | 'unsupported' | 'unauthorized' | 'poweredOff' | 'poweredOn';
 export interface BleBinding extends EventEmitter {
     startScanning(serviceUUIDs?: string[], allowDuplicates?: boolean, callback?: (error?: Error) => void): void;
@@ -39,6 +39,7 @@ export interface PeripheralAnnouncement {
 }
 export interface BlePeripheralAnnouncement extends PeripheralAnnouncement {
     advertisement: any;
+    manufacturerData?: Buffer;
     peripheral: BleRawPeripheral;
 }
 export interface BlePeripheralInfo {
@@ -86,7 +87,7 @@ export type DiscoverResult = {
     services: BleService[];
     characteristics: BleRawCharacteristic[];
 };
-export type BleProperty = 'notify' | 'read' | 'write';
+export type BleProperty = 'notify' | 'read' | 'write' | 'indicate';
 export interface BleCharacteristic {
     uuid: string;
     properties: BleProperty[];
@@ -152,6 +153,7 @@ export interface IBlePeripheral {
     subscribeSelected(characteristics: string[], callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
     read(characteristicUUID: string): Promise<Buffer>;
     write(characteristicUUID: string, data: Buffer, options?: BleWriteProps): Promise<Buffer>;
+    getManufacturerData?(): Buffer;
 }
 export interface IBleSensor extends EventEmitter {
     startSensor(): Promise<boolean>;

package/lib/ble/zwift/click/adapter.d.ts

@@ -0,0 +1,19 @@
+import { BleDeviceData } from '../../base/types';
+import { LegacyProfile } from '../../../antv2/types';
+import BleAdapter from '../../base/adapter';
+import { BleZwiftClickSensor } from './sensor';
+import { DeviceProperties, IAdapter, IncyclistAdapterData, IncyclistCapability } from '../../../types';
+import { BleDeviceSettings, BleStartProperties, IBlePeripheral } from '../../types';
+export declare class ZwiftClickAdapter extends BleAdapter<BleDeviceData, BleZwiftClickSensor> {
+    protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
+    protected static CAPABILITIES: IncyclistCapability[];
+    constructor(settings: BleDeviceSettings, props?: DeviceProperties);
+    protected checkCapabilities(): Promise<void>;
+    start(startProps?: BleStartProperties): Promise<boolean>;
+    startSensor(): Promise<boolean>;
+    isSame(adapter: IAdapter): boolean;
+    updateSensor(peripheral: IBlePeripheral): void;
+    getProfile(): LegacyProfile;
+    getDisplayName(): string;
+    mapData(deviceData: BleDeviceData): IncyclistAdapterData;
+}

package/lib/ble/zwift/click/adapter.js

@@ -0,0 +1,74 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZwiftClickAdapter = void 0;
+const gd_eventlog_1 = require("gd-eventlog");
+const adapter_1 = __importDefault(require("../../base/adapter"));
+const sensor_1 = require("./sensor");
+const types_1 = require("../../../types");
+class ZwiftClickAdapter extends adapter_1.default {
+    constructor(settings, props) {
+        super(settings, props);
+        this.logger = new gd_eventlog_1.EventLogger('Zwift-Click');
+        this.device = new sensor_1.BleZwiftClickSensor(this.getPeripheral(), { logger: this.logger });
+        this.capabilities = ZwiftClickAdapter.CAPABILITIES;
+    }
+    checkCapabilities() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return;
+        });
+    }
+    start(startProps) {
+        return super.start(startProps);
+    }
+    startSensor() {
+        const _super = Object.create(null, {
+            startSensor: { get: () => super.startSensor }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            let connected = yield _super.startSensor.call(this);
+            if (connected) {
+                const sensor = this.getSensor();
+                connected = yield sensor.pair();
+                sensor.on('up', (duration) => {
+                    console.log('Up button pressed for', duration, 'ms');
+                });
+                sensor.on('down', (duration) => {
+                    console.log('Down button pressed for', duration, 'ms');
+                });
+            }
+            return connected;
+        });
+    }
+    isSame(adapter) {
+        if (!(adapter instanceof ZwiftClickAdapter))
+            return false;
+        return this.isEqual(adapter.settings);
+    }
+    updateSensor(peripheral) {
+        this.device = new sensor_1.BleZwiftClickSensor(peripheral, { logger: this.logger });
+    }
+    getProfile() {
+        return ZwiftClickAdapter.INCYCLIST_PROFILE_NAME;
+    }
+    getDisplayName() {
+        return this.getName();
+    }
+    mapData(deviceData) {
+        return {};
+    }
+}
+exports.ZwiftClickAdapter = ZwiftClickAdapter;
+ZwiftClickAdapter.INCYCLIST_PROFILE_NAME = 'Controller';
+ZwiftClickAdapter.CAPABILITIES = [types_1.IncyclistCapability.AppControl];

package/lib/ble/zwift/click/index.d.ts

@@ -0,0 +1,2 @@
+export * from './sensor';
+export * from './adapter';

package/lib/ble/zwift/click/index.js

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

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

@@ -0,0 +1,40 @@
+import { LegacyProfile } from "incyclist-devices/lib/antv2/types";
+import { TBleSensor } from "../../base/sensor";
+import { BleProtocol } from "../../types";
+import { EventEmitter } from "stream";
+type ButtonState = {
+    pressed: boolean;
+    timestamp: number;
+};
+type DeviceType = 'left' | 'right' | 'click';
+export declare class BleZwiftClickSensor extends TBleSensor {
+    static readonly profile: LegacyProfile;
+    static readonly protocol: BleProtocol;
+    static readonly services: string[];
+    static readonly characteristics: any[];
+    static readonly detectionPriority = 1;
+    protected emitter: EventEmitter;
+    protected paired: boolean;
+    protected encrypted: boolean;
+    protected deviceKey: Buffer;
+    protected prevClickMessage: string;
+    protected upState: ButtonState;
+    protected downState: ButtonState;
+    protected deviceType: DeviceType;
+    protected publicKey: Buffer;
+    protected privateKey: Buffer;
+    constructor(peripheral: any, props?: any);
+    reconnectSensor(): Promise<void>;
+    stopSensor(): Promise<boolean>;
+    protected getRequiredCharacteristics(): Array<string>;
+    onData(characteristic: string, data: Buffer, isNotify?: boolean): boolean;
+    onPlayMeasurement(data: Buffer): boolean;
+    onButtonMessage(message: Buffer): void;
+    onPingMessage(message: Buffer): void;
+    onPairResponse(data: Buffer): boolean;
+    read(characteristic: string, ignoreErrors?: boolean): Promise<Buffer | null>;
+    pair(): Promise<boolean>;
+    reset(): void;
+    protected setInitialState(): void;
+}
+export {};