@switchbot/homebridge-switchbot 2.0.0-beta.1 → 2.0.0-beta.10

package/src/device/striplight.ts

@@ -6,7 +6,7 @@ import { interval, Subject } from 'rxjs';
 import { SwitchBotPlatform } from '../platform';
 import { debounceTime, skipWhile, tap } from 'rxjs/operators';
 import { Service, PlatformAccessory, CharacteristicValue, ControllerConstructor, Controller, ControllerServiceMap } from 'homebridge';
-import { device, devicesConfig, switchbot, hs2rgb, rgb2hs, deviceStatus, HostDomain, DevicePath } from '../settings';
+import { device, devicesConfig, switchbot, hs2rgb, rgb2hs, deviceStatus, HostDomain, DevicePath, ad, serviceData } from '../settings';
 
 /**
  * Platform Accessory
@@ -19,13 +19,9 @@ export class StripLight {
 
   // Characteristic Values
   On!: CharacteristicValue;
-  OnCached!: CharacteristicValue;
   Hue!: CharacteristicValue;
-  HueCached!: CharacteristicValue;
   Saturation!: CharacteristicValue;
-  SaturationCached!: CharacteristicValue;
   Brightness!: CharacteristicValue;
-  BrightnessCached!: CharacteristicValue;
 
   // OpenAPI Others
   power: deviceStatus['power'];
@@ -34,10 +30,18 @@ export class StripLight {
   deviceStatus!: any; //deviceStatusResponse;
 
   // BLE Others
+  connected?: boolean;
   switchbot!: switchbot;
+  address!: ad['address'];
+  SwitchToOpenAPI?: boolean;
+  serviceData!: serviceData;
+  state: serviceData['state'];
+  delay: serviceData['delay'];
+  wifiRssi: serviceData['wifiRssi'];
 
   // Config
   set_minStep?: number;
+  scanDuration!: number;
   deviceLogging!: string;
   deviceRefreshRate!: number;
   adaptiveLightingShift?: number;
@@ -57,6 +61,7 @@ export class StripLight {
   constructor(private readonly platform: SwitchBotPlatform, private accessory: PlatformAccessory, public device: device & devicesConfig) {
     // default placeholders
     this.logs(device);
+    this.scan(device);
     this.refreshRate(device);
     this.config(device);
     if (this.On === undefined) {
@@ -176,6 +181,27 @@ export class StripLight {
   }
 
   async parseStatus(): Promise<void> {
+    if (this.SwitchToOpenAPI || !this.device.ble) {
+      await this.openAPIparseStatus();
+    } else {
+      await this.BLEparseStatus();
+    }
+  }
+
+  async BLEparseStatus(): Promise<void> {
+    this.debugLog(`Strip Light: ${this.accessory.displayName} BLE parseStatus`);
+    // State
+    switch (this.state) {
+      case 'on':
+        this.On = true;
+        break;
+      default:
+        this.On = false;
+    }
+    this.debugLog(`Strip Light: ${this.accessory.displayName} On: ${this.On}`);
+  }
+
+  async openAPIparseStatus(): Promise<void> {
     switch (this.power) {
       case 'on':
         this.On = true;
@@ -211,6 +237,130 @@ export class StripLight {
   }
 
   async refreshStatus(): Promise<void> {
+    if (this.device.ble) {
+      await this.BLERefreshStatus();
+    } else {
+      await this.openAPIRefreshStatus();
+    }
+  }
+
+  async BLERefreshStatus(): Promise<void> {
+    this.debugLog(`Strip Light: ${this.accessory.displayName} BLE refreshStatus`);
+    const switchbot = await this.platform.connectBLE();
+    // Convert to BLE Address
+    this.device.bleMac = this.device
+      .deviceId!.match(/.{1,2}/g)!
+      .join(':')
+      .toLowerCase();
+    this.debugLog(`Strip Light: ${this.accessory.displayName} BLE Address: ${this.device.bleMac}`);
+    this.getCustomBLEAddress(switchbot);
+    // Start to monitor advertisement packets
+    if (switchbot !== false) {
+      switchbot
+        .startScan({
+          model: 'r',
+          id: this.device.bleMac,
+        })
+        .then(() => {
+          // Set an event hander
+          switchbot.onadvertisement = (ad: any) => {
+            this.address = ad.address;
+            if (this.deviceLogging.includes('debug')) {
+              this.infoLog(this.address);
+              this.infoLog(this.device.bleMac);
+              this.infoLog(`Strip Light: ${this.accessory.displayName} BLE Address Found: ${this.address}`);
+              this.infoLog(`Strip Light: ${this.accessory.displayName} Config BLE Address: ${this.device.bleMac}`);
+            }
+            this.errorLog(`Strip Light: ${this.accessory.displayName} serviceData: ${JSON.stringify(ad.serviceData)}`);
+            this.serviceData = ad.serviceData;
+            //this.state = ad.serviceData.state;
+            //this.delay = ad.serviceData.delay;
+            //this.timer = ad.serviceData.timer;
+            //this.syncUtcTime = ad.serviceData.syncUtcTime;
+            //this.wifiRssi = ad.serviceData.wifiRssi;
+            //this.overload = ad.serviceData.overload;
+            //this.currentPower = ad.serviceData.currentPower;
+            this.debugLog(`Strip Light: ${this.accessory.displayName} serviceData: ${JSON.stringify(ad.serviceData)}`);
+            /*this.debugLog(
+              `Strip Light: ${this.accessory.displayName} state: ${ad.serviceData.state}, ` +
+                `delay: ${ad.serviceData.delay}, timer: ${ad.serviceData.timer}, syncUtcTime: ${ad.serviceData.syncUtcTime} ` +
+                `wifiRssi: ${ad.serviceData.wifiRssi}, overload: ${ad.serviceData.overload}, currentPower: ${ad.serviceData.currentPower}`,
+            );*/
+
+            if (this.serviceData) {
+              this.connected = true;
+              this.debugLog(`Strip Light: ${this.accessory.displayName} connected: ${this.connected}`);
+            } else {
+              this.connected = false;
+              this.debugLog(`Strip Light: ${this.accessory.displayName} connected: ${this.connected}`);
+            }
+          };
+          // Wait 2 seconds
+          return switchbot.wait(this.scanDuration * 1000);
+        })
+        .then(async () => {
+        // Stop to monitor
+          switchbot.stopScan();
+          if (this.connected) {
+            this.parseStatus();
+            this.updateHomeKitCharacteristics();
+          } else {
+            this.errorLog(`Strip Light: ${this.accessory.displayName} wasn't able to establish BLE Connection`);
+            if (this.platform.config.credentials?.token) {
+              this.warnLog(`Strip Light: ${this.accessory.displayName} Using OpenAPI Connection`);
+              this.SwitchToOpenAPI = true;
+              await this.openAPIRefreshStatus();
+            }
+          }
+        })
+        .catch(async (e: any) => {
+          this.errorLog(`Strip Light: ${this.accessory.displayName} failed refreshStatus with BLE Connection`);
+          if (this.deviceLogging.includes('debug')) {
+            this.errorLog(
+              `Strip Light: ${this.accessory.displayName} failed refreshStatus with BLE Connection,` + ` Error Message: ${JSON.stringify(e.message)}`,
+            );
+          }
+          if (this.platform.config.credentials?.token) {
+            this.warnLog(`Strip Light: ${this.accessory.displayName} Using OpenAPI Connection`);
+            this.SwitchToOpenAPI = true;
+            await this.openAPIRefreshStatus();
+          }
+          this.apiError(e);
+        });
+    } else {
+      await this.BLEconnection(switchbot);
+    }
+  }
+
+  async getCustomBLEAddress(switchbot: any) {
+    if (this.device.customBLEaddress && this.deviceLogging.includes('debug')) {
+      this.debugLog(`Strip Light: ${this.accessory.displayName} customBLEaddress: ${this.device.customBLEaddress}`);
+      (async () => {
+        // Start to monitor advertisement packets
+        await switchbot.startScan({
+          model: 'r',
+        });
+        // Set an event handler
+        switchbot.onadvertisement = (ad: any) => {
+          this.warnLog(`Strip Light: ${this.accessory.displayName} ad: ${JSON.stringify(ad, null, '  ')}`);
+        };
+        await switchbot.wait(10000);
+        // Stop to monitor
+        switchbot.stopScan();
+      })();
+    }
+  }
+
+  async BLEconnection(switchbot: any): Promise<void> {
+    this.errorLog(`Strip Light: ${this.accessory.displayName} wasn't able to establish BLE Connection, node-switchbot: ${switchbot}`);
+    if (this.platform.config.credentials?.token) {
+      this.warnLog(`Strip Light: ${this.accessory.displayName} Using OpenAPI Connection`);
+      this.SwitchToOpenAPI = true;
+      await this.openAPIRefreshStatus();
+    }
+  }
+
+  async openAPIRefreshStatus(): Promise<void> {
     try {
       const t = Date.now();
       const nonce = 'requestID';
@@ -279,7 +429,7 @@ export class StripLight {
    */
   async pushChanges(): Promise<void> {
     try {
-      if (this.On !== this.OnCached) {
+      if (this.On !== this.accessory.context.On) {
         // Make Push On request to the API
         const t = Date.now();
         const nonce = 'requestID';
@@ -329,8 +479,6 @@ export class StripLight {
         req.write(body);
         req.end();
         this.debugLog(`Strip Light: ${this.accessory.displayName} pushchanges: ${JSON.stringify(req)}`);
-        this.OnCached = this.On;
-        this.accessory.context.On = this.OnCached;
       }
       // Push Brightness Update
       if (this.On) {
@@ -354,7 +502,7 @@ export class StripLight {
 
   async pushHueSaturationChanges(): Promise<void> {
     try {
-      if (this.Hue !== this.HueCached || this.Saturation !== this.SaturationCached) {
+      if (this.Hue !== this.accessory.context.Hue || this.Saturation !== this.accessory.context.Saturation) {
         this.debugLog(`Strip Light: ${this.accessory.displayName} Hue: ${JSON.stringify(this.Hue)}`);
         this.debugLog(`Strip Light: ${this.accessory.displayName} Saturation: ${JSON.stringify(this.Saturation)}`);
 
@@ -402,12 +550,11 @@ export class StripLight {
         req.write(body);
         req.end();
         this.debugLog(`Strip Light: ${this.accessory.displayName} pushHueSaturationChanges: ${JSON.stringify(req)}`);
-        this.HueCached = this.Hue;
-        this.SaturationCached = this.Saturation;
       } else {
         this.debugLog(
           `Strip Light: ${this.accessory.displayName} No Changes.` +
-            `Hue: ${this.Hue}, HueCached: ${this.HueCached}, Saturation: ${this.Saturation}, SaturationCached: ${this.SaturationCached}`,
+            `Hue: ${this.Hue}, HueCached: ${this.accessory.context.Hue}, Saturation: ${this.Saturation}, `
+            +`SaturationCached: ${this.accessory.context.Saturation}`,
         );
       }
     } catch (e: any) {
@@ -424,7 +571,7 @@ export class StripLight {
 
   async pushBrightnessChanges(): Promise<void> {
     try {
-      if (this.Brightness !== this.BrightnessCached) {
+      if (this.Brightness !== this.accessory.context.Brightness) {
         // Make Push On request to the API
         const t = Date.now();
         const nonce = 'requestID';
@@ -467,10 +614,10 @@ export class StripLight {
         req.write(body);
         req.end();
         this.debugLog(`Strip Light: ${this.accessory.displayName} pushBrightnessChanges: ${JSON.stringify(req)}`);
-        this.BrightnessCached = this.Brightness;
       } else {
         this.debugLog(
-          `Strip Light: ${this.accessory.displayName} No Changes.` + `Brightness: ${this.Brightness}, BrightnessCached: ${this.BrightnessCached}`,
+          `Strip Light: ${this.accessory.displayName} No Changes.` + `Brightness: ${this.Brightness}, `
+          +`BrightnessCached: ${this.accessory.context.Brightness}`,
         );
       }
     } catch (e: any) {
@@ -489,24 +636,28 @@ export class StripLight {
     if (this.On === undefined) {
       this.debugLog(`Strip Light: ${this.accessory.displayName} On: ${this.On}`);
     } else {
+      this.accessory.context.On = this.On;
       this.lightBulbService.updateCharacteristic(this.platform.Characteristic.On, this.On);
       this.debugLog(`Strip Light: ${this.accessory.displayName} updateCharacteristic On: ${this.On}`);
     }
     if (this.Brightness === undefined) {
       this.debugLog(`Strip Light: ${this.accessory.displayName} Brightness: ${this.Brightness}`);
     } else {
+      this.accessory.context.Brightness = this.Brightness;
       this.lightBulbService.updateCharacteristic(this.platform.Characteristic.Brightness, this.Brightness);
       this.debugLog(`Strip Light: ${this.accessory.displayName} updateCharacteristic Brightness: ${this.Brightness}`);
     }
     if (this.Hue === undefined) {
       this.debugLog(`Strip Light: ${this.accessory.displayName} Hue: ${this.Hue}`);
     } else {
+      this.accessory.context.Hue = this.Hue;
       this.lightBulbService.updateCharacteristic(this.platform.Characteristic.Hue, this.Hue);
       this.debugLog(`Strip Light: ${this.accessory.displayName} updateCharacteristic Hue: ${this.Hue}`);
     }
     if (this.Saturation === undefined) {
       this.debugLog(`Strip Light: ${this.accessory.displayName} Saturation: ${this.Saturation}`);
     } else {
+      this.accessory.context.Saturation = this.Saturation;
       this.lightBulbService.updateCharacteristic(this.platform.Characteristic.Saturation, this.Saturation);
       this.debugLog(`Strip Light: ${this.accessory.displayName} updateCharacteristic Saturation: ${this.Saturation}`);
     }
@@ -639,6 +790,20 @@ export class StripLight {
     }
   }
 
+  async scan(device: device & devicesConfig): Promise<void> {
+    if (device.scanDuration) {
+      this.scanDuration = this.accessory.context.scanDuration = device.scanDuration;
+      if (device.ble) {
+        this.debugLog(`Bot: ${this.accessory.displayName} Using Device Config scanDuration: ${this.scanDuration}`);
+      }
+    } else {
+      this.scanDuration = this.accessory.context.scanDuration = 1;
+      if (this.device.ble) {
+        this.debugLog(`Bot: ${this.accessory.displayName} Using Default scanDuration: ${this.scanDuration}`);
+      }
+    }
+  }
+
   async logs(device: device & devicesConfig): Promise<void> {
     if (this.platform.debugMode) {
       this.deviceLogging = this.accessory.context.logging = 'debugMode';

package/src/platform.ts

@@ -188,34 +188,34 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       if (this.platformLogging?.includes('debug')) {
         this.debugLog('Using Default Refresh Rate (2 minutes).');
       }
+    }
 
-      if (!this.config.options.pushRate) {
+    if (!this.config.options.pushRate) {
         // default 100 milliseconds
         this.config.options!.pushRate! = 0.1;
         if (this.platformLogging?.includes('debug')) {
           this.warnLog('Using Default Push Rate.');
         }
-      }
+    }
 
-      if (!this.config.credentials) {
-        if (this.platformLogging?.includes('debug')) {
-          this.debugLog('Missing Credentials');
-        }
+    if (!this.config.credentials) {
+      if (this.platformLogging?.includes('debug')) {
+        this.debugLog('Missing Credentials');
+      }
+    }
+    if (!this.config.credentials?.token) {
+      if (this.platformLogging?.includes('debug')) {
+        this.errorLog('Missing token');
+        this.warnLog('Cloud Enabled SwitchBot Devices & IR Devices will not work');
       }
-      if (!this.config.credentials?.token) {
+    }
+    if (this.config.credentials?.token) {
+      if (!this.config.credentials?.secret) {
         if (this.platformLogging?.includes('debug')) {
-          this.errorLog('Missing token');
+          this.errorLog('Missing secret');
           this.warnLog('Cloud Enabled SwitchBot Devices & IR Devices will not work');
         }
-      }
-      if (this.config.credentials?.token) {
-        if (!this.config.credentials?.secret) {
-          if (this.platformLogging?.includes('debug')) {
-            this.errorLog('Missing secret');
-            this.warnLog('Cloud Enabled SwitchBot Devices & IR Devices will not work');
-          }
-          throw Error('Missing secret');
-        }
+        throw Error('Missing secret');
       }
     }
   }
@@ -591,23 +591,6 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
     }
   }
 
-  private registerDevice(device: device & devicesConfig) {
-    if (!device.hide_device && device.enableCloudService && device.ble) {
-      this.registeringDevice = true;
-      this.debugLog(`Device: ${device.deviceName} Both OpenAPI and BLE Connections Enabled`);
-    } else if (!device.hide_device && device.deviceId && device.configDeviceType && device.configDeviceName && !device.enableCloudService) {
-      this.registeringDevice = true;
-      this.debugLog(`Device: ${device.deviceName} BLE Connection Enabled`);
-    } else if (!device.hide_device && device.enableCloudService && !device.ble) {
-      this.registeringDevice = true;
-      this.debugLog(`Device: ${device.deviceName} OpenAPI Connection Enabled`);
-    } else {
-      this.registeringDevice = false;
-      this.debugLog(`Device: ${device.deviceName} OpenAPI and BLE Are Not Enabled`);
-    }
-    return this.registeringDevice;
-  }
-
   private async createHumidifier(device: device & devicesConfig) {
     const uuid = this.api.hap.uuid.generate(`${device.deviceId}-${device.deviceType}`);
 
@@ -656,8 +639,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       new Humidifier(this, accessory, device);
       this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
 
-      // link the accessory to your platform
-      this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+      // publish device externally or link the accessory to your platform
+      this.externalOrPlatform(device, accessory);
       this.accessories.push(accessory);
     } else {
       this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
@@ -716,8 +699,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       new Bot(this, accessory, device);
       this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
 
-      // link the accessory to your platform
-      this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+      // publish device externally or link the accessory to your platform
+      this.externalOrPlatform(device, accessory);
       this.accessories.push(accessory);
     } else {
       this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
@@ -771,8 +754,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       new Meter(this, accessory, device);
       this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
 
-      // link the accessory to your platform
-      this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+      // publish device externally or link the accessory to your platform
+      this.externalOrPlatform(device, accessory);
       this.accessories.push(accessory);
     } else {
       this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
@@ -826,8 +809,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       new MeterPlus(this, accessory, device);
       this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
 
-      // link the accessory to your platform
-      this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+      // publish device externally or link the accessory to your platform
+      this.externalOrPlatform(device, accessory);
       this.accessories.push(accessory);
     } else {
       this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
@@ -881,8 +864,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       new Motion(this, accessory, device);
       this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
 
-      // link the accessory to your platform
-      this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+      // publish device externally or link the accessory to your platform
+      this.externalOrPlatform(device, accessory);
       this.accessories.push(accessory);
     } else {
       this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
@@ -936,8 +919,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       new Contact(this, accessory, device);
       this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
 
-      // link the accessory to your platform
-      this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+      // publish device externally or link the accessory to your platform
+      this.externalOrPlatform(device, accessory);
       this.accessories.push(accessory);
     } else {
       this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
@@ -1002,8 +985,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       new Curtain(this, accessory, device);
       this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
 
-      // link the accessory to your platform
-      this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+      // publish device externally or link the accessory to your platform
+      this.externalOrPlatform(device, accessory);
       this.accessories.push(accessory);
     } else {
       this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
@@ -1072,8 +1055,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       new Plug(this, accessory, device);
       this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
 
-      // link the accessory to your platform
-      this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+      // publish device externally or link the accessory to your platform
+      this.externalOrPlatform(device, accessory);
       this.accessories.push(accessory);
     } else {
       this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
@@ -1127,8 +1110,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       new Lock(this, accessory, device);
       this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
 
-      // link the accessory to your platform
-      this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+      // publish device externally or link the accessory to your platform
+      this.externalOrPlatform(device, accessory);
       this.accessories.push(accessory);
     } else {
       this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
@@ -1182,8 +1165,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       new ColorBulb(this, accessory, device);
       this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
 
-      // link the accessory to your platform
-      this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+      // publish device externally or link the accessory to your platform
+      this.externalOrPlatform(device, accessory);
       this.accessories.push(accessory);
     } else {
       this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
@@ -1237,8 +1220,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       new StripLight(this, accessory, device);
       this.debugLog(`${device.deviceType} uuid: ${device.deviceId}-${device.deviceType}, (${accessory.UUID})`);
 
-      // link the accessory to your platform
-      this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+      // publish device externally or link the accessory to your platform
+      this.externalOrPlatform(device, accessory);
       this.accessories.push(accessory);
     } else {
       this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.deviceType} - ${device.deviceId}`);
@@ -1292,7 +1275,7 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
        * Only one TV can exist per bridge, to bypass this limitation, you should
        * publish your TV as an external accessory.
        */
-      this.api.publishExternalAccessories(PLUGIN_NAME, [accessory]);
+      this.externalAccessory(accessory);
       this.accessories.push(accessory);
     } else {
       this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
@@ -1347,8 +1330,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       new Fan(this, accessory, device);
       this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
 
-      // link the accessory to your platform
-      this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+      // publish device externally or link the accessory to your platform
+      this.externalOrPlatform(device, accessory);
       this.accessories.push(accessory);
     } else {
       this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
@@ -1402,8 +1385,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       new Light(this, accessory, device);
       this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
 
-      // link the accessory to your platform
-      this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+      // publish device externally or link the accessory to your platform
+      this.externalOrPlatform(device, accessory);
       this.accessories.push(accessory);
     } else {
       this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
@@ -1457,8 +1440,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       new AirConditioner(this, accessory, device);
       this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
 
-      // link the accessory to your platform
-      this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+      // publish device externally or link the accessory to your platform
+      this.externalOrPlatform(device, accessory);
       this.accessories.push(accessory);
     } else {
       this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
@@ -1512,8 +1495,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       new AirPurifier(this, accessory, device);
       this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
 
-      // link the accessory to your platform
-      this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+      // publish device externally or link the accessory to your platform
+      this.externalOrPlatform(device, accessory);
       this.accessories.push(accessory);
     } else {
       this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
@@ -1567,8 +1550,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       new WaterHeater(this, accessory, device);
       this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
 
-      // link the accessory to your platform
-      this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+      // publish device externally or link the accessory to your platform
+      this.externalOrPlatform(device, accessory);
       this.accessories.push(accessory);
     } else {
       this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
@@ -1622,8 +1605,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       new VacuumCleaner(this, accessory, device);
       this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
 
-      // link the accessory to your platform
-      this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+      // publish device externally or link the accessory to your platform
+      this.externalOrPlatform(device, accessory);
       this.accessories.push(accessory);
     } else {
       this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
@@ -1677,8 +1660,8 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       new Camera(this, accessory, device);
       this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
 
-      // link the accessory to your platform
-      this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+      // publish device externally or link the accessory to your platform
+      this.externalOrPlatform(device, accessory);
       this.accessories.push(accessory);
     } else {
       this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
@@ -1732,14 +1715,46 @@ export class SwitchBotPlatform implements DynamicPlatformPlugin {
       new Others(this, accessory, device);
       this.debugLog(`${device.remoteType} uuid: ${device.deviceId}-${device.remoteType}, (${accessory.UUID})`);
 
-      // link the accessory to your platform
-      this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+      // publish device externally or link the accessory to your platform
+      this.externalOrPlatform(device, accessory);
       this.accessories.push(accessory);
     } else {
       this.debugLog(`Unable to Register new device: ${device.deviceName} ${device.remoteType} - ${device.deviceId}`);
     }
   }
 
+  private registerDevice(device: device & devicesConfig) {
+    if (!device.hide_device && device.enableCloudService && device.ble) {
+      this.registeringDevice = true;
+      this.debugLog(`Device: ${device.deviceName} Both OpenAPI and BLE Connections Enabled`);
+    } else if (!device.hide_device && device.deviceId && device.configDeviceType && device.configDeviceName
+      && !device.enableCloudService) {
+      this.registeringDevice = true;
+      this.debugLog(`Device: ${device.deviceName} BLE Connection Enabled`);
+    } else if (!device.hide_device && device.enableCloudService && !device.ble) {
+      this.registeringDevice = true;
+      this.debugLog(`Device: ${device.deviceName} OpenAPI Connection Enabled`);
+    } else {
+      this.registeringDevice = false;
+      this.debugLog(`Device: ${device.deviceName} OpenAPI and BLE Are Not Enabled`);
+    }
+    return this.registeringDevice;
+  }
+
+  public async externalOrPlatform(device: device & devicesConfig, accessory: PlatformAccessory) {
+    this.debugLog(`${accessory.displayName} External Accessory Mode: ${device.external}`);
+    if (device.external) {
+      this.warnLog(`${accessory.displayName} External Accessory Mode`);
+      this.externalAccessory(accessory);
+    } else {
+      this.api.registerPlatformAccessories(PLUGIN_NAME, PLATFORM_NAME, [accessory]);
+    }
+  }
+
+  public async externalAccessory(accessory: PlatformAccessory) {
+    this.api.publishExternalAccessories(PLUGIN_NAME, [accessory]);
+  }
+
   public async connectionTypeNewAccessory(device: device & devicesConfig, accessory: PlatformAccessory) {
     if (device.ble) {
       accessory.context.connectionType = 'BLE';

package/src/settings.ts

@@ -44,6 +44,7 @@ export interface devicesConfig extends device {
   configDeviceType: string;
   configDeviceName?: string;
   deviceId: string;
+  external?: boolean;
   logging?: string;
   refreshRate?: number;
   firmware?: string;
@@ -123,6 +124,7 @@ export type lock = {
 export interface irDevicesConfig extends irdevice {
   configRemoteType?: string;
   deviceId: string;
+  external?: boolean;
   logging?: string;
   irfan?: irfan;
   irair?: irair;