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

package/dist/device/curtain.js

@@ -1,60 +1,118 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Curtain = 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");
-const os_1 = require("os");
-class Curtain {
+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';
+import { hostname } from 'os';
+export class Curtain {
+    platform;
+    accessory;
+    device;
+    api;
+    log;
+    config;
+    hap;
+    // Services
+    batteryService;
+    lightSensorService;
+    windowCoveringService;
+    // Characteristic Values
+    BatteryLevel;
+    HoldPosition;
+    PositionState;
+    TargetPosition;
+    CurrentPosition;
+    FirmwareRevision;
+    StatusLowBattery;
+    CurrentAmbientLightLevel;
+    // OpenAPI Status
+    OpenAPI_InMotion;
+    OpenAPI_BatteryLevel;
+    OpenAPI_FirmwareRevision;
+    OpenAPI_CurrentPosition;
+    OpenAPI_CurrentAmbientLightLevel;
+    // OpenAPI Others
+    Mode;
+    setPositionMode;
+    // 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
+    updateRate;
+    set_minLux;
+    set_maxLux;
+    set_minStep;
+    setOpenMode;
+    setCloseMode;
+    scanDuration;
+    deviceLogging;
+    deviceRefreshRate;
+    // Updates
+    curtainUpdateInProgress;
+    doCurtainUpdate;
+    // Connection
+    OpenAPI;
+    BLE;
+    // EVE history service handler
+    historyService = null;
     constructor(platform, accessory, device) {
         this.platform = platform;
         this.accessory = accessory;
         this.device = device;
-        //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';
-        // EVE history service handler
-        this.historyService = null;
         // 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 is subject we use to track when we need to POST changes to the SwitchBot API
-        this.doCurtainUpdate = new rxjs_1.Subject();
+        this.doCurtainUpdate = new Subject();
         this.curtainUpdateInProgress = 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, 'W0701600')
-            .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, 'W0701600')
+            .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 = `${accessory.displayName} ${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);
+        (this.windowCoveringService = 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);
         }
         // each service must implement at-minimum the "required characteristics" for the given service type
         // see https://developers.homebridge.io/#/service/WindowCovering
         // 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,
@@ -65,7 +123,7 @@ class Curtain {
             return this.CurrentPosition;
         });
         this.windowCoveringService
-            .getCharacteristic(this.platform.Characteristic.TargetPosition)
+            .getCharacteristic(this.hap.Characteristic.TargetPosition)
             .setProps({
             minStep: this.minStep(device),
             minValue: 0,
@@ -74,7 +132,7 @@ class Curtain {
         })
             .onSet(this.TargetPositionSet.bind(this));
         this.windowCoveringService
-            .getCharacteristic(this.platform.Characteristic.HoldPosition)
+            .getCharacteristic(this.hap.Characteristic.HoldPosition)
             .setProps({
             minStep: this.minStep(device),
             minValue: 0,
@@ -85,17 +143,17 @@ class Curtain {
         // Light Sensor Service
         if (device.curtain?.hide_lightsensor) {
             this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Removing Light Sensor Service`);
-            this.lightSensorService = this.accessory.getService(this.platform.Service.LightSensor);
+            this.lightSensorService = this.accessory.getService(this.hap.Service.LightSensor);
             accessory.removeService(this.lightSensorService);
         }
         else if (!this.lightSensorService) {
             this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Add Light Sensor Service`);
             const lightSensorService = `${accessory.displayName} Light Sensor`;
-            (this.lightSensorService = this.accessory.getService(this.platform.Service.LightSensor)
-                || this.accessory.addService(this.platform.Service.LightSensor)), lightSensorService;
-            this.lightSensorService.setCharacteristic(this.platform.Characteristic.Name, `${accessory.displayName} Light Sensor`);
-            if (!this.lightSensorService?.testCharacteristic(this.platform.Characteristic.ConfiguredName)) {
-                this.lightSensorService.addCharacteristic(this.platform.Characteristic.ConfiguredName, `${accessory.displayName} Light Sensor`);
+            (this.lightSensorService = this.accessory.getService(this.hap.Service.LightSensor)
+                || this.accessory.addService(this.hap.Service.LightSensor)), lightSensorService;
+            this.lightSensorService.setCharacteristic(this.hap.Characteristic.Name, `${accessory.displayName} Light Sensor`);
+            if (!this.lightSensorService?.testCharacteristic(this.hap.Characteristic.ConfiguredName)) {
+                this.lightSensorService.addCharacteristic(this.hap.Characteristic.ConfiguredName, `${accessory.displayName} Light Sensor`);
             }
         }
         else {
@@ -103,17 +161,17 @@ class Curtain {
         }
         // 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.curtainUpdateInProgress))
+        interval(this.deviceRefreshRate * 1000)
+            .pipe(skipWhile(() => this.curtainUpdateInProgress))
             .subscribe(async () => {
             await this.refreshStatus();
         });
@@ -140,10 +198,10 @@ class Curtain {
             };
         }
         // update slide progress
-        (0, rxjs_1.interval)(this.updateRate * 1000)
+        interval(this.updateRate * 1000)
             //.pipe(skipWhile(() => this.curtainUpdateInProgress))
             .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}`);
