@switchbot/homebridge-switchbot 1.8.3-beta.0 → 1.10.1-beta.0

package/src/irdevices/airconditioners.ts

@@ -1,7 +1,7 @@
-import { AxiosResponse } from "axios";
-import { SwitchBotPlatform } from "../platform";
-import { irDevicesConfig, DeviceURL, irdevice, payload } from "../settings";
-import { CharacteristicValue, PlatformAccessory, Service } from "homebridge";
+import { AxiosResponse } from 'axios';
+import { SwitchBotPlatform } from '../platform';
+import { irDevicesConfig, DeviceURL, irdevice, payload } from '../settings';
+import { CharacteristicValue, PlatformAccessory, Service } from 'homebridge';
 
 /**
  * Platform Accessory
@@ -42,15 +42,13 @@ export class AirConditioner {
   // Config
   deviceLogging!: string;
   hide_automode?: boolean;
+  pushOn?: boolean;
 
-  constructor(
-    private readonly platform: SwitchBotPlatform,
-    private accessory: PlatformAccessory,
-    public device: irdevice & irDevicesConfig,
-  ) {
+  constructor(private readonly platform: SwitchBotPlatform, private accessory: PlatformAccessory, public device: irdevice & irDevicesConfig) {
     // default placeholders
     this.logs(device);
     this.config(device);
+    this.pushOnChanges(device);
     if (this.Active === undefined) {
       this.Active = this.platform.Characteristic.Active.INACTIVE;
     } else {
@@ -72,18 +70,13 @@ export class AirConditioner {
     // set accessory information
     accessory
       .getService(this.platform.Service.AccessoryInformation)!
-      .setCharacteristic(this.platform.Characteristic.Manufacturer, "SwitchBot")
+      .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!);
 
     // get the Television service if it exists, otherwise create a new Television service
     // you can create multiple services for each accessory
-    (this.service =
-      accessory.getService(this.platform.Service.HeaterCooler) ||
-      accessory.addService(this.platform.Service.HeaterCooler)),
+    (this.service = accessory.getService(this.platform.Service.HeaterCooler) || accessory.addService(this.platform.Service.HeaterCooler)),
     `${accessory.displayName} Air Conditioner`;
 
     // To avoid "Cannot add a Service with the same UUID another Service without also defining a unique 'subtype' property." error,
@@ -92,15 +85,10 @@ export class AirConditioner {
 
     // set the service name, this is what is displayed as the default name on the Home app
     // in this example we are using the name we stored in the `accessory.context` in the `discoverDevices` method.
-    this.service.setCharacteristic(
-      this.platform.Characteristic.Name,
-      accessory.displayName,
-    );
+    this.service.setCharacteristic(this.platform.Characteristic.Name, accessory.displayName);
 
     // handle on / off events using the Active characteristic
-    this.service
-      .getCharacteristic(this.platform.Characteristic.Active)
-      .onSet(this.ActiveSet.bind(this));
+    this.service.getCharacteristic(this.platform.Characteristic.Active).onSet(this.ActiveSet.bind(this));
 
     this.service
       .getCharacteristic(this.platform.Characteristic.CurrentTemperature)
@@ -117,18 +105,14 @@ export class AirConditioner {
       this.TargetHeaterCoolerState = 1 || 2;
       this.ValidValues = [1, 2];
       this.debugLog(
-        `Air Conditioner: ${
-          this.accessory.displayName
-        } ValidValues: ${JSON.stringify(this.ValidValues)},` +
+        `Air Conditioner: ${this.accessory.displayName} ValidValues: ${JSON.stringify(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)},` +
+        `Air Conditioner: ${this.accessory.displayName} ValidValues: ${JSON.stringify(this.ValidValues)},` +
           ` hide_automode: ${this.hide_automode}, TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`,
       );
     }
@@ -142,16 +126,12 @@ export class AirConditioner {
       })
       .onSet(this.TargetHeaterCoolerStateSet.bind(this));
 
-    this.service
-      .getCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState)
-      .onGet(async () => {
-        return this.CurrentHeaterCoolerStateGet();
-      });
+    this.service.getCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState).onGet(async () => {
+      return this.CurrentHeaterCoolerStateGet();
+    });
 
     this.service
-      .getCharacteristic(
-        this.platform.Characteristic.HeatingThresholdTemperature,
-      )
+      .getCharacteristic(this.platform.Characteristic.HeatingThresholdTemperature)
       .setProps({
         minValue: 16,
         maxValue: 30,
@@ -163,9 +143,7 @@ export class AirConditioner {
       .onSet(this.HeatingThresholdTemperatureSet.bind(this));
 
     this.service
-      .getCharacteristic(
-        this.platform.Characteristic.CoolingThresholdTemperature,
-      )
+      .getCharacteristic(this.platform.Characteristic.CoolingThresholdTemperature)
       .setProps({
         minValue: 16,
         maxValue: 30,
@@ -198,8 +176,8 @@ export class AirConditioner {
    * AirConditioner:        "command"       "middleSpeed"    "default"	        =        fan speed to medium
    * AirConditioner:        "command"       "highSpeed"      "default"	        =        fan speed to high
    */
