@switchbot/homebridge-switchbot 2.0.0-beta.9 → 2.0.1-beta.0

package/dist/irdevice/airconditioner.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AirConditioner = void 0;
 const https_1 = __importDefault(require("https"));
 const crypto_1 = __importDefault(require("crypto"));
+const super_stringify_1 = __importDefault(require("super-stringify"));
 const settings_1 = require("../settings");
 /**
  * Platform Accessory
@@ -24,32 +25,16 @@ class AirConditioner {
         this.logs(device);
         this.config(device);
         this.pushOnChanges(device);
-        if (this.Active === undefined) {
-            this.Active = this.platform.Characteristic.Active.INACTIVE;
-        }
-        else {
-            this.Active = this.accessory.context.Active;
-        }
-        if (this.CurrentTemperature === undefined) {
-            this.CurrentTemperature = 24;
-        }
-        else {
-            this.CurrentTemperature = this.accessory.context.CurrentTemperature;
-        }
-        if (device.irair?.hide_automode) {
-            this.hide_automode = device.irair?.hide_automode;
-            this.accessory.context.hide_automode = this.hide_automode;
-        }
-        else {
-            this.hide_automode = device.irair?.hide_automode;
-            this.accessory.context.hide_automode = this.hide_automode;
-        }
+        this.context(device);
         // set accessory information
         accessory
             .getService(this.platform.Service.AccessoryInformation)
             .setCharacteristic(this.platform.Characteristic.Manufacturer, 'SwitchBot')
             .setCharacteristic(this.platform.Characteristic.Model, device.remoteType)
-            .setCharacteristic(this.platform.Characteristic.SerialNumber, device.deviceId);
+            .setCharacteristic(this.platform.Characteristic.SerialNumber, device.deviceId)
+            .setCharacteristic(this.platform.Characteristic.FirmwareRevision, this.FirmwareRevision(accessory, device))
+            .getCharacteristic(this.platform.Characteristic.FirmwareRevision)
+            .updateValue(this.FirmwareRevision(accessory, device));
         // get the Television service if it exists, otherwise create a new Television service
         // you can create multiple services for each accessory
         (this.coolerService = accessory.getService(this.platform.Service.HeaterCooler) || accessory.addService(this.platform.Service.HeaterCooler)),
@@ -75,13 +60,13 @@ class AirConditioner {
         if (this.hide_automode) {
             this.TargetHeaterCoolerState = 1 || 2;
             this.ValidValues = [1, 2];
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} ValidValues: ${JSON.stringify(this.ValidValues)},` +
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} ValidValues: ${(0, super_stringify_1.default)(this.ValidValues)},` +
                 ` hide_automode: ${this.hide_automode}, TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
         }
         else {
             this.TargetHeaterCoolerState = 0 || 1 || 2;
             this.ValidValues = [0, 1, 2];
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} ValidValues: ${JSON.stringify(this.ValidValues)},` +
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} ValidValues: ${(0, super_stringify_1.default)(this.ValidValues)},` +
                 ` hide_automode: ${this.hide_automode}, TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
         }
         this.coolerService
@@ -141,19 +126,23 @@ class AirConditioner {
      */
     async pushAirConditionerOnChanges() {
         if (this.Active !== this.platform.Characteristic.Active.ACTIVE || this.pushOn) {
-            const body = JSON.stringify({
-                'command': 'turnOn',
+            const commandType = await this.commandType();
+            const command = await this.commandOn();
+            const body = (0, super_stringify_1.default)({
+                'command': command,
                 'parameter': 'default',
-                'commandType': 'command',
+                'commandType': commandType,
             });
             await this.pushChanges(body);
         }
     }
     async pushAirConditionerOffChanges() {
-        const body = JSON.stringify({
-            'command': 'turnOff',
+        const commandType = await this.commandType();
+        const command = await this.commandOff();
+        const body = (0, super_stringify_1.default)({
+            'command': command,
             'parameter': 'default',
-            'commandType': 'command',
+            'commandType': commandType,
         });
         await this.pushChanges(body);
     }
@@ -182,22 +171,23 @@ class AirConditioner {
         }
         if (this.CurrentMode === 1) {
             this.CurrentTemperature = 25;
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} CurrentMode: ${this.CurrentMode},` + ` CurrentTemperature: ${this.CurrentTemperature}`);
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CurrentMode: ${this.CurrentMode},`
+                + ` CurrentTemperature: ${this.CurrentTemperature}`);
         }
         const parameter = `${this.CurrentTemperature},${this.CurrentMode},${this.CurrentFanSpeed},${this.state}`;
         if (this.Active === this.platform.Characteristic.Active.ACTIVE) {
             this.CurrentTemperatureUndefined();
-            if (this.CurrentTemperature < this.CurrentTemperatureCached) {
+            if (this.CurrentTemperature < this.accessory.context.CurrentTemperature) {
                 this.CurrentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.COOLING;
             }
-            else if (this.CurrentTemperature > this.CurrentTemperatureCached) {
+            else if (this.CurrentTemperature > this.accessory.context.CurrentTemperature) {
                 this.CurrentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.HEATING;
             }
         }
         else {
             this.CurrentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.INACTIVE;
         }
-        const body = JSON.stringify({
+        const body = (0, super_stringify_1.default)({
             'command': 'setAll',
             'parameter': `${parameter}`,
             'commandType': 'command',
@@ -205,161 +195,73 @@ class AirConditioner {
         await this.pushChanges(body);
     }
     async pushChanges(body) {
-        try {
-            // Make Push On request to the API
-            const t = Date.now();
-            const nonce = 'requestID';
-            const data = this.platform.config.credentials?.token + t + nonce;
-            const signTerm = crypto_1.default.createHmac('sha256', this.platform.config.credentials?.secret)
-                .update(Buffer.from(data, 'utf-8'))
-                .digest();
-            const sign = signTerm.toString('base64');
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} sign: ${sign}`);
-            this.infoLog(`Air Conditioner: ${this.accessory.displayName} Sending request to SwitchBot API. body: ${body},`);
-            const options = {
-                hostname: settings_1.HostDomain,
-                port: 443,
-                path: `${settings_1.DevicePath}/${this.device.deviceId}/commands`,
-                method: 'POST',
-                headers: {
-                    'Authorization': this.platform.config.credentials?.token,
-                    'sign': sign,
-                    'nonce': nonce,
-                    't': t,
-                    'Content-Type': 'application/json',
-                    'Content-Length': body.length,
-                },
-            };
-            const req = https_1.default.request(options, res => {
-                this.debugLog(`Air Conditioner: ${this.accessory.displayName} statusCode: ${res.statusCode}`);
-                this.statusCode({ res });
-                res.on('data', d => {
-                    this.debugLog(`Air Conditioner: ${this.accessory.displayName} d: ${d}`);
+        if (this.device.connectionType === 'OpenAPI') {
+            try {
+                // Make Push On request to the API
+                const t = Date.now();
+                const nonce = 'requestID';
+                const data = this.platform.config.credentials?.token + t + nonce;
+                const signTerm = crypto_1.default.createHmac('sha256', this.platform.config.credentials?.secret)
+                    .update(Buffer.from(data, 'utf-8'))
+                    .digest();
+                const sign = signTerm.toString('base64');
+                this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} sign: ${sign}`);
+                this.infoLog(`${this.device.remoteType}: ${this.accessory.displayName} Sending request to SwitchBot API. body: ${body},`);
+                const options = {
+                    hostname: settings_1.HostDomain,
+                    port: 443,
+                    path: `${settings_1.DevicePath}/${this.device.deviceId}/commands`,
+                    method: 'POST',
+                    headers: {
+                        'Authorization': this.platform.config.credentials?.token,
+                        'sign': sign,
+                        'nonce': nonce,
+                        't': t,
+                        'Content-Type': 'application/json',
+                        'Content-Length': body.length,
+                    },
+                };
+                const req = https_1.default.request(options, res => {
+                    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushchanges statusCode: ${res.statusCode}`);
+                    this.statusCode({ res });
+                    res.on('data', d => {
+                        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} d: ${d}`);
+                    });
                 });
-            });
-            req.on('error', (e) => {
-                this.errorLog(`Air Conditioner: ${this.accessory.displayName} error message: ${e.message}`);
-            });
-            req.write(body);
-            req.end();
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} pushchanges: ${JSON.stringify(req)}`);
-            this.CurrentTemperatureCached = this.CurrentTemperature;
-            this.accessory.context.CurrentTemperature = this.CurrentTemperatureCached;
-            this.HeatingThresholdTemperature = this.CurrentTemperatureCached;
-            this.HeatingThresholdTemperatureCached = this.CurrentTemperatureCached;
-            this.accessory.context.HeatingThresholdTemperature = this.HeatingThresholdTemperatureCached;
-            this.CoolingThresholdTemperature = this.CurrentTemperatureCached;
-            this.CoolingThresholdTemperatureCached = this.CurrentTemperatureCached;
-            this.accessory.context.CoolingThresholdTemperature = this.CoolingThresholdTemperatureCached;
-            this.updateHomeKitCharacteristics();
-        }
-        catch (e) {
-            this.errorLog(`Air Conditioner: ${this.accessory.displayName} failed pushChanges`);
-            if (this.deviceLogging.includes('debug')) {
-                this.errorLog(`Air Conditioner: ${this.accessory.displayName} failed pushChanges,` + ` Error Message: ${JSON.stringify(e.message)}`);
+                req.on('error', (e) => {
+                    this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} error message: ${e.message}`);
+                });
+                req.write(body);
+                req.end();
+                this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushchanges: ${(0, super_stringify_1.default)(req)}`);
+                this.accessory.context.CurrentTemperature = this.CurrentTemperature;
+                this.HeatingThresholdTemperature = this.CurrentTemperature;
+                this.CoolingThresholdTemperature = this.CurrentTemperature;
+                this.accessory.context.HeatingThresholdTemperature = this.HeatingThresholdTemperature;
+                this.accessory.context.CoolingThresholdTemperature = this.CoolingThresholdTemperature;
+                this.updateHomeKitCharacteristics();
+            }
+            catch (e) {
+                this.apiError(e);
+                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} failed pushChanges with ${this.device.connectionType} Connection,`
+                    + ` Error Message: ${(0, super_stringify_1.default)(e.message)}`);
             }
