@switchbot/homebridge-switchbot 2.0.0-beta.22 → 2.0.0-beta.23

package/src/device/bot.ts

@@ -484,17 +484,17 @@ export class Bot {
             this.BLEparseStatus();
             this.updateHomeKitCharacteristics();
           } else {
-            await this.BLEconnection(switchbot);
+            await this.BLERefreshConnection(switchbot);
           }
         })
         .catch(async (e: any) => {
           this.apiError(e);
           this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLERefreshStatus with ${this.device.connectionType}`
               + ` Connection, Error Message: ${superStringify(e.message)}`);
-          await this.BLEconnection(switchbot);
+          await this.BLERefreshConnection(switchbot);
         });
     } else {
-      await this.BLEconnection(switchbot);
+      await this.BLERefreshConnection(switchbot);
     }
   }
 
@@ -1084,10 +1084,17 @@ export class Bot {
     }
   }
 
-  async BLEconnection(switchbot: any): Promise<void> {
+  async BLEPushConnection() {
+    if (this.platform.config.credentials?.token && this.device.connectionType !== 'BLE/OpenAPI') {
+      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection to Push Changes`);
+      await this.openAPIpushChanges();
+    }
+  }
+
+  async BLERefreshConnection(switchbot: any): Promise<void> {
     this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`);
     if (this.platform.config.credentials?.token && this.device.connectionType !== 'BLE/OpenAPI') {
-      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
+      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection to Refresh Status`);
       await this.openAPIRefreshStatus();
     }
   }

package/src/device/colorbulb.ts

@@ -366,17 +366,17 @@ export class ColorBulb {
             this.BLEparseStatus();
             this.updateHomeKitCharacteristics();
           } else {
-            await this.BLEconnection(switchbot);
+            await this.BLERefreshConnection(switchbot);
           }
         })
         .catch(async (e: any) => {
           this.apiError(e);
           this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLERefreshStatus with ${this.device.connectionType}`
                 + ` Connection, Error Message: ${superStringify(e.message)}`);
-          await this.BLEconnection(switchbot);
+          await this.BLERefreshConnection(switchbot);
         });
     } else {
-      await this.BLEconnection(switchbot);
+      await this.BLERefreshConnection(switchbot);
     }
   }
 
@@ -491,10 +491,7 @@ export class ColorBulb {
           this.apiError(e);
           this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLEpushChanges with ${this.device.connectionType}`
         + ` Connection, Error Message: ${superStringify(e.message)}`);
-          if (this.platform.config.credentials?.token && this.device.connectionType !== 'BLE/OpenAPI') {
-            this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
-            await this.openAPIpushChanges();
-          }
+          await this.BLEPushConnection();
         });
     } else {
       this.debugLog(
@@ -896,10 +893,17 @@ export class ColorBulb {
     }
   }
 
-  async BLEconnection(switchbot: any): Promise<void> {
+  async BLEPushConnection() {
+    if (this.platform.config.credentials?.token && this.device.connectionType !== 'BLE/OpenAPI') {
+      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection to Push Changes`);
+      await this.openAPIpushChanges();
+    }
+  }
+
+  async BLERefreshConnection(switchbot: any): Promise<void> {
     this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`);
-    if (this.platform.config.credentials?.token) {
-      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
+    if (this.platform.config.credentials?.token && this.device.connectionType !== 'BLE/OpenAPI') {
+      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection to Refresh Status`);
       await this.openAPIRefreshStatus();
     }
   }

package/src/device/contact.ts

@@ -329,17 +329,17 @@ export class Contact {
             this.BLEparseStatus();
             this.updateHomeKitCharacteristics();
           } else {
-            await this.BLEconnection(switchbot);
+            await this.BLERefreshConnection(switchbot);
           }
         })
         .catch(async (e: any) => {
           this.apiError(e);
           this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLERefreshStatus with ${this.device.connectionType}`
                 + ` Connection, Error Message: ${superStringify(e.message)}`);
-          await this.BLEconnection(switchbot);
+          await this.BLERefreshConnection(switchbot);
         });
     } else {
-      await this.BLEconnection(switchbot);
+      await this.BLERefreshConnection(switchbot);
     }
   }
 
@@ -464,10 +464,10 @@ export class Contact {
     }
   }
 
