@switchbot/homebridge-switchbot 2.14.1-beta.0 → 3.0.0-beta.0

package/dist/device/blindtilt.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BlindTilt = void 0;
-const undici_1 = require("undici");
-const utils_1 = require("../utils");
-const rxjs_1 = require("rxjs");
-const async_mqtt_1 = require("async-mqtt");
-const operators_1 = require("rxjs/operators");
-const settings_1 = require("../settings");
+import { request } from 'undici';
+import { sleep } from '../utils';
+import { interval, Subject } from 'rxjs';
+import { connectAsync } from 'async-mqtt';
+import { debounceTime, skipWhile, take, tap } from 'rxjs/operators';
+import { Devices } from '../settings';
 var BlindTiltMappingMode;
 (function (BlindTiltMappingMode) {
     BlindTiltMappingMode["OnlyUp"] = "only_up";
@@ -15,53 +12,117 @@ var BlindTiltMappingMode;
     BlindTiltMappingMode["UpAndDown"] = "up_and_down";
     BlindTiltMappingMode["UseTiltForDirection"] = "use_tilt_for_direction";
 })(BlindTiltMappingMode || (BlindTiltMappingMode = {}));
-class BlindTilt {
+export class BlindTilt {
+    platform;
+    accessory;
+    device;
+    api;
+    log;
+    config;
+    hap;
+    // Services
+    batteryService;
+    lightSensorService;
+    windowCoveringService;
+    // Characteristic Values
+    BatteryLevel;
+    PositionState;
+    TargetPosition;
+    CurrentPosition;
+    StatusLowBattery;
+    FirmwareRevision;
+    CurrentAmbientLightLevel;
+    TargetHorizontalTiltAngle;
+    CurrentHorizontalTiltAngle;
+    // OpenAPI Status
+    OpenAPI_InMotion;
+    OpenAPI_BatteryLevel;
+    OpenAPI_Direction;
+    OpenAPI_Calibration;
+    OpenAPI_CurrentPosition;
+    OpenAPI_FirmwareRevision;
+    OpenAPI_CurrentAmbientLightLevel;
+    // OpenAPI Others
+    Mode;
+    setPositionMode;
+    mappingMode = BlindTiltMappingMode.OnlyUp;
+    // BLE Status
+    BLE_InMotion;
+    BLE_BatteryLevel;
+    BLE_Calibration;
+    BLE_CurrentPosition;
+    BLE_CurrentAmbientLightLevel;
+    // BLE Others
+    BLE_IsConnected;
+    spaceBetweenLevels;
+    // Target
+    setNewTarget;
+    setNewTargetTimer;
+    //MQTT stuff
+    mqttClient = null;
+    // Config
+    set_minStep;
+    updateRate;
+    set_minLux;
+    set_maxLux;
+    scanDuration;
+    deviceLogging;
+    deviceRefreshRate;
+    setCloseMode;
+    setOpenMode;
+    // Updates
+    blindTiltUpdateInProgress;
+    doBlindTiltUpdate;
+    // Connection
+    OpenAPI;
+    BLE;
     constructor(platform, accessory, device) {
         this.platform = platform;
         this.accessory = accessory;
         this.device = device;
-        this.mappingMode = BlindTiltMappingMode.OnlyUp;
-        //MQTT stuff
-        this.mqttClient = null;
+        this.api = this.platform.api;
+        this.log = this.platform.log;
+        this.config = this.platform.config;
+        this.hap = this.api.hap;
         // Connection
         this.BLE = this.device.connectionType === 'BLE' || this.device.connectionType === 'BLE/OpenAPI';
         this.OpenAPI = this.device.connectionType === 'OpenAPI' || this.device.connectionType === 'BLE/OpenAPI';
         // default placeholders
-        this.logs(device);
+        this.deviceLogs(device);
         this.refreshRate(device);
         this.scan(device);
         this.setupMqtt(device);
         this.context();
-        this.config(device);
+        this.deviceConfig(device);
         this.mappingMode = device.blindTilt?.mode ?? BlindTiltMappingMode.OnlyUp;
         this.debugLog(`Mapping mode: ${this.mappingMode}`);
         // this is subject we use to track when we need to POST changes to the SwitchBot API
-        this.doBlindTiltUpdate = new rxjs_1.Subject();
+        this.doBlindTiltUpdate = new Subject();
         this.blindTiltUpdateInProgress = false;
         this.setNewTarget = false;
         // Retrieve initial values and updateHomekit
         this.refreshStatus();
         // set accessory information
         accessory
-            .getService(this.platform.Service.AccessoryInformation)
-            .setCharacteristic(this.platform.Characteristic.Manufacturer, 'SwitchBot')
-            .setCharacteristic(this.platform.Characteristic.Model, 'W2701600')
-            .setCharacteristic(this.platform.Characteristic.SerialNumber, device.deviceId)
-            .setCharacteristic(this.platform.Characteristic.FirmwareRevision, accessory.context.FirmwareRevision);
+            .getService(this.hap.Service.AccessoryInformation)
+            .setCharacteristic(this.hap.Characteristic.Manufacturer, 'SwitchBot')
+            .setCharacteristic(this.hap.Characteristic.Model, 'W2701600')
+            .setCharacteristic(this.hap.Characteristic.SerialNumber, device.deviceId)
+            .setCharacteristic(this.hap.Characteristic.FirmwareRevision, accessory.context.FirmwareRevision);
         // get the WindowCovering service if it exists, otherwise create a new WindowCovering service
         // you can create multiple services for each accessory
         const windowCoveringService = `${device.deviceName} ${device.deviceType}`;
         (this.windowCoveringService =
-            accessory.getService(this.platform.Service.WindowCovering)
-                || accessory.addService(this.platform.Service.WindowCovering)), windowCoveringService;
-        this.windowCoveringService.setCharacteristic(this.platform.Characteristic.Name, accessory.displayName);
-        if (!this.windowCoveringService.testCharacteristic(this.platform.Characteristic.ConfiguredName)) {
-            this.windowCoveringService.addCharacteristic(this.platform.Characteristic.ConfiguredName, accessory.displayName);
+            accessory.getService(this.hap.Service.WindowCovering)
+                || accessory.addService(this.hap.Service.WindowCovering)), windowCoveringService;
+        this.windowCoveringService.setCharacteristic(this.hap.Characteristic.Name, accessory.displayName);
+        if (!this.windowCoveringService.testCharacteristic(this.hap.Characteristic.ConfiguredName)) {
+            this.windowCoveringService.addCharacteristic(this.hap.Characteristic.ConfiguredName, accessory.displayName);
         }
         // create handlers for required characteristics
-        this.windowCoveringService.setCharacteristic(this.platform.Characteristic.PositionState, this.PositionState);
+        this.windowCoveringService.setCharacteristic(this.hap.Characteristic.PositionState, this.PositionState);
         this.windowCoveringService
-            .getCharacteristic(this.platform.Characteristic.CurrentPosition)
+            .getCharacteristic(this.hap.Characteristic.CurrentPosition)
             .setProps({
             minStep: this.minStep(device),
             minValue: 0,
@@ -72,7 +133,7 @@ class BlindTilt {
             return this.CurrentPosition;
         });
         this.windowCoveringService
-            .getCharacteristic(this.platform.Characteristic.TargetPosition)
+            .getCharacteristic(this.hap.Characteristic.TargetPosition)
             .setProps({
             minStep: this.minStep(device),
             minValue: 0,
@@ -82,7 +143,7 @@ class BlindTilt {
             .onSet(this.TargetPositionSet.bind(this));
         this.CurrentHorizontalTiltAngle = 90;
         this.windowCoveringService
-            .getCharacteristic(this.platform.Characteristic.CurrentHorizontalTiltAngle)
+            .getCharacteristic(this.hap.Characteristic.CurrentHorizontalTiltAngle)
             .setProps({
             minStep: 180,
             minValue: -90,
@@ -95,7 +156,7 @@ class BlindTilt {
         });
         this.TargetHorizontalTiltAngle = 90;
         this.windowCoveringService
-            .getCharacteristic(this.platform.Characteristic.TargetHorizontalTiltAngle)
+            .getCharacteristic(this.hap.Characteristic.TargetHorizontalTiltAngle)
             .setProps({
             minStep: 180,
             minValue: -90,
@@ -105,17 +166,17 @@ class BlindTilt {
             .onSet(this.TargetHorizontalTiltAngleSet.bind(this));
         // Battery Service
         const batteryService = `${accessory.displayName} Battery`;
-        (this.batteryService = this.accessory.getService(this.platform.Service.Battery)
-            || accessory.addService(this.platform.Service.Battery)), batteryService;
-        this.batteryService.setCharacteristic(this.platform.Characteristic.Name, `${accessory.displayName} Battery`);
-        if (!this.batteryService.testCharacteristic(this.platform.Characteristic.ConfiguredName)) {
-            this.batteryService.addCharacteristic(this.platform.Characteristic.ConfiguredName, `${accessory.displayName} Battery`);
+        (this.batteryService = this.accessory.getService(this.hap.Service.Battery)
+            || accessory.addService(this.hap.Service.Battery)), batteryService;
+        this.batteryService.setCharacteristic(this.hap.Characteristic.Name, `${accessory.displayName} Battery`);
+        if (!this.batteryService.testCharacteristic(this.hap.Characteristic.ConfiguredName)) {
+            this.batteryService.addCharacteristic(this.hap.Characteristic.ConfiguredName, `${accessory.displayName} Battery`);
         }
         // Update Homekit
         this.updateHomeKitCharacteristics();
         // Start an update interval
-        (0, rxjs_1.interval)(this.deviceRefreshRate * 1000)
-            .pipe((0, operators_1.skipWhile)(() => this.blindTiltUpdateInProgress))
+        interval(this.deviceRefreshRate * 1000)
+            .pipe(skipWhile(() => this.blindTiltUpdateInProgress))
             .subscribe(async () => {
             await this.refreshStatus();
         });
@@ -143,10 +204,10 @@ class BlindTilt {
             };
         }
         // update slide progress
-        (0, rxjs_1.interval)(this.updateRate * 1000)
+        interval(this.updateRate * 1000)
             //.pipe(skipWhile(() => this.blindTiltUpdateInProgress))
             .subscribe(async () => {
-            if (this.PositionState === this.platform.Characteristic.PositionState.STOPPED) {
+            if (this.PositionState === this.hap.Characteristic.PositionState.STOPPED) {
                 return;
             }
             this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Refresh Status When Moving, PositionState: ${this.PositionState}`);
@@ -155,9 +216,9 @@ class BlindTilt {
         // Watch for BlindTilt change events
         // We put in a debounce of 100ms so we don't make duplicate calls
         this.doBlindTiltUpdate
-            .pipe((0, operators_1.tap)(() => {
+            .pipe(tap(() => {
             this.blindTiltUpdateInProgress = true;
-        }), (0, operators_1.debounceTime)(this.platform.config.options.pushRate * 1000))
+        }), debounceTime(this.platform.config.options.pushRate * 1000))
             .subscribe(async () => {
             try {
                 await this.pushChanges();
@@ -201,27 +262,27 @@ class BlindTilt {
             await this.setMinMax();
             if (Number(this.TargetPosition) > this.CurrentPosition) {
                 this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Closing, CurrentPosition: ${this.CurrentPosition}`);
-                this.PositionState = this.platform.Characteristic.PositionState.INCREASING;
-                this.windowCoveringService.getCharacteristic(this.platform.Characteristic.PositionState).updateValue(this.PositionState);
+                this.PositionState = this.hap.Characteristic.PositionState.INCREASING;
+                this.windowCoveringService.getCharacteristic(this.hap.Characteristic.PositionState).updateValue(this.PositionState);
                 this.debugLog(`${this.device.deviceType}: ${this.CurrentPosition} INCREASING PositionState: ${this.PositionState}`);
             }
             else if (Number(this.TargetPosition) < this.CurrentPosition) {
                 this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Opening, CurrentPosition: ${this.CurrentPosition}`);
-                this.PositionState = this.platform.Characteristic.PositionState.DECREASING;
-                this.windowCoveringService.getCharacteristic(this.platform.Characteristic.PositionState).updateValue(this.PositionState);
+                this.PositionState = this.hap.Characteristic.PositionState.DECREASING;
+                this.windowCoveringService.getCharacteristic(this.hap.Characteristic.PositionState).updateValue(this.PositionState);
                 this.debugLog(`${this.device.deviceType}: ${this.CurrentPosition} DECREASING PositionState: ${this.PositionState}`);
             }
             else {
                 this.debugLog(`${this.device.deviceType}: ${this.CurrentPosition} Standby2, CurrentPosition: ${this.CurrentPosition}`);
-                this.PositionState = this.platform.Characteristic.PositionState.STOPPED;
-                this.windowCoveringService.getCharacteristic(this.platform.Characteristic.PositionState).updateValue(this.PositionState);
+                this.PositionState = this.hap.Characteristic.PositionState.STOPPED;
+                this.windowCoveringService.getCharacteristic(this.hap.Characteristic.PositionState).updateValue(this.PositionState);
                 this.debugLog(`${this.device.deviceType}: ${this.CurrentPosition} STOPPED PositionState: ${this.PositionState}`);
             }
         }
         else {
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Standby, CurrentPosition: ${this.CurrentPosition}`);
             this.TargetPosition = this.CurrentPosition;
-            this.PositionState = this.platform.Characteristic.PositionState.STOPPED;
+            this.PositionState = this.hap.Characteristic.PositionState.STOPPED;
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Stopped`);
         }
         this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} CurrentPosition: ${this.CurrentPosition},` +
@@ -280,10 +341,10 @@ class BlindTilt {
         // Battery
         this.BatteryLevel = Number(this.BLE_BatteryLevel);
         if (this.BatteryLevel < 10) {
-            this.StatusLowBattery = this.platform.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW;
+            this.StatusLowBattery = this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW;
         }
         else {
-            this.StatusLowBattery = this.platform.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
+            this.StatusLowBattery = this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
         }
         this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BatteryLevel: ${this.BatteryLevel},` + ` StatusLowBattery: ${this.StatusLowBattery}`);
     }
@@ -306,20 +367,20 @@ class BlindTilt {
             await this.setMinMax();
             if (this.TargetPosition > this.CurrentPosition || (homekitTiltAngle && this.TargetHorizontalTiltAngle !== this.CurrentHorizontalTiltAngle)) {
                 this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Closing, CurrentPosition: ${this.CurrentPosition} `);
-                this.PositionState = this.platform.Characteristic.PositionState.INCREASING;
-                this.windowCoveringService.getCharacteristic(this.platform.Characteristic.PositionState).updateValue(this.PositionState);
+                this.PositionState = this.hap.Characteristic.PositionState.INCREASING;
+                this.windowCoveringService.getCharacteristic(this.hap.Characteristic.PositionState).updateValue(this.PositionState);
                 this.debugLog(`${this.device.deviceType}: ${this.CurrentPosition} INCREASING PositionState: ${this.PositionState}`);
             }
             else if (this.TargetPosition < this.CurrentPosition) {
                 this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Opening, CurrentPosition: ${this.CurrentPosition} `);
-                this.PositionState = this.platform.Characteristic.PositionState.DECREASING;
-                this.windowCoveringService.getCharacteristic(this.platform.Characteristic.PositionState).updateValue(this.PositionState);
+                this.PositionState = this.hap.Characteristic.PositionState.DECREASING;
+                this.windowCoveringService.getCharacteristic(this.hap.Characteristic.PositionState).updateValue(this.PositionState);
                 this.debugLog(`${this.device.deviceType}: ${this.CurrentPosition} DECREASING PositionState: ${this.PositionState}`);
             }
             else {
                 this.debugLog(`${this.device.deviceType}: ${this.CurrentPosition} Standby because reached position,` + ` CurrentPosition: ${this.CurrentPosition}`);
-                this.PositionState = this.platform.Characteristic.PositionState.STOPPED;
-                this.windowCoveringService.getCharacteristic(this.platform.Characteristic.PositionState).updateValue(this.PositionState);
+                this.PositionState = this.hap.Characteristic.PositionState.STOPPED;
+                this.windowCoveringService.getCharacteristic(this.hap.Characteristic.PositionState).updateValue(this.PositionState);
                 this.debugLog(`${this.device.deviceType}: ${this.CurrentPosition} STOPPED PositionState: ${this.PositionState}`);
             }
         }
@@ -329,7 +390,7 @@ class BlindTilt {
             if (homekitTiltAngle) {
                 this.TargetHorizontalTiltAngle = this.CurrentHorizontalTiltAngle;
             }
-            this.PositionState = this.platform.Characteristic.PositionState.STOPPED;
+            this.PositionState = this.hap.Characteristic.PositionState.STOPPED;
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Stopped`);
         }
         this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} CurrentPosition: ${this.CurrentPosition},` +
@@ -351,10 +412,10 @@ class BlindTilt {
         // BatteryLevel
         this.BatteryLevel = Number(this.OpenAPI_BatteryLevel);
         if (this.BatteryLevel < 10) {
-            this.StatusLowBattery = this.platform.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW;
+            this.StatusLowBattery = this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW;
         }
         else {
-            this.StatusLowBattery = this.platform.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
+            this.StatusLowBattery = this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
         }
         if (Number.isNaN(this.BatteryLevel)) {
             this.BatteryLevel = 100;
@@ -423,7 +484,7 @@ class BlindTilt {
                     }
                 };
                 // Wait
-                return await (0, utils_1.sleep)(this.scanDuration * 1000);
+                return await sleep(this.scanDuration * 1000);
             })
                 .then(async () => {
                 // Stop to monitor
@@ -443,7 +504,7 @@ class BlindTilt {
     async openAPIRefreshStatus() {
         this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIRefreshStatus`);
         try {
-            const { body, statusCode, headers } = await (0, undici_1.request)(`${settings_1.Devices}/${this.device.deviceId}/status`, {
+            const { body, statusCode, headers } = await request(`${Devices}/${this.device.deviceId}/status`, {
                 headers: this.platform.generateHeaders(),
             });
             this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} body: ${JSON.stringify(body)}`);
@@ -491,9 +552,9 @@ class BlindTilt {
             this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} Connection Type:` + ` ${this.device.connectionType}, pushChanges will not happen.`);
         }
         // Refresh the status from the API
-        (0, rxjs_1.interval)(15000)
-            .pipe((0, operators_1.skipWhile)(() => this.blindTiltUpdateInProgress))
-            .pipe((0, operators_1.take)(1))
+        interval(15000)
+            .pipe(skipWhile(() => this.blindTiltUpdateInProgress))
+            .pipe(take(1))
             .subscribe(async () => {
             await this.refreshStatus();
         });
@@ -553,7 +614,7 @@ class BlindTilt {
             }
             this.infoLog(e);
             this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Retrying`);
-            await (0, utils_1.sleep)(1000);
+            await sleep(1000);
             return this.retry({ max: max - 1, fn });
         });
     }
@@ -594,7 +655,7 @@ class BlindTilt {
             }
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Sending request to SwitchBot API, body: ${bodyChange},`);
             try {
-                const { body, statusCode, headers } = await (0, undici_1.request)(`${settings_1.Devices}/${this.device.deviceId}/commands`, {
+                const { body, statusCode, headers } = await request(`${Devices}/${this.device.deviceId}/commands`, {
                     body: bodyChange,
                     method: 'POST',
                     headers: this.platform.generateHeaders(),
@@ -664,22 +725,22 @@ class BlindTilt {
         await this.setMinMax();
         this.debugLog('setMinMax');
         if (this.TargetPosition > this.CurrentPosition || this.TargetHorizontalTiltAngle !== this.CurrentHorizontalTiltAngle) {
-            this.PositionState = this.platform.Characteristic.PositionState.INCREASING;
+            this.PositionState = this.hap.Characteristic.PositionState.INCREASING;
             this.setNewTarget = true;
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} value: ${this.CurrentPosition},` + ` CurrentPosition: ${this.CurrentPosition}`);
         }
         else if (this.TargetPosition < this.CurrentPosition) {
-            this.PositionState = this.platform.Characteristic.PositionState.DECREASING;
+            this.PositionState = this.hap.Characteristic.PositionState.DECREASING;
             this.setNewTarget = true;
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} value: ${this.CurrentPosition},` + ` CurrentPosition: ${this.CurrentPosition}`);
         }
         else {
-            this.PositionState = this.platform.Characteristic.PositionState.STOPPED;
+            this.PositionState = this.hap.Characteristic.PositionState.STOPPED;
             this.setNewTarget = false;
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} value: ${this.CurrentPosition},` + ` CurrentPosition: ${this.CurrentPosition}`);
         }
-        this.windowCoveringService.setCharacteristic(this.platform.Characteristic.PositionState, this.PositionState);
-        this.windowCoveringService.getCharacteristic(this.platform.Characteristic.PositionState).updateValue(this.PositionState);
+        this.windowCoveringService.setCharacteristic(this.hap.Characteristic.PositionState, this.PositionState);
+        this.windowCoveringService.getCharacteristic(this.hap.Characteristic.PositionState).updateValue(this.PositionState);
         /**
          * If Blind Tilt movement time is short, the moving flag from backend is always false.
          * The minimum time depends on the network control latency.
@@ -706,7 +767,7 @@ class BlindTilt {
                     this.mqttPublish('CurrentHorizontalTiltAngle', this.CurrentHorizontalTiltAngle);
                 }
                 this.accessory.context.CurrentHorizontalTiltAngle = this.CurrentHorizontalTiltAngle;
-                this.windowCoveringService.updateCharacteristic(this.platform.Characteristic.CurrentHorizontalTiltAngle, Number(this.CurrentHorizontalTiltAngle));
+                this.windowCoveringService.updateCharacteristic(this.hap.Characteristic.CurrentHorizontalTiltAngle, Number(this.CurrentHorizontalTiltAngle));
                 this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} 
         updateCharacteristic CurrentHorizontalTiltAngle: ${this.CurrentHorizontalTiltAngle}`);
             }
@@ -720,7 +781,7 @@ class BlindTilt {
                 this.mqttPublish('CurrentPosition', this.CurrentPosition);
             }
             this.accessory.context.CurrentPosition = this.CurrentPosition;
-            this.windowCoveringService.updateCharacteristic(this.platform.Characteristic.CurrentPosition, Number(this.CurrentPosition));
+            this.windowCoveringService.updateCharacteristic(this.hap.Characteristic.CurrentPosition, Number(this.CurrentPosition));
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic CurrentPosition: ${this.CurrentPosition}`);
         }
         // PositionState
@@ -732,7 +793,7 @@ class BlindTilt {
                 this.mqttPublish('PositionState', this.PositionState);
             }
             this.accessory.context.PositionState = this.PositionState;
-            this.windowCoveringService.updateCharacteristic(this.platform.Characteristic.PositionState, Number(this.PositionState));
+            this.windowCoveringService.updateCharacteristic(this.hap.Characteristic.PositionState, Number(this.PositionState));
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic PositionState: ${this.PositionState}`);
         }
         // TargetPosition
@@ -744,7 +805,7 @@ class BlindTilt {
                 this.mqttPublish('TargetPosition', this.TargetPosition);
             }
             this.accessory.context.TargetPosition = this.TargetPosition;
-            this.windowCoveringService.updateCharacteristic(this.platform.Characteristic.TargetPosition, Number(this.TargetPosition));
+            this.windowCoveringService.updateCharacteristic(this.hap.Characteristic.TargetPosition, Number(this.TargetPosition));
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic TargetPosition: ${this.TargetPosition}`);
         }
         // CurrentAmbientLightLevel
@@ -757,7 +818,7 @@ class BlindTilt {
                     this.mqttPublish('CurrentAmbientLightLevel', this.CurrentAmbientLightLevel);
                 }
                 this.accessory.context.CurrentAmbientLightLevel = this.CurrentAmbientLightLevel;
-                this.lightSensorService?.updateCharacteristic(this.platform.Characteristic.CurrentAmbientLightLevel, this.CurrentAmbientLightLevel);
+                this.lightSensorService?.updateCharacteristic(this.hap.Characteristic.CurrentAmbientLightLevel, this.CurrentAmbientLightLevel);
                 this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName}` +
                     ` updateCharacteristic CurrentAmbientLightLevel: ${this.CurrentAmbientLightLevel}`);
             }
@@ -771,7 +832,7 @@ class BlindTilt {
                 this.mqttPublish('BatteryLevel', this.BatteryLevel);
             }
             this.accessory.context.BatteryLevel = this.BatteryLevel;
-            this.batteryService?.updateCharacteristic(this.platform.Characteristic.BatteryLevel, this.BatteryLevel);
+            this.batteryService?.updateCharacteristic(this.hap.Characteristic.BatteryLevel, this.BatteryLevel);
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic BatteryLevel: ${this.BatteryLevel}`);
         }
         // StatusLowBattery
@@ -783,7 +844,7 @@ class BlindTilt {
                 this.mqttPublish('StatusLowBattery', this.StatusLowBattery);
             }
             this.accessory.context.StatusLowBattery = this.StatusLowBattery;
-            this.batteryService?.updateCharacteristic(this.platform.Characteristic.StatusLowBattery, this.StatusLowBattery);
+            this.batteryService?.updateCharacteristic(this.hap.Characteristic.StatusLowBattery, this.StatusLowBattery);
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic StatusLowBattery: ${this.StatusLowBattery}`);
         }
     }
@@ -806,7 +867,7 @@ class BlindTilt {
     async setupMqtt(device) {
         if (device.mqttURL) {
             try {
-                this.mqttClient = await (0, async_mqtt_1.connectAsync)(device.mqttURL, device.mqttOptions || {});
+                this.mqttClient = await connectAsync(device.mqttURL, device.mqttOptions || {});
                 this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} MQTT connection has been established successfully.`);
                 this.mqttClient.on('error', (e) => {
                     this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} Failed to publish MQTT messages. ${e}`);
@@ -839,7 +900,7 @@ class BlindTilt {
                 switchbot.onadvertisement = (ad) => {
                     this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} ad: ${JSON.stringify(ad, null, '  ')}`);
                 };
-                await (0, utils_1.sleep)(10000);
+                await sleep(10000);
                 // Stop to monitor
                 await switchbot.stopScan();
             })();
@@ -992,15 +1053,15 @@ class BlindTilt {
         }
     }
     async apiError(e) {
-        this.windowCoveringService.updateCharacteristic(this.platform.Characteristic.CurrentPosition, e);
-        this.windowCoveringService.updateCharacteristic(this.platform.Characteristic.PositionState, e);
-        this.windowCoveringService.updateCharacteristic(this.platform.Characteristic.TargetPosition, e);
+        this.windowCoveringService.updateCharacteristic(this.hap.Characteristic.CurrentPosition, e);
+        this.windowCoveringService.updateCharacteristic(this.hap.Characteristic.PositionState, e);
+        this.windowCoveringService.updateCharacteristic(this.hap.Characteristic.TargetPosition, e);
         if (!this.device.curtain?.hide_lightsensor) {
-            this.lightSensorService?.updateCharacteristic(this.platform.Characteristic.CurrentAmbientLightLevel, e);
+            this.lightSensorService?.updateCharacteristic(this.hap.Characteristic.CurrentAmbientLightLevel, e);
         }
         if (this.BLE) {
-            this.batteryService?.updateCharacteristic(this.platform.Characteristic.BatteryLevel, e);
-            this.batteryService?.updateCharacteristic(this.platform.Characteristic.StatusLowBattery, e);
+            this.batteryService?.updateCharacteristic(this.hap.Characteristic.BatteryLevel, e);
+            this.batteryService?.updateCharacteristic(this.hap.Characteristic.StatusLowBattery, e);
         }
         //throw new this.platform.api.hap.HapStatusError(HAPStatus.SERVICE_COMMUNICATION_FAILURE);
     }
@@ -1018,7 +1079,7 @@ class BlindTilt {
             this.TargetPosition = this.accessory.context.TargetPosition;
         }
         if (this.PositionState === undefined) {
-            this.PositionState = this.platform.Characteristic.PositionState.STOPPED;
+            this.PositionState = this.hap.Characteristic.PositionState.STOPPED;
         }
         else {
             this.PositionState = this.accessory.context.PositionState;
@@ -1162,7 +1223,7 @@ class BlindTilt {
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Default Blind Tilt updateRate: ${this.updateRate}`);
         }
     }
-    async config(device) {
+    async deviceConfig(device) {
         let config = {};
         if (device.blindTilt) {
             config = device.blindTilt;
@@ -1198,7 +1259,7 @@ class BlindTilt {
             this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} Config: ${JSON.stringify(config)}`);
         }
     }
-    async logs(device) {
+    async deviceLogs(device) {
         if (this.platform.debugMode) {
             this.deviceLogging = this.accessory.context.logging = 'debugMode';
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Debug Mode Logging: ${this.deviceLogging}`);
@@ -1262,5 +1323,4 @@ class BlindTilt {
         return this.deviceLogging.includes('debug') || this.deviceLogging === 'standard';
     }
 }
-exports.BlindTilt = BlindTilt;
 //# sourceMappingURL=blindtilt.js.map