-            this.apiError(e);
-        }
-    }
-    async statusCode({ res }) {
-        switch (res.statusCode) {
-            case 151:
-                this.errorLog(`Air Conditioner: ${this.accessory.displayName} Command not supported by this device type.`);
-                break;
-            case 152:
-                this.errorLog(`Air Conditioner: ${this.accessory.displayName} Device not found.`);
-                break;
-            case 160:
-                this.errorLog(`Air Conditioner: ${this.accessory.displayName} Command is not supported.`);
-                break;
-            case 161:
-                this.errorLog(`Air Conditioner: ${this.accessory.displayName} Device is offline.`);
-                break;
-            case 171:
-                this.errorLog(`Air Conditioner: ${this.accessory.displayName} Hub Device is offline. Hub: ${this.device.hubDeviceId}`);
-                break;
-            case 190:
-                this.errorLog(`Air Conditioner: ${this.accessory.displayName} Device internal error due to device states not synchronized` +
-                    ` with server, Or command: ${JSON.stringify(res)} format is invalid`);
-                break;
-            case 100:
-                this.debugLog(`Air Conditioner: ${this.accessory.displayName} Command successfully sent.`);
-                break;
-            default:
-                this.debugLog(`Air Conditioner: ${this.accessory.displayName} Unknown statusCode.`);
-        }
-    }
-    async updateHomeKitCharacteristics() {
-        if (this.Active === undefined) {
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} Active: ${this.Active}`);
-        }
-        else {
-            this.coolerService?.updateCharacteristic(this.platform.Characteristic.Active, this.Active);
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} updateCharacteristic Active: ${this.Active}`);
-        }
-        if (this.RotationSpeed === undefined) {
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} RotationSpeed: ${this.RotationSpeed}`);
-        }
-        else {
-            this.coolerService?.updateCharacteristic(this.platform.Characteristic.RotationSpeed, this.RotationSpeed);
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} updateCharacteristic RotationSpeed: ${this.RotationSpeed}`);
-        }
-        if (this.CurrentTemperature === undefined) {
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} CurrentTemperature: ${this.CurrentTemperature}`);
-        }
-        else {
-            this.coolerService?.updateCharacteristic(this.platform.Characteristic.CurrentTemperature, this.CurrentTemperature);
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} updateCharacteristic CurrentTemperature: ${this.CurrentTemperature}`);
-        }
-        if (this.TargetHeaterCoolerState === undefined) {
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
-        }
-        else {
-            this.coolerService?.updateCharacteristic(this.platform.Characteristic.TargetHeaterCoolerState, this.TargetHeaterCoolerState);
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName}` + ` updateCharacteristic TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
-        }
-        if (this.CurrentHeaterCoolerState === undefined) {
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
-        }
-        else {
-            this.coolerService?.updateCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState, this.CurrentHeaterCoolerState);
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName}` + ` updateCharacteristic CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
-        }
-        if (this.HeatingThresholdTemperature === undefined) {
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} HeatingThresholdTemperature: ${this.HeatingThresholdTemperature}`);
-        }
-        else {
-            this.coolerService?.updateCharacteristic(this.platform.Characteristic.HeatingThresholdTemperature, this.HeatingThresholdTemperature);
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName}` + ` updateCharacteristic HeatingThresholdTemperature: ${this.HeatingThresholdTemperature}`);
-        }
-        if (this.CoolingThresholdTemperature === undefined) {
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} CoolingThresholdTemperature: ${this.CoolingThresholdTemperature}`);
         }
         else {
-            this.coolerService?.updateCharacteristic(this.platform.Characteristic.CoolingThresholdTemperature, this.CoolingThresholdTemperature);
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName}` + ` updateCharacteristic CoolingThresholdTemperature: ${this.CoolingThresholdTemperature}`);
+            this.warnLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+                + ` Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`);
         }
     }