-  /*async pushAirConditionerOnChanges() {
-    if (this.Active !== this.platform.Characteristic.Active.ACTIVE) {
+  async pushAirConditionerOnChanges() {
+    if (this.Active !== this.platform.Characteristic.Active.ACTIVE || this.pushOn) {
       const payload = {
         commandType: 'command',
         parameter: 'default',
@@ -207,13 +185,13 @@ export class AirConditioner {
       } as any;
       await this.pushChanges(payload);
     }
-  }*/
+  }
 
   async pushAirConditionerOffChanges() {
     const payload = {
-      commandType: "command",
-      parameter: "default",
-      command: "turnOff",
+      commandType: 'command',
+      parameter: 'default',
+      command: 'turnOff',
     } as any;
     await this.pushChanges(payload);
   }
@@ -221,22 +199,18 @@ export class AirConditioner {
   async pushAirConditionerStatusChanges() {
     if (!this.Busy) {
       this.Busy = true;
-      this.CurrentHeaterCoolerState =
-        this.platform.Characteristic.CurrentHeaterCoolerState.IDLE;
+      this.CurrentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.IDLE;
     }
     clearTimeout(this.Timeout);
 
     // Make a new Timeout set to go off in 1000ms (1 second)
-    this.Timeout = setTimeout(
-      this.pushAirConditionerDetailsChanges.bind(this),
-      1500,
-    );
+    this.Timeout = setTimeout(this.pushAirConditionerDetailsChanges.bind(this), 1500);
   }
 
   async pushAirConditionerDetailsChanges() {
     const payload = {
-      commandType: "command",
-      command: "setAll",
+      commandType: 'command',
+      command: 'setAll',
     } as any;
 
     this.CurrentTemperatureUndefined();
@@ -247,15 +221,14 @@ export class AirConditioner {
       this.CurrentFanSpeed = 1;
     }
     if (this.Active === this.platform.Characteristic.Active.ACTIVE) {
-      this.state = "on";
+      this.state = 'on';
     } else {
-      this.state = "off";
+      this.state = 'off';
     }
     if (this.CurrentMode === 1) {
       this.CurrentTemperature = 25;
       this.debugLog(
-        `Air Conditioner: ${this.accessory.displayName} CurrentMode: ${this.CurrentMode},` +
-          ` CurrentTemperature: ${this.CurrentTemperature}`,
+        `Air Conditioner: ${this.accessory.displayName} CurrentMode: ${this.CurrentMode},` + ` CurrentTemperature: ${this.CurrentTemperature}`,
       );
     }
     payload.parameter = `${this.CurrentTemperature},${this.CurrentMode},${this.CurrentFanSpeed},${this.state}`;
@@ -263,15 +236,12 @@ export class AirConditioner {
     if (this.Active === this.platform.Characteristic.Active.ACTIVE) {
       this.CurrentTemperatureUndefined();
       if (this.CurrentTemperature < this.CurrentTemperatureCached) {
-        this.CurrentHeaterCoolerState =
-          this.platform.Characteristic.CurrentHeaterCoolerState.COOLING;
+        this.CurrentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.COOLING;
       } else if (this.CurrentTemperature > this.CurrentTemperatureCached) {
-        this.CurrentHeaterCoolerState =
-          this.platform.Characteristic.CurrentHeaterCoolerState.HEATING;
+        this.CurrentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.HEATING;
       }
     } else {
-      this.CurrentHeaterCoolerState =
-        this.platform.Characteristic.CurrentHeaterCoolerState.INACTIVE;
+      this.CurrentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.INACTIVE;
     }
 
     await this.pushChanges(payload);
@@ -285,42 +255,25 @@ export class AirConditioner {
       );
 
       // Make the API request
-      const push: any = await this.platform.axios.post(
-        `${DeviceURL}/${this.device.deviceId}/commands`,
-        payload,
-      );
-      this.debugLog(
-        `Air Conditioner: ${
-          this.accessory.displayName
-        } pushChanges: ${JSON.stringify(push.data)}`,
-      );
+      const push: any = await this.platform.axios.post(`${DeviceURL}/${this.device.deviceId}/commands`, payload);
+      this.debugLog(`Air Conditioner: ${this.accessory.displayName} pushChanges: ${JSON.stringify(push.data)}`);
       this.statusCode(push);
       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.accessory.context.HeatingThresholdTemperature = this.HeatingThresholdTemperatureCached;
       this.CoolingThresholdTemperature = this.CurrentTemperatureCached;
       this.CoolingThresholdTemperatureCached = this.CurrentTemperatureCached;
-      this.accessory.context.CoolingThresholdTemperature =
-        this.CoolingThresholdTemperatureCached;
+      this.accessory.context.CoolingThresholdTemperature = this.CoolingThresholdTemperatureCached;
       this.updateHomeKitCharacteristics();
     } catch (e: any) {
-      this.errorLog(
-        `Air Conditioner: ${this.accessory.displayName} failed pushChanges`,
-      );
-      if (this.deviceLogging === "debug") {
-        this.errorLog(
-          `Air Conditioner: ${this.accessory.displayName} failed pushChanges,` +
-            ` Error Message: ${JSON.stringify(e.message)}`,
-        );
+      this.errorLog(`Air Conditioner: ${this.accessory.displayName} failed pushChanges`);
+      if (this.deviceLogging === 'debug') {
+        this.errorLog(`Air Conditioner: ${this.accessory.displayName} failed pushChanges,` + ` Error Message: ${JSON.stringify(e.message)}`);
       }
       if (this.platform.debugMode) {
-        this.errorLog(
-          `Air Conditioner: ${this.accessory.displayName} failed pushChanges,` +
-            ` Error: ${JSON.stringify(e)}`,
-        );
+        this.errorLog(`Air Conditioner: ${this.accessory.displayName} failed pushChanges,` + ` Error: ${JSON.stringify(e)}`);
       }
       this.apiError(e);
     }
@@ -329,174 +282,95 @@ export class AirConditioner {
   statusCode(push: AxiosResponse<{ statusCode: number }>) {
     switch (push.data.statusCode) {
       case 151:
-        this.errorLog(
-          `Air Conditioner: ${this.accessory.displayName} Command not supported by this device type.`,
-        );
+        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.`,
-        );
+        this.errorLog(`Air Conditioner: ${this.accessory.displayName} Device not found.`);
         break;
       case 160:
-        this.errorLog(
-          `Air Conditioner: ${this.accessory.displayName} Command is not supported.`,
-        );
+        this.errorLog(`Air Conditioner: ${this.accessory.displayName} Command is not supported.`);
         break;
       case 161:
-        this.errorLog(
-          `Air Conditioner: ${this.accessory.displayName} Device is offline.`,
-        );
+        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}`,
-        );
+        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(
-              push.data,
-            )} format is invalid`,
+            ` with server, Or command: ${JSON.stringify(push.data)} format is invalid`,
         );
         break;
       case 100:
-        this.debugLog(
-          `Air Conditioner: ${this.accessory.displayName} Command successfully sent.`,
-        );
+        this.debugLog(`Air Conditioner: ${this.accessory.displayName} Command successfully sent.`);
         break;
       default:
-        this.debugLog(
-          `Air Conditioner: ${this.accessory.displayName} Unknown statusCode.`,
-        );
+        this.debugLog(`Air Conditioner: ${this.accessory.displayName} Unknown statusCode.`);
     }
   }
 
   updateHomeKitCharacteristics() {
     if (this.Active === undefined) {
-      this.debugLog(
-        `Air Conditioner: ${this.accessory.displayName} Active: ${this.Active}`,
-      );
+      this.debugLog(`Air Conditioner: ${this.accessory.displayName} Active: ${this.Active}`);
     } else {
-      this.service?.updateCharacteristic(
-        this.platform.Characteristic.Active,
-        this.Active,
-      );
-      this.debugLog(
-        `Air Conditioner: ${this.accessory.displayName} updateCharacteristic Active: ${this.Active}`,
-      );
+      this.service?.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}`,
-      );
+      this.debugLog(`Air Conditioner: ${this.accessory.displayName} RotationSpeed: ${this.RotationSpeed}`);
     } else {
-      this.service?.updateCharacteristic(
-        this.platform.Characteristic.RotationSpeed,
-        this.RotationSpeed,
-      );
-      this.debugLog(
-        `Air Conditioner: ${this.accessory.displayName} updateCharacteristic RotationSpeed: ${this.RotationSpeed}`,
-      );
+      this.service?.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}`,
-      );
+      this.debugLog(`Air Conditioner: ${this.accessory.displayName} CurrentTemperature: ${this.CurrentTemperature}`);
     } else {
-      this.service?.updateCharacteristic(
-        this.platform.Characteristic.CurrentTemperature,
-        this.CurrentTemperature,
-      );
-      this.debugLog(
-        `Air Conditioner: ${this.accessory.displayName} updateCharacteristic CurrentTemperature: ${this.CurrentTemperature}`,
-      );
+      this.service?.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}`,
-      );
+      this.debugLog(`Air Conditioner: ${this.accessory.displayName} TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
     } else {
-      this.service?.updateCharacteristic(
-        this.platform.Characteristic.TargetHeaterCoolerState,
-        this.TargetHeaterCoolerState,
-      );
+      this.service?.updateCharacteristic(this.platform.Characteristic.TargetHeaterCoolerState, this.TargetHeaterCoolerState);
       this.debugLog(
-        `Air Conditioner: ${this.accessory.displayName}` +
-          ` updateCharacteristic TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`,
+        `Air Conditioner: ${this.accessory.displayName}` + ` updateCharacteristic TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`,
       );
     }
     if (this.CurrentHeaterCoolerState === undefined) {
-      this.debugLog(
-        `Air Conditioner: ${this.accessory.displayName} CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`,
-      );
+      this.debugLog(`Air Conditioner: ${this.accessory.displayName} CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
     } else {
-      this.service?.updateCharacteristic(
-        this.platform.Characteristic.CurrentHeaterCoolerState,
-        this.CurrentHeaterCoolerState,
-      );
+      this.service?.updateCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState, this.CurrentHeaterCoolerState);
       this.debugLog(
-        `Air Conditioner: ${this.accessory.displayName}` +
-          ` updateCharacteristic CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`,
+        `Air Conditioner: ${this.accessory.displayName}` + ` updateCharacteristic CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`,
       );
     }
     if (this.HeatingThresholdTemperature === undefined) {
-      this.debugLog(
-        `Air Conditioner: ${this.accessory.displayName} HeatingThresholdTemperature: ${this.HeatingThresholdTemperature}`,
-      );
+      this.debugLog(`Air Conditioner: ${this.accessory.displayName} HeatingThresholdTemperature: ${this.HeatingThresholdTemperature}`);
     } else {
-      this.service?.updateCharacteristic(
-        this.platform.Characteristic.HeatingThresholdTemperature,
-        this.HeatingThresholdTemperature,
-      );
+      this.service?.updateCharacteristic(this.platform.Characteristic.HeatingThresholdTemperature, this.HeatingThresholdTemperature);
       this.debugLog(
-        `Air Conditioner: ${this.accessory.displayName}` +
-          ` updateCharacteristic HeatingThresholdTemperature: ${this.HeatingThresholdTemperature}`,
+        `Air Conditioner: ${this.accessory.displayName}` + ` updateCharacteristic HeatingThresholdTemperature: ${this.HeatingThresholdTemperature}`,
       );
     }
     if (this.CoolingThresholdTemperature === undefined) {
-      this.debugLog(
-        `Air Conditioner: ${this.accessory.displayName} CoolingThresholdTemperature: ${this.CoolingThresholdTemperature}`,
-      );
+      this.debugLog(`Air Conditioner: ${this.accessory.displayName} CoolingThresholdTemperature: ${this.CoolingThresholdTemperature}`);
     } else {
-      this.service?.updateCharacteristic(
-        this.platform.Characteristic.CoolingThresholdTemperature,
-        this.CoolingThresholdTemperature,
-      );
+      this.service?.updateCharacteristic(this.platform.Characteristic.CoolingThresholdTemperature, this.CoolingThresholdTemperature);
       this.debugLog(
-        `Air Conditioner: ${this.accessory.displayName}` +
-          ` updateCharacteristic CoolingThresholdTemperature: ${this.CoolingThresholdTemperature}`,
+        `Air Conditioner: ${this.accessory.displayName}` + ` updateCharacteristic CoolingThresholdTemperature: ${this.CoolingThresholdTemperature}`,
       );
     }
   }
 
   public apiError(e: any) {
     this.service.updateCharacteristic(this.platform.Characteristic.Active, e);
-    this.service.updateCharacteristic(
-      this.platform.Characteristic.RotationSpeed,
-      e,
-    );
-    this.service.updateCharacteristic(
-      this.platform.Characteristic.CurrentTemperature,
-      e,
-    );
-    this.service.updateCharacteristic(
-      this.platform.Characteristic.TargetHeaterCoolerState,
-      e,
-    );
-    this.service.updateCharacteristic(
-      this.platform.Characteristic.CurrentHeaterCoolerState,
-      e,
-    );
-    this.service.updateCharacteristic(
-      this.platform.Characteristic.HeatingThresholdTemperature,
-      e,
-    );
-    this.service.updateCharacteristic(
-      this.platform.Characteristic.CoolingThresholdTemperature,
-      e,
-    );
+    this.service.updateCharacteristic(this.platform.Characteristic.RotationSpeed, e);
+    this.service.updateCharacteristic(this.platform.Characteristic.CurrentTemperature, e);
+    this.service.updateCharacteristic(this.platform.Characteristic.TargetHeaterCoolerState, e);
+    this.service.updateCharacteristic(this.platform.Characteristic.CurrentHeaterCoolerState, e);
+    this.service.updateCharacteristic(this.platform.Characteristic.HeatingThresholdTemperature, e);
+    this.service.updateCharacteristic(this.platform.Characteristic.CoolingThresholdTemperature, e);
     //throw new this.platform.api.hap.HapStatusError(HAPStatus.SERVICE_COMMUNICATION_FAILURE);
   }
 