-  async BLEconnection(switchbot: any): Promise<void> {
+  async BLERefreshConnection(switchbot: any): Promise<void> {
     this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`);
     if (this.platform.config.credentials?.token && this.device.connectionType !== 'BLE/OpenAPI') {
-      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
+      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection to Refresh Status`);
       await this.openAPIRefreshStatus();
     }
   }

package/src/device/curtain.ts

@@ -452,17 +452,17 @@ export class Curtain {
             this.BLEparseStatus();
             this.updateHomeKitCharacteristics();
           } else {
-            await this.BLEconnection(switchbot);
+            await this.BLERefreshConnection(switchbot);
           }
         })
         .catch(async (e: any) => {
           this.apiError(e);
           this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLERefreshStatus with ${this.device.connectionType}`
                 + ` Connection, Error Message: ${superStringify(e.message)}`);
-          await this.BLEconnection(switchbot);
+          await this.BLERefreshConnection(switchbot);
         });
     } else {
-      await this.BLEconnection(switchbot);
+      await this.BLERefreshConnection(switchbot);
     }
   }
 
@@ -566,17 +566,11 @@ export class Curtain {
             this.apiError(e);
             this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLEpushChanges with ${this.device.connectionType}`
           + ` Connection, Error Message: ${superStringify(e.message)}`);
-            if (this.platform.config.credentials?.token && this.device.connectionType !== 'BLE/OpenAPI') {
-              this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
-              await this.openAPIpushChanges();
-            }
+            await this.BLEPushConnection();
           });
       } else {
         this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} wasn't able to establish BLE Connection`);
-        if (this.platform.config.credentials?.token) {
-          this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
-          await this.openAPIpushChanges();
-        }
+        await this.BLEPushConnection();
       }
     } else {
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No BLEpushChanges, CurrentPosition & TargetPosition Are the Same.` +
@@ -808,10 +802,17 @@ export class Curtain {
     }
   }
 
-  async BLEconnection(switchbot: any): Promise<void> {
+  async BLEPushConnection() {
+    if (this.platform.config.credentials?.token && this.device.connectionType !== 'BLE/OpenAPI') {
+      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection to Push Changes`);
+      await this.openAPIpushChanges();
+    }
+  }
+
+  async BLERefreshConnection(switchbot: any): Promise<void> {
     this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`);
     if (this.platform.config.credentials?.token && this.device.connectionType !== 'BLE/OpenAPI') {
-      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
+      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection to Refresh Status`);
       await this.openAPIRefreshStatus();
     }
   }

package/src/device/humidifier.ts

@@ -344,17 +344,17 @@ export class Humidifier {
             this.BLEparseStatus();
             this.updateHomeKitCharacteristics();
           } else {
-            await this.BLEconnection(switchbot);
+            await this.BLERefreshConnection(switchbot);
           }
         })
         .catch(async (e: any) => {
           this.apiError(e);
           this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLERefreshStatus with ${this.device.connectionType}`
                 + ` Connection, Error Message: ${superStringify(e.message)}`);
-          await this.BLEconnection(switchbot);
+          await this.BLERefreshConnection(switchbot);
         });
     } else {
-      await this.BLEconnection(switchbot);
+      await this.BLERefreshConnection(switchbot);
     }
   }
 
@@ -460,10 +460,7 @@ export class Humidifier {
         this.apiError(e);
         this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLEpushChanges with ${this.device.connectionType}`
       + ` Connection, Error Message: ${superStringify(e.message)}`);
-        if (this.platform.config.credentials?.token && this.device.connectionType !== 'BLE/OpenAPI') {
-          this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
-          await this.openAPIpushChanges();
-        }
+        await this.BLEPushConnection();
       });
   }
 
@@ -775,10 +772,17 @@ export class Humidifier {
     }
   }
 