@@ -152,9 +210,9 @@ class Curtain {
         // Watch for Curtain change events
         // We put in a debounce of 100ms so we don't make duplicate calls
         this.doCurtainUpdate
-            .pipe((0, operators_1.tap)(() => {
+            .pipe(tap(() => {
             this.curtainUpdateInProgress = true;
-        }), (0, operators_1.debounceTime)(this.platform.config.options.pushRate * 1000))
+        }), debounceTime(this.platform.config.options.pushRate * 1000))
             .subscribe(async () => {
             try {
                 await this.pushChanges();
@@ -183,10 +241,10 @@ class Curtain {
         this.historyService = new this.platform.fakegatoAPI('custom', this.accessory, {
             log: this.platform.log,
             storage: 'fs',
-            filename: `${(0, os_1.hostname)().split('.')[0]}_${mac}_persist.json`,
+            filename: `${hostname().split('.')[0]}_${mac}_persist.json`,
         });
-        const motion = this.accessory.getService(this.platform.Service.MotionSensor) ||
-            this.accessory.addService(this.platform.Service.MotionSensor, `${this.accessory.displayName} Motion`);
+        const motion = this.accessory.getService(this.hap.Service.MotionSensor) ||
+            this.accessory.addService(this.hap.Service.MotionSensor, `${this.accessory.displayName} Motion`);
         motion.addOptionalCharacteristic(this.platform.eve.Characteristics.LastActivation);
         motion.getCharacteristic(this.platform.eve.Characteristics.LastActivation).onGet(() => {
             const lastActivation = this.accessory.context.lastActivation
@@ -195,9 +253,9 @@ class Curtain {
             return lastActivation;
         });
         await this.setMinMax();
-        motion.getCharacteristic(this.platform.Characteristic.MotionDetected).on('change', (event) => {
+        motion.getCharacteristic(this.hap.Characteristic.MotionDetected).on('change', (event) => {
             if (event.newValue !== event.oldValue) {
-                const sensor = this.accessory.getService(this.platform.Service.MotionSensor);
+                const sensor = this.accessory.getService(this.hap.Service.MotionSensor);
                 const entry = {
                     time: Math.round(new Date().valueOf() / 1000),
                     motion: event.newValue,
@@ -248,27 +306,27 @@ class Curtain {
             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} Standby, 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},` +
@@ -327,10 +385,10 @@ class Curtain {
         // 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}`);
     }
@@ -347,27 +405,27 @@ class Curtain {
             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} Standby, 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},` +
@@ -389,10 +447,10 @@ class Curtain {
         // 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;
@@ -461,7 +519,7 @@ class Curtain {
                     }
                 };
                 // Wait
-                return await (0, utils_1.sleep)(this.scanDuration * 1000);
+                return await sleep(this.scanDuration * 1000);
             })
                 .then(async () => {
                 // Stop to monitor
@@ -481,7 +539,7 @@ class Curtain {
     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)}`);
@@ -528,9 +586,9 @@ class Curtain {
             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.curtainUpdateInProgress))
-            .pipe((0, operators_1.take)(1))
+        interval(15000)
+            .pipe(skipWhile(() => this.curtainUpdateInProgress))
+            .pipe(take(1))
             .subscribe(async () => {
             await this.refreshStatus();
         });
@@ -591,7 +649,7 @@ class Curtain {
             }
             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 });
         });
     }
@@ -645,7 +703,7 @@ class Curtain {
             });
             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(),
@@ -689,7 +747,7 @@ class Curtain {
         }
         // Set HoldPosition to false when TargetPosition is changed
         this.HoldPosition = false;