@@ -507,9 +381,7 @@ export class AirConditioner {
     } else {
       this.CurrentTemperatureCached = this.CurrentTemperature;
     }
-    this.debugLog(
-      `Air Conditioner: ${this.accessory.displayName} Get CurrentTemperature: ${this.CurrentTemperature}`,
-    );
+    this.debugLog(`Air Conditioner: ${this.accessory.displayName} Get CurrentTemperature: ${this.CurrentTemperature}`);
     this.accessory.context.CurrentTemperature = this.CurrentTemperatureCached;
     return this.CurrentTemperature;
   }
@@ -522,9 +394,7 @@ export class AirConditioner {
     } else {
       this.RotationSpeed = this.CurrentFanSpeed - 1;
     }
-    this.debugLog(
-      `Air Conditioner: ${this.accessory.displayName} Get RotationSpeed: ${this.RotationSpeed}`,
-    );
+    this.debugLog(`Air Conditioner: ${this.accessory.displayName} Get RotationSpeed: ${this.RotationSpeed}`);
     this.RotationSpeedCached = this.RotationSpeed;
     this.accessory.context.RotationSpeed = this.RotationSpeedCached;
     return this.RotationSpeed;
@@ -542,40 +412,36 @@ export class AirConditioner {
     this.pushAirConditionerStatusChanges();
   }
 