-  async BLEconnection(switchbot: any): Promise<void> {
+  async BLEPushConnection() {
+    if (this.platform.config.credentials?.token && this.device.connectionType !== 'BLE/OpenAPI') {
+      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection to Push Changes`);
+      await this.openAPIpushChanges();
+    }
+  }
+
+  async BLERefreshConnection(switchbot: any): Promise<void> {
     this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`);
     if (this.platform.config.credentials?.token && this.device.connectionType !== 'BLE/OpenAPI') {
-      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
+      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection to Refresh Status`);
       await this.openAPIRefreshStatus();
     }
   }

package/src/device/lock.ts

@@ -300,10 +300,7 @@ export class Lock {
           this.apiError(e);
           this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLEpushChanges with ${this.device.connectionType}`
         + ` Connection, Error Message: ${superStringify(e.message)}`);
-          if (this.platform.config.credentials?.token && this.device.connectionType !== 'BLE/OpenAPI') {
-            this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
-            await this.openAPIpushChanges();
-          }
+          await this.BLEPushConnection();
         });
     } else {
       this.debugLog(
@@ -415,6 +412,21 @@ export class Lock {
     }
   }
 
+  async BLEPushConnection() {
+    if (this.platform.config.credentials?.token && this.device.connectionType !== 'BLE/OpenAPI') {
+      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection to Push Changes`);
+      await this.openAPIpushChanges();
+    }
+  }
+
+  async BLERefreshConnection(switchbot: any): Promise<void> {
+    this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`);
+    if (this.platform.config.credentials?.token && this.device.connectionType !== 'BLE/OpenAPI') {
+      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection to Refresh Status`);
+      await this.openAPIRefreshStatus();
+    }
+  }
+
   async scan(device: device & devicesConfig): Promise<void> {
     if (device.scanDuration) {
       this.scanDuration = this.accessory.context.scanDuration = device.scanDuration;

package/src/device/meter.ts

@@ -300,17 +300,17 @@ export class Meter {
             this.BLEparseStatus();
             this.updateHomeKitCharacteristics();
           } else {
-            await this.BLEconnection(switchbot);
+            await this.BLERefreshConnection(switchbot);
           }
         })
         .catch(async (e: any) => {
           this.apiError(e);
           this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLERefreshStatus with ${this.device.connectionType}`
                 + ` Connection, Error Message: ${superStringify(e.message)}`);
-          await this.BLEconnection(switchbot);
+          await this.BLERefreshConnection(switchbot);
         });
     } else {
-      await this.BLEconnection(switchbot);
+      await this.BLERefreshConnection(switchbot);
     }
   }
 
@@ -489,10 +489,10 @@ export class Meter {
     }
   }
 
-  async BLEconnection(switchbot: any): Promise<void> {
+  async BLERefreshConnection(switchbot: any): Promise<void> {
     this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`);
     if (this.platform.config.credentials?.token && this.device.connectionType !== 'BLE/OpenAPI') {
-      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
+      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection to Refresh Status`);
       await this.openAPIRefreshStatus();
     }
   }

package/src/device/meterplus.ts

@@ -300,17 +300,17 @@ export class MeterPlus {
             this.parseStatus();
             this.updateHomeKitCharacteristics();
           } else {
-            await this.BLEconnection(switchbot);
+            await this.BLERefreshConnection(switchbot);
           }
         })
         .catch(async (e: any) => {
           this.apiError(e);
           this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLERefreshStatus with ${this.device.connectionType}`
                 + ` Connection, Error Message: ${superStringify(e.message)}`);
-          await this.BLEconnection(switchbot);
+          await this.BLERefreshConnection(switchbot);
         });
     } else {
-      await this.BLEconnection(switchbot);
+      await this.BLERefreshConnection(switchbot);
     }
   }
 
@@ -488,10 +488,10 @@ export class MeterPlus {
     }
   }
 
-  async BLEconnection(switchbot: any): Promise<void> {
+  async BLERefreshConnection(switchbot: any): Promise<void> {
     this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`);
     if (this.platform.config.credentials?.token && this.device.connectionType !== 'BLE/OpenAPI') {
-      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
+      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection to Refresh Status`);
       await this.openAPIRefreshStatus();
     }
   }

package/src/device/motion.ts

@@ -280,17 +280,17 @@ export class Motion {
             this.BLEparseStatus();
             this.updateHomeKitCharacteristics();
           } else {
-            await this.BLEconnection(switchbot);
+            await this.BLERefreshConnection(switchbot);
           }
         })
         .catch(async (e: any) => {
           this.apiError(e);
           this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLERefreshStatus with ${this.device.connectionType}`
                 + ` Connection, Error Message: ${superStringify(e.message)}`);
-          await this.BLEconnection(switchbot);
+          await this.BLERefreshConnection(switchbot);
         });
     } else {
-      await this.BLEconnection(switchbot);
+      await this.BLERefreshConnection(switchbot);
     }
   }
 
