@switchbot/homebridge-switchbot 3.5.0-beta.23 → 3.5.0-beta.25

package/dist/irdevice/airconditioner.js

@@ -1,24 +1,22 @@
+/* Copyright(C) 2021-2024, donavanbecker (https://github.com/donavanbecker). All rights reserved.
+ *
+ * airconditioners.ts: @switchbot/homebridge-switchbot.
+ */
 import { request } from 'undici';
+import { irdeviceBase } from './irdevice.js';
 import { Devices } from '../settings.js';
 /**
  * Platform Accessory
  * An instance of this class is created for each accessory your platform registers
  * Each accessory may expose multiple services of different service types.
  */
-export class AirConditioner {
+export class AirConditioner extends irdeviceBase {
     platform;
-    accessory;
-    device;
-    api;
-    log;
-    config;
-    hap;
     // Services
     coolerService;
     // Characteristic Values
     Active;
     RotationSpeed;
-    FirmwareRevision;
     CurrentTemperature;
     ThresholdTemperature;
     CurrentRelativeHumidity;
@@ -35,49 +33,98 @@ export class AirConditioner {
     static MODE_COOL;
     static MODE_HEAT;
     // Config
-    deviceLogging;
     hide_automode;
     set_max_heat;
     set_min_heat;
     set_max_cool;
     set_min_cool;
-    disablePushOn;
-    disablePushOff;
     meter;
-    disablePushDetail;
     valid12 = [1, 2];
     valid012 = [0, 1, 2];
     constructor(platform, accessory, device) {
+        super(platform, accessory, device);
         this.platform = platform;
-        this.accessory = accessory;
-        this.device = device;
-        this.api = this.platform.api;
-        this.log = this.platform.log;
-        this.config = this.platform.config;
-        this.hap = this.api.hap;
-        // default placeholders
-        this.deviceLogs(device);
-        this.deviceContext();
-        this.disablePushOnChanges(device);
-        this.disablePushOffChanges(device);
-        this.disablePushDetailChanges(device);
-        this.deviceConfig(device);
-        // set accessory information
-        accessory
-            .getService(this.hap.Service.AccessoryInformation)
-            .setCharacteristic(this.hap.Characteristic.Manufacturer, 'SwitchBot')
-            .setCharacteristic(this.hap.Characteristic.Model, device.remoteType)
-            .setCharacteristic(this.hap.Characteristic.SerialNumber, device.deviceId)
-            .setCharacteristic(this.hap.Characteristic.FirmwareRevision, accessory.context.FirmwareRevision);
+        if (this.Active === undefined) {
+            this.Active = this.hap.Characteristic.Active.INACTIVE;
+        }
+        else if (this.Active) {
+            this.Active;
+        }
+        else {
+            this.Active = this.accessory.context.Active;
+        }
+        if (this.CurrentTemperature === undefined && this.accessory.context.CurrentTemperature === undefined) {
+            this.CurrentTemperature = 24;
+        }
+        else {
+            this.CurrentTemperature = this.CurrentTemperature || this.accessory.context.CurrentTemperature;
+        }
+        if (this.ThresholdTemperature === undefined && this.accessory.context.ThresholdTemperature === undefined) {
+            this.ThresholdTemperature = 24;
+        }
+        else {
+            this.ThresholdTemperature = this.ThresholdTemperature || this.accessory.context.ThresholdTemperature;
+        }
+        if (this.RotationSpeed === undefined && this.accessory.context.RotationSpeed === undefined) {
+            this.RotationSpeed = 4;
+        }
+        else {
+            this.RotationSpeed = this.RotationSpeed || this.accessory.context.RotationSpeed;
+        }
+        if (this.device.irair?.hide_automode) {
+            this.hide_automode = this.device.irair?.hide_automode;
+            this.accessory.context.hide_automode = this.hide_automode;
+        }
+        else {
+            this.hide_automode = this.device.irair?.hide_automode;
+            this.accessory.context.hide_automode = this.hide_automode;
+        }
+        if (this.device.irair?.set_max_heat) {
+            this.set_max_heat = this.device.irair?.set_max_heat;
+            this.accessory.context.set_max_heat = this.set_max_heat;
+        }
+        else {
+            this.set_max_heat = 35;
+            this.accessory.context.set_max_heat = this.set_max_heat;
+        }
+        if (this.device.irair?.set_min_heat) {
+            this.set_min_heat = this.device.irair?.set_min_heat;
+            this.accessory.context.set_min_heat = this.set_min_heat;
+        }
+        else {
+            this.set_min_heat = 0;
+            this.accessory.context.set_min_heat = this.set_min_heat;
+        }
+        if (this.device.irair?.set_max_cool) {
+            this.set_max_cool = this.device.irair?.set_max_cool;
+            this.accessory.context.set_max_cool = this.set_max_cool;
+        }
+        else {
+            this.set_max_cool = 35;
+            this.accessory.context.set_max_cool = this.set_max_cool;
+        }
+        if (this.device.irair?.set_min_cool) {
+            this.set_min_cool = this.device.irair?.set_min_cool;
+            this.accessory.context.set_min_cool = this.set_min_cool;
+        }
+        else {
+            this.set_min_cool = 0;
+            this.accessory.context.set_min_cool = this.set_min_cool;
+        }
+        if (this.meter) {
+            if (this.CurrentRelativeHumidity === undefined && this.accessory.context.CurrentRelativeHumidity === undefined) {
+                this.CurrentRelativeHumidity = 0;
+            }
+            else {
+                this.CurrentRelativeHumidity = this.CurrentRelativeHumidity || this.accessory.context.CurrentRelativeHumidity;
+            }
+        }
         // get the Television service if it exists, otherwise create a new Television service
         // you can create multiple services for each accessory
         const coolerService = `${accessory.displayName} ${device.remoteType}`;
         (this.coolerService = accessory.getService(this.hap.Service.HeaterCooler)
             || accessory.addService(this.hap.Service.HeaterCooler)), coolerService;
         this.coolerService.setCharacteristic(this.hap.Characteristic.Name, accessory.displayName);
-        if (!this.coolerService.testCharacteristic(this.hap.Characteristic.ConfiguredName)) {
-            this.coolerService.addCharacteristic(this.hap.Characteristic.ConfiguredName, accessory.displayName);
-        }
         // handle on / off events using the Active characteristic
         this.coolerService.getCharacteristic(this.hap.Characteristic.Active).onSet(this.ActiveSet.bind(this));
         this.coolerService.getCharacteristic(this.hap.Characteristic.CurrentTemperature).onGet(this.CurrentTemperatureGet.bind(this));
@@ -207,7 +254,81 @@ export class AirConditioner {
     }
     async UpdateCurrentHeaterCoolerState() {
         if (this.Active === this.hap.Characteristic.Active.ACTIVE) {
-            await this.deviceContext();
+            if (this.Active === undefined) {
+                this.Active = this.hap.Characteristic.Active.INACTIVE;
+            }
+            else if (this.Active) {
+                this.Active;
+            }
+            else {
+                this.Active = this.accessory.context.Active;
+            }
+            if (this.CurrentTemperature === undefined && this.accessory.context.CurrentTemperature === undefined) {
+                this.CurrentTemperature = 24;
+            }
+            else {
+                this.CurrentTemperature = this.CurrentTemperature || this.accessory.context.CurrentTemperature;
+            }
+            if (this.ThresholdTemperature === undefined && this.accessory.context.ThresholdTemperature === undefined) {
+                this.ThresholdTemperature = 24;
+            }
+            else {
+                this.ThresholdTemperature = this.ThresholdTemperature || this.accessory.context.ThresholdTemperature;
+            }
+            if (this.RotationSpeed === undefined && this.accessory.context.RotationSpeed === undefined) {
+                this.RotationSpeed = 4;
+            }
+            else {
+                this.RotationSpeed = this.RotationSpeed || this.accessory.context.RotationSpeed;
+            }
+            if (this.device.irair?.hide_automode) {
+                this.hide_automode = this.device.irair?.hide_automode;
+                this.accessory.context.hide_automode = this.hide_automode;
+            }
+            else {
+                this.hide_automode = this.device.irair?.hide_automode;
+                this.accessory.context.hide_automode = this.hide_automode;
+            }
+            if (this.device.irair?.set_max_heat) {
+                this.set_max_heat = this.device.irair?.set_max_heat;
+                this.accessory.context.set_max_heat = this.set_max_heat;
+            }
+            else {
+                this.set_max_heat = 35;
+                this.accessory.context.set_max_heat = this.set_max_heat;
+            }
+            if (this.device.irair?.set_min_heat) {
+                this.set_min_heat = this.device.irair?.set_min_heat;
+                this.accessory.context.set_min_heat = this.set_min_heat;
+            }
+            else {
+                this.set_min_heat = 0;
+                this.accessory.context.set_min_heat = this.set_min_heat;
+            }
+            if (this.device.irair?.set_max_cool) {
+                this.set_max_cool = this.device.irair?.set_max_cool;
+                this.accessory.context.set_max_cool = this.set_max_cool;
+            }
+            else {
+                this.set_max_cool = 35;
+                this.accessory.context.set_max_cool = this.set_max_cool;
+            }
+            if (this.device.irair?.set_min_cool) {
+                this.set_min_cool = this.device.irair?.set_min_cool;
+                this.accessory.context.set_min_cool = this.set_min_cool;
+            }
+            else {
+                this.set_min_cool = 0;
+                this.accessory.context.set_min_cool = this.set_min_cool;
+            }
+            if (this.meter) {
+                if (this.CurrentRelativeHumidity === undefined && this.accessory.context.CurrentRelativeHumidity === undefined) {
+                    this.CurrentRelativeHumidity = 0;
+                }
+                else {
+                    this.CurrentRelativeHumidity = this.CurrentRelativeHumidity || this.accessory.context.CurrentRelativeHumidity;
+                }
+            }
             if (this.ThresholdTemperature < this.CurrentTemperature &&
                 this.TargetHeaterCoolerState !== this.hap.Characteristic.TargetHeaterCoolerState.HEAT) {
                 this.CurrentHeaterCoolerState = this.hap.Characteristic.CurrentHeaterCoolerState.COOLING;
@@ -382,219 +503,6 @@ export class AirConditioner {
         }
     }
     async ThresholdTemperatureGet() {
-        await this.deviceContext();
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get ThresholdTemperature: ${this.ThresholdTemperature}`);
-        return this.ThresholdTemperature;
-    }
-    async ThresholdTemperatureSet(value) {
-        this.ThresholdTemperature = value;
-        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set ThresholdTemperature: ${this.ThresholdTemperature},` +
-            ` ThresholdTemperatureCached: ${this.accessory.context.ThresholdTemperature}`);
-        this.pushAirConditionerStatusChanges();
-    }
-    async updateHomeKitCharacteristics() {
-        // Active
-        if (this.Active === undefined) {
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Active: ${this.Active}`);
-        }
-        else {
-            this.accessory.context.Active = this.Active;
-            this.coolerService?.updateCharacteristic(this.hap.Characteristic.Active, this.Active);
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic Active: ${this.Active}`);
-        }
-        // RotationSpeed
-        if (this.RotationSpeed === undefined) {
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} RotationSpeed: ${this.RotationSpeed}`);
-        }
-        else {
-            this.accessory.context.RotationSpeed = this.RotationSpeed;
-            this.coolerService?.updateCharacteristic(this.hap.Characteristic.RotationSpeed, this.RotationSpeed);
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic RotationSpeed: ${this.RotationSpeed}`);
-        }
-        // CurrentTemperature
-        if (this.CurrentTemperature === undefined) {
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentTemperature: ${this.CurrentTemperature}`);
-        }
-        else {
-            this.accessory.context.CurrentTemperature = this.CurrentTemperature;
-            this.coolerService?.updateCharacteristic(this.hap.Characteristic.CurrentTemperature, this.CurrentTemperature);
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic CurrentTemperature: ${this.CurrentTemperature}`);
-        }
-        // CurrentRelativeHumidity
-        if (this.meter) {
-            if (this.CurrentRelativeHumidity === undefined) {
-                this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentRelativeHumidity: ${this.CurrentRelativeHumidity}`);
-            }
-            else {
-                this.accessory.context.CurrentRelativeHumidity = this.CurrentRelativeHumidity;
-                this.coolerService?.updateCharacteristic(this.hap.Characteristic.CurrentRelativeHumidity, this.CurrentRelativeHumidity);
-                this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic CurrentRelativeHumidity: ${this.CurrentRelativeHumidity}`);
-            }
-        }
-        // TargetHeaterCoolerState
-        if (this.TargetHeaterCoolerState === undefined) {
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
-        }
-        else {
-            this.accessory.context.TargetHeaterCoolerState = this.TargetHeaterCoolerState;
-            this.coolerService?.updateCharacteristic(this.hap.Characteristic.TargetHeaterCoolerState, this.TargetHeaterCoolerState);
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}` + ` updateCharacteristic TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
-        }
-        // CurrentHeaterCoolerState
-        if (this.CurrentHeaterCoolerState === undefined) {
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
-        }
-        else {
-            this.accessory.context.CurrentHeaterCoolerState = this.CurrentHeaterCoolerState;
-            this.coolerService?.updateCharacteristic(this.hap.Characteristic.CurrentHeaterCoolerState, this.CurrentHeaterCoolerState);
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}` +
-                ` updateCharacteristic CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
-        }
-        // ThresholdTemperature
-        if (this.ThresholdTemperature === undefined) {
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} ThresholdTemperature: ${this.ThresholdTemperature}`);
-        }
-        else {
-            this.accessory.context.ThresholdTemperature = this.ThresholdTemperature;
-            this.coolerService?.updateCharacteristic(this.hap.Characteristic.HeatingThresholdTemperature, this.ThresholdTemperature);
-            this.coolerService?.updateCharacteristic(this.hap.Characteristic.CoolingThresholdTemperature, this.ThresholdTemperature);
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}` + ` updateCharacteristic ThresholdTemperature: ${this.ThresholdTemperature}`);
-        }
-    }
-    async disablePushOnChanges(device) {
-        if (device.disablePushOn === undefined) {
-            this.disablePushOn = false;
-        }
-        else {
-            this.disablePushOn = device.disablePushOn;
-        }
-    }
-    async disablePushOffChanges(device) {
-        if (device.disablePushOff === undefined) {
-            this.disablePushOff = false;
-        }
-        else {
-            this.disablePushOff = device.disablePushOff;
-        }
-    }
-    async disablePushDetailChanges(device) {
-        if (device.disablePushDetail === undefined) {
-            this.disablePushDetail = false;
-        }
-        else {
-            this.disablePushDetail = device.disablePushDetail;
-        }
-    }
-    async commandType() {
-        let commandType;
-        if (this.device.customize) {
-            commandType = 'customize';
-        }
-        else {
-            commandType = 'command';
-        }
-        return commandType;
-    }
-    async commandOn() {
-        let command;
-        if (this.device.customize && this.device.customOn) {
-            command = this.device.customOn;
-        }
-        else {
-            command = 'turnOn';
-        }
-        return command;
-    }
-    async commandOff() {
-        let command;
-        if (this.device.customize && this.device.customOff) {
-            command = this.device.customOff;
-        }
-        else {
-            command = 'turnOff';
-        }
-        return command;
-    }
-    async statusCode(statusCode) {
-        switch (statusCode) {
-            case 151:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Command not supported by this deviceType, statusCode: ${statusCode}`);
-                break;
-            case 152:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Device not found, statusCode: ${statusCode}`);
-                break;
-            case 160:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Command is not supported, statusCode: ${statusCode}`);
-                break;
-            case 161:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Device is offline, statusCode: ${statusCode}`);
-                break;
-            case 171:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Hub Device is offline, statusCode: ${statusCode}. ` +
-                    `Hub: ${this.device.hubDeviceId}`);
-                break;
-            case 190:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Device internal error due to device states not synchronized with server,` +
-                    ` Or command format is invalid, statusCode: ${statusCode}`);
-                break;
-            case 100:
-                this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Command successfully sent, statusCode: ${statusCode}`);
-                break;
-            case 200:
-                this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Request successful, statusCode: ${statusCode}`);
-                break;
-            case 400:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Bad Request, The client has issued an invalid request. `
-                    + `This is commonly used to specify validation errors in a request payload, statusCode: ${statusCode}`);
-                break;
-            case 401:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Unauthorized,	Authorization for the API is required, `
-                    + `but the request has not been authenticated, statusCode: ${statusCode}`);
-                break;
-            case 403:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Forbidden,	The request has been authenticated but does not `
-                    + `have appropriate permissions, or a requested resource is not found, statusCode: ${statusCode}`);
-                break;
-            case 404:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Not Found,	Specifies the requested path does not exist, `
-                    + `statusCode: ${statusCode}`);
-                break;
-            case 406:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Not Acceptable,	The client has requested a MIME type via `
-                    + `the Accept header for a value not supported by the server, statusCode: ${statusCode}`);
-                break;
-            case 415:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Unsupported Media Type,	The client has defined a contentType `
-                    + `header that is not supported by the server, statusCode: ${statusCode}`);
-                break;
-            case 422:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Unprocessable Entity,	The client has made a valid request, but `
-                    + `the server cannot process it. This is often used for APIs for which certain limits have been exceeded, statusCode: ${statusCode}`);
-                break;
-            case 429:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Too Many Requests,	The client has exceeded the number of `
-                    + `requests allowed for a given time window, statusCode: ${statusCode}`);
-                break;
-            case 500:
-                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Internal Server Error,	An unexpected error on the SmartThings `
-                    + `servers has occurred. These errors should be rare, statusCode: ${statusCode}`);
-                break;
-            default:
-                this.infoLog(`${this.device.remoteType}: ${this.accessory.displayName} Unknown statusCode: ` +
-                    `${statusCode}, Submit Bugs Here: ' + 'https://tinyurl.com/SwitchBotBug`);
-        }
-    }
-    async apiError({ e }) {
-        this.coolerService.updateCharacteristic(this.hap.Characteristic.Active, e);
-        this.coolerService.updateCharacteristic(this.hap.Characteristic.RotationSpeed, e);
-        this.coolerService.updateCharacteristic(this.hap.Characteristic.CurrentTemperature, e);
-        this.coolerService.updateCharacteristic(this.hap.Characteristic.CurrentRelativeHumidity, e);
-        this.coolerService.updateCharacteristic(this.hap.Characteristic.TargetHeaterCoolerState, e);
-        this.coolerService.updateCharacteristic(this.hap.Characteristic.CurrentHeaterCoolerState, e);
-        this.coolerService.updateCharacteristic(this.hap.Characteristic.HeatingThresholdTemperature, e);
-        this.coolerService.updateCharacteristic(this.hap.Characteristic.CoolingThresholdTemperature, e);
-    }
-    async deviceContext() {
         if (this.Active === undefined) {
             this.Active = this.hap.Characteristic.Active.INACTIVE;
         }
@@ -670,110 +578,93 @@ export class AirConditioner {
                 this.CurrentRelativeHumidity = this.CurrentRelativeHumidity || this.accessory.context.CurrentRelativeHumidity;
             }
         }
