@switchbot/homebridge-switchbot 3.5.1-beta.0 → 3.5.1-beta.2

package/src/device/blindtilt.ts

@@ -265,14 +265,13 @@ export class BlindTilt extends deviceBase {
     this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} CurrentPosition: ${this.WindowCovering.CurrentPosition},`
       + ` TargetPosition: ${this.WindowCovering.TargetPosition}, PositionState: ${this.WindowCovering.PositionState},`);
 
-    if (!this.device.blindTilt?.hide_lightsensor) {
-      const set_minLux = this.device.blindTilt?.set_minLux ?? 1;
-      const set_maxLux = this.device.blindTilt?.set_maxLux ?? 6001;
-      const spaceBetweenLevels = 9;
-
+    if (!this.device.blindTilt?.hide_lightsensor && this.LightSensor?.Service) {
       if (this.LightSensor?.CurrentAmbientLightLevel === 0) {
         this.LightSensor!.CurrentAmbientLightLevel = 0.0001;
       }
+      const set_minLux = this.device.blindTilt?.set_minLux ?? 1;
+      const set_maxLux = this.device.blindTilt?.set_maxLux ?? 6001;
+      const spaceBetweenLevels = 9;
 
       // Brightness
       switch (serviceData.lightLevel) {
@@ -465,9 +464,9 @@ export class BlindTilt extends deviceBase {
     if (switchbot === undefined) {
       await this.BLERefreshConnection(switchbot);
     } else {
-    // Start to monitor advertisement packets
-      (async () => {
       // Start to monitor advertisement packets
+      (async () => {
+        // Start to monitor advertisement packets
         const serviceData: serviceData = await this.monitorAdvertisementPackets(switchbot);
         // Update HomeKit
         if (serviceData.model !== '' && serviceData.modelName !== '') {
@@ -495,9 +494,8 @@ export class BlindTilt extends deviceBase {
         await this.statusCodes(statusCode, deviceStatus);
       }
     } catch (e: any) {
-      this.apiError(e);
-      this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed openAPIRefreshStatus with ${this.device.connectionType}`
-        + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+      await this.apiError(e);
+      await this.openAPIRefreshError(e);
     }
   }
 
@@ -518,7 +516,7 @@ export class BlindTilt extends deviceBase {
           if (!device.blindTilt?.hide_lightsensor) {
             this.LightSensor!.CurrentAmbientLightLevel = lightLevel;
           }
-          this.updateHomeKitCharacteristics();
+          await this.updateHomeKitCharacteristics();
         } catch (e: any) {
           this.errorLog(`${device.deviceType}: ${accessory.displayName} failed to handle webhook. Received: ${JSON.stringify(context)} Error: ${e}`);
         }