@@ -405,10 +405,10 @@ export class Motion {
     }
   }
 
-  async BLEconnection(switchbot: any): Promise<void> {
+  async BLERefreshConnection(switchbot: any): Promise<void> {
     this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`);
     if (this.platform.config.credentials?.token && this.device.connectionType !== 'BLE/OpenAPI') {
-      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
+      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection to Refresh Status`);
       await this.openAPIRefreshStatus();
     }
   }

package/src/device/plug.ts

@@ -234,17 +234,17 @@ export class Plug {
             this.BLEparseStatus();
             this.updateHomeKitCharacteristics();
           } else {
-            await this.BLEconnection(switchbot);
+            await this.BLERefreshConnection(switchbot);
           }
         })
         .catch(async (e: any) => {
           this.apiError(e);
           this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLERefreshStatus with ${this.device.connectionType}`
                 + ` Connection, Error Message: ${superStringify(e.message)}`);
-          await this.BLEconnection(switchbot);
+          await this.BLERefreshConnection(switchbot);
         });
     } else {
-      await this.BLEconnection(switchbot);
+      await this.BLERefreshConnection(switchbot);
     }
   }
 
@@ -355,10 +355,7 @@ export class Plug {
           this.apiError(e);
           this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLEpushChanges with ${this.device.connectionType}`
         + ` Connection, Error Message: ${superStringify(e.message)}`);
-          if (this.platform.config.credentials?.token && this.device.connectionType !== 'BLE/OpenAPI') {
-            this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
-            await this.openAPIpushChanges();
-          }
+          await this.BLEPushConnection();
         });
     } else {
       this.debugLog(
@@ -481,10 +478,17 @@ export class Plug {
     }
   }
 
-  async BLEconnection(switchbot: any): Promise<void> {
+  async BLEPushConnection() {
+    if (this.platform.config.credentials?.token && this.device.connectionType !== 'BLE/OpenAPI') {
+      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection to Push Changes`);
+      await this.openAPIpushChanges();
+    }
+  }
+
+  async BLERefreshConnection(switchbot: any): Promise<void> {
     this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`);
     if (this.platform.config.credentials?.token && this.device.connectionType !== 'BLE/OpenAPI') {
-      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
+      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection to Refresh Status`);
       await this.openAPIRefreshStatus();
     }
   }

package/src/device/striplight.ts

@@ -354,17 +354,17 @@ export class StripLight {
             this.BLEparseStatus();
             this.updateHomeKitCharacteristics();
           } else {
-            await this.BLEconnection(switchbot);
+            await this.BLERefreshConnection(switchbot);
           }
         })
         .catch(async (e: any) => {
           this.apiError(e);
           this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLERefreshStatus with ${this.device.connectionType}`
                 + ` Connection, Error Message: ${superStringify(e.message)}`);
-          await this.BLEconnection(switchbot);
+          await this.BLERefreshConnection(switchbot);
         });
     } else {
-      await this.BLEconnection(switchbot);
+      await this.BLERefreshConnection(switchbot);
     }
   }
 
@@ -477,10 +477,7 @@ export class StripLight {
           this.apiError(e);
           this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} failed BLEpushChanges with ${this.device.connectionType}`
         + ` Connection, Error Message: ${superStringify(e.message)}`);
-          if (this.platform.config.credentials?.token && this.device.connectionType !== 'BLE/OpenAPI') {
-            this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
-            await this.openAPIpushChanges();
-          }
+          await this.BLEPushConnection();
         });
     } else {
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} No BLEpushChanges.` + `On: ${this.On}, `
@@ -808,10 +805,17 @@ export class StripLight {
     }
   }
 
-  async BLEconnection(switchbot: any): Promise<void> {
+  async BLEPushConnection() {
+    if (this.platform.config.credentials?.token && this.device.connectionType !== 'BLE/OpenAPI') {
+      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection to Push Changes`);
+      await this.openAPIpushChanges();
+    }
+  }
+
+  async BLERefreshConnection(switchbot: any): Promise<void> {
     this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`);
     if (this.platform.config.credentials?.token && this.device.connectionType !== 'BLE/OpenAPI') {
-      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
+      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection to Refresh Status`);
       await this.openAPIRefreshStatus();
     }
   }