-        this.windowCoveringService.updateCharacteristic(this.platform.Characteristic.HoldPosition, this.HoldPosition);
+        this.windowCoveringService.updateCharacteristic(this.hap.Characteristic.HoldPosition, this.HoldPosition);
         this.TargetPosition = value;
         if (this.device.mqttURL) {
             this.mqttPublish('TargetPosition', this.TargetPosition);
@@ -697,22 +755,22 @@ class Curtain {
         }
         await this.setMinMax();
         if (value > this.CurrentPosition) {
-            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: ${value}, CurrentPosition: ${this.CurrentPosition}`);
         }
         else if (value < 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: ${value}, 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: ${value}, 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 Curtain movement time is short, the moving flag from backend is always false.
          * The minimum time depends on the network control latency.
@@ -745,7 +803,7 @@ class Curtain {
                 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}`);
         }
         if (this.PositionState === undefined) {
@@ -756,7 +814,7 @@ class Curtain {
                 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}`);
         }
         if (this.TargetPosition === undefined || Number.isNaN(this.TargetPosition)) {
@@ -767,7 +825,7 @@ class Curtain {
                 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}`);
         }
         if (this.HoldPosition === undefined) {
@@ -778,7 +836,7 @@ class Curtain {
                 this.mqttPublish('HoldPosition', this.HoldPosition);
             }
             this.accessory.context.HoldPosition = this.HoldPosition;
-            this.windowCoveringService.updateCharacteristic(this.platform.Characteristic.HoldPosition, this.HoldPosition);
+            this.windowCoveringService.updateCharacteristic(this.hap.Characteristic.HoldPosition, this.HoldPosition);
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic HoldPosition: ${this.HoldPosition}`);
         }
         if (!this.device.curtain?.hide_lightsensor) {
@@ -790,7 +848,7 @@ class Curtain {
                     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}`);
                 if (this.device.history) {
@@ -809,7 +867,7 @@ class Curtain {
                 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}`);
         }
         if (this.StatusLowBattery === undefined) {
@@ -820,7 +878,7 @@ class Curtain {
                 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}`);
         }
     }
@@ -843,7 +901,7 @@ class Curtain {
     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}`);
@@ -876,7 +934,7 @@ class Curtain {
                 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();
             })();
@@ -929,9 +987,9 @@ class Curtain {
             }
         }
         if (this.device.history) {
-            const motion = this.accessory.getService(this.platform.Service.MotionSensor);
+            const motion = this.accessory.getService(this.hap.Service.MotionSensor);
             const state = Number(this.CurrentPosition) > 0 ? 1 : 0;
-            motion?.updateCharacteristic(this.platform.Characteristic.MotionDetected, state);
+            motion?.updateCharacteristic(this.hap.Characteristic.MotionDetected, state);
         }
     }
     minStep(device) {
@@ -1031,14 +1089,14 @@ class Curtain {
         }
     }
     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);
         }
-        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);
     }
     async context() {
@@ -1055,7 +1113,7 @@ class Curtain {
             this.TargetPosition = this.accessory.context.TargetPosition;
         }
         if (this.accessory.context.PositionState === undefined) {
-            this.PositionState = this.platform.Characteristic.PositionState.STOPPED;
+            this.PositionState = this.hap.Characteristic.PositionState.STOPPED;
         }
         else {
             this.PositionState = this.accessory.context.PositionState;
@@ -1073,7 +1131,7 @@ class Curtain {
                 this.BatteryLevel = this.accessory.context.BatteryLevel;
             }
             if (this.accessory.context.StatusLowBattery === undefined) {
-                this.StatusLowBattery = this.platform.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
+                this.StatusLowBattery = this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL;
             }
             else {
                 this.StatusLowBattery = this.accessory.context.StatusLowBattery;
@@ -1112,7 +1170,7 @@ class Curtain {
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Using Default Curtain updateRate: ${this.updateRate}`);
         }
     }
-    async config(device) {
+    async deviceConfig(device) {
         let config = {};
         if (device.curtain) {
             config = device.curtain;
@@ -1142,7 +1200,7 @@ class Curtain {
             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}`);
@@ -1206,5 +1264,4 @@ class Curtain {
         return this.deviceLogging.includes('debug') || this.deviceLogging === 'standard';
     }
 }
-exports.Curtain = Curtain;
 //# sourceMappingURL=curtain.js.map