@@ -537,8 +535,7 @@ export class BlindTilt extends deviceBase {
       await this.openAPIpushChanges();
     } else {
       await this.offlineOff();
-      this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} Connection Type:`
-        + ` ${this.device.connectionType}, pushChanges will not happen.`);
+      await this.pushChangeDisabled();
     }
     // Refresh the status from the API
     interval(15000)
@@ -575,13 +572,12 @@ export class BlindTilt extends deviceBase {
               + `Target Position: ${this.WindowCovering.TargetPosition} sent over BLE,  sent successfully`);
           })
           .catch(async (e: any) => {
-            this.apiError(e);
-            this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLEpushChanges with ${this.device.connectionType}`
-              + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+            await this.apiError(e);
+            await this.failedBLEChanges(e);
             await this.BLEPushConnection();
           });
       } else {
-        this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} wasn't able to establish BLE Connection`);
+        this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} wasn't able to establish BLE Connection,`);
         await this.BLEPushConnection();
       }
     } else {
@@ -652,36 +648,31 @@ export class BlindTilt extends deviceBase {
    * Handle requests to set the value of the "Target Horizontal Tilt" characteristic
    */
   async TargetHorizontalTiltAngleSet(value: CharacteristicValue): Promise<void> {
-    if (this.WindowCovering.TargetHorizontalTiltAngle === this.accessory.context.TargetHorizontalTiltAngle) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, Set TargetHorizontalTiltAngle: ${value}`);
+    if (this.WindowCovering.TargetHorizontalTiltAngle !== this.accessory.context.TargetHorizontalTiltAngle) {
+      await this.changeSet(value, 'TargetHorizontalTiltAngle');
     } else {
-      this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set TargetHorizontalTiltAngle: ${value}`);
+      await this.noChangeSet(value, 'TargetHorizontalTiltAngle');
     }
 
     //value = value < 0 ? -90 : 90;
     this.WindowCovering.TargetHorizontalTiltAngle = value;
-    if (this.device.mqttURL) {
-      this.mqttPublish('TargetHorizontalTiltAngle', this.WindowCovering.TargetHorizontalTiltAngle.toString());
-    }
-
-    this.startUpdatingBlindTiltIfNeeded();
+    await this.mqtt('TargetHorizontalTiltAngle', this.WindowCovering.TargetHorizontalTiltAngle);
+    await this.startUpdatingBlindTiltIfNeeded();
   }
 
   /**
    * Handle requests to set the value of the "Target Position" characteristic
    */
   async TargetPositionSet(value: CharacteristicValue): Promise<void> {
-    if (this.WindowCovering.TargetPosition === this.accessory.context.TargetPosition) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No Changes, Set TargetPosition: ${value}`);
+    if (this.WindowCovering.TargetPosition !== this.accessory.context.TargetPosition) {
+      await this.changeSet(value, 'TargetPosition');
     } else {
-      this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} Set TargetPosition: ${value}`);
+      await this.noChangeSet(value, 'TargetPosition');
     }
 
     this.WindowCovering.TargetPosition = value;
-    if (this.device.mqttURL) {
-      this.mqttPublish('TargetPosition', this.WindowCovering.TargetPosition.toString());
-    }
-    this.startUpdatingBlindTiltIfNeeded();
+    await this.mqtt('TargetPosition', this.WindowCovering.TargetPosition);
+    await this.startUpdatingBlindTiltIfNeeded();
   }
 
   async startUpdatingBlindTiltIfNeeded(): Promise<void> {
@@ -726,106 +717,33 @@ export class BlindTilt extends deviceBase {
     await this.setMinMax();
     // CurrentHorizontalTiltAngle
     if (this.mappingMode === BlindTiltMappingMode.UseTiltForDirection) {
-      if (this.WindowCovering.CurrentHorizontalTiltAngle === undefined || Number.isNaN(this.WindowCovering.CurrentHorizontalTiltAngle)) {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName}`
-          + ` CurrentHorizontalTiltAngle: ${this.WindowCovering.CurrentHorizontalTiltAngle}`);
-      } else {
-        if (this.device.mqttURL) {
-          this.mqttPublish('CurrentHorizontalTiltAngle', this.WindowCovering.CurrentHorizontalTiltAngle.toString());
-        }
-        this.accessory.context.CurrentHorizontalTiltAngle = this.WindowCovering.CurrentHorizontalTiltAngle;
-        this.WindowCovering.Service.updateCharacteristic(
-          this.hap.Characteristic.CurrentHorizontalTiltAngle,
-          Number(this.WindowCovering.CurrentHorizontalTiltAngle));
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} 
-        updateCharacteristic CurrentHorizontalTiltAngle: ${this.WindowCovering.CurrentHorizontalTiltAngle}`);
-      }
+      await this.updateCharacteristic(this.WindowCovering.Service, this.hap.Characteristic.CurrentHorizontalTiltAngle,
+        this.WindowCovering.CurrentHorizontalTiltAngle, 'CurrentHorizontalTiltAngle');
     }
     // CurrentPosition