-        if (this.FirmwareRevision === undefined) {
-            this.FirmwareRevision = this.platform.version;
-            this.accessory.context.FirmwareRevision = this.FirmwareRevision;
-        }
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get ThresholdTemperature: ${this.ThresholdTemperature}`);
+        return this.ThresholdTemperature;
     }
-    async deviceConfig(device) {
-        let config = {};
-        if (device.irair) {
-            config = device.irair;
-        }
-        if (device.logging !== undefined) {
-            config['logging'] = device.logging;
-        }
-        if (device.connectionType !== undefined) {
-            config['connectionType'] = device.connectionType;
-        }
-        if (device.external !== undefined) {
-            config['external'] = device.external;
-        }
-        if (device.customOn !== undefined) {
-            config['customOn'] = device.customOn;
-        }
-        if (device.customOff !== undefined) {
-            config['customOff'] = device.customOff;
-        }
-        if (device.customize !== undefined) {
-            config['customize'] = device.customize;
-        }
-        if (device.disablePushOn !== undefined) {
-            config['disablePushOn'] = device.disablePushOn;
-        }
-        if (device.disablePushOff !== undefined) {
-            config['disablePushOff'] = device.disablePushOff;
-        }
-        if (device.disablePushDetail !== undefined) {
-            config['disablePushDetail'] = device.disablePushDetail;
+    async ThresholdTemperatureSet(value) {
+        this.ThresholdTemperature = value;
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set ThresholdTemperature: ${this.ThresholdTemperature},` +
+            ` ThresholdTemperatureCached: ${this.accessory.context.ThresholdTemperature}`);
+        this.pushAirConditionerStatusChanges();
+    }
+    async updateHomeKitCharacteristics() {
+        // Active
+        if (this.Active === undefined) {
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Active: ${this.Active}`);
         }
-        if (Object.entries(config).length !== 0) {
-            this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} Config: ${JSON.stringify(config)}`);
+        else {
+            this.accessory.context.Active = this.Active;
+            this.coolerService?.updateCharacteristic(this.hap.Characteristic.Active, this.Active);
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic Active: ${this.Active}`);
         }
-    }
-    async deviceLogs(device) {
-        if (this.platform.debugMode) {
-            this.deviceLogging = this.accessory.context.logging = 'debugMode';
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Using Debug Mode Logging: ${this.deviceLogging}`);
+        // RotationSpeed
+        if (this.RotationSpeed === undefined) {
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} RotationSpeed: ${this.RotationSpeed}`);
         }
-        else if (device.logging) {
-            this.deviceLogging = this.accessory.context.logging = device.logging;
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Using Device Config Logging: ${this.deviceLogging}`);
+        else {
+            this.accessory.context.RotationSpeed = this.RotationSpeed;
+            this.coolerService?.updateCharacteristic(this.hap.Characteristic.RotationSpeed, this.RotationSpeed);
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic RotationSpeed: ${this.RotationSpeed}`);
         }
-        else if (this.platform.config.options?.logging) {
-            this.deviceLogging = this.accessory.context.logging = this.platform.config.options?.logging;
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Using Platform Config Logging: ${this.deviceLogging}`);
+        // CurrentTemperature
+        if (this.CurrentTemperature === undefined) {
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentTemperature: ${this.CurrentTemperature}`);
         }
         else {
-            this.deviceLogging = this.accessory.context.logging = 'standard';
-            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Logging Not Set, Using: ${this.deviceLogging}`);
+            this.accessory.context.CurrentTemperature = this.CurrentTemperature;
+            this.coolerService?.updateCharacteristic(this.hap.Characteristic.CurrentTemperature, this.CurrentTemperature);
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic CurrentTemperature: ${this.CurrentTemperature}`);
         }
-    }
-    /**
-     * Logging for Device
-     */
-    successLog(...log) {
-        if (this.enablingDeviceLogging()) {
-            this.platform.log.success(String(...log));
+        // CurrentRelativeHumidity
+        if (this.meter) {
+            if (this.CurrentRelativeHumidity === undefined) {
+                this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentRelativeHumidity: ${this.CurrentRelativeHumidity}`);
+            }
+            else {
+                this.accessory.context.CurrentRelativeHumidity = this.CurrentRelativeHumidity;
+                this.coolerService?.updateCharacteristic(this.hap.Characteristic.CurrentRelativeHumidity, this.CurrentRelativeHumidity);
+                this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic CurrentRelativeHumidity: ${this.CurrentRelativeHumidity}`);
+            }
         }
-    }
-    infoLog(...log) {
-        if (this.enablingDeviceLogging()) {
-            this.platform.log.info(String(...log));
+        // TargetHeaterCoolerState
+        if (this.TargetHeaterCoolerState === undefined) {
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
         }
-    }
-    warnLog(...log) {
-        if (this.enablingDeviceLogging()) {
-            this.platform.log.warn(String(...log));
+        else {
+            this.accessory.context.TargetHeaterCoolerState = this.TargetHeaterCoolerState;
+            this.coolerService?.updateCharacteristic(this.hap.Characteristic.TargetHeaterCoolerState, this.TargetHeaterCoolerState);
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}` + ` updateCharacteristic TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
         }
-    }
-    debugWarnLog(...log) {
-        if (this.enablingDeviceLogging() && this.deviceLogging?.includes('debug')) {
-            this.platform.log.warn('[DEBUG]', String(...log));
+        // CurrentHeaterCoolerState
+        if (this.CurrentHeaterCoolerState === undefined) {
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
         }
-    }
-    errorLog(...log) {
-        if (this.enablingDeviceLogging()) {
-            this.platform.log.error(String(...log));
+        else {
+            this.accessory.context.CurrentHeaterCoolerState = this.CurrentHeaterCoolerState;
+            this.coolerService?.updateCharacteristic(this.hap.Characteristic.CurrentHeaterCoolerState, this.CurrentHeaterCoolerState);
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}` +
+                ` updateCharacteristic CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
         }
-    }
-    debugErrorLog(...log) {
-        if (this.enablingDeviceLogging() && this.deviceLogging?.includes('debug')) {
-            this.platform.log.error('[DEBUG]', String(...log));
+        // ThresholdTemperature
+        if (this.ThresholdTemperature === undefined) {
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} ThresholdTemperature: ${this.ThresholdTemperature}`);
         }