-    async apiError(e) {
-        this.coolerService.updateCharacteristic(this.platform.Characteristic.Active, e);
-        this.coolerService.updateCharacteristic(this.platform.Characteristic.RotationSpeed, e);
-        this.coolerService.updateCharacteristic(this.platform.Characteristic.CurrentTemperature, e);
-        this.coolerService.updateCharacteristic(this.platform.Characteristic.TargetHeaterCoolerState, e);
-        this.coolerService.updateCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState, e);
-        this.coolerService.updateCharacteristic(this.platform.Characteristic.HeatingThresholdTemperature, e);
-        this.coolerService.updateCharacteristic(this.platform.Characteristic.CoolingThresholdTemperature, e);
-        //throw new this.platform.api.hap.HapStatusError(HAPStatus.SERVICE_COMMUNICATION_FAILURE);
-    }
     async CurrentTemperatureGet() {
         if (this.CurrentTemperature === undefined) {
             this.CurrentTemperature = 24;
-            this.CurrentTemperatureCached = this.CurrentTemperature;
+            this.accessory.context.CurrentTemperature = this.CurrentTemperature;
         }
         else {
-            this.CurrentTemperatureCached = this.CurrentTemperature;
+            this.accessory.context.CurrentTemperature = this.CurrentTemperature;
         }
-        this.debugLog(`Air Conditioner: ${this.accessory.displayName} Get CurrentTemperature: ${this.CurrentTemperature}`);
-        this.accessory.context.CurrentTemperature = this.CurrentTemperatureCached;
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get CurrentTemperature: ${this.CurrentTemperature}`);
+        this.accessory.context.CurrentTemperature = this.CurrentTemperature;
         return this.CurrentTemperature;
     }
     async RotationSpeedGet() {
@@ -372,9 +274,8 @@ class AirConditioner {
         else {
             this.RotationSpeed = this.CurrentFanSpeed - 1;
         }
-        this.debugLog(`Air Conditioner: ${this.accessory.displayName} Get RotationSpeed: ${this.RotationSpeed}`);
-        this.RotationSpeedCached = this.RotationSpeed;
-        this.accessory.context.RotationSpeed = this.RotationSpeedCached;
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get RotationSpeed: ${this.RotationSpeed}`);
+        this.accessory.context.RotationSpeed = this.RotationSpeed;
         return this.RotationSpeed;
     }
     async RotationSpeedSet(value) {
@@ -385,21 +286,19 @@ class AirConditioner {
             this.CurrentFanSpeed = Number(value) + 1;
         }
         this.RotationSpeed = this.CurrentFanSpeed;
-        this.RotationSpeedCached = this.RotationSpeed;
-        this.accessory.context.RotationSpeed = this.RotationSpeedCached;
+        this.accessory.context.RotationSpeed = this.RotationSpeed;
         this.pushAirConditionerStatusChanges();
     }
     async ActiveSet(value) {
-        this.debugLog(`Air Conditioner: ${this.accessory.displayName} Set Active: ${value}`);
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set Active: ${value}`);
         this.Active = value;
-        this.ActiveCached = this.Active;
-        this.accessory.context.Active = this.ActiveCached;
+        this.accessory.context.Active = this.Active;
         if (value === this.platform.Characteristic.Active.INACTIVE) {
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} pushAirConditionerOffChanges, Active: ${this.Active}`);
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerOffChanges, Active: ${this.Active}`);
             this.pushAirConditionerOffChanges();
         }
         else {
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} pushAirConditionerOnChanges, Active: ${this.Active}`);
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerOnChanges, Active: ${this.Active}`);
             if (this.pushOn) {
                 this.pushAirConditionerOnChanges();
             }
@@ -411,21 +310,20 @@ class AirConditioner {
     async TargetHeaterCoolerStateGet() {
         if (this.ValidValues === this.valid012) {
             this.TargetHeaterCoolerState = this.platform.Characteristic.TargetHeaterCoolerState.AUTO;
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} Get (AUTO) TargetHeaterCoolerState: ${this.CurrentHeaterCoolerState},` +
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get (AUTO) TargetHeaterCoolerState: ${this.CurrentHeaterCoolerState},` +
                 ` ValidValues: ${this.ValidValues}`);
         }
         else if (this.ValidValues === this.valid12) {
             this.TargetHeaterCoolerState =
                 this.platform.Characteristic.TargetHeaterCoolerState.COOL || this.platform.Characteristic.TargetHeaterCoolerState.HEAT;
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} Get (COOL/HEAT) TargetHeaterCoolerState: ${this.CurrentHeaterCoolerState},` +
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get (COOL/HEAT) TargetHeaterCoolerState: ${this.CurrentHeaterCoolerState},` +
                 ` ValidValues: ${this.ValidValues}`);
         }
         else {
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} Get TargetHeaterCoolerState: ${this.CurrentHeaterCoolerState},` +
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get TargetHeaterCoolerState: ${this.CurrentHeaterCoolerState},` +
                 ` ValidValues: ${this.ValidValues}`);
         }
-        this.TargetHeaterCoolerStateCached = this.TargetHeaterCoolerState;
-        this.accessory.context.TargetHeaterCoolerState = this.TargetHeaterCoolerStateCached;
+        this.accessory.context.TargetHeaterCoolerState = this.TargetHeaterCoolerState;
         return this.TargetHeaterCoolerState;
     }
     async TargetHeaterCoolerStateSet(value) {
@@ -437,7 +335,7 @@ class AirConditioner {
                 this.TargetHeaterCoolerStateCOOL();
             }
             else {
-                this.errorLog(`Air Conditioner: ${this.accessory.displayName} Set TargetHeaterCoolerState: ${this.TargetHeaterCoolerState},` +
+                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Set TargetHeaterCoolerState: ${this.TargetHeaterCoolerState},` +
                     ` hide_automode: ${this.hide_automode} `);
             }
         }