-    if (this.WindowCovering.CurrentPosition === undefined || Number.isNaN(this.WindowCovering.CurrentPosition)) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
-    } else {
-      if (this.device.mqttURL) {
-        this.mqttPublish('CurrentPosition', this.WindowCovering.CurrentPosition.toString());
-      }
-      this.accessory.context.CurrentPosition = this.WindowCovering.CurrentPosition;
-      this.WindowCovering.Service.updateCharacteristic(this.hap.Characteristic.CurrentPosition, Number(this.WindowCovering.CurrentPosition));
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName}`
-        + ` updateCharacteristic CurrentPosition: ${this.WindowCovering.CurrentPosition}`);
-    }
+    await this.updateCharacteristic(this.WindowCovering.Service, this.hap.Characteristic.CurrentPosition,
+      this.WindowCovering.CurrentPosition, 'CurrentPosition');
     // PositionState
-    if (this.WindowCovering.PositionState === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} PositionState: ${this.WindowCovering.PositionState}`);
-    } else {
-      if (this.device.mqttURL) {
-        this.mqttPublish('PositionState', this.WindowCovering.PositionState.toString());
-      }
-      this.accessory.context.PositionState = this.WindowCovering.PositionState;
-      this.WindowCovering.Service.updateCharacteristic(this.hap.Characteristic.PositionState, Number(this.WindowCovering.PositionState));
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
-        + ` PositionState: ${this.WindowCovering.PositionState}`);
-    }
+    await this.updateCharacteristic(this.WindowCovering.Service, this.hap.Characteristic.PositionState,
+      this.WindowCovering.PositionState, 'PositionState');
     // TargetPosition
