@switchbot/homebridge-switchbot 2.2.2-beta.9 → 2.2.3-beta.0

package/src/device/bot.ts

@@ -1063,7 +1063,7 @@ export class Bot {
     }
   }
 
-  async stopScanning({ switchbot }: { switchbot: any; }): Promise<void> {
+  async stopScanning(switchbot: any) {
     await switchbot.stopScan();
     if (this.connected) {
       await this.BLEparseStatus();

package/src/device/ceilinglight.ts

@@ -909,7 +909,7 @@ export class CeilingLight {
     }
   }
 
-  async stopScanning({ switchbot }: { switchbot: any; }): Promise<void> {
+  async stopScanning(switchbot: any) {
     await switchbot.stopScan();
     if (this.connected) {
       await this.BLEparseStatus();

package/src/device/colorbulb.ts

@@ -392,7 +392,7 @@ export class ColorBulb {
             if (this.serviceData) {
               this.connected = true;
               this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} connected: ${this.connected}`);
-              await this.stopScanning({ switchbot });
+              await this.stopScanning(switchbot);
             } else {
               this.connected = false;
               this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} connected: ${this.connected}`);
@@ -403,7 +403,7 @@ export class ColorBulb {
         })
         .then(async () => {
         // Stop to monitor
-          await this.stopScanning({ switchbot });
+          await this.stopScanning(switchbot);
         })
         .catch(async (e: any) => {
           this.apiError(e);
@@ -1065,7 +1065,7 @@ export class ColorBulb {
     }
   }
 
-  async stopScanning({ switchbot }: { switchbot: any; }): Promise<void> {
+  async stopScanning(switchbot: any) {
     await switchbot.stopScan();
     if (this.connected) {
       await this.BLEparseStatus();

package/src/device/contact.ts

@@ -35,7 +35,12 @@ export class Contact {
   deviceStatus!: any; //deviceStatusResponse;
 
   // BLE Others
+  tested!: any;
+  contact_open!: any;
+  button_count!: any;
+  scanning!: boolean;
   connected?: boolean;
+  contact_timeout!: any;
   switchbot!: switchbot;
   serviceData!: serviceData;
   address!: ad['address'];
@@ -43,10 +48,6 @@ export class Contact {
   movement!: serviceData['movement'];
   doorState!: serviceData['doorState'];
   is_light!: any; //serviceData['lightLevel'];
-  tested!: any;
-  contact_open!: any;
-  contact_timeout!: any;
-  button_count!: any;
 
   // Config
   set_minLux!: number;
@@ -195,10 +196,18 @@ export class Contact {
       default:
         this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} timeout no closed, doorstate: ${this.doorState}`);
     }
+    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ContactSensorState: ${this.ContactSensorState}`);
+    if ((this.ContactSensorState !== this.accessory.context.ContactSensorState)
+    && this.platform.Characteristic.ContactSensorState.CONTACT_NOT_DETECTED) {
+      this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Opened`);
+    }
     // Movement
     if (!this.device.contact?.hide_motionsensor) {
       this.MotionDetected = Boolean(this.movement);
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} MotionDetected: ${this.MotionDetected}`);
+      if ((this.MotionDetected !== this.accessory.context.MotionDetected) && this.MotionDetected) {
+        this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Detected Motion`);
+      }
     }
     // Light Level
     if (!this.device.contact?.hide_lightsensor) {
@@ -211,10 +220,11 @@ export class Contact {
         default:
           this.CurrentAmbientLightLevel = this.set_maxLux;
       }
-      this.debugLog(
-        `${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.is_light},` +
-          ` CurrentAmbientLightLevel: ${this.CurrentAmbientLightLevel}`,
-      );
+      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.is_light},` +
+          ` CurrentAmbientLightLevel: ${this.CurrentAmbientLightLevel}`);
+      if (this.CurrentAmbientLightLevel !== this.accessory.context.CurrentAmbientLightLevel) {
+        this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} CurrentAmbientLightLevel: ${this.CurrentAmbientLightLevel}`);
+      }
     }
     // Battery
     if (this.battery === undefined) {
@@ -301,6 +311,7 @@ export class Contact {
         })
         .then(async () => {
           // Set an event hander
+          this.scanning = true;
           switchbot.onadvertisement = async (ad: any) => {
             this.address = ad.address;
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Config BLE Address: ${this.device.bleMac},`
@@ -324,6 +335,7 @@ export class Contact {
               this.connected = true;
               this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} connected: ${this.connected}`);
               await this.stopScanning(switchbot);
+              this.scanning = false;
             } else {
               this.connected = false;
               this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} connected: ${this.connected}`);
@@ -334,7 +346,9 @@ export class Contact {
         })
         .then(async () => {
           // Stop to monitor
-          await this.stopScanning(switchbot);
+          if (this.scanning) {
+            await this.stopScanning(switchbot);
+          }
         })
         .catch(async (e: any) => {
           this.apiError(e);
@@ -450,7 +464,7 @@ export class Contact {
     }
   }
 
-  async stopScanning({ switchbot }: { switchbot: any; }): Promise<void> {
+  async stopScanning(switchbot: any) {
     await switchbot.stopScan();
     if (this.connected) {
       await this.BLEparseStatus();

package/src/device/humidifier.ts

@@ -765,7 +765,7 @@ export class Humidifier {
     }
   }
 
-  async stopScanning({ switchbot }: { switchbot: any; }): Promise<void> {
+  async stopScanning(switchbot: any) {
     await switchbot.stopScan();
     if (this.connected) {
       await this.BLEparseStatus();
@@ -923,21 +923,17 @@ export class Humidifier {
     }
     if (this.TargetHumidifierDehumidifierState === undefined) {
       this.TargetHumidifierDehumidifierState = this.platform.Characteristic.TargetHumidifierDehumidifierState.HUMIDIFIER;
+    } else if (this.accessory.context.TargetHumidifierDehumidifierState === undefined) {
+      this.TargetHumidifierDehumidifierState = this.platform.Characteristic.TargetHumidifierDehumidifierState.HUMIDIFIER;
     } else {
       this.TargetHumidifierDehumidifierState = this.accessory.context.TargetHumidifierDehumidifierState;
-      if (this.accessory.context.TargetHumidifierDehumidifierState === undefined) {
-        this.TargetHumidifierDehumidifierState = this.platform.Characteristic.TargetHumidifierDehumidifierState.HUMIDIFIER;
-      }
-      this.warnLog(this.TargetHumidifierDehumidifierState);
     }
     if (this.CurrentHumidifierDehumidifierState === undefined) {
       this.CurrentHumidifierDehumidifierState = this.platform.Characteristic.CurrentHumidifierDehumidifierState.INACTIVE;
+    } else if (this.accessory.context.CurrentHumidifierDehumidifierState === undefined) {
+      this.CurrentHumidifierDehumidifierState = this.platform.Characteristic.CurrentHumidifierDehumidifierState.INACTIVE;
     } else {
       this.CurrentHumidifierDehumidifierState = this.accessory.context.CurrentHumidifierDehumidifierState;
-      if (this.accessory.context.CurrentHumidifierDehumidifierState === undefined) {
-        this.CurrentHumidifierDehumidifierState = this.platform.Characteristic.CurrentHumidifierDehumidifierState.INACTIVE;
-      }
-      this.warnLog(this.CurrentHumidifierDehumidifierState);
     }
     if (this.RelativeHumidityHumidifierThreshold === undefined) {
       this.RelativeHumidityHumidifierThreshold = 0;
@@ -1008,19 +1004,19 @@ export class Humidifier {
   /**
    * Logging for Device
    */
-  infoLog(...log: any[]): void {
+  async infoLog(...log: any[]): Promise<void> {
     if (this.enablingDeviceLogging()) {
       this.platform.log.info(String(...log));
     }
   }
 
-  warnLog(...log: any[]): void {
+  async warnLog(...log: any[]): Promise<void> {
     if (this.enablingDeviceLogging()) {
       this.platform.log.warn(String(...log));
     }
   }
 
-  debugWarnLog(...log: any[]): void {
+  async debugWarnLog(...log: any[]): Promise<void> {
     if (this.enablingDeviceLogging()) {
       if (this.deviceLogging?.includes('debug')) {
         this.platform.log.warn('[DEBUG]', String(...log));
@@ -1028,13 +1024,13 @@ export class Humidifier {
     }
   }
 
-  errorLog(...log: any[]): void {
+  async errorLog(...log: any[]): Promise<void> {
     if (this.enablingDeviceLogging()) {
       this.platform.log.error(String(...log));
     }
   }
 
-  debugErrorLog(...log: any[]): void {
+  async debugErrorLog(...log: any[]): Promise<void> {
     if (this.enablingDeviceLogging()) {
       if (this.deviceLogging?.includes('debug')) {
         this.platform.log.error('[DEBUG]', String(...log));
@@ -1042,7 +1038,7 @@ export class Humidifier {
     }
   }
 
-  debugLog(...log: any[]): void {
+  async debugLog(...log: any[]): Promise<void> {
     if (this.enablingDeviceLogging()) {
       if (this.deviceLogging === 'debug') {
         this.platform.log.info('[DEBUG]', String(...log));

package/src/device/meter.ts

@@ -488,7 +488,7 @@ export class Meter {
       : null;
   }
 
-  async stopScanning({ switchbot }: { switchbot: any; }): Promise<void> {
+  async stopScanning(switchbot: any) {
     await switchbot.stopScan();
     if (this.connected) {
       await this.BLEparseStatus();

package/src/device/meterplus.ts

@@ -487,7 +487,7 @@ export class MeterPlus {
       : null;
   }
 
-  async stopScanning({ switchbot }: { switchbot: any; }): Promise<void> {
+  async stopScanning(switchbot: any) {
     await switchbot.stopScan();
     if (this.connected) {
       await this.BLEparseStatus();

package/src/device/motion.ts

@@ -32,6 +32,7 @@ export class Motion {
   brightness: deviceStatus['brightness'];
 
   // BLE Others
+  scanning!: boolean;
   connected?: boolean;
   switchbot!: switchbot;
   serviceData!: serviceData;
@@ -165,6 +166,9 @@ export class Motion {
     // Movement
     this.MotionDetected = this.movement!;
     this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} MotionDetected: ${this.MotionDetected}`);
+    if ((this.MotionDetected !== this.accessory.context.MotionDetected) && this.MotionDetected) {
+      this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Detected Motion`);
+    }
     // Light Level
     if (!this.device.motion?.hide_lightsensor) {
       this.set_minLux = this.minLux();
@@ -177,10 +181,11 @@ export class Motion {
         default:
           this.CurrentAmbientLightLevel = this.set_maxLux;
       }
-      this.debugLog(
-        `${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.lightLevel},` +
-          ` CurrentAmbientLightLevel: ${this.CurrentAmbientLightLevel}`,
-      );
+      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.lightLevel},` +
+          ` CurrentAmbientLightLevel: ${this.CurrentAmbientLightLevel}`);
+      if (this.CurrentAmbientLightLevel !== this.accessory.context.CurrentAmbientLightLevel) {
+        this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} CurrentAmbientLightLevel: ${this.CurrentAmbientLightLevel}`);
+      }
     }
     // Battery
     if (this.battery === undefined) {
@@ -255,6 +260,7 @@ export class Motion {
         })
         .then(async () => {
           // Set an event hander
+          this.scanning = true;
           switchbot.onadvertisement = async (ad: any) => {
             this.address = ad.address;
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Config BLE Address: ${this.device.bleMac},`
@@ -278,6 +284,8 @@ export class Motion {
               this.connected = true;
               this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} connected: ${this.connected}`);
               await this.stopScanning(switchbot);
+              this.scanning = false;
+              this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} scanning: ${this.scanning}`);
             } else {
               this.connected = false;
               this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} connected: ${this.connected}`);
@@ -288,7 +296,10 @@ export class Motion {
         })
         .then(async () => {
           // Stop to monitor
-          await this.stopScanning(switchbot);
+          this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} scanning: ${this.scanning}`);
+          if (this.scanning) {
+            await this.stopScanning(switchbot);
+          }
         })
         .catch(async (e: any) => {
           this.apiError(e);
@@ -394,8 +405,8 @@ export class Motion {
     }
   }
 
-  async stopScanning({ switchbot }: { switchbot: any; }): Promise<void> {
-    await await switchbot.stopScan();
+  async stopScanning(switchbot: any) {
+    await switchbot.stopScan();
     if (this.connected) {
       await this.BLEparseStatus();
       await this.updateHomeKitCharacteristics();

package/src/device/plug.ts

@@ -458,7 +458,7 @@ export class Plug {
     }
   }
 
-  async stopScanning({ switchbot }: { switchbot: any; }): Promise<void> {
+  async stopScanning(switchbot: any) {
     await switchbot.stopScan();
     if (this.connected) {
       await this.BLEparseStatus();

package/src/device/striplight.ts

@@ -215,9 +215,9 @@ export class StripLight {
   async parseStatus(): Promise<void> {
     if (!this.device.enableCloudService && this.OpenAPI) {
       this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} parseStatus enableCloudService: ${this.device.enableCloudService}`);
-    } else/*if (this.BLE) {
+    } else if (this.BLE) {
       await this.BLEparseStatus();
-    } else*/ if (this.OpenAPI && this.platform.config.credentials?.token) {
+    } else if (this.OpenAPI && this.platform.config.credentials?.token) {
       await this.openAPIparseStatus();
     } else {
       await this.offlineOff();
@@ -282,9 +282,9 @@ export class StripLight {
   async refreshStatus(): Promise<void> {
     if (!this.device.enableCloudService && this.OpenAPI) {
       this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} refreshStatus enableCloudService: ${this.device.enableCloudService}`);
-    } else/*if (this.BLE) {
+    } else if (this.BLE) {
       await this.BLERefreshStatus();
-    } else*/ if (this.OpenAPI && this.platform.config.credentials?.token) {
+    } else if (this.OpenAPI && this.platform.config.credentials?.token) {
       await this.openAPIRefreshStatus();
     } else {
       await this.offlineOff();
@@ -830,7 +830,7 @@ export class StripLight {
     }
   }
 
-  async stopScanning({ switchbot }: { switchbot: any; }): Promise<void> {
+  async stopScanning(switchbot: any) {
     await switchbot.stopScan();
     if (this.connected) {
       await this.BLEparseStatus();

package/src/irdevice/airconditioner.ts

@@ -3,7 +3,7 @@ import crypto from 'crypto';
 import { IncomingMessage } from 'http';
 import superStringify from 'super-stringify';
 import { SwitchBotPlatform } from '../platform';
-import { irDevicesConfig, irdevice, HostDomain, DevicePath } from '../settings';
+import { irDevicesConfig, irdevice, HostDomain, DevicePath, body } from '../settings';
 import { CharacteristicValue, PlatformAccessory, Service } from 'homebridge';
 
 /**
@@ -36,8 +36,9 @@ export class AirConditioner {
   static MODE_HEAT: number;
 
   // Config
-  allowPushOn?: boolean;
-  allowPushOff?: boolean;
+  disablePushOn?: boolean;
+  disablePushOff?: boolean;
+  disablePushDetail?: boolean;
   deviceLogging!: string;
   hide_automode?: boolean;
 
@@ -49,8 +50,9 @@ export class AirConditioner {
     this.logs({ device });
     this.config({ device });
     this.context();
-    this.allowPushOnChanges({ device });
-    this.allowPushOffChanges({ device });
+    this.disablePushOnChanges({ device });
+    this.disablePushOffChanges({ device });
+    this.disablePushDetailChanges({ device });
 
     // set accessory information
     accessory
@@ -65,7 +67,7 @@ export class AirConditioner {
     // 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)),
-    `${accessory.displayName} Air Conditioner`;
+    `${accessory.displayName} ${device.remoteType}`;
 
     // To avoid "Cannot add a Service with the same UUID another Service without also defining a unique 'subtype' property." error,
     // when creating multiple services of the same type, you need to use the following syntax to specify a name and subtype id:
@@ -166,8 +168,8 @@ export class AirConditioner {
    */
   async pushAirConditionerOnChanges(): Promise<void> {
     this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerOnChanges Active: ${this.Active},`
-    + ` allowPushOn: ${this.allowPushOn}`);
-    if (this.Active === this.platform.Characteristic.Active.INACTIVE || this.allowPushOn) {
+    + ` disablePushOn: ${this.disablePushOn}`);
+    if (this.Active === this.platform.Characteristic.Active.ACTIVE && !this.disablePushOn) {
       const commandType: string = await this.commandType();
       const command: string = await this.commandOn();
       const body = superStringify({
@@ -181,8 +183,8 @@ export class AirConditioner {
 
   async pushAirConditionerOffChanges(): Promise<void> {
     this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerOffChanges Active: ${this.Active},`
-    + ` allowPushOff: ${this.allowPushOff}`);
-    if (this.Active === this.platform.Characteristic.Active.ACTIVE || this.allowPushOff) {
+    + ` disablePushOff: ${this.disablePushOff}`);
+    if (this.Active === this.platform.Characteristic.Active.INACTIVE && !this.disablePushOff) {
       const commandType: string = await this.commandType();
       const command: string = await this.commandOff();
       const body = superStringify({
@@ -195,6 +197,8 @@ export class AirConditioner {
   }
 
   async pushAirConditionerStatusChanges(): Promise<void> {
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerStatusChanges Active: ${this.Active},`
+    + ` disablePushOff: ${this.disablePushOff},  disablePushOn: ${this.disablePushOn}`);
     if (!this.Busy) {
       this.Busy = true;
       this.CurrentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.IDLE;
@@ -206,7 +210,9 @@ export class AirConditioner {
   }
 
   async pushAirConditionerDetailsChanges(): Promise<void> {
-    await this.context();
+    this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerDetailsChanges Active: ${this.Active},`
+    + ` disablePushOff: ${this.disablePushOff},  disablePushOn: ${this.disablePushOn}`);
+    //await this.context();
     if (this.CurrentMode === undefined) {
       this.CurrentMode = 1;
     }
@@ -246,10 +252,11 @@ export class AirConditioner {
     await this.pushChanges(body);
   }
 
-  async pushChanges(body: any): Promise<void> {
-    if (this.device.connectionType === 'OpenAPI') {
+  async pushChanges(body: Array<body>): Promise<void> {
+    if (this.device.connectionType === 'OpenAPI' && !this.disablePushDetail) {
       try {
-      // Make Push On request to the API
+        this.debugWarnLog(`${this.device.remoteType}: ${this.accessory.displayName} body: ${body}`);
+        // Make Push On request to the API
         const t = Date.now();
         const nonce = 'requestID';
         const data = this.platform.config.credentials?.token + t + nonce;
@@ -286,11 +293,6 @@ export class AirConditioner {
         req.write(body);
         req.end();
         this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushchanges: ${superStringify(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: any) {
         this.apiError({ e });
@@ -301,18 +303,19 @@ export class AirConditioner {
     } else {
       this.warnLog(`${this.device.remoteType}: ${this.accessory.displayName}`
       + ` Connection Type: ${this.device.connectionType}, commands will not be sent to OpenAPI`);
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
+      + ` Connection Type: ${this.device.connectionType}, disablePushDetials: ${this.disablePushDetail}`);
+      this.updateHomeKitCharacteristics();
     }
   }
 
   async CurrentTemperatureGet(): Promise<CharacteristicValue> {
     if (this.CurrentTemperature === undefined) {
       this.CurrentTemperature = 24;
-      this.accessory.context.CurrentTemperature = this.CurrentTemperature;
     } else {
-      this.accessory.context.CurrentTemperature = this.CurrentTemperature;
+      this.CurrentTemperature = this.accessory.context.CurrentTemperature;
     }
     this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get CurrentTemperature: ${this.CurrentTemperature}`);
-    this.accessory.context.CurrentTemperature = this.CurrentTemperature;
     return this.CurrentTemperature;
   }
 
@@ -325,7 +328,6 @@ export class AirConditioner {
       this.RotationSpeed = this.CurrentFanSpeed - 1;
     }
     this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Get RotationSpeed: ${this.RotationSpeed}`);
-    this.accessory.context.RotationSpeed = this.RotationSpeed;
     return this.RotationSpeed;
   }
 
@@ -341,22 +343,19 @@ export class AirConditioner {
 
   async ActiveSet(value: CharacteristicValue): Promise<void> {
     this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} Set Active: ${value}`);
-    if (value === this.platform.Characteristic.Active.INACTIVE) {
-      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerOffChanges, Active: ${this.Active}`);
-      this.pushAirConditionerOffChanges();
-    } else {
+
+    this.Active = value;
+    if (this.Active === this.platform.Characteristic.Active.ACTIVE) {
       this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerOnChanges, Active: ${this.Active}`);
-      if (this.allowPushOn) {
-        this.pushAirConditionerOnChanges();
-      } else {
+      if (this.disablePushOn) {
         this.pushAirConditionerStatusChanges();
+      } else {
+        this.pushAirConditionerOnChanges();
       }
+    } else {
+      this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName} pushAirConditionerOffChanges, Active: ${this.Active}`);
+      this.pushAirConditionerOffChanges();
     }
-    /**
-     * pushAirConditionerOnChanges and pushAirConditionerOffChanges above assume they are measuring the state of the accessory BEFORE
-     * they are updated, so we are only updating the accessory state after calling the above.
-     */
-    this.Active = value;
   }
 
   async TargetHeaterCoolerStateGet(): Promise<CharacteristicValue> {
@@ -379,7 +378,6 @@ export class AirConditioner {
           ` ValidValues: ${this.ValidValues}`,
       );
     }
-    this.accessory.context.TargetHeaterCoolerState = this.TargetHeaterCoolerState;
     return this.TargetHeaterCoolerState;
   }
 
@@ -435,7 +433,6 @@ export class AirConditioner {
 
   async CurrentHeaterCoolerStateGet(): Promise<CharacteristicValue> {
     if (this.Active === this.platform.Characteristic.Active.ACTIVE) {
-      await this.context();
       if (this.CurrentTemperature < this.accessory.context.CurrentTemperature) {
         this.CurrentHeaterCoolerState = this.platform.Characteristic.CurrentHeaterCoolerState.COOLING;
         this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
@@ -450,15 +447,11 @@ export class AirConditioner {
       this.debugLog(`${this.device.remoteType}: ${this.accessory.displayName}`
       +` Get (INACTIVE) CurrentHeaterCoolerState: ${this.CurrentHeaterCoolerState}`);
     }
-    this.accessory.context.CurrentHeaterCoolerState = this.CurrentHeaterCoolerState;
     return this.CurrentHeaterCoolerState;
   }
 
   async HeatingThresholdTemperatureGet(): Promise<CharacteristicValue> {
     await this.context();
-    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;
   }
@@ -472,9 +465,6 @@ export class AirConditioner {
 
   async CoolingThresholdTemperatureGet(): Promise<CharacteristicValue> {
     await this.context();
-    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;
   }
@@ -549,19 +539,27 @@ export class AirConditioner {
     }
   }
 
-  async allowPushOnChanges({ device }: { device: irdevice & irDevicesConfig; }): Promise<void> {
-    if (device.allowPushOn) {
-      this.allowPushOn = true;
+  async disablePushOnChanges({ device }: { device: irdevice & irDevicesConfig; }): Promise<void> {
+    if (device.disablePushOn === undefined) {
+      this.disablePushOn = false;
+    } else {
+      this.disablePushOn = device.disablePushOn;
+    }
+  }
+
+  async disablePushOffChanges({ device }: { device: irdevice & irDevicesConfig; }): Promise<void> {
+    if (device.disablePushOff === undefined) {
+      this.disablePushOff = false;
     } else {
-      this.allowPushOn = false;
+      this.disablePushOff = device.disablePushOff;
     }
   }
 
-  async allowPushOffChanges({ device }: { device: irdevice & irDevicesConfig; }): Promise<void> {
-    if (device.allowPushOff) {
-      this.allowPushOff = true;
+  async disablePushDetailChanges({ device }: { device: irdevice & irDevicesConfig; }): Promise<void> {
+    if (device.disablePushDetail === undefined) {
+      this.disablePushDetail = false;
     } else {
-      this.allowPushOff = false;
+      this.disablePushDetail = device.disablePushDetail;
     }
   }
 
@@ -655,17 +653,29 @@ export class AirConditioner {
   async context(): Promise<void> {
     if (this.Active === undefined) {
       this.Active = this.platform.Characteristic.Active.INACTIVE;
+    } else if (this.Active) {
+      this.Active;
     } else {
       this.Active = this.accessory.context.Active;
     }
     if (this.CurrentTemperature === undefined) {
       this.CurrentTemperature = 24;
+    } else if (this.CurrentTemperature) {
+      this.CurrentTemperature;
+    } else if (this.accessory.context.CurrentTemperature === undefined) {
+      this.CurrentTemperature = 24;
     } else {
       this.CurrentTemperature = this.accessory.context.CurrentTemperature;
     }
-    if (this.accessory.context.CurrentTemperature === undefined) {
-      this.CurrentTemperature = 30;
+
+    if (this.CoolingThresholdTemperature === undefined) {
+      this.CoolingThresholdTemperature = this.CurrentTemperature;
+    }
+
+    if (this.HeatingThresholdTemperature === undefined) {
+      this.HeatingThresholdTemperature = this.CurrentTemperature;
     }
+
     if (this.device.irair?.hide_automode) {
       this.hide_automode = this.device.irair?.hide_automode;
       this.accessory.context.hide_automode = this.hide_automode;
@@ -698,11 +708,14 @@ export class AirConditioner {
     if (device.customize !== undefined) {
       config['customize'] = device.customize;
     }
-    if (device.allowPushOn !== undefined) {
-      config['allowPushOn'] = device.allowPushOn;
+    if (device.disablePushOn !== undefined) {
+      config['disablePushOn'] = device.disablePushOn;
+    }
+    if (device.disablePushOff !== undefined) {
+      config['disablePushOff'] = device.disablePushOff;
     }
-    if (device.allowPushOff !== undefined) {
-      config['allowPushOff'] = device.allowPushOff;
+    if (device.disablePushDetail !== undefined) {
+      config['disablePushDetail'] = device.disablePushDetail;
     }
     if (Object.entries(config).length !== 0) {
       this.infoLog(`${this.device.remoteType}: ${this.accessory.displayName} Config: ${superStringify(config)}`);