-    }
-    debugLog(...log) {
-        if (this.enablingDeviceLogging()) {
-            if (this.deviceLogging === 'debug') {
-                this.platform.log.info('[DEBUG]', String(...log));
-            }
-            else {
-                this.platform.log.debug(String(...log));
-            }
+        else {
+            this.accessory.context.ThresholdTemperature = this.ThresholdTemperature;
+            this.coolerService?.updateCharacteristic(this.hap.Characteristic.HeatingThresholdTemperature, this.ThresholdTemperature);
+            this.coolerService?.updateCharacteristic(this.hap.Characteristic.CoolingThresholdTemperature, this.ThresholdTemperature);
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}` + ` updateCharacteristic ThresholdTemperature: ${this.ThresholdTemperature}`);
         }
     }
-    enablingDeviceLogging() {
-        return this.deviceLogging.includes('debug') || this.deviceLogging === 'standard';
+    async apiError({ e }) {
+        this.coolerService.updateCharacteristic(this.hap.Characteristic.Active, e);
+        this.coolerService.updateCharacteristic(this.hap.Characteristic.RotationSpeed, e);
+        this.coolerService.updateCharacteristic(this.hap.Characteristic.CurrentTemperature, e);
+        this.coolerService.updateCharacteristic(this.hap.Characteristic.CurrentRelativeHumidity, e);
+        this.coolerService.updateCharacteristic(this.hap.Characteristic.TargetHeaterCoolerState, e);
+        this.coolerService.updateCharacteristic(this.hap.Characteristic.CurrentHeaterCoolerState, e);
+        this.coolerService.updateCharacteristic(this.hap.Characteristic.HeatingThresholdTemperature, e);
+        this.coolerService.updateCharacteristic(this.hap.Characteristic.CoolingThresholdTemperature, e);
     }
 }
 //# sourceMappingURL=airconditioner.js.map