-    if (this.WindowCovering.TargetPosition === undefined || Number.isNaN(this.WindowCovering.TargetPosition)) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} TargetPosition: ${this.WindowCovering.TargetPosition}`);
-    } else {
-      if (this.device.mqttURL) {
-        this.mqttPublish('TargetPosition', this.WindowCovering.TargetPosition.toString());
-      }
-      this.accessory.context.TargetPosition = this.WindowCovering.TargetPosition;
-      this.WindowCovering.Service.updateCharacteristic(this.hap.Characteristic.TargetPosition, Number(this.WindowCovering.TargetPosition));
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
-        + ` TargetPosition: ${this.WindowCovering.TargetPosition}`);
-    }
+    await this.updateCharacteristic(this.WindowCovering.Service, this.hap.Characteristic.TargetPosition,
+      this.WindowCovering.TargetPosition, 'TargetPosition');
     // CurrentAmbientLightLevel
-    if (!this.device.blindTilt?.hide_lightsensor) {
-      if (this.LightSensor!.CurrentAmbientLightLevel === undefined || Number.isNaN(this.LightSensor!.CurrentAmbientLightLevel)) {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName}`
-          + ` CurrentAmbientLightLevel: ${this.LightSensor!.CurrentAmbientLightLevel}`);
-      } else {
-        if (this.device.mqttURL) {
-          this.mqttPublish('CurrentAmbientLightLevel', this.LightSensor!.CurrentAmbientLightLevel.toString());
-        }
-        this.accessory.context.CurrentAmbientLightLevel = this.LightSensor!.CurrentAmbientLightLevel;
-        this.LightSensor!.Service.updateCharacteristic(this.hap.Characteristic.CurrentAmbientLightLevel, this.LightSensor!.CurrentAmbientLightLevel);
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName}`
-          + ` updateCharacteristic CurrentAmbientLightLevel: ${this.LightSensor!.CurrentAmbientLightLevel}`);
-      }
+    if (!this.device.blindTilt?.hide_lightsensor && this.LightSensor?.Service) {
+      const history = { time: Math.round(new Date().valueOf() / 1000), lux: this.LightSensor.CurrentAmbientLightLevel };
+      await this.updateCharacteristic(this.LightSensor?.Service, this.hap.Characteristic.CurrentAmbientLightLevel,
+        this.LightSensor?.CurrentAmbientLightLevel, 'CurrentAmbientLightLevel', history);
     }
     // BatteryLevel
-    if (this.Battery.BatteryLevel === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BatteryLevel: ${this.Battery.BatteryLevel}`);
-    } else {
-      if (this.device.mqttURL) {
-        this.mqttPublish('BatteryLevel', this.Battery.BatteryLevel.toString());
-      }
-      this.accessory.context.BatteryLevel = this.Battery.BatteryLevel;
-      this.Battery?.Service.updateCharacteristic(this.hap.Characteristic.BatteryLevel, this.Battery.BatteryLevel);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic BatteryLevel: ${this.Battery.BatteryLevel}`);
-    }
+    await this.updateCharacteristic(this.Battery.Service, this.hap.Characteristic.BatteryLevel,
+      this.Battery.BatteryLevel, 'BatteryLevel');
     // StatusLowBattery
-    if (this.Battery.StatusLowBattery === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} StatusLowBattery: ${this.Battery.StatusLowBattery}`);
-    } else {
-      if (this.device.mqttURL) {
-        this.mqttPublish('StatusLowBattery', this.Battery.StatusLowBattery.toString());
-      }
-      this.accessory.context.StatusLowBattery = this.Battery.StatusLowBattery;
-      this.Battery?.Service.updateCharacteristic(this.hap.Characteristic.StatusLowBattery, this.Battery.StatusLowBattery);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
-        + ` StatusLowBattery: ${this.Battery.StatusLowBattery}`);
-    }
-    if (this.Battery.ChargingState === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ChargingState: ${this.Battery.ChargingState}`);
-    } else {
-      if (this.device.mqttURL) {
-        this.mqttPublish('ChargingState', this.Battery.ChargingState.toString());
-      }
-      this.accessory.context.ChargingState = this.Battery.ChargingState;
-      this.Battery.Service.updateCharacteristic(this.hap.Characteristic.ChargingState, this.Battery.ChargingState);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
-        + ` ChargingState: ${this.Battery.ChargingState}`);
-    }
+    await this.updateCharacteristic(this.Battery.Service, this.hap.Characteristic.StatusLowBattery,
+      this.Battery.StatusLowBattery, 'StatusLowBattery');
+    // ChargingState
+    await this.updateCharacteristic(this.Battery.Service, this.hap.Characteristic.ChargingState,
+      this.Battery.ChargingState, 'ChargingState');
   }
 
   async BLEPushConnection() {

package/src/device/bot.ts

@@ -632,9 +632,8 @@ export class Bot extends deviceBase {
         await this.statusCodes(statusCode, deviceStatus);
       }
     } catch (e: any) {
-      this.apiError(e);
-      this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed openAPIRefreshStatus with ${this.device.connectionType}`
-        + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+      await this.apiError(e);
+      await this.openAPIRefreshError(e);
     }
   }
 
@@ -679,8 +678,7 @@ export class Bot extends deviceBase {
       await this.openAPIpushChanges();
     } else {
       await this.offlineOff();
-      this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} Connection Type:`
-        + ` ${this.device.connectionType}, pushChanges will not happen.`);
+      await this.pushChangeDisabled();
     }
     // Refresh the status from the API
     interval(15000)

package/src/device/ceilinglight.ts

@@ -314,9 +314,8 @@ export class CeilingLight extends deviceBase {
         await this.statusCodes(statusCode, deviceStatus);
       }
     } catch (e: any) {
-      this.apiError(e);
-      this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed openAPIRefreshStatus with ${this.device.connectionType}`
-        + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+      await this.apiError(e);
+      await this.openAPIRefreshError(e);
     }
   }
 
