incyclist-devices 2.3.0-beta.1 → 2.3.0-beta.11

package/lib/ble/base/interface.js

@@ -49,6 +49,7 @@ class BleInterface extends events_1.default {
         this.expectedServices = ['180d', '1818', '1826', '6e40fec1'];
         this.matching = [];
         this.connectedPeripherals = [];
+        this.connectAttemptCnt = 0;
         this.instanceId = ++instanceCount;
         this.props = props;
         this.logEnabled = props.log || true;
@@ -90,46 +91,51 @@ class BleInterface extends events_1.default {
                 return false;
             }
             if (this.isConnecting()) {
-                this.logEvent({ message: 'connect - already connecting' });
+                this.logEvent({ message: 'BLE connect - already connecting' });
                 return this.connectTask.getPromise();
             }
             if (this.isConnected())
                 return true;
-            this.logEvent({ message: 'Ble connect request' });
+            this.logEvent({ message: 'BLE connect request' });
             this.connectTask = new task_1.InteruptableTask(this.connectBle(), {
-                timeout: BLE_DEFAULT_CONNECT_TIMEOUT,
-                name: 'connect',
+                timeout: this.getConnectTimeout(),
+                name: 'BLE connect',
                 errorOnTimeout: false,
                 log: this.logEvent.bind(this),
             });
-            const success = yield this.connectTask.run();
+            const success = yield this.connectTask.run().catch(() => false);
             if (success) {
                 this.startPeripheralScan();
             }
-            this.expectedServices = factories_1.BleAdapterFactory.getInstance('ble').getAllSupportedServices();
             return success;
         });
     }
