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

package/src/device/contact.ts

@@ -37,7 +37,6 @@ export class Contact {
   // BLE Others
   connected?: boolean;
   switchbot!: switchbot;
-  SwitchToOpenAPI!: boolean;
   serviceData!: serviceData;
   address!: ad['address'];
   battery!: serviceData['battery'];
@@ -57,8 +56,8 @@ export class Contact {
   doContactUpdate!: Subject<void>;
 
   // Connection
-  private readonly BLE = (this.device.connectionType === 'BLE' || this.device.connectionType === 'Both');
-  private readonly OpenAPI = (this.device.connectionType === 'OpenAPI' || this.device.connectionType === 'Both');
+  private readonly BLE = (this.device.connectionType === 'BLE' || this.device.connectionType === 'BLE/OpenAPI');
+  private readonly OpenAPI = (this.device.connectionType === 'OpenAPI' || this.device.connectionType === 'BLE/OpenAPI');
 
   constructor(private readonly platform: SwitchBotPlatform, private accessory: PlatformAccessory, public device: device & devicesConfig) {
     // default placeholders
@@ -164,10 +163,9 @@ export class Contact {
    * Parse the device status from the SwitchBot api
    */
   async parseStatus(): Promise<void> {
-    if (this.BLE && !this.SwitchToOpenAPI) {
+    if (this.BLE) {
       await this.BLEparseStatus();
     } else if (this.OpenAPI && this.platform.config.credentials?.token) {
-      this.SwitchToOpenAPI = false;
       await this.openAPIparseStatus();
     } else {
       this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Connection Type:`
@@ -328,20 +326,20 @@ export class Contact {
           // Stop to monitor
           switchbot.stopScan();
           if (this.connected) {
-            this.parseStatus();
+            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);
     }
   }
 
@@ -381,7 +379,7 @@ export class Contact {
             this.openState = this.deviceStatus.body.openState;
             this.moveDetected = this.deviceStatus.body.moveDetected;
             this.brightness = this.deviceStatus.body.brightness;
-            this.parseStatus();
+            this.openAPIparseStatus();
             this.updateHomeKitCharacteristics();
           } catch (e: any) {
             this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} error message: ${e.message}`);
@@ -466,11 +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 !== 'Both') {
-      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
-      this.SwitchToOpenAPI = true;
+    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/curtain.ts

@@ -39,7 +39,6 @@ export class Curtain {
   serviceData!: serviceData;
   spaceBetweenLevels!: number;
   address!: ad['address'];
-  SwitchToOpenAPI?: boolean;
   calibration: serviceData['calibration'];
   battery: serviceData['battery'];
   position: serviceData['position'];
@@ -68,8 +67,8 @@ export class Curtain {
   doCurtainUpdate!: Subject<void>;
 
   // Connection
-  private readonly BLE = (this.device.connectionType === 'BLE' || this.device.connectionType === 'Both');
-  private readonly OpenAPI = (this.device.connectionType === 'OpenAPI' || this.device.connectionType === 'Both');
+  private readonly BLE = (this.device.connectionType === 'BLE' || this.device.connectionType === 'BLE/OpenAPI');
+  private readonly OpenAPI = (this.device.connectionType === 'OpenAPI' || this.device.connectionType === 'BLE/OpenAPI');
 
   constructor(private readonly platform: SwitchBotPlatform, private accessory: PlatformAccessory, public device: device & devicesConfig) {
     // default placeholders
@@ -215,10 +214,9 @@ export class Curtain {
    * Parse the device status from the SwitchBot api
    */
   async parseStatus(): Promise<void> {
-    if (this.BLE && !this.SwitchToOpenAPI) {
+    if (this.BLE) {
       await this.BLEparseStatus();
     } else if (this.OpenAPI && this.platform.config.credentials?.token) {
-      this.SwitchToOpenAPI = false;
       await this.openAPIparseStatus();
     } else {
       this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Connection Type:`
@@ -451,20 +449,20 @@ export class Curtain {
           // Stop to monitor
           switchbot.stopScan();
           if (this.connected) {
-            this.parseStatus();
+            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);
     }
   }
 
@@ -504,7 +502,7 @@ export class Curtain {
             this.slidePosition = this.deviceStatus.body.slidePosition;
             this.moving = this.deviceStatus.body.moving;
             this.brightness = this.deviceStatus.body.brightness;
-            this.parseStatus();
+            this.openAPIparseStatus();
             this.updateHomeKitCharacteristics();
           } catch (e: any) {
             this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} error message: ${e.message}`);
@@ -568,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 !== 'Both') {
-              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.` +
@@ -810,11 +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 !== 'Both') {
-      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
-      this.SwitchToOpenAPI = true;
+    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/humidifier.ts

@@ -41,7 +41,6 @@ export class Humidifier {
   connected?: boolean;
   serviceData!: serviceData;
   address!: ad['address'];
-  SwitchToOpenAPI?: boolean;
   onState!: serviceData['onState'];
   autoMode!: serviceData['autoMode'];
   percentage!: serviceData['percentage'];
@@ -57,8 +56,8 @@ export class Humidifier {
   doHumidifierUpdate!: Subject<void>;
 
   // Connection
-  private readonly BLE = (this.device.connectionType === 'BLE' || this.device.connectionType === 'Both');
-  private readonly OpenAPI = (this.device.connectionType === 'OpenAPI' || this.device.connectionType === 'Both');
+  private readonly BLE = (this.device.connectionType === 'BLE' || this.device.connectionType === 'BLE/OpenAPI');
+  private readonly OpenAPI = (this.device.connectionType === 'OpenAPI' || this.device.connectionType === 'BLE/OpenAPI');
 
   constructor(private readonly platform: SwitchBotPlatform, private accessory: PlatformAccessory, public device: device & devicesConfig) {
     // default placeholders
@@ -193,10 +192,9 @@ export class Humidifier {
    * Parse the device status from the SwitchBot api
    */
   async parseStatus(): Promise<void> {
-    if (this.BLE && !this.SwitchToOpenAPI) {
+    if (this.BLE) {
       await this.BLEparseStatus();
     } else if (this.OpenAPI && this.platform.config.credentials?.token) {
-      this.SwitchToOpenAPI = false;
       await this.openAPIparseStatus();
     } else {
       this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Connection Type:`
@@ -343,20 +341,20 @@ export class Humidifier {
           // Stop to monitor
           switchbot.stopScan();
           if (this.connected) {
-            this.parseStatus();
+            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);
     }
   }
 
@@ -399,7 +397,7 @@ export class Humidifier {
             this.humidity = this.deviceStatus.body.humidity;
             this.temperature = this.deviceStatus.body.temperature;
             this.nebulizationEfficiency = this.deviceStatus.body.nebulizationEfficiency;
-            this.parseStatus();
+            this.openAPIparseStatus();
             this.updateHomeKitCharacteristics();
           } catch (e: any) {
             this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} error message: ${e.message}`);
@@ -462,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 !== 'Both') {
-          this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
-          await this.openAPIpushChanges();
-        }
+        await this.BLEPushConnection();
       });
   }
 
@@ -777,11 +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 !== 'Both') {
-      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
-      this.SwitchToOpenAPI = true;
+    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/lock.ts

@@ -34,8 +34,8 @@ export class Lock {
   doLockUpdate!: Subject<void>;
 
   // Connection
-  private readonly BLE = (this.device.connectionType === 'BLE' || this.device.connectionType === 'Both');
-  private readonly OpenAPI = (this.device.connectionType === 'OpenAPI' || this.device.connectionType === 'Both');
+  private readonly BLE = (this.device.connectionType === 'BLE' || this.device.connectionType === 'BLE/OpenAPI');
+  private readonly OpenAPI = (this.device.connectionType === 'OpenAPI' || this.device.connectionType === 'BLE/OpenAPI');
 
   constructor(private readonly platform: SwitchBotPlatform, private accessory: PlatformAccessory, public device: device & devicesConfig) {
     // default placeholders
@@ -132,10 +132,9 @@ export class Lock {
    * Parse the device status from the SwitchBot api
    */
   async parseStatus(): Promise<void> {
-    /*if (this.BLE && !this.SwitchToOpenAPI) {
+    /*if (this.BLE) {
       await this.BLEparseStatus();
-    } else*/ if (this.OpenAPI) {
-      //this.SwitchToOpenAPI = false;
+    } else*/ if (this.OpenAPI && this.platform.config.credentials?.token) {
       await this.openAPIparseStatus();
     } else {
       this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Connection Type:`
@@ -143,6 +142,27 @@ export class Lock {
     }
   }
 
+  async BLEparseStatus(): Promise<void> {
+    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} BLEparseStatus`);
+    switch (this.lockState) {
+      case 'locked':
+        this.LockCurrentState = this.platform.Characteristic.LockCurrentState.SECURED;
+        this.LockTargetState = this.platform.Characteristic.LockTargetState.SECURED;
+        break;
+      default:
+        this.LockCurrentState = this.platform.Characteristic.LockCurrentState.UNSECURED;
+        this.LockTargetState = this.platform.Characteristic.LockTargetState.UNSECURED;
+    }
+    switch (this.doorState) {
+      case 'opened':
+        this.ContactSensorState = this.platform.Characteristic.ContactSensorState.CONTACT_NOT_DETECTED;
+        break;
+      default:
+        this.ContactSensorState = this.platform.Characteristic.ContactSensorState.CONTACT_DETECTED;
+    }
+    this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} On: ${this.LockTargetState}`);
+  }
+
   //{"deviceId":"DBDC23B53139","deviceType":"Smart Lock","hubDeviceId":"E68B14109DA2","lockState":"locked","doorState":"opened","calibrate":true}
 
   async openAPIparseStatus(): Promise<void> {
@@ -215,7 +235,7 @@ export class Lock {
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIRefreshStatus: ${superStringify(this.deviceStatus)}`);
             this.lockState = this.deviceStatus.body.lockState;
             this.doorState = this.deviceStatus.body.doorState;
-            this.parseStatus();
+            this.openAPIparseStatus();
             this.updateHomeKitCharacteristics();
           } catch (e: any) {
             this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} error message: ${e.message}`);
@@ -280,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 !== 'Both') {
-            this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
-            await this.openAPIpushChanges();
-          }
+          await this.BLEPushConnection();
         });
     } else {
       this.debugLog(
@@ -395,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

@@ -40,7 +40,6 @@ export class Meter {
   switchbot!: switchbot;
   serviceData!: serviceData;
   address!: ad['address'];
-  SwitchToOpenAPI?: boolean;
   temperature!: temperature['c'];
   battery!: serviceData['battery'];
   humidity!: serviceData['humidity'];
@@ -61,8 +60,8 @@ export class Meter {
   doMeterUpdate: Subject<void>;
 
   // Connection
-  private readonly BLE = (this.device.connectionType === 'BLE' || this.device.connectionType === 'Both');
-  private readonly OpenAPI = (this.device.connectionType === 'OpenAPI' || this.device.connectionType === 'Both');
+  private readonly BLE = (this.device.connectionType === 'BLE' || this.device.connectionType === 'BLE/OpenAPI');
+  private readonly OpenAPI = (this.device.connectionType === 'OpenAPI' || this.device.connectionType === 'BLE/OpenAPI');
 
   constructor(private readonly platform: SwitchBotPlatform, private accessory: PlatformAccessory, public device: device & devicesConfig) {
     // default placeholders
@@ -177,10 +176,9 @@ export class Meter {
    * Parse the device status from the SwitchBot api
    */
   async parseStatus(): Promise<void> {
-    if (this.BLE && !this.SwitchToOpenAPI) {
+    if (this.BLE) {
       await this.BLEparseStatus();
     } else if (this.OpenAPI && this.platform.config.credentials?.token) {
-      this.SwitchToOpenAPI = false;
       await this.openAPIparseStatus();
     } else {
       this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Connection Type:`
@@ -299,20 +297,20 @@ export class Meter {
           // Stop to monitor
           switchbot.stopScan();
           if (this.connected) {
-            this.parseStatus();
+            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);
     }
   }
 
@@ -351,7 +349,7 @@ export class Meter {
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIRefreshStatus: ${superStringify(this.deviceStatus)}`);
             this.Humidity = this.deviceStatus.body.humidity!;
             this.Temperature = this.deviceStatus.body.temperature!;
-            this.parseStatus();
+            this.openAPIparseStatus();
             this.updateHomeKitCharacteristics();
           } catch (e: any) {
             this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} error message: ${e.message}`);
@@ -491,11 +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 !== 'Both') {
-      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
-      this.SwitchToOpenAPI = true;
+    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/meterplus.ts

@@ -40,7 +40,6 @@ export class MeterPlus {
   switchbot!: switchbot;
   serviceData!: serviceData;
   address!: ad['address'];
-  SwitchToOpenAPI?: boolean;
   temperature!: temperature['c'];
   battery!: serviceData['battery'];
   humidity!: serviceData['humidity'];
@@ -61,8 +60,8 @@ export class MeterPlus {
   doMeterUpdate: Subject<void>;
 
   // Connection
-  private readonly BLE = (this.device.connectionType === 'BLE' || this.device.connectionType === 'Both');
-  private readonly OpenAPI = (this.device.connectionType === 'OpenAPI' || this.device.connectionType === 'Both');
+  private readonly BLE = (this.device.connectionType === 'BLE' || this.device.connectionType === 'BLE/OpenAPI');
+  private readonly OpenAPI = (this.device.connectionType === 'OpenAPI' || this.device.connectionType === 'BLE/OpenAPI');
 
   constructor(private readonly platform: SwitchBotPlatform, private accessory: PlatformAccessory, public device: device & devicesConfig) {
     // default placeholders
@@ -177,10 +176,9 @@ export class MeterPlus {
    * Parse the device status from the SwitchBot api
    */
   async parseStatus(): Promise<void> {
-    if (this.BLE && !this.SwitchToOpenAPI) {
+    if (this.BLE) {
       await this.BLEparseStatus();
     } else if (this.OpenAPI && this.platform.config.credentials?.token) {
-      this.SwitchToOpenAPI = false;
       await this.openAPIparseStatus();
     } else {
       this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Connection Type:`
@@ -302,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);
     }
   }
 
@@ -490,11 +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 !== 'Both') {
-      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
-      this.SwitchToOpenAPI = true;
+    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/motion.ts

@@ -36,7 +36,6 @@ export class Motion {
   switchbot!: switchbot;
   serviceData!: serviceData;
   address!: ad['address'];
-  SwitchToOpenAPI?: boolean;
   battery!: serviceData['battery'];
   movement!: serviceData['movement'];
   lightLevel!: serviceData['lightLevel'];
@@ -53,8 +52,8 @@ export class Motion {
   doMotionUpdate!: Subject<void>;
 
   // Connection
-  private readonly BLE = (this.device.connectionType === 'BLE' || this.device.connectionType === 'Both');
-  private readonly OpenAPI = (this.device.connectionType === 'OpenAPI' || this.device.connectionType === 'Both');
+  private readonly BLE = (this.device.connectionType === 'BLE' || this.device.connectionType === 'BLE/OpenAPI');
+  private readonly OpenAPI = (this.device.connectionType === 'OpenAPI' || this.device.connectionType === 'BLE/OpenAPI');
 
   constructor(private readonly platform: SwitchBotPlatform, private accessory: PlatformAccessory, public device: device & devicesConfig) {
     // default placeholders
@@ -143,10 +142,9 @@ export class Motion {
    * Parse the device status from the SwitchBot api
    */
   async parseStatus(): Promise<void> {
-    if (this.BLE && !this.SwitchToOpenAPI) {
+    if (this.BLE) {
       await this.BLEparseStatus();
     } else if (this.OpenAPI && this.platform.config.credentials?.token) {
-      this.SwitchToOpenAPI = false;
       await this.openAPIparseStatus();
     } else {
       this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Connection Type:`
@@ -279,20 +277,20 @@ export class Motion {
           // Stop to monitor
           switchbot.stopScan();
           if (this.connected) {
-            this.parseStatus();
+            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);
     }
   }
 
@@ -332,7 +330,7 @@ export class Motion {
             this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} openAPIRefreshStatus: ${superStringify(this.deviceStatus)}`);
             this.moveDetected = this.deviceStatus.body.moveDetected;
             this.brightness = this.deviceStatus.body.brightness;
-            this.parseStatus();
+            this.openAPIparseStatus();
             this.updateHomeKitCharacteristics();
           } catch (e: any) {
             this.errorLog(`${this.device.deviceType}: ${this.accessory.displayName} error message: ${e.message}`);
@@ -407,11 +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 !== 'Both') {
-      this.warnLog(`${this.device.deviceType}: ${this.accessory.displayName} Using OpenAPI Connection`);
-      this.SwitchToOpenAPI = true;
+    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();
     }
   }