@@ -387,8 +386,7 @@ export class CeilingLight extends deviceBase {
       await this.openAPIpushChanges();
     } else {
       await this.offlineOff();
-      this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} Connection Type:`
-        + ` ${this.device.connectionType}, pushChanges will not happen.`);
+      await this.pushChangeDisabled();
     }
     // Refresh the status from the API
     interval(15000)
@@ -691,42 +689,21 @@ export class CeilingLight extends deviceBase {
   }
 
   async updateHomeKitCharacteristics(): Promise<void> {
-    if (this.LightBulb.On === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${this.LightBulb.On}`);
-    } else {
-      this.accessory.context.On = this.LightBulb.On;
-      this.LightBulb!.Service.updateCharacteristic(this.hap.Characteristic.On, this.LightBulb.On);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic On: ${this.LightBulb.On}`);
-    }
-    if (this.LightBulb.Brightness === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Brightness: ${this.LightBulb.Brightness}`);
-    } else {
-      this.accessory.context.Brightness = this.LightBulb.Brightness;
-      this.LightBulb!.Service.updateCharacteristic(this.hap.Characteristic.Brightness, this.LightBulb.Brightness);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic Brightness: ${this.LightBulb.Brightness}`);
-    }
-    if (this.LightBulb.ColorTemperature === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ColorTemperature: ${this.LightBulb.ColorTemperature}`);
-    } else {
-      this.accessory.context.ColorTemperature = this.LightBulb.ColorTemperature;
-      this.LightBulb!.Service.updateCharacteristic(this.hap.Characteristic.ColorTemperature, this.LightBulb.ColorTemperature);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName}`
-        + ` updateCharacteristic ColorTemperature: ${this.LightBulb.ColorTemperature}`);
-    }
-    if (this.LightBulb.Hue === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Hue: ${this.LightBulb.Hue}`);
-    } else {
-      this.accessory.context.Hue = this.LightBulb.Hue;
-      this.LightBulb!.Service.updateCharacteristic(this.hap.Characteristic.Hue, this.LightBulb.Hue);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic Hue: ${this.LightBulb.Hue}`);
-    }
-    if (this.LightBulb.Saturation === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Saturation: ${this.LightBulb.Saturation}`);
-    } else {
-      this.accessory.context.Saturation = this.LightBulb.Saturation;
-      this.LightBulb!.Service.updateCharacteristic(this.hap.Characteristic.Saturation, this.LightBulb.Saturation);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic Saturation: ${this.LightBulb.Saturation}`);
-    }
+    // On
+    await this.updateCharacteristic(this.LightBulb.Service, this.hap.Characteristic.On,
+      this.LightBulb.On, 'On');
+    // Brightness
+    await this.updateCharacteristic(this.LightBulb.Service, this.hap.Characteristic.Brightness,
+      this.LightBulb.Brightness, 'Brightness');
+    // ColorTemperature
+    await this.updateCharacteristic(this.LightBulb.Service, this.hap.Characteristic.ColorTemperature,
+      this.LightBulb.ColorTemperature, 'ColorTemperature');
+    // Hue
+    await this.updateCharacteristic(this.LightBulb.Service, this.hap.Characteristic.Hue,
+      this.LightBulb.Hue, 'Hue');
+    // Saturation
+    await this.updateCharacteristic(this.LightBulb.Service, this.hap.Characteristic.Saturation,
+      this.LightBulb.Saturation, 'Saturation');
   }
 
   async adaptiveLighting(device: device & devicesConfig): Promise<void> {
@@ -761,7 +738,7 @@ export class CeilingLight extends deviceBase {
     }
   }
 
-  apiError(e: any): void {
+  async apiError(e: any): Promise<void> {
     this.LightBulb!.Service.updateCharacteristic(this.hap.Characteristic.On, e);
     this.LightBulb!.Service.updateCharacteristic(this.hap.Characteristic.Hue, e);
     this.LightBulb!.Service.updateCharacteristic(this.hap.Characteristic.Brightness, e);

package/src/device/colorbulb.ts

@@ -341,9 +341,8 @@ export class ColorBulb extends deviceBase {
         await this.statusCodes(statusCode, deviceStatus);
       }
     } catch (e: any) {
-      this.apiError(e);
-      this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed openAPIRefreshStatus with ${this.device.connectionType}`
-        + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+      await this.apiError(e);
+      await this.openAPIRefreshError(e);
     }
   }
 