@@ -452,96 +350,260 @@ class AirConditioner {
                 this.TargetHeaterCoolerStateCOOL();
             }
             else {
-                this.errorLog(`Air Conditioner: ${this.accessory.displayName} Set TargetHeaterCoolerState: ${this.TargetHeaterCoolerState},` +
+                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Set TargetHeaterCoolerState: ${this.TargetHeaterCoolerState},` +
                     ` hide_automode: ${this.hide_automode} `);
             }
         }
-        this.TargetHeaterCoolerStateCached = this.TargetHeaterCoolerState;
-        this.accessory.context.TargetHeaterCoolerState = this.TargetHeaterCoolerStateCached;
+        this.accessory.context.TargetHeaterCoolerState = this.TargetHeaterCoolerState;
         this.pushAirConditionerStatusChanges();
     }
     async TargetHeaterCoolerStateAUTO() {
         this.TargetHeaterCoolerState = this.platform.Characteristic.TargetHeaterCoolerState.AUTO;
         this.CurrentMode = 1;
-        this.debugLog(`Air Conditioner: ${this.accessory.displayName} Set (AUTO) TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
-        this.debugLog(`Air Conditioner: ${this.accessory.displayName} Switchbot CurrentMode: ${this.CurrentMode}`);
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set (AUTO) TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Switchbot CurrentMode: ${this.CurrentMode}`);
     }
     async TargetHeaterCoolerStateCOOL() {
         this.TargetHeaterCoolerState = this.platform.Characteristic.TargetHeaterCoolerState.COOL;
         this.CurrentMode = 2;
-        this.debugLog(`Air Conditioner: ${this.accessory.displayName} Set (COOL) TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
-        this.debugLog(`Air Conditioner: ${this.accessory.displayName} Switchbot CurrentMode: ${this.CurrentMode}`);
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set (COOL) TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Switchbot CurrentMode: ${this.CurrentMode}`);
     }
     async TargetHeaterCoolerStateHEAT() {
         this.TargetHeaterCoolerState = this.platform.Characteristic.TargetHeaterCoolerState.HEAT;
         this.CurrentMode = 5;
-        this.debugLog(`Air Conditioner: ${this.accessory.displayName} Set (HEAT) TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
-        this.debugLog(`Air Conditioner: ${this.accessory.displayName} Switchbot CurrentMode: ${this.CurrentMode}`);
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set (HEAT) TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Switchbot CurrentMode: ${this.CurrentMode}`);
     }
     async CurrentHeaterCoolerStateGet() {
         if (this.Active === this.platform.Characteristic.Active.ACTIVE) {
             this.CurrentTemperatureUndefined();
-            if (this.CurrentTemperature < this.CurrentTemperatureCached) {
+            if (this.CurrentTemperature < this.accessory.context.CurrentTemperature) {
                 this.CurrentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.COOLING;
-                this.debugLog(`Air Conditioner: ${this.accessory.displayName} Get (COOLLING) CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
+                this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+                    + ` Get (COOLLING) CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
             }
-            else if (this.CurrentTemperature > this.CurrentTemperatureCached) {
+            else if (this.CurrentTemperature > this.accessory.context.CurrentTemperature) {
                 this.CurrentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.HEATING;
-                this.debugLog(`Air Conditioner: ${this.accessory.displayName} Get (HEATING) CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
+                this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+                    + ` Get (HEATING) CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
             }
         }
         else {
             this.CurrentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.INACTIVE;
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} Get (INACTIVE) CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+                + ` Get (INACTIVE) CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
         }
-        this.CurrentHeaterCoolerStateCached = this.CurrentHeaterCoolerState;
-        this.accessory.context.CurrentHeaterCoolerState = this.CurrentHeaterCoolerStateCached;
+        this.accessory.context.CurrentHeaterCoolerState = this.CurrentHeaterCoolerState;
         return this.CurrentHeaterCoolerState;
     }
     async HeatingThresholdTemperatureGet() {
         this.CurrentTemperatureUndefined;
-        this.CurrentTemperature = this.CurrentTemperatureCached;
-        this.HeatingThresholdTemperature = this.CurrentTemperatureCached;
-        this.HeatingThresholdTemperatureCached = this.HeatingThresholdTemperature;
-        this.accessory.context.HeatingThresholdTemperature = this.HeatingThresholdTemperatureCached;
-        this.debugLog(`Air Conditioner: ${this.accessory.displayName} Get HeatingThresholdTemperature: ${this.HeatingThresholdTemperature}`);
+        this.CurrentTemperature = this.accessory.context.CurrentTemperature;
+        this.HeatingThresholdTemperature = this.accessory.context.CurrentTemperature;
+        this.accessory.context.HeatingThresholdTemperature = this.HeatingThresholdTemperature;
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get HeatingThresholdTemperature: ${this.HeatingThresholdTemperature}`);
         return this.HeatingThresholdTemperature;
     }
     async HeatingThresholdTemperatureSet(value) {
-        this.CurrentTemperatureCached = this.CurrentTemperature;
+        this.accessory.context.CurrentTemperature = this.CurrentTemperature;
         this.CurrentTemperature = value;
-        this.HeatingThresholdTemperatureCached = this.HeatingThresholdTemperature;
-        this.accessory.context.HeatingThresholdTemperature = this.HeatingThresholdTemperatureCached;
-        this.debugLog(`Air Conditioner: ${this.accessory.displayName} Set HeatingThresholdTemperature: ${this.HeatingThresholdTemperature},` +
-            ` CurrentTemperatureCached: ${this.CurrentTemperatureCached}`);
+        this.accessory.context.HeatingThresholdTemperature = this.HeatingThresholdTemperature;
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set HeatingThresholdTemperature: ${this.HeatingThresholdTemperature},` +
+            ` CurrentTemperatureCached: ${this.accessory.context.CurrentTemperature}`);
         this.pushAirConditionerStatusChanges();
     }
     async CoolingThresholdTemperatureGet() {
         this.CurrentTemperatureUndefined;
-        this.CurrentTemperature = this.CurrentTemperatureCached;
-        this.CoolingThresholdTemperature = this.CurrentTemperatureCached;
-        this.CoolingThresholdTemperatureCached = this.CoolingThresholdTemperature;
-        this.accessory.context.CoolingThresholdTemperature = this.CoolingThresholdTemperatureCached;
-        this.debugLog(`Air Conditioner: ${this.accessory.displayName} Get CoolingThresholdTemperature: ${this.CoolingThresholdTemperature}`);
+        this.CurrentTemperature = this.accessory.context.CurrentTemperature;
+        this.CoolingThresholdTemperature = this.accessory.context.CurrentTemperature;
+        this.accessory.context.CoolingThresholdTemperature = this.CoolingThresholdTemperature;
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get CoolingThresholdTemperature: ${this.CoolingThresholdTemperature}`);
         return this.CoolingThresholdTemperature;
     }
     async CoolingThresholdTemperatureSet(value) {
-        this.CurrentTemperatureCached = this.CurrentTemperature;
+        this.accessory.context.CurrentTemperature = this.CurrentTemperature;
         this.CurrentTemperature = value;
-        this.CoolingThresholdTemperatureCached = this.CoolingThresholdTemperature;
-        this.accessory.context.CoolingThresholdTemperature = this.CoolingThresholdTemperatureCached;
-        this.debugLog(`Air Conditioner: ${this.accessory.displayName} Set CoolingThresholdTemperature: ${this.CoolingThresholdTemperature},` +
-            ` CurrentTemperatureCached: ${this.CurrentTemperatureCached}`);
+        this.accessory.context.CoolingThresholdTemperature = this.CoolingThresholdTemperature;
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set CoolingThresholdTemperature: ${this.CoolingThresholdTemperature},` +
+            ` CurrentTemperatureCached: ${this.accessory.context.CurrentTemperature}`);
         this.pushAirConditionerStatusChanges();
     }
     async CurrentTemperatureUndefined() {
         if (this.CurrentTemperature === undefined) {
             this.CurrentTemperature = 24;
         }
-        if (this.CurrentTemperatureCached === undefined) {
+        if (this.accessory.context.CurrentTemperature === undefined) {
             this.CurrentTemperature = 30;
         }
     }
+    async updateHomeKitCharacteristics() {
+        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.platform.Characteristic.Active, this.Active);
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic Active: ${this.Active}`);
+        }
+        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.platform.Characteristic.RotationSpeed, this.RotationSpeed);
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic RotationSpeed: ${this.RotationSpeed}`);
+        }
+        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.platform.Characteristic.CurrentTemperature, this.CurrentTemperature);
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} updateCharacteristic CurrentTemperature: ${this.CurrentTemperature}`);
+        }
+        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.platform.Characteristic.TargetHeaterCoolerState, this.TargetHeaterCoolerState);
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}` + ` updateCharacteristic TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
+        }
+        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.platform.Characteristic.CurrentHeaterCoolerState, this.CurrentHeaterCoolerState);
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+                + ` updateCharacteristic CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
+        }
+        if (this.HeatingThresholdTemperature === undefined) {
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} HeatingThresholdTemperature: ${this.HeatingThresholdTemperature}`);
+        }
+        else {
+            this.accessory.context.HeatingThresholdTemperature = this.HeatingThresholdTemperature;
+            this.coolerService?.updateCharacteristic(this.platform.Characteristic.HeatingThresholdTemperature, this.HeatingThresholdTemperature);
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+                + ` updateCharacteristic HeatingThresholdTemperature: ${this.HeatingThresholdTemperature}`);
+        }
+        if (this.CoolingThresholdTemperature === undefined) {
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} CoolingThresholdTemperature: ${this.CoolingThresholdTemperature}`);
+        }
+        else {
+            this.accessory.context.CoolingThresholdTemperature = this.CoolingThresholdTemperature;
+            this.coolerService?.updateCharacteristic(this.platform.Characteristic.CoolingThresholdTemperature, this.CoolingThresholdTemperature);
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+                + ` updateCharacteristic CoolingThresholdTemperature: ${this.CoolingThresholdTemperature}`);
+        }
+    }
+    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.customOn) {
+            command = this.device.customOn;
+        }
+        else {
+            command = 'turnOff';
+        }
+        return command;
+    }
+    async statusCode({ res }) {
+        switch (res.statusCode) {
+            case 151:
+                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Command not supported by this device type.`);
+                break;
+            case 152:
+                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Device not found.`);
+                break;
+            case 160:
+                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Command is not supported.`);
+                break;
+            case 161:
+                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Device is offline.`);
+                break;
+            case 171:
+                this.errorLog(`${this.device.remoteType}: ${this.accessory.displayName} Hub Device is offline. 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: ${(0, super_stringify_1.default)(res)} format is invalid`);
+                break;
+            case 100:
+                this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Command successfully sent.`);
+                break;
+            default:
+                this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Unknown statusCode.`);
+        }
+    }
+    async apiError(e) {
+        this.coolerService.updateCharacteristic(this.platform.Characteristic.Active, e);
+        this.coolerService.updateCharacteristic(this.platform.Characteristic.RotationSpeed, e);
+        this.coolerService.updateCharacteristic(this.platform.Characteristic.CurrentTemperature, e);
+        this.coolerService.updateCharacteristic(this.platform.Characteristic.TargetHeaterCoolerState, e);
+        this.coolerService.updateCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState, e);
+        this.coolerService.updateCharacteristic(this.platform.Characteristic.HeatingThresholdTemperature, e);
+        this.coolerService.updateCharacteristic(this.platform.Characteristic.CoolingThresholdTemperature, e);
+    }
+    FirmwareRevision(accessory, device) {
+        let FirmwareRevision;
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+            + ` accessory.context.FirmwareRevision: ${accessory.context.FirmwareRevision}`);
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} device.firmware: ${device.firmware}`);
+        this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} this.platform.version: ${this.platform.version}`);
+        if (accessory.context.FirmwareRevision) {
+            FirmwareRevision = accessory.context.FirmwareRevision;
+        }
+        else if (device.firmware) {
+            FirmwareRevision = device.firmware;
+        }
+        else {
+            FirmwareRevision = this.platform.version;
+        }
+        return FirmwareRevision;
+    }
+    async context(device) {
+        if (this.Active === undefined) {
+            this.Active = this.platform.Characteristic.Active.INACTIVE;
+        }
+        else {
+            this.Active = this.accessory.context.Active;
+        }
+        if (this.CurrentTemperature === undefined) {
+            this.CurrentTemperature = 24;
+        }
+        else {
+            this.CurrentTemperature = this.accessory.context.CurrentTemperature;
+        }
+        if (device.irair?.hide_automode) {
+            this.hide_automode = device.irair?.hide_automode;
+            this.accessory.context.hide_automode = this.hide_automode;
+        }
+        else {
+            this.hide_automode = device.irair?.hide_automode;
+            this.accessory.context.hide_automode = this.hide_automode;
+        }
+    }
     async config(device) {
         let config = {};
         if (device.irair) {
@@ -550,26 +612,32 @@ class AirConditioner {
         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 (Object.entries(config).length !== 0) {
-            this.infoLog(`Air Conditioner: ${this.accessory.displayName} Config: ${JSON.stringify(config)}`);
+            this.infoLog(`${this.device.remoteType}: ${this.accessory.displayName} Config: ${(0, super_stringify_1.default)(config)}`);
         }
     }
     async logs(device) {
         if (this.platform.debugMode) {
             this.deviceLogging = this.accessory.context.logging = 'debugMode';
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} Using Debug Mode Logging: ${this.deviceLogging}`);
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Using Debug Mode Logging: ${this.deviceLogging}`);
         }
         else if (device.logging) {
             this.deviceLogging = this.accessory.context.logging = device.logging;
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} Using Device Config Logging: ${this.deviceLogging}`);
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Using Device Config Logging: ${this.deviceLogging}`);
         }
         else if (this.platform.config.options?.logging) {
             this.deviceLogging = this.accessory.context.logging = this.platform.config.options?.logging;
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} Using Platform Config Logging: ${this.deviceLogging}`);
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Using Platform Config Logging: ${this.deviceLogging}`);
         }
         else {
             this.deviceLogging = this.accessory.context.logging = 'standard';
-            this.debugLog(`Air Conditioner: ${this.accessory.displayName} Logging Not Set, Using: ${this.deviceLogging}`);
+            this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Logging Not Set, Using: ${this.deviceLogging}`);
         }
     }
     async pushOnChanges(device) {
@@ -593,11 +661,25 @@ class AirConditioner {
             this.platform.log.warn(String(...log));
         }
     }
+    debugWarnLog(...log) {
+        if (this.enablingDeviceLogging()) {
+            if (this.deviceLogging?.includes('debug')) {
+                this.platform.log.warn('[DEBUG]', String(...log));
+            }
+        }
+    }
     errorLog(...log) {
         if (this.enablingDeviceLogging()) {
             this.platform.log.error(String(...log));
         }
     }
+    debugErrorLog(...log) {
+        if (this.enablingDeviceLogging()) {
+            if (this.deviceLogging?.includes('debug')) {
+                this.platform.log.error('[DEBUG]', String(...log));
+            }
+        }
+    }
     debugLog(...log) {
         if (this.enablingDeviceLogging()) {
             if (this.deviceLogging === 'debug') {