-  ActiveSet(value: CharacteristicValue): void {
-    this.debugLog(
-      `Air Conditioner: ${this.accessory.displayName} Set Active: ${value}`,
-    );
+  ActiveSet(value: CharacteristicValue) {
+    this.debugLog(`Air Conditioner: ${this.accessory.displayName} Set Active: ${value}`);
 
     this.Active = value;
     this.ActiveCached = this.Active;
     this.accessory.context.Active = this.ActiveCached;
 
     if (value === this.platform.Characteristic.Active.INACTIVE) {
-      this.debugLog(
-        `Air Conditioner: ${this.accessory.displayName} pushAirConditionerOffChanges, Active: ${this.Active}`,
-      );
+      this.debugLog(`Air Conditioner: ${this.accessory.displayName} pushAirConditionerOffChanges, Active: ${this.Active}`);
       this.pushAirConditionerOffChanges();
     } else {
-      this.debugLog(
-        `Air Conditioner: ${this.accessory.displayName} pushAirConditionerOnChanges, Active: ${this.Active}`,
-      );
-      this.pushAirConditionerStatusChanges();
+      this.debugLog(`Air Conditioner: ${this.accessory.displayName} pushAirConditionerOnChanges, Active: ${this.Active}`);
+      if (this.pushOn) {
+        this.pushAirConditionerOnChanges();
+      } else {
+        this.pushAirConditionerStatusChanges();
+      }
     }
   }
 
   TargetHeaterCoolerStateGet() {
     if (this.ValidValues === [0, 1, 2]) {
-      this.TargetHeaterCoolerState =
-        this.platform.Characteristic.TargetHeaterCoolerState.AUTO;
+      this.TargetHeaterCoolerState = this.platform.Characteristic.TargetHeaterCoolerState.AUTO;
       this.debugLog(
         `Air Conditioner: ${this.accessory.displayName} Get (AUTO) TargetHeaterCoolerState: ${this.CurrentHeaterCoolerState},` +
           ` ValidValues: ${this.ValidValues}`,
       );
     } else if (this.ValidValues === [1, 2]) {
       this.TargetHeaterCoolerState =
-        this.platform.Characteristic.TargetHeaterCoolerState.COOL ||
-        this.platform.Characteristic.TargetHeaterCoolerState.HEAT;
+        this.platform.Characteristic.TargetHeaterCoolerState.COOL || this.platform.Characteristic.TargetHeaterCoolerState.HEAT;
       this.debugLog(
         `Air Conditioner: ${this.accessory.displayName} Get (COOL/HEAT) TargetHeaterCoolerState: ${this.CurrentHeaterCoolerState},` +
           ` ValidValues: ${this.ValidValues}`,
@@ -587,8 +453,7 @@ export class AirConditioner {
       );
     }
     this.TargetHeaterCoolerStateCached = this.TargetHeaterCoolerState;
-    this.accessory.context.TargetHeaterCoolerState =
-      this.TargetHeaterCoolerStateCached;
+    this.accessory.context.TargetHeaterCoolerState = this.TargetHeaterCoolerStateCached;
     return this.TargetHeaterCoolerState;
   }
 
@@ -596,9 +461,7 @@ export class AirConditioner {
     if (this.hide_automode) {
       if (value === this.platform.Characteristic.TargetHeaterCoolerState.HEAT) {
         this.TargetHeaterCoolerStateHEAT();
-      } else if (
-        value === this.platform.Characteristic.TargetHeaterCoolerState.COOL
-      ) {
+      } else if (value === this.platform.Characteristic.TargetHeaterCoolerState.COOL) {
         this.TargetHeaterCoolerStateCOOL();
       } else {
         this.errorLog(
@@ -609,13 +472,9 @@ export class AirConditioner {
     } else {
       if (value === this.platform.Characteristic.TargetHeaterCoolerState.AUTO) {
         this.TargetHeaterCoolerStateAUTO();
-      } else if (
-        value === this.platform.Characteristic.TargetHeaterCoolerState.HEAT
-      ) {
+      } else if (value === this.platform.Characteristic.TargetHeaterCoolerState.HEAT) {
         this.TargetHeaterCoolerStateHEAT();
-      } else if (
-        value === this.platform.Characteristic.TargetHeaterCoolerState.COOL
-      ) {
+      } else if (value === this.platform.Characteristic.TargetHeaterCoolerState.COOL) {
         this.TargetHeaterCoolerStateCOOL();
       } else {
         this.errorLog(
@@ -625,73 +484,47 @@ export class AirConditioner {
       }
     }
     this.TargetHeaterCoolerStateCached = this.TargetHeaterCoolerState;
-    this.accessory.context.TargetHeaterCoolerState =
-      this.TargetHeaterCoolerStateCached;
+    this.accessory.context.TargetHeaterCoolerState = this.TargetHeaterCoolerStateCached;
     this.pushAirConditionerStatusChanges();
   }
 
   private TargetHeaterCoolerStateAUTO() {
-    this.TargetHeaterCoolerState =
-      this.platform.Characteristic.TargetHeaterCoolerState.AUTO;
+    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(`Air Conditioner: ${this.accessory.displayName} Set (AUTO) TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
+    this.debugLog(`Air Conditioner: ${this.accessory.displayName} Switchbot CurrentMode: ${this.CurrentMode}`);
   }
 
   private TargetHeaterCoolerStateCOOL() {
-    this.TargetHeaterCoolerState =
-      this.platform.Characteristic.TargetHeaterCoolerState.COOL;
+    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(`Air Conditioner: ${this.accessory.displayName} Set (COOL) TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
+    this.debugLog(`Air Conditioner: ${this.accessory.displayName} Switchbot CurrentMode: ${this.CurrentMode}`);
   }
 
   private TargetHeaterCoolerStateHEAT() {
-    this.TargetHeaterCoolerState =
-      this.platform.Characteristic.TargetHeaterCoolerState.HEAT;
+    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(`Air Conditioner: ${this.accessory.displayName} Set (HEAT) TargetHeaterCoolerState: ${this.TargetHeaterCoolerState}`);
+    this.debugLog(`Air Conditioner: ${this.accessory.displayName} Switchbot CurrentMode: ${this.CurrentMode}`);
   }
 
   CurrentHeaterCoolerStateGet() {
     if (this.Active === this.platform.Characteristic.Active.ACTIVE) {
       this.CurrentTemperatureUndefined();
       if (this.CurrentTemperature < this.CurrentTemperatureCached) {
-        this.CurrentHeaterCoolerState =
-          this.platform.Characteristic.CurrentHeaterCoolerState.COOLING;
-        this.debugLog(
-          `Air Conditioner: ${this.accessory.displayName} Get (COOLLING) CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`,
-        );
+        this.CurrentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.COOLING;
+        this.debugLog(`Air Conditioner: ${this.accessory.displayName} Get (COOLLING) CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
       } else if (this.CurrentTemperature > this.CurrentTemperatureCached) {
-        this.CurrentHeaterCoolerState =
-          this.platform.Characteristic.CurrentHeaterCoolerState.HEATING;
-        this.debugLog(
-          `Air Conditioner: ${this.accessory.displayName} Get (HEATING) CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`,
-        );
+        this.CurrentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.HEATING;
+        this.debugLog(`Air Conditioner: ${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.CurrentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.INACTIVE;
+      this.debugLog(`Air Conditioner: ${this.accessory.displayName} Get (INACTIVE) CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
     }
     this.CurrentHeaterCoolerStateCached = this.CurrentHeaterCoolerState;
-    this.accessory.context.CurrentHeaterCoolerState =
-      this.CurrentHeaterCoolerStateCached;
+    this.accessory.context.CurrentHeaterCoolerState = this.CurrentHeaterCoolerStateCached;
     return this.CurrentHeaterCoolerState;
   }
 
@@ -700,11 +533,8 @@ export class AirConditioner {
     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.accessory.context.HeatingThresholdTemperature = this.HeatingThresholdTemperatureCached;
+    this.debugLog(`Air Conditioner: ${this.accessory.displayName} Get HeatingThresholdTemperature: ${this.HeatingThresholdTemperature}`);
     return this.HeatingThresholdTemperature;
   }
 
@@ -712,8 +542,7 @@ export class AirConditioner {
     this.CurrentTemperatureCached = this.CurrentTemperature;
     this.CurrentTemperature = value;
     this.HeatingThresholdTemperatureCached = this.HeatingThresholdTemperature;
-    this.accessory.context.HeatingThresholdTemperature =
-      this.HeatingThresholdTemperatureCached;
+    this.accessory.context.HeatingThresholdTemperature = this.HeatingThresholdTemperatureCached;
     this.debugLog(
       `Air Conditioner: ${this.accessory.displayName} Set HeatingThresholdTemperature: ${this.HeatingThresholdTemperature},` +
         ` CurrentTemperatureCached: ${this.CurrentTemperatureCached}`,
@@ -726,11 +555,8 @@ export class AirConditioner {
     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.accessory.context.CoolingThresholdTemperature = this.CoolingThresholdTemperatureCached;
+    this.debugLog(`Air Conditioner: ${this.accessory.displayName} Get CoolingThresholdTemperature: ${this.CoolingThresholdTemperature}`);
     return this.CoolingThresholdTemperature;
   }
 
@@ -738,8 +564,7 @@ export class AirConditioner {
     this.CurrentTemperatureCached = this.CurrentTemperature;
     this.CurrentTemperature = value;
     this.CoolingThresholdTemperatureCached = this.CoolingThresholdTemperature;
-    this.accessory.context.CoolingThresholdTemperature =
-      this.CoolingThresholdTemperatureCached;
+    this.accessory.context.CoolingThresholdTemperature = this.CoolingThresholdTemperatureCached;
     this.debugLog(
       `Air Conditioner: ${this.accessory.displayName} Set CoolingThresholdTemperature: ${this.CoolingThresholdTemperature},` +
         ` CurrentTemperatureCached: ${this.CurrentTemperatureCached}`,
@@ -762,39 +587,35 @@ export class AirConditioner {
       config = device.irair;
     }
     if (device.logging !== undefined) {
-      config["logging"] = device.logging;
+      config['logging'] = device.logging;
     }
     if (Object.entries(config).length !== 0) {
-      this.warnLog(
-        `Air Conditioner: ${
-          this.accessory.displayName
-        } Config: ${JSON.stringify(config)}`,
-      );
+      this.warnLog(`Air Conditioner: ${this.accessory.displayName} Config: ${JSON.stringify(config)}`);
     }
   }
 
   logs(device: irdevice & irDevicesConfig) {
     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.deviceLogging = this.accessory.context.logging = 'debugMode';
+      this.debugLog(`Air Conditioner: ${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(`Air Conditioner: ${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.deviceLogging = this.accessory.context.logging = this.platform.config.options?.logging;
+      this.debugLog(`Air Conditioner: ${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.deviceLogging = this.accessory.context.logging = 'standard';
+      this.debugLog(`Air Conditioner: ${this.accessory.displayName} Logging Not Set, Using: ${this.deviceLogging}`);
+    }
+  }
+
+
+  pushOnChanges(device: irdevice & irDevicesConfig) {
+    if (device.irair?.pushOn) {
+      this.pushOn = true;
+    } else {
+      this.pushOn = false;
     }
   }
 
@@ -821,8 +642,8 @@ export class AirConditioner {
 
   debugLog(...log: any[]) {
     if (this.enablingDeviceLogging()) {
-      if (this.deviceLogging === "debug") {
-        this.platform.log.info("[DEBUG]", String(...log));
+      if (this.deviceLogging === 'debug') {
+        this.platform.log.info('[DEBUG]', String(...log));
       } else {
         this.platform.log.debug(String(...log));
       }
@@ -830,6 +651,6 @@ export class AirConditioner {
   }
 
   enablingDeviceLogging(): boolean {
-    return this.deviceLogging.includes("debug") || this.deviceLogging === "standard";
+    return this.deviceLogging === 'debug' || this.deviceLogging === 'standard';
   }
 }