@@ -440,8 +439,7 @@ export class ColorBulb extends deviceBase {
       await this.openAPIpushChanges();
     } else {
       await this.offlineOff();
-      this.debugWarnLog(`${this.device.deviceType}: ${this.accessory.displayName} Connection Type:`
-        + ` ${this.device.connectionType}, pushChanges will not happen.`);
+      await this.pushChangeDisabled();
     }
     // Refresh the status from the API
     interval(15000)
@@ -499,6 +497,7 @@ export class ColorBulb extends deviceBase {
       if (this.LightBulb.On) {
         await this.BLEpushRGBChanges();
       }
+      await this.updateHomeKitCharacteristics();
     } else {
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No BLEpushChanges, On: ${this.LightBulb.On},`
         + ` OnCached: ${this.accessory.context.On}`);
@@ -852,46 +851,20 @@ export class ColorBulb extends deviceBase {
 
   async updateHomeKitCharacteristics(): Promise<void> {
     // On
-    if (this.LightBulb.On === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${this.LightBulb.On}`);
-    } else {
-      this.accessory.context.On = this.LightBulb.On;
-      this.LightBulb.Service.updateCharacteristic(this.hap.Characteristic.On, this.LightBulb.On);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic On: ${this.LightBulb.On}`);
-    }
+    await this.updateCharacteristic(this.LightBulb.Service, this.hap.Characteristic.On,
+      this.LightBulb.On, 'On');
     // Brightness
-    if (this.LightBulb.Brightness === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Brightness: ${this.LightBulb.Brightness}`);
-    } else {
-      this.accessory.context.Brightness = this.LightBulb.Brightness;
-      this.LightBulb.Service.updateCharacteristic(this.hap.Characteristic.Brightness, this.LightBulb.Brightness);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic Brightness: ${this.LightBulb.Brightness}`);
-    }
+    await this.updateCharacteristic(this.LightBulb.Service, this.hap.Characteristic.Brightness,
+      this.LightBulb.Brightness, 'Brightness');
     // ColorTemperature
-    if (this.LightBulb.ColorTemperature === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ColorTemperature: ${this.LightBulb.ColorTemperature}`);
-    } else {
-      this.accessory.context.ColorTemperature = this.LightBulb.ColorTemperature;
-      this.LightBulb.Service.updateCharacteristic(this.hap.Characteristic.ColorTemperature, this.LightBulb.ColorTemperature);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
-        + ` ColorTemperature: ${this.LightBulb.ColorTemperature}`);
-    }
+    await this.updateCharacteristic(this.LightBulb.Service, this.hap.Characteristic.ColorTemperature,
+      this.LightBulb.ColorTemperature, 'ColorTemperature');
     // Hue
-    if (this.LightBulb.Hue === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Hue: ${this.LightBulb.Hue}`);
-    } else {
-      this.accessory.context.Hue = this.LightBulb.Hue;
-      this.LightBulb.Service.updateCharacteristic(this.hap.Characteristic.Hue, this.LightBulb.Hue);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic Hue: ${this.LightBulb.Hue}`);
-    }
+    await this.updateCharacteristic(this.LightBulb.Service, this.hap.Characteristic.Hue,
+      this.LightBulb.Hue, 'Hue');
     // Saturation
