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

package/src/device/hub.ts

@@ -165,14 +165,102 @@ export class Hub {
         try {
           this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} received Webhook: ${JSON.stringify(context)}`);
           if (context.scale === 'CELSIUS') {
-            const { temperature, humidity } = context;
-            const { CurrentTemperature, CurrentRelativeHumidity } = this;
+            const { temperature, humidity, lightLevel } = context;
+            const { CurrentTemperature, CurrentRelativeHumidity, CurrentAmbientLightLevel } = this;
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ` +
-                '(temperature, humidity) = ' +
-                `Webhook:(${temperature}, ${humidity}), ` +
-                `current:(${CurrentTemperature}, ${CurrentRelativeHumidity})`);
+                '(temperature, humidity, lightLevel) = ' +
+                `Webhook:(${temperature}, ${humidity}, ${lightLevel}), ` +
+                `current:(${CurrentTemperature}, ${CurrentRelativeHumidity}, ${CurrentAmbientLightLevel})`);
             this.CurrentRelativeHumidity = humidity;
             this.CurrentTemperature = temperature;
+            this.set_minLux = this.minLux();
+            this.set_maxLux = this.maxLux();
+            this.spaceBetweenLevels = 19;
+            switch (lightLevel) {
+              case 1:
+                this.CurrentAmbientLightLevel = this.set_minLux;
+                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.OpenAPI_CurrentAmbientLightLevel}`);
+                break;
+              case 2:
+                this.CurrentAmbientLightLevel = (this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels;
+                this.debugLog(
+                  `${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.OpenAPI_CurrentAmbientLightLevel},` +
+                  ` Calculation: ${(this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels}`,
+                );
+                break;
+              case 3:
+                this.CurrentAmbientLightLevel = ((this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels) * 2;
+                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.OpenAPI_CurrentAmbientLightLevel}`);
+                break;
+              case 4:
+                this.CurrentAmbientLightLevel = ((this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels) * 3;
+                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.OpenAPI_CurrentAmbientLightLevel}`);
+                break;
+              case 5:
+                this.CurrentAmbientLightLevel = ((this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels) * 4;
+                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.OpenAPI_CurrentAmbientLightLevel}`);
+                break;
+              case 6:
+                this.CurrentAmbientLightLevel = ((this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels) * 5;
+                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.OpenAPI_CurrentAmbientLightLevel}`);
+                break;
+              case 7:
+                this.CurrentAmbientLightLevel = ((this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels) * 6;
+                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.OpenAPI_CurrentAmbientLightLevel}`);
+                break;
+              case 8:
+                this.CurrentAmbientLightLevel = ((this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels) * 7;
+                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.OpenAPI_CurrentAmbientLightLevel}`);
+                break;
+              case 9:
+                this.CurrentAmbientLightLevel = ((this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels) * 8;
+                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.OpenAPI_CurrentAmbientLightLevel}`);
+                break;
+              case 10:
+                this.CurrentAmbientLightLevel = ((this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels) * 9;
+                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.OpenAPI_CurrentAmbientLightLevel}`);
+                break;
+              case 11:
+                this.CurrentAmbientLightLevel = ((this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels) * 10;
+                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.OpenAPI_CurrentAmbientLightLevel}`);
+                break;
+              case 12:
+                this.CurrentAmbientLightLevel = ((this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels) * 11;
+                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.OpenAPI_CurrentAmbientLightLevel}`);
+                break;
+              case 13:
+                this.CurrentAmbientLightLevel = ((this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels) * 12;
+                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.OpenAPI_CurrentAmbientLightLevel}`);
+                break;
+              case 14:
+                this.CurrentAmbientLightLevel = ((this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels) * 13;
+                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.OpenAPI_CurrentAmbientLightLevel}`);
+                break;
+              case 15:
+                this.CurrentAmbientLightLevel = ((this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels) * 14;
+                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.OpenAPI_CurrentAmbientLightLevel}`);
+                break;
+              case 16:
+                this.CurrentAmbientLightLevel = ((this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels) * 15;
+                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.OpenAPI_CurrentAmbientLightLevel}`);
+                break;
+              case 17:
+                this.CurrentAmbientLightLevel = ((this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels) * 16;
+                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.OpenAPI_CurrentAmbientLightLevel}`);
+                break;
+              case 18:
+                this.CurrentAmbientLightLevel = ((this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels) * 17;
+                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.OpenAPI_CurrentAmbientLightLevel}`);
+                break;
+              case 19:
+                this.CurrentAmbientLightLevel = ((this.set_maxLux - this.set_minLux) / this.spaceBetweenLevels) * 18;
+                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.OpenAPI_CurrentAmbientLightLevel}`);
+                break;
+              case 20:
+              default:
+                this.CurrentAmbientLightLevel = this.set_maxLux;
+                this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.OpenAPI_CurrentAmbientLightLevel}`);
+            }
             this.updateHomeKitCharacteristics();
           }
         } catch (e: any) {
@@ -300,7 +388,7 @@ export class Hub {
           case 20:
           default:
             this.CurrentAmbientLightLevel = this.set_maxLux;
-            this.debugLog();
+            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.OpenAPI_CurrentAmbientLightLevel}`);
         }
         this.debugLog(
           `${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${this.OpenAPI_CurrentAmbientLightLevel},` +

package/src/device/humidifier.ts

@@ -164,6 +164,30 @@ export class Humidifier {
         this.refreshStatus();
       });
 