-    disconnect() {
+    disconnect(cleanup) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             if (!this.getBinding()) {
                 return false;
             }
-            if (!this.isConnected())
+            if (!this.isConnected() && !cleanup)
                 return true;
-            this.logEvent({ message: 'disconnect request' });
+            if (!cleanup)
+                this.logEvent({ message: 'disconnect request' });
+            this.emit('disconnect-request');
             yield this.stopPeripheralScan();
             const promises = this.connectedPeripherals.map(p => p.disconnect());
             yield Promise.allSettled(promises);
             this.connectedPeripherals = [];
-            yield this.connectTask.stop();
+            if (this.isConnecting())
+                yield ((_a = this.connectTask) === null || _a === void 0 ? void 0 : _a.stop());
             this.getBinding().removeAllListeners();
+            this.connectAttemptCnt = 0;
+            this.emit('disconnect-done');
             return true;
         });
     }
     isConnected() {
         var _a;
-        return ((_a = this.getBinding()) === null || _a === void 0 ? void 0 : _a.state) === 'poweredOn';
+        return this.connectAttemptCnt > 0 && ((_a = this.getBinding()) === null || _a === void 0 ? void 0 : _a.state) === 'poweredOn';
     }
     registerConnected(peripheral) {
         this.connectedPeripherals.push(peripheral);
@@ -200,11 +206,16 @@ class BleInterface extends events_1.default {
         if (peripheral)
             return Promise.resolve(peripheral);
         return new Promise((done) => {
+            const wasDiscovering = this.isDiscovering();
+            if (!wasDiscovering)
+                this.startPeripheralScan();
             const onDevice = (device) => {
                 if (device.name === settings.name) {
                     const peripheral = this.createPeripheralFromSettings(settings);
                     if (peripheral) {
                         this.off('device', onDevice);
+                        if (!wasDiscovering)
+                            this.stopPeripheralScan();
                         done(peripheral);
                     }
                 }
@@ -216,7 +227,7 @@ class BleInterface extends events_1.default {
         const { peripheral } = service;
         if (peripheral.address === undefined || peripheral.address === '')
             peripheral.address = peripheral.id || peripheral.name;
-        const protocol = this.getAdapterFactory().getProtocol(service.serviceUUIDs);
+        const protocol = this.getAdapterFactory().getProtocol(service.advertisement.serviceUuids);
         const { id, name, address } = (0, utils_1.getPeripheralInfo)(peripheral);
         return { interface: BleInterface.INTERFACE_NAME, protocol, id, name, address };
     }
@@ -228,6 +239,7 @@ class BleInterface extends events_1.default {
     }
     startPeripheralScan() {
         return __awaiter(this, arguments, void 0, function* (retry = false) {
+            this.expectedServices = this.getExpectedServices();
             if (!retry)
                 this.logEvent({ message: 'starting peripheral discovery ...' });
             if (!this.isConnected() || this.isDiscovering()) {
@@ -254,9 +266,10 @@ class BleInterface extends events_1.default {
             return;
         this.logEvent({ message: 'stopping peripheral discovery ...' });
         this.discoverTask.stop();
-        this.getBinding().off('discover', this.onDiscovered);
+        const ble = this.getBinding();
+        ble.off('discover', this.onDiscovered);
         return new Promise(done => {
-            this.getBinding().stopScanning(() => {
+            ble.stopScanning(() => {
                 done();
             });
         });
@@ -284,21 +297,6 @@ class BleInterface extends events_1.default {
             });
         });
     }
-    pauseDiscovery() {
-        this.getBinding().off('discover', this.onDiscovered);
-        return new Promise(done => {
-            try {
-                this.getBinding().stopScanning();
-                done();
-            }
-            catch (err) {
-                done();
-            }
-        });
-    }
-    resumeDiscovery() {
-        return this.discoverPeripherals();
-    }
     onPeripheralFound(peripheral) {
         if (!this.isConnected() || !this.isDiscovering())
             return;
@@ -312,24 +310,33 @@ class BleInterface extends events_1.default {
             return;
         }
         if (announcement.serviceUUIDs.length === 0) {
-            if (this.isCompleting(announcement)) {
-                return;
-            }
-            this.addCompleting(announcement);
-            setTimeout(() => {
-                if (this.find(announcement)) {
-                    this.removeCompleting(announcement);
-                    return;
-                }
-                this.updateWithServices(announcement)
-                    .then(() => {
-                    if (this.isSupportedPeripheral(announcement))
-                        this.addService(announcement);
-                });
-            }, 1000);
+            return;
+        }
+        const isWahoo = this.checkForWahooEnhancement(announcement);
+        if (isWahoo) {
+            this.processWahooAnnouncement(announcement);
+            return;
         }
         this.addService(announcement);
     }
+    checkForWahooEnhancement(announcement) {
+        if (announcement.name.includes('KICKR')) {
+            const supported = announcement.serviceUUIDs.map(s => (0, utils_1.beautifyUUID)(s));
+            if (supported.length === 1 && supported[0] === '1818')
+                return true;
+        }
+        return false;
+    }
+    processWahooAnnouncement(announcement) {
+        if (this.isCompleting(announcement)) {
+            return;
+        }
+        this.updateWithServices(announcement)
+            .then(() => {
+            if (this.isSupportedPeripheral(announcement))
+                this.addService(announcement);
+        });
+    }
     buildAnnouncement(peripheral) {
         var _a;
         return {
@@ -359,7 +366,6 @@ class BleInterface extends events_1.default {
             const device = Object.assign({}, announcement);
             delete device.peripheral;
             const { peripheral } = announcement;
-            let paused = false;
             try {
                 peripheral.on('error', (err) => {
                     peripheral.removeAllListeners();
@@ -378,14 +384,11 @@ class BleInterface extends events_1.default {
                     const res = yield peripheral.discoverSomeServicesAndCharacteristicsAsync([], []);
                     announcement.serviceUUIDs = res.services.map(s => s.uuid);
                 }
-                peripheral.removeAllListeners();
             }
             catch (err) {
                 this.logEvent({ message: 'discover services failed', reason: err.message, device });
             }
-            if (paused) {
-                yield this.resumeDiscovery();
-            }
+            peripheral === null || peripheral === void 0 ? void 0 : peripheral.removeAllListeners();
             return device.serviceUUIDs;
         });
     }
@@ -497,8 +500,10 @@ class BleInterface extends events_1.default {
     }
     connectBle() {
         return __awaiter(this, void 0, void 0, function* () {
+            this.connectAttemptCnt++;
             const state = this.getBinding().state;
             if (state === 'poweredOn') {
+                this.logEvent({ message: 'BLE connected' });
                 return true;
             }
             const res = yield this.waitForBleConnected();
@@ -513,10 +518,7 @@ class BleInterface extends events_1.default {
             });
             this.getBinding().on('stateChange', (state) => {
                 if (state === 'poweredOn') {
-                    this.logEvent({ message: 'Ble connect result: success' });
-                    this.getBinding().removeAllListeners('stateChange');
-                    this.getBinding().on('stateChange', this.onBleStateChange.bind(this));
-                    this.getBinding().on('error', console.log);
+                    this.onConnected();
                     return done(true);
                 }
                 else {
@@ -525,11 +527,40 @@ class BleInterface extends events_1.default {
             });
         });
     }
+    onError(err) {
+        this.logError(err, 'BLE connect');
+    }
+    onConnected() {
+        this.logEvent({ message: 'BLE connected' });
+        this.getBinding().removeAllListeners('error');
+        this.getBinding().removeAllListeners('stateChange');
+        this.getBinding().on('stateChange', this.onBleStateChange.bind(this));
+        this.getBinding().on('error', this.onError.bind(this));
+    }
+    onDisconnected() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logEvent({ message: 'BLE Disconnected' });
+            yield this.disconnect(true);
+            this.getBinding().on('stateChange', this.onBleStateChange.bind(this));
+            this.getBinding().on('error', this.onError.bind(this));
+        });
+    }
     onBleStateChange(state) {
+        if (state !== 'poweredOn') {
+            this.onDisconnected();
+        }
+        else
+            this.onConnected();
     }
     getAdapterFactory() {
         return factories_1.BleAdapterFactory.getInstance('ble');
     }
+    getConnectTimeout() {
+        return BLE_DEFAULT_CONNECT_TIMEOUT;
+    }
+    getExpectedServices() {
+        return this.getAdapterFactory().getAllSupportedServices();
+    }
     logEvent(event) {
         if (this.logDisabled && event.message !== 'Error')
             return;

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

@@ -25,6 +25,7 @@ export declare class BlePeripheral implements IBlePeripheral {
     unsubscribe(characteristicUUID: string): Promise<boolean>;
     subscribeSelected(characteristics: string[], callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
     discoverAllCharacteristics(): Promise<string[]>;
+    discoverSomeCharacteristics(characteristics: string[]): Promise<string[]>;
     subscribeAll(callback: (characteristicUuid: string, data: Buffer) => void): Promise<boolean>;
     unsubscribeAll(): Promise<boolean>;
     read(characteristicUUID: string): Promise<Buffer>;

package/lib/ble/base/peripheral.js

@@ -29,10 +29,12 @@ class BlePeripheral {
     }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.isConnected())
+                return true;
             yield this.getPeripheral().connectAsync();
             this.ble.registerConnected(this);
             this.connected = true;
-            return true;
+            return this.connected;
         });
     }
     disconnect() {
@@ -53,7 +55,7 @@ class BlePeripheral {
             yield this.getPeripheral().disconnectAsync();
             this.connected = false;
             this.disconnecting = false;
-            return true;
+            return !this.connected;
         });
     }
     isConnected() {
@@ -68,10 +70,12 @@ class BlePeripheral {
     discoverServices() {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.getPeripheral().discoverServicesAsync) {
+                this.logEvent({ message: 'discover services' });
                 const services = yield this.getPeripheral().discoverServicesAsync([]);
                 return services.map(s => s.uuid);
             }
             else {
+                this.logEvent({ message: 'discover services and characteristics' });
                 const res = yield this.getPeripheral().discoverSomeServicesAndCharacteristicsAsync([], []);
                 return res.services.map(s => s.uuid);
             }
@@ -92,8 +96,17 @@ class BlePeripheral {
             try {
                 if (this.disconnecting || !this.connected)
                     return false;
+                const onData = (data) => {
+                    try {
+                        callback(characteristicUUID, data);
+                    }
+                    catch (_a) { }
+                };
                 const subscription = this.subscribed.find(s => s.uuid === characteristicUUID);
                 if (subscription) {
+                    const c = this.getRawCharacteristic(characteristicUUID);
+                    if (c)
+                        c.on('data', onData);
                     return true;
                 }
                 const c = this.getRawCharacteristic(characteristicUUID);
@@ -114,12 +127,6 @@ class BlePeripheral {
                         }
                         else {
                             if (callback) {
-                                const onData = (data) => {
-                                    try {
-                                        callback(characteristicUUID, data);
-                                    }
-                                    catch (_a) { }
-                                };
                                 this.subscribed.push({ uuid: characteristicUUID, callback: onData });
                                 c.on('data', onData);
                             }
@@ -214,6 +221,24 @@ class BlePeripheral {
             }
         });
     }
+    discoverSomeCharacteristics(characteristics) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const target = characteristics.map(c => (0, utils_1.fullUUID)(c));
+                const res = yield this.getPeripheral().discoverSomeServicesAndCharacteristicsAsync([], target);
+                const found = [];
+                res.characteristics.forEach(c => {
+                    this.characteristics[(0, utils_1.beautifyUUID)(c.uuid)] = c;
+                    found.push(c.uuid);
+                });
+                return found;
+            }
+            catch (err) {
+                this.logEvent({ message: 'Error', fn: 'discoverAllCharacteristics', error: err.message, stack: err.stack });
+                return [];
+            }
+        });
+    }
     subscribeAll(callback) {
         return __awaiter(this, void 0, void 0, function* () {
             const characteristics = yield this.discoverAllCharacteristics();

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

@@ -20,7 +20,7 @@ export declare class TBleSensor extends EventEmitter implements IBleSensor {
     hasPeripheral(): boolean;
     startSensor(reconnect?: boolean): Promise<boolean>;
     protected getRequiredCharacteristics(): Array<string>;
-    protected subscribe(): Promise<boolean>;
+    subscribe(): Promise<boolean>;
     stopSensor(): Promise<boolean>;
     reconnectSensor(): Promise<void>;
     reset(): void;

package/lib/ble/base/sensor.js

@@ -74,7 +74,7 @@ class TBleSensor extends events_1.default {
                 return false;
             if (!reconnect)
                 this.peripheral.onDisconnect(this.reconnectSensor.bind(this));
-            return yield this.subscribe();
+            return true;
         });
     }
     getRequiredCharacteristics() {
@@ -101,11 +101,19 @@ class TBleSensor extends events_1.default {
     }
     reconnectSensor() {
         return __awaiter(this, void 0, void 0, function* () {
+            let connected = false;
+            let subscribed = false;
             let success = false;
             do {
-                success = yield this.startSensor(true);
+                if (!connected) {
+                    connected = yield this.startSensor(true);
+                }
+                if (connected && !subscribed) {
+                    subscribed = yield this.subscribe();
+                }
+                success = connected && subscribed;
                 if (!success) {
-                    yield (0, utils_1.sleep)(5000);
+                    yield (0, utils_1.sleep)(1000);
                 }
             } while (!success || this.stopRequested);
         });
@@ -119,10 +127,16 @@ class TBleSensor extends events_1.default {
     }
     read(characteristicUUID) {
         var _a;
+        if (!this.isConnected()) {
+            return Promise.reject(new Error('not connected'));
+        }
         return (_a = this.peripheral) === null || _a === void 0 ? void 0 : _a.read(characteristicUUID);
     }
     write(characteristicUUID, data, options) {
         var _a;
+        if (!this.isConnected()) {
+            return Promise.reject(new Error('not connected'));
+        }
         return (_a = this.peripheral) === null || _a === void 0 ? void 0 : _a.write(characteristicUUID, data, options);
     }
     onData(characteristic, data) {

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

@@ -7,8 +7,9 @@ import { IAdapter, IncyclistAdapterData, IncyclistBikeData } from '../../types';
 import { LegacyProfile } from '../../antv2/types';
 export default class BleFmAdapter extends BleAdapter<IndoorBikeData, BleFitnessMachineDevice> {
     protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
-    distanceInternal: number;
-    connectPromise: Promise<boolean>;
+    protected distanceInternal: number;
+    protected connectPromise: Promise<boolean>;
+    protected requestControlRetryDelay: number;
     constructor(settings: BleDeviceSettings, props?: BleDeviceProperties);
     updateSensor(peripheral: IBlePeripheral): void;
     isSame(device: IAdapter): boolean;

package/lib/ble/fm/adapter.js

@@ -20,11 +20,12 @@ const sensor_1 = __importDefault(require("./sensor"));
 const adapter_1 = __importDefault(require("../base/adapter"));
 const consts_1 = require("./consts");
 const types_1 = require("../../types");
-const task_1 = require("../../utils/task");
+const utils_1 = require("../../utils/utils");
 class BleFmAdapter extends adapter_1.default {
     constructor(settings, props) {
         super(settings, props);
         this.distanceInternal = 0;
+        this.requestControlRetryDelay = 1000;
         this.logger = new gd_eventlog_1.EventLogger('BLE-FM');
         this.device = new sensor_1.default(this.getPeripheral(), { logger: this.logger });
         this.capabilities = [
@@ -117,6 +118,8 @@ class BleFmAdapter extends adapter_1.default {
     }
     initControl(_startProps) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isStarting())
+                return;
             this.setConstants();
             yield this.establishControl();
             this.setConstants();
@@ -146,38 +149,30 @@ class BleFmAdapter extends adapter_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.isStarting())
                 return false;
-            let waitTask;
-            let iv;
+            let hasControl = false;
+            let tryCnt = 0;
             const sensor = this.getComms();
-            const wait = () => {
-                const res = new Promise((resolve) => {
-                    iv = setInterval(() => __awaiter(this, void 0, void 0, function* () {
-                        if (!this.isStarting() || !(waitTask === null || waitTask === void 0 ? void 0 : waitTask.isRunning)) {
-                            resolve(false);
-                            clearInterval(iv);
-                            return;
+            return new Promise((resolve) => {
+                this.startTask.notifyOnStop(() => {
+                    resolve(false);
+                });
+                const waitUntilControl = () => __awaiter(this, void 0, void 0, function* () {
+                    while (!hasControl && this.isStarting()) {
+                        if (tryCnt++ === 0) {
+                            this.logEvent({ message: 'requesting control', device: this.getName(), interface: this.getInterface() });
                         }
-                        const hasControl = yield sensor.requestControl();
+                        hasControl = yield sensor.requestControl();
                         if (hasControl) {
-                            clearInterval(iv);
-                            resolve(true);
+                            this.logEvent({ message: 'control granted', device: this.getName(), interface: this.getInterface() });
+                            resolve(this.isStarting());
                         }
-                        else if (!this.isStarting() || !(waitTask === null || waitTask === void 0 ? void 0 : waitTask.isRunning)) {
-                            resolve(false);
-                            clearInterval(iv);
+                        else {
+                            yield (0, utils_1.sleep)(this.requestControlRetryDelay);
                         }
-                    }), 1000);
+                    }
                 });
-                return res;
-            };
-            waitTask = new task_1.InteruptableTask(wait(), {
-                errorOnTimeout: false,
-                timeout: 10000
+                waitUntilControl();
             });
-            const hasControl = yield waitTask.run();
-            clearInterval(iv);
-            if (!hasControl && this.isStarting())
-                throw new Error('could not establish control');
         });
     }
     sendInitialRequest() {
@@ -212,7 +207,7 @@ class BleFmAdapter extends adapter_1.default {
             try {
                 const update = this.getCyclingMode().sendBikeUpdate(request);
                 this.logEvent({ message: 'send bike update requested', profile: this.getProfile(), update, request });
-                const device = this.device;
+                const device = this.getComms();
                 if (update.slope !== undefined) {
                     yield device.setSlope(update.slope);
                 }

package/lib/ble/fm/sensor.js

@@ -100,8 +100,6 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
             this.logEvent({ message: 'setTargetPower', power, skip: (this.data.targetPower !== undefined && this.data.targetPower === power) });
             if (this.data.targetPower !== undefined && this.data.targetPower === power)
                 return true;
-            if (!this.hasControl)
-                return;
             const hasControl = yield this.requestControl();
             if (!hasControl) {
                 this.logEvent({ message: 'setTargetPower failed', reason: 'control is disabled' });
@@ -111,15 +109,15 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
             data.writeUInt8(5, 0);
             data.writeInt16LE(Math.round(power), 1);
             const res = yield this.writeFtmsMessage(5, data);
+            if (res === 5) {
+                this.hasControl = false;
+            }
             return (res === 1);
         });
     }
     setSlope(slope) {
         return __awaiter(this, void 0, void 0, function* () {
             this.logEvent({ message: 'setSlope', slope });
-            const hasControl = yield this.requestControl();
-            if (!hasControl)
-                return;
             const { windSpeed, crr, cw } = this;
             return yield this.setIndoorBikeSimulation(windSpeed, slope, crr, cw);
         });
@@ -331,6 +329,9 @@ class BleFitnessMachineDevice extends sensor_1.TBleSensor {
             data.writeUInt8(Math.round(crr * 10000), 5);
             data.writeUInt8(Math.round(cw * 100), 6);
             const res = yield this.writeFtmsMessage(17, data);
+            if (res === 5) {
+                this.hasControl = false;
+            }
             return (res === 1);
         });
     }

package/lib/ble/tacx/sensor.js

@@ -452,8 +452,14 @@ class TacxAdvancedFitnessMachineDevice extends sensor_1.default {
     sendMessage(message) {
         return __awaiter(this, void 0, void 0, function* () {
             this.logEvent({ message: 'write', characteristic: this.tacxTx, data: message.toString('hex') });
-            yield this.write(this.tacxTx, message, { withoutResponse: true });
-            return true;
+            try {
+                yield this.write(this.tacxTx, message, { withoutResponse: true });
+                return true;
+            }
+            catch (err) {
+                this.logEvent({ message: 'write failed', characteristic: this.tacxTx, reason: err.message });
+                return false;
+            }
         });
     }
     sendUserConfiguration(userWeight, bikeWeight, wheelDiameter, gearRatio) {

package/lib/ble/types.d.ts

@@ -13,11 +13,17 @@ export interface BleBinding extends EventEmitter {
     state: BleInterfaceState;
     on(eventName: string | symbol, listener: (...args: any[]) => void): this;
 }
+export interface BleRawAdvertisement {
+    address?: string;
+    localName?: string;
+    serviceUuids?: string[];
+    rssi?: number;
+}
 export interface BleRawPeripheral extends EventEmitter {
     id?: string;
     address?: string;
     name?: string;
-    services: [];
+    services: any[];
     advertisement: any;
     state: string;
     connectAsync(): Promise<void>;

package/lib/ble/utils.js

@@ -6,6 +6,7 @@ exports.uuid = uuid;
 exports.matches = matches;
 exports.getPeripheralInfo = getPeripheralInfo;
 exports.getCharachteristicsInfo = getCharachteristicsInfo;
+const gd_eventlog_1 = require("gd-eventlog");
 function mapLegacyProfile(profile) {
     switch (profile) {
         case 'Smart Trainer': return { profile: 'Smart Trainer', protocol: 'fm' };
@@ -74,7 +75,15 @@ const parseUUID = (str) => {
 };
 exports.parseUUID = parseUUID;
 const beautifyUUID = (str, withX = false) => {
-    const uuid = (0, exports.parseUUID)(str);
+    let uuid;
+    try {
+        uuid = (0, exports.parseUUID)(str);
+    }
+    catch (err) {
+        const logger = new gd_eventlog_1.EventLogger('Incyclist');
+        logger.logEvent({ message: 'beautifyUUID error', uuid: str, error: err.message });
+        return str;
+    }
     const parts = [
         uuid.substring(0, 8),
         uuid.substring(8, 12),

package/lib/direct-connect/base/interface.d.ts

@@ -57,7 +57,7 @@ export default class DirectConnectInterface extends EventEmitter implements IBle
         interface: string;
         name: string;
     }[];
-    protected addService(service: MulticastDnsAnnouncement): void;
+    protected addService(service: MulticastDnsAnnouncement, source?: string): void;
     protected find(service: MulticastDnsAnnouncement): Announcement;
     protected getAll(): Announcement[];
     setDebug(enabled: boolean): void;