-    if (this.LightBulb.Saturation === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Saturation: ${this.LightBulb.Saturation}`);
-    } else {
-      this.accessory.context.Saturation = this.LightBulb.Saturation;
-      this.LightBulb.Service.updateCharacteristic(this.hap.Characteristic.Saturation, this.LightBulb.Saturation);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic Saturation: ${this.LightBulb.Saturation}`);
-    }
+    await this.updateCharacteristic(this.LightBulb.Service, this.hap.Characteristic.Saturation,
+      this.LightBulb.Saturation, 'Saturation');
   }
 
   async adaptiveLighting(device: device & devicesConfig): Promise<void> {

package/src/device/contact.ts

@@ -340,9 +340,8 @@ export class Contact extends deviceBase {
         await this.statusCodes(statusCode, deviceStatus);
       }
     } catch (e: any) {
-      this.apiError(e);
-      this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed openAPIRefreshStatus with ${this.device.connectionType}`
-        + ` Connection, Error Message: ${JSON.stringify(e.message)}`);
+      await this.apiError(e);
+      await this.openAPIRefreshError(e);
     }
   }
 
@@ -381,50 +380,25 @@ export class Contact extends deviceBase {
    * Updates the status for each of the HomeKit Characteristics
    */
   async updateHomeKitCharacteristics(): Promise<void> {
-    if (this.ContactSensor.ContactSensorState === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ContactSensorState: ${this.ContactSensor.ContactSensorState}`);
-    } else {
-      this.accessory.context.ContactSensorState = this.ContactSensor.ContactSensorState;
-      this.ContactSensor.Service.updateCharacteristic(this.hap.Characteristic.ContactSensorState, this.ContactSensor.ContactSensorState);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
-        + ` ContactSensorState: ${this.ContactSensor.ContactSensorState}`);
+    // ContactSensorState
+    await this.updateCharacteristic(this.ContactSensor.Service, this.hap.Characteristic.ContactSensorState,
+      this.ContactSensor.ContactSensorState, 'ContactSensorState');
+    // MotionDetected
+    if (!this.device.contact?.hide_motionsensor && this.MotionSensor?.Service) {
+      await this.updateCharacteristic(this.MotionSensor.Service, this.hap.Characteristic.MotionDetected,
+        this.MotionSensor.MotionDetected, 'MotionDetected');
     }
-    if (!this.device.contact?.hide_motionsensor) {
-      if (this.MotionSensor!.MotionDetected === undefined) {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} MotionDetected: ${this.MotionSensor!.MotionDetected}`);
-      } else {
-        this.accessory.context.MotionDetected = this.MotionSensor!.MotionDetected;
-        this.MotionSensor!.Service.updateCharacteristic(this.hap.Characteristic.MotionDetected, this.MotionSensor!.MotionDetected);
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
-          + ` MotionDetected: ${this.MotionSensor!.MotionDetected}`);
-      }
-    }
-    if (!this.device.contact?.hide_lightsensor) {
-      if (this.LightSensor?.CurrentAmbientLightLevel === undefined) {
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName}`
-          + ` CurrentAmbientLightLevel: ${this.LightSensor?.CurrentAmbientLightLevel}`);
-      } else {
-        this.accessory.context.CurrentAmbientLightLevel = this.LightSensor.CurrentAmbientLightLevel;
-        this.LightSensor.Service.updateCharacteristic(this.hap.Characteristic.CurrentAmbientLightLevel, this.LightSensor.CurrentAmbientLightLevel);
-        this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName}`
-          + ` updateCharacteristic CurrentAmbientLightLevel: ${this.LightSensor.CurrentAmbientLightLevel}`);
-      }
-    }
-    if (this.Battery.BatteryLevel === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BatteryLevel: ${this.Battery.BatteryLevel}`);
-    } else {
-      this.accessory.context.BatteryLevel = this.Battery.BatteryLevel;
-      this.Battery.Service.updateCharacteristic(this.hap.Characteristic.BatteryLevel, this.Battery.BatteryLevel);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic BatteryLevel: ${this.Battery.BatteryLevel}`);
-    }
-    if (this.Battery.StatusLowBattery === undefined) {
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} StatusLowBattery: ${this.Battery.StatusLowBattery}`);
-    } else {
-      this.accessory.context.StatusLowBattery = this.Battery.StatusLowBattery;
-      this.Battery.Service.updateCharacteristic(this.hap.Characteristic.StatusLowBattery, this.Battery.StatusLowBattery);
-      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
-        + ` StatusLowBattery: ${this.Battery.StatusLowBattery}`);
+    // CurrentAmbientLightLevel
+    if (!this.device.contact?.hide_lightsensor && this.LightSensor?.Service) {
+      await this.updateCharacteristic(this.LightSensor.Service, this.hap.Characteristic.CurrentAmbientLightLevel,
+        this.LightSensor.CurrentAmbientLightLevel, 'CurrentAmbientLightLevel');
     }