+    //regisiter webhook event handler
+    if (this.device.webhook) {
+      this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} is listening webhook.`);
+      this.platform.webhookEventHandler[this.device.deviceId] = async (context) => {
+        try {
+          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} received Webhook: ${JSON.stringify(context)}`);
+          if (context.scale === 'CELSIUS') {
+            const { temperature, humidity } = context;
+            const { CurrentTemperature, CurrentRelativeHumidity } = this;
+            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ` +
+                    '(temperature, humidity) = ' +
+                    `Webhook:(${temperature}, ${humidity}), ` +
+                    `current:(${CurrentTemperature}, ${CurrentRelativeHumidity})`);
+            this.CurrentRelativeHumidity = humidity;
+            this.CurrentTemperature = temperature;
+            this.updateHomeKitCharacteristics();
+          }
+        } catch (e: any) {
+          this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} `
+                  + `failed to handle webhook. Received: ${JSON.stringify(context)} Error: ${e}`);
+        }
+      };
+    }
+
     // Watch for Humidifier change events
     // We put in a debounce of 100ms so we don't make duplicate calls
     this.doHumidifierUpdate

package/src/device/iosensor.ts

@@ -169,6 +169,30 @@ export class IOSensor {
       .subscribe(async () => {
         await this.refreshStatus();
       });
+
+    //regisiter webhook event handler
+    if (this.device.webhook) {
+      this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} is listening webhook.`);
+      this.platform.webhookEventHandler[this.device.deviceId] = async (context) => {
+        try {
+          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} received Webhook: ${JSON.stringify(context)}`);
+          if (context.scale === 'CELSIUS') {
+            const { temperature, humidity } = context;
+            const { CurrentTemperature, CurrentRelativeHumidity } = this;
+            this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ` +
+                  '(temperature, humidity) = ' +
+                  `Webhook:(${temperature}, ${humidity}), ` +
+                  `current:(${CurrentTemperature}, ${CurrentRelativeHumidity})`);
+            this.CurrentRelativeHumidity = humidity;
+            this.CurrentTemperature = temperature;
+            this.updateHomeKitCharacteristics();
+          }
+        } catch (e: any) {
+          this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} `
+                + `failed to handle webhook. Received: ${JSON.stringify(context)} Error: ${e}`);
+        }
+      };
+    }
   }
 
   /**

package/src/device/lightstrip.ts

@@ -183,6 +183,48 @@ export class StripLight {
         await this.refreshStatus();
       });
 
+    //regisiter webhook event handler
+    if (this.device.webhook) {
+      this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} is listening webhook.`);
+      this.platform.webhookEventHandler[this.device.deviceId] = async (context) => {
+        try {
+          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} received Webhook: ${JSON.stringify(context)}`);
+          const { powerState, brightness, color, colorTemperature } = context;
+          const { On, Brightness, Hue, Saturation, ColorTemperature } = this;
+          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ` +
+              '(powerState, brightness, color, colorTemperature) = ' +
+              `Webhook:(${powerState}, ${brightness}, ${color}, ${colorTemperature}), ` +
+              `current:(${On}, ${Brightness}, ${Hue}, ${Saturation}, ${ColorTemperature})`);
+          this.On = powerState === 'ON' ? true : false;
+          this.Brightness = brightness;
+
+          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} color: ${JSON.stringify(color)}`);
+          const [red, green, blue] = color!.split(':');
+          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} red: ${JSON.stringify(red)}`);
+          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} green: ${JSON.stringify(green)}`);
+          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} blue: ${JSON.stringify(blue)}`);
+
+          const [hue, saturation] = rgb2hs(Number(red), Number(green), Number(blue));
+          this.debugLog(
+            `${this.device.deviceType}: ${this.accessory.displayName}` + ` hs: ${JSON.stringify(rgb2hs(Number(red), Number(green), Number(blue)))}`,
+          );
+
+          // Hue
+          this.Hue = hue;
+          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Hue: ${this.Hue}`);
+
+          // Saturation
+          this.Saturation = saturation;
+          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} Saturation: ${this.Saturation}`);
+
+          this.updateHomeKitCharacteristics();
+        } catch (e: any) {
+          this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} `
+              + `failed to handle webhook. Received: ${JSON.stringify(context)} Error: ${e}`);
+        }
+      };
+    }
+
     // Watch for Bulb change events
     // We put in a debounce of 1000ms so we don't make duplicate calls
     this.doStripLightUpdate

package/src/device/lock.ts

@@ -132,6 +132,27 @@ export class Lock {
         await this.refreshStatus();
       });
 
+    //regisiter webhook event handler
+    if (this.device.webhook) {
+      this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} is listening webhook.`);
+      this.platform.webhookEventHandler[this.device.deviceId] = async (context) => {
+        try {
+          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} received Webhook: ${JSON.stringify(context)}`);
+          const { lockState } = context;
+          const { LockCurrentState } = this;
+          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ` +
+                    '(lockState) = ' +
+                    `Webhook:(${lockState}), ` +
+                    `current:(${LockCurrentState})`);
+          this.LockCurrentState = lockState === 'LOCKED' ? 1 : 0;
+          this.updateHomeKitCharacteristics();
+        } catch (e: any) {
+          this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} `
+                  + `failed to handle webhook. Received: ${JSON.stringify(context)} Error: ${e}`);
+        }
+      };
+    }
+
     // Watch for Lock change events
     // We put in a debounce of 100ms so we don't make duplicate calls
     this.doLockUpdate

package/src/device/motion.ts

@@ -131,6 +131,27 @@ export class Motion {
       .subscribe(async () => {
         await this.refreshStatus();
       });
+
+    //regisiter webhook event handler
+    if (this.device.webhook) {
+      this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} is listening webhook.`);
+      this.platform.webhookEventHandler[this.device.deviceId] = async (context) => {
+        try {
+          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} received Webhook: ${JSON.stringify(context)}`);
+          const { detectionState } = context;
+          const { MotionDetected } = this;
+          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ` +
+                    '(detectionState) = ' +
+                    `Webhook:(${detectionState}), ` +
+                    `current:(${MotionDetected})`);
+          this.MotionDetected = detectionState === 'DETECTED' ? true : false;
+          this.updateHomeKitCharacteristics();
+        } catch (e: any) {
+          this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} `
+                  + `failed to handle webhook. Received: ${JSON.stringify(context)} Error: ${e}`);
+        }
+      };
+    }
   }
 
   /**

package/src/device/plug.ts

@@ -88,6 +88,27 @@ export class Plug {
         await this.refreshStatus();
       });
 
+    //regisiter webhook event handler
+    if (this.device.webhook) {
+      this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} is listening webhook.`);
+      this.platform.webhookEventHandler[this.device.deviceId] = async (context) => {
+        try {
+          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} received Webhook: ${JSON.stringify(context)}`);
+          const { powerState } = context;
+          const { On } = this;
+          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ` +
+                      '(powerState) = ' +
+                      `Webhook:(${powerState}), ` +
+                      `current:(${On})`);
+          this.On = powerState === 'ON' ? true : false;
+          this.updateHomeKitCharacteristics();
+        } catch (e: any) {
+          this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} `
+                    + `failed to handle webhook. Received: ${JSON.stringify(context)} Error: ${e}`);
+        }
+      };
+    }
+
     // Watch for Plug change events
     // We put in a debounce of 100ms so we don't make duplicate calls
     this.doPlugUpdate

package/src/device/robotvacuumcleaner.ts

@@ -120,6 +120,28 @@ export class RobotVacuumCleaner {
         await this.refreshStatus();
       });
 
+    //regisiter webhook event handler
+    if (this.device.webhook) {
+      this.infoLog(`${this.device.deviceType}: ${this.accessory.displayName} is listening webhook.`);
+      this.platform.webhookEventHandler[this.device.deviceId] = async (context) => {
+        try {
+          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} received Webhook: ${JSON.stringify(context)}`);
+          const { onlineStatus, battery } = context;
+          const { On, BatteryLevel } = this;
+          this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ` +
+                        '(onlineStatus, battery) = ' +
+                        `Webhook:(${onlineStatus}, ${battery}), ` +
+                        `current:(${On}, ${BatteryLevel})`);
+          this.On = onlineStatus === 'online' ? true : false;
+          this.BatteryLevel = battery;
+          this.updateHomeKitCharacteristics();
+        } catch (e: any) {
+          this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} `
+                      + `failed to handle webhook. Received: ${JSON.stringify(context)} Error: ${e}`);
+        }
+      };
+    }
+
     // Watch for Plug change events
     // We put in a debounce of 100ms so we don't make duplicate calls
     this.doRobotVacuumCleanerUpdate