+    // BatteryLevel
+    await this.updateCharacteristic(this.Battery.Service, this.hap.Characteristic.BatteryLevel,
+      this.Battery.BatteryLevel, 'BatteryLevel');
+    // StatusLowBattery
+    await this.updateCharacteristic(this.Battery.Service, this.hap.Characteristic.StatusLowBattery,
+      this.Battery.StatusLowBattery, 'StatusLowBattery');
   }
 
   async BLERefreshConnection(switchbot: any): Promise<void> {
@@ -440,11 +414,11 @@ export class Contact extends deviceBase {
     if (this.device.offline) {
       this.ContactSensor.Service.updateCharacteristic(this.hap.Characteristic.ContactSensorState,
         this.hap.Characteristic.ContactSensorState.CONTACT_DETECTED);
-      if (!this.device.contact?.hide_motionsensor) {
-        this.MotionSensor!.Service.updateCharacteristic(this.hap.Characteristic.MotionDetected, false);
+      if (!this.device.contact?.hide_motionsensor && this.MotionSensor?.Service) {
+        this.MotionSensor.Service.updateCharacteristic(this.hap.Characteristic.MotionDetected, false);
       }
-      if (!this.device.contact?.hide_lightsensor) {
-        this.LightSensor!.Service.updateCharacteristic(this.hap.Characteristic.CurrentAmbientLightLevel, 100);
+      if (!this.device.contact?.hide_lightsensor && this.LightSensor?.Service) {
+        this.LightSensor.Service.updateCharacteristic(this.hap.Characteristic.CurrentAmbientLightLevel, 100);
       }
     }
   }
@@ -452,13 +426,13 @@ export class Contact extends deviceBase {
   async apiError(e: any): Promise<void> {
     this.ContactSensor.Service.updateCharacteristic(this.hap.Characteristic.ContactSensorState, e);
     this.ContactSensor.Service.updateCharacteristic(this.hap.Characteristic.StatusActive, e);
-    if (!this.device.contact?.hide_motionsensor) {
-      this.MotionSensor!.Service.updateCharacteristic(this.hap.Characteristic.MotionDetected, e);
-      this.MotionSensor!.Service.updateCharacteristic(this.hap.Characteristic.StatusActive, e);
+    if (!this.device.contact?.hide_motionsensor && this.MotionSensor?.Service) {
+      this.MotionSensor.Service.updateCharacteristic(this.hap.Characteristic.MotionDetected, e);
+      this.MotionSensor.Service.updateCharacteristic(this.hap.Characteristic.StatusActive, e);
     }
-    if (!this.device.contact?.hide_lightsensor) {
-      this.LightSensor!.Service.updateCharacteristic(this.hap.Characteristic.CurrentAmbientLightLevel, e);
-      this.LightSensor!.Service.updateCharacteristic(this.hap.Characteristic.StatusActive, e);
+    if (!this.device.contact?.hide_lightsensor && this.LightSensor?.Service) {
+      this.LightSensor.Service.updateCharacteristic(this.hap.Characteristic.CurrentAmbientLightLevel, e);
+      this.LightSensor.Service.updateCharacteristic(this.hap.Characteristic.StatusActive, e);
     }
     this.Battery.Service.updateCharacteristic(this.hap.Characteristic.BatteryLevel, e);
     this.Battery.Service.updateCharacteristic(this.hap.Characteristic.StatusLowBattery, e);