@switchbot/homebridge-switchbot 0.1.2-beta.7 → 0.2.0-alpha.1

package/src/devices/humidifiers.ts

@@ -2,8 +2,7 @@ import { Service, PlatformAccessory, CharacteristicValue } from 'homebridge';
 import { SwitchBotPlatform } from '../platform';
 import { interval, Subject } from 'rxjs';
 import { debounceTime, skipWhile, tap } from 'rxjs/operators';
-import { DeviceURL, device, deviceStatusResponse } from '../settings';
-import { AxiosResponse } from 'axios';
+import { DeviceURL, device, devicesConfig } from '../settings';
 
 /**
  * Platform Accessory
@@ -25,16 +24,17 @@ export class Humidifier {
   WaterLevel!: CharacteristicValue;
 
   // Others
-  deviceStatus!: deviceStatusResponse;
+  deviceStatus!: any;
 
   // Updates
   humidifierUpdateInProgress!: boolean;
   doHumidifierUpdate;
+  set_minStep: number | undefined;
 
   constructor(
     private readonly platform: SwitchBotPlatform,
     private accessory: PlatformAccessory,
-    public device: device,
+    public device: device & devicesConfig,
   ) {
     // default placeholders
     this.CurrentRelativeHumidity = 0;
@@ -63,7 +63,7 @@ export class Humidifier {
     // you can create multiple services for each accessory
     (this.service =
       accessory.getService(this.platform.Service.HumidifierDehumidifier) ||
-      accessory.addService(this.platform.Service.HumidifierDehumidifier)), `${device.deviceName} ${device.deviceType}`;
+      accessory.addService(this.platform.Service.HumidifierDehumidifier)), `${accessory.displayName} Humidifier`;
 
     // To avoid "Cannot add a Service with the same UUID another Service without also defining a unique 'subtype' property." error,
     // when creating multiple services of the same type, you need to use the following syntax to specify a name and subtype id:
@@ -100,25 +100,23 @@ export class Humidifier {
         validValueRanges: [0, 100],
         minValue: 0,
         maxValue: 100,
-        minStep: this.platform.config.options?.humidifier?.set_minStep || 1,
+        minStep: this.minStep(),
       })
       .onSet(this.handleRelativeHumidityHumidifierThresholdSet.bind(this));
 
     // create a new Temperature Sensor service
     // Temperature Sensor Service
-    if (this.platform.config.options?.humidifier?.hide_temperature) {
-      if (this.platform.config.options.debug) {
-        this.platform.log.error('Removing service');
-      }
+    if (device.humidifier?.hide_temperature) {
+      this.platform.device('Removing Temerature Sensor Service');
       this.temperatureservice = this.accessory.getService(this.platform.Service.TemperatureSensor);
       accessory.removeService(this.temperatureservice!);
     } else if (!this.temperatureservice) {
-      if (this.platform.config.options?.debug) {
-        this.platform.log.warn('Adding service');
-      }
+      this.platform.device('Adding Temerature Sensor Service');
       (this.temperatureservice =
         this.accessory.getService(this.platform.Service.TemperatureSensor) ||
-        this.accessory.addService(this.platform.Service.TemperatureSensor)), `${device.deviceName} ${device.deviceType} TemperatureSensor`;
+        this.accessory.addService(this.platform.Service.TemperatureSensor)), `${accessory.displayName} Temperature Sensor`;
+
+      this.temperatureservice.setCharacteristic(this.platform.Characteristic.Name, `${accessory.displayName} Temperature Sensor`);
 
       this.temperatureservice
         .getCharacteristic(this.platform.Characteristic.CurrentTemperature)
@@ -129,11 +127,11 @@ export class Humidifier {
           minStep: 0.1,
         })
         .onGet(() => {
-          return this.CurrentTemperature;
+          return Number.isNaN(this.CurrentTemperature);
         });
     } else {
       if (this.platform.config.options?.debug) {
-        this.platform.log.warn('TemperatureSensor not added.');
+        this.platform.device('Temperature Sensor Not Added');
       }
     }
 
@@ -168,6 +166,15 @@ export class Humidifier {
       });
   }
 
+  private minStep(): number | undefined {
+    if (this.device.humidifier?.set_minStep) {
+      this.set_minStep = this.device.humidifier?.set_minStep;
+    } else {
+      this.set_minStep = 1;
+    }
+    return this.set_minStep;
+  }
+
   /**
    * Parse the device status from the SwitchBot api
    */
@@ -175,9 +182,7 @@ export class Humidifier {
     // Current Relative Humidity
     this.CurrentRelativeHumidity = this.deviceStatus.body.humidity!;
     this.platform.debug(`Humidifier ${this.accessory.displayName} CurrentRelativeHumidity: ${this.CurrentRelativeHumidity}`);
-    if (this.platform.config.options?.debug) {
-      this.platform.log.warn(JSON.stringify(this.deviceStatus.body));
-    }
+    this.platform.device(JSON.stringify(this.deviceStatus.body));
     // Water Level
     if (this.deviceStatus.body.lackWater) {
       this.WaterLevel = 0;
@@ -220,8 +225,8 @@ export class Humidifier {
     this.platform.debug(`Humidifier ${this.accessory.displayName} RelativeHumidityHumidifierThreshold: ${this.RelativeHumidityHumidifierThreshold}`);
     this.platform.debug(`Humidifier ${this.accessory.displayName} CurrentHumidifierDehumidifierState: ${this.CurrentHumidifierDehumidifierState}`);
     // Current Temperature
-    if (!this.platform.config.options?.humidifier?.hide_temperature) {
-      this.CurrentTemperature = this.deviceStatus.body.temperature!;
+    if (!this.device.humidifier?.hide_temperature) {
+      this.CurrentTemperature = this.deviceStatus.body.temperature;
       this.platform.debug(`Humidifier ${this.accessory.displayName} CurrentTemperature: ${this.CurrentTemperature}`);
     }
   }
@@ -231,18 +236,17 @@ export class Humidifier {
    */
   async refreshStatus() {
     try {
-      const deviceStatus: deviceStatusResponse = (
-        await this.platform.axios.get(`${DeviceURL}/${this.device.deviceId}/status`)
-      ).data;
-      if (deviceStatus.message === 'success') {
-        this.deviceStatus = deviceStatus;
+      this.deviceStatus = (await this.platform.axios.get(`${DeviceURL}/${this.device.deviceId}/status`)).data;
+      if (this.deviceStatus.message === 'success') {
         this.platform.debug(`Humidifier ${this.accessory.displayName} refreshStatus: ${JSON.stringify(this.deviceStatus)}`);
         this.parseStatus();
         this.updateHomeKitCharacteristics();
+      } else {
+        this.platform.debug(this.deviceStatus);
       }
     } catch (e: any) {
-      this.platform.log.error(`Humidifier - Failed to update status of ${this.device.deviceName}: ${JSON.stringify(e.message)}`);
-      this.platform.debug(`Humidifier ${this.accessory.displayName} ${JSON.stringify(e)}`);
+      this.platform.log.error(`Humidifier ${this.accessory.displayName}, Failed to update status. Error Message: ${JSON.stringify(e.message)}`);
+      this.platform.debug(`Humidifier ${this.accessory.displayName}, Error: ${JSON.stringify(e)}`);
       this.apiError(e);
     }
   }
@@ -273,11 +277,11 @@ export class Humidifier {
         'commandType:',
         payload.commandType,
       );
-      this.platform.debug(`Humidifier ${this.accessory.displayName} pushChanges - ${JSON.stringify(payload)}`);
+      this.platform.debug(`Humidifier ${this.accessory.displayName} pushChanges: ${JSON.stringify(payload)}`);
 
       // Make the API request
-      const push = await this.platform.axios.post(`${DeviceURL}/${this.device.deviceId}/commands`, payload);
-      this.platform.debug(`Humidifier ${this.accessory.displayName} Changes pushed - ${push.data}`);
+      const push: any = (await this.platform.axios.post(`${DeviceURL}/${this.device.deviceId}/commands`, payload));
+      this.platform.debug(`Humidifier ${this.accessory.displayName} Changes pushed: ${JSON.stringify(push.data)}`);
       this.statusCode(push);
     } else if (
       this.TargetHumidifierDehumidifierState ===
@@ -317,12 +321,12 @@ export class Humidifier {
           'commandType:',
           payload.commandType,
         );
-        this.platform.debug(`Humidifier ${this.accessory.displayName} pushAutoChanges - ${JSON.stringify(payload)}`);
+        this.platform.debug(`Humidifier ${this.accessory.displayName} pushAutoChanges: ${JSON.stringify(payload)}`);
 
         // Make the API request
-        const pushAuto = await this.platform.axios.post(`${DeviceURL}/${this.device.deviceId}/commands`, payload);
-        this.platform.debug(`Humidifier ${this.accessory.displayName} Changes pushed - ${pushAuto.data}`);
-        this.statusCodeAuto(pushAuto);
+        const push: any = (await this.platform.axios.post(`${DeviceURL}/${this.device.deviceId}/commands`, payload));
+        this.platform.debug(`Humidifier ${this.accessory.displayName} Changes pushed: ${JSON.stringify(push.data)}`);
+        this.statusCode(push);
       }
     } catch (e: any) {
       this.platform.log.error(JSON.stringify(e.message));
@@ -354,12 +358,12 @@ export class Humidifier {
           'commandType:',
           payload.commandType,
         );
-        this.platform.debug(`Humidifier ${this.accessory.displayName} pushActiveChanges - ${JSON.stringify(payload)}`);
+        this.platform.debug(`Humidifier ${this.accessory.displayName} pushActiveChanges: ${JSON.stringify(payload)}`);
 
         // Make the API request
-        const pushActive = await this.platform.axios.post(`${DeviceURL}/${this.device.deviceId}/commands`, payload);
-        this.platform.debug(`Humidifier ${this.accessory.displayName} Changes pushed - ${pushActive.data}`);
-        this.statusCodeActive(pushActive);
+        const push: any = (await this.platform.axios.post(`${DeviceURL}/${this.device.deviceId}/commands`, payload));
+        this.platform.debug(`Humidifier ${this.accessory.displayName} Changes pushed: ${JSON.stringify(push.data)}`);
+        this.statusCode(push);
       }
     } catch (e: any) {
       this.platform.log.error(JSON.stringify(e.message));
@@ -372,41 +376,51 @@ export class Humidifier {
    * Updates the status for each of the HomeKit Characteristics
    */
   updateHomeKitCharacteristics() {
-    if (this.CurrentRelativeHumidity !== undefined) {
-      this.service.updateCharacteristic(
-        this.platform.Characteristic.CurrentRelativeHumidity,
-        this.CurrentRelativeHumidity,
-      );
+    if (this.CurrentRelativeHumidity === undefined) {
+      this.platform.debug(`Humidifier ${this.accessory.displayName} CurrentRelativeHumidity: ${this.CurrentRelativeHumidity}`);
+    } else {
+      this.service.updateCharacteristic(this.platform.Characteristic.CurrentRelativeHumidity, this.CurrentRelativeHumidity);
+      this.platform.device(`Humidifier ${this.accessory.displayName} updateCharacteristic CurrentRelativeHumidity: ${this.CurrentRelativeHumidity}`);
     }
-    if (this.WaterLevel !== undefined) {
+    if (this.WaterLevel === undefined) {
+      this.platform.debug(`Humidifier ${this.accessory.displayName} WaterLevel: ${this.WaterLevel}`);
+    } else {
       this.service.updateCharacteristic(this.platform.Characteristic.WaterLevel, this.WaterLevel);
+      this.platform.device(`Humidifier ${this.accessory.displayName} updateCharacteristic WaterLevel: ${this.WaterLevel}`);
     }
-    if (this.CurrentHumidifierDehumidifierState !== undefined) {
-      this.service.updateCharacteristic(
-        this.platform.Characteristic.CurrentHumidifierDehumidifierState,
-        this.CurrentHumidifierDehumidifierState,
-      );
+    if (this.CurrentHumidifierDehumidifierState === undefined) {
+      this.platform.debug(`Humidifier ${this.accessory.displayName} CurrentHumidifierDehumidifierState: ${this.CurrentHumidifierDehumidifierState}`);
+    } else {
+      this.service.updateCharacteristic(this.platform.Characteristic.CurrentHumidifierDehumidifierState, this.CurrentHumidifierDehumidifierState);
+      this.platform.device(`Humidifier ${this.accessory.displayName}`
+        + ` updateCharacteristic CurrentHumidifierDehumidifierState: ${this.CurrentHumidifierDehumidifierState}`);
     }
-    if (this.TargetHumidifierDehumidifierState !== undefined) {
-      this.service.updateCharacteristic(
-        this.platform.Characteristic.TargetHumidifierDehumidifierState,
-        this.TargetHumidifierDehumidifierState,
-      );
+    if (this.TargetHumidifierDehumidifierState === undefined) {
+      this.platform.debug(`Humidifier ${this.accessory.displayName} TargetHumidifierDehumidifierState: ${this.TargetHumidifierDehumidifierState}`);
+    } else {
+      this.service.updateCharacteristic(this.platform.Characteristic.TargetHumidifierDehumidifierState, this.TargetHumidifierDehumidifierState);
+      this.platform.device(`Humidifier ${this.accessory.displayName}`
+        + ` updateCharacteristic TargetHumidifierDehumidifierState: ${this.TargetHumidifierDehumidifierState}`);
     }
-    if (this.Active !== undefined) {
+    if (this.Active === undefined) {
+      this.platform.debug(`Humidifier ${this.accessory.displayName} Active: ${this.Active}`);
+    } else {
       this.service.updateCharacteristic(this.platform.Characteristic.Active, this.Active);
+      this.platform.device(`Humidifier ${this.accessory.displayName} updateCharacteristic Active: ${this.Active}`);
     }
-    if (this.RelativeHumidityHumidifierThreshold !== undefined) {
-      this.service.updateCharacteristic(
-        this.platform.Characteristic.RelativeHumidityHumidifierThreshold,
-        this.RelativeHumidityHumidifierThreshold,
-      );
+    if (this.RelativeHumidityHumidifierThreshold === undefined) {
+      this.platform.debug(`Humidifier ${this.accessory.displayName}`
+        + ` RelativeHumidityHumidifierThreshold: ${this.RelativeHumidityHumidifierThreshold}`);
+    } else {
+      this.service.updateCharacteristic(this.platform.Characteristic.RelativeHumidityHumidifierThreshold, this.RelativeHumidityHumidifierThreshold);
+      this.platform.device(`Humidifier ${this.accessory.displayName}`
+        + ` updateCharacteristic RelativeHumidityHumidifierThreshold: ${this.RelativeHumidityHumidifierThreshold}`);
     }
-    if (!this.platform.config.options?.humidifier?.hide_temperature && this.CurrentTemperature !== undefined) {
-      this.temperatureservice!.updateCharacteristic(
-        this.platform.Characteristic.CurrentTemperature,
-        this.CurrentTemperature,
-      );
+    if (!this.device.humidifier?.hide_temperature || this.CurrentTemperature === undefined) {
+      this.platform.debug(`Humidifier ${this.accessory.displayName} CurrentTemperature: ${this.CurrentTemperature}`);
+    } else {
+      this.temperatureservice!.updateCharacteristic(this.platform.Characteristic.CurrentTemperature, this.CurrentTemperature);
+      this.platform.device(`Humidifier ${this.accessory.displayName} updateCharacteristic CurrentTemperature: ${this.CurrentTemperature}`);
     }
   }
 
@@ -417,12 +431,12 @@ export class Humidifier {
     this.service.updateCharacteristic(this.platform.Characteristic.TargetHumidifierDehumidifierState, e);
     this.service.updateCharacteristic(this.platform.Characteristic.Active, e);
     this.service.updateCharacteristic(this.platform.Characteristic.RelativeHumidityHumidifierThreshold, e);
-    if (!this.platform.config.options?.humidifier?.hide_temperature) {
+    if (!this.device.humidifier?.hide_temperature) {
       this.temperatureservice!.updateCharacteristic(this.platform.Characteristic.CurrentTemperature, e);
     }
   }
 
-  private statusCode(push: AxiosResponse<any>) {
+  private statusCode(push: { data: { statusCode: any; }; }) {
     switch (push.data.statusCode) {
       case 151:
         this.platform.log.error('Command not supported by this device type.');
@@ -450,62 +464,6 @@ export class Humidifier {
     }
   }
 
-  private statusCodeAuto(pushAuto: AxiosResponse<any>) {
-    switch (pushAuto.data.statusCode) {
-      case 151:
-        this.platform.log.error('Command not supported by this device type.');
-        break;
-      case 152:
-        this.platform.log.error('Device not found.');
-        break;
-      case 160:
-        this.platform.log.error('Command is not supported.');
-        break;
-      case 161:
-        this.platform.log.error('Device is offline.');
-        break;
-      case 171:
-        this.platform.log.error('Hub Device is offline.');
-        break;
-      case 190:
-        this.platform.log.error('Device internal error due to device states not synchronized with server. Or command fomrat is invalid.');
-        break;
-      case 100:
-        this.platform.debug('Command successfully sent.');
-        break;
-      default:
-        this.platform.debug('Unknown statusCode.');
-    }
-  }
-
-  private statusCodeActive(pushActive: AxiosResponse<any>) {
-    switch (pushActive.data.statusCode) {
-      case 151:
-        this.platform.log.error('Command not supported by this device type.');
-        break;
-      case 152:
-        this.platform.log.error('Device not found.');
-        break;
-      case 160:
-        this.platform.log.error('Command is not supported.');
-        break;
-      case 161:
-        this.platform.log.error('Device is offline.');
-        break;
-      case 171:
-        this.platform.log.error('Hub Device is offline.');
-        break;
-      case 190:
-        this.platform.log.error('Device internal error due to device states not synchronized with server. Or command fomrat is invalid.');
-        break;
-      case 100:
-        this.platform.debug('Command successfully sent.');
-        break;
-      default:
-        this.platform.debug('Unknown statusCode.');
-    }
-  }
-
   /**
    * Handle requests to set the "Target Humidifier Dehumidifier State" characteristic
    */

package/src/devices/indoorcam.ts

@@ -0,0 +1,303 @@
+import { Service, PlatformAccessory, CharacteristicValue, MacAddress } from 'homebridge';
+import { SwitchBotPlatform } from '../platform';
+import { interval, Subject } from 'rxjs';
+import { debounceTime, skipWhile, tap } from 'rxjs/operators';
+import { DeviceURL, device, devicesConfig } from '../settings';
+
+export class IndoorCam {
+  // Services
+  private service: Service;
+
+  // Characteristic Values
+  On!: CharacteristicValue;
+  OutletInUse!: CharacteristicValue;
+
+  // Others
+  deviceStatus!: any;
+  switchbot!: {
+    discover: (
+      arg0:
+        {
+          duration: any;
+          model: string;
+          quick: boolean;
+          id: MacAddress;
+        }
+    ) => Promise<any>;
+    wait: (
+      arg0: number
+    ) => any;
+  };
+
+  // Updates
+  cameraUpdateInProgress!: boolean;
+  doCameraUpdate;
+
+  constructor(
+    private readonly platform: SwitchBotPlatform,
+    private accessory: PlatformAccessory,
+    public device: device & devicesConfig,
+  ) {
+    // default placeholders
+    this.On = false;
+    this.OutletInUse = true;
+
+    // BLE Connections
+    if (device.ble) {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const SwitchBot = require('node-switchbot');
+      this.switchbot = new SwitchBot();
+      const colon = device.deviceId!.match(/.{1,2}/g);
+      const bleMac = colon!.join(':'); //returns 1A:23:B4:56:78:9A;
+      this.device.bleMac = bleMac.toLowerCase();
+      this.platform.device(this.device.bleMac.toLowerCase());
+    }
+
+    // this is subject we use to track when we need to POST changes to the SwitchBot API
+    this.doCameraUpdate = new Subject();
+    this.cameraUpdateInProgress = false;
+
+    // Retrieve initial values and updateHomekit
+    this.refreshStatus();
+
+    // set accessory information
+    accessory
+      .getService(this.platform.Service.AccessoryInformation)!
+      .setCharacteristic(this.platform.Characteristic.Manufacturer, 'SwitchBot')
+      .setCharacteristic(this.platform.Characteristic.Model, 'SWITCHBOT-CAMERA-')
+      .setCharacteristic(this.platform.Characteristic.SerialNumber, device.deviceId!);
+
+    // get the WindowCovering service if it exists, otherwise create a new WindowCovering service
+    // you can create multiple services for each accessory
+    (this.service =
+      accessory.getService(this.platform.Service.Outlet) ||
+      accessory.addService(this.platform.Service.Outlet)), `${accessory.displayName} Indoor Camera`;
+
+    // To avoid "Cannot add a Service with the same UUID another Service without also defining a unique 'subtype' property." error,
+    // when creating multiple services of the same type, you need to use the following syntax to specify a name and subtype id:
+    // accessory.getService('NAME') ?? accessory.addService(this.platform.Service.Lightbulb, 'NAME', 'USER_DEFINED_SUBTYPE');
+
+    // set the service name, this is what is displayed as the default name on the Home app
+    // in this example we are using the name we stored in the `accessory.context` in the `discoverDevices` method.
+    this.service.setCharacteristic(this.platform.Characteristic.Name, accessory.displayName);
+
+    // each service must implement at-minimum the "required characteristics" for the given service type
+    // see https://developers.homebridge.io/#/service/WindowCovering
+
+    // create handlers for required characteristics
+    this.service.getCharacteristic(this.platform.Characteristic.On).onSet(this.OnSet.bind(this));
+
+    this.service.setCharacteristic(this.platform.Characteristic.OutletInUse, this.OutletInUse || true);
+
+    // Update Homekit
+    this.updateHomeKitCharacteristics();
+
+    // Start an update interval
+    interval(this.platform.config.options!.refreshRate! * 1000)
+      .pipe(skipWhile(() => this.cameraUpdateInProgress))
+      .subscribe(() => {
+        this.refreshStatus();
+      });
+
+    // Watch for Camera change events
+    // We put in a debounce of 100ms so we don't make duplicate calls
+    this.doCameraUpdate
+      .pipe(
+        tap(() => {
+          this.cameraUpdateInProgress = true;
+        }),
+        debounceTime(this.platform.config.options!.pushRate! * 1000),
+      )
+      .subscribe(async () => {
+        try {
+          await this.pushChanges();
+        } catch (e: any) {
+          this.platform.log.error(JSON.stringify(e.message));
+          this.platform.debug(`Camera ${accessory.displayName} - ${JSON.stringify(e)}`);
+          this.apiError(e);
+        }
+        this.cameraUpdateInProgress = false;
+      });
+  }
+
+  parseStatus() {
+    switch (this.deviceStatus.body.power) {
+      case 'on':
+        this.On = true;
+        break;
+      default:
+        this.On = false;
+    }
+    this.platform.debug(`Camera ${this.accessory.displayName} On: ${this.On}`);
+  }
+
+  async refreshStatus() {
+    if (this.device.ble) {
+      this.platform.device('BLE');
+      await this.BLErefreshStatus();
+    } else {
+      this.platform.device('OpenAPI');
+      await this.openAPIRefreshStatus();
+    }
+  }
+
+  private async BLErefreshStatus() {
+    this.platform.debug('IndoorCam BLE Device RefreshStatus');
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const Switchbot = require('node-switchbot');
+    const switchbot = new Switchbot();
+    const colon = this.device.deviceId!.match(/.{1,2}/g);
+    const bleMac = colon!.join(':'); //returns 1A:23:B4:56:78:9A;
+    this.device.bleMac = bleMac.toLowerCase();
+    this.platform.device(this.device.bleMac!);
+    switchbot.onadvertisement = (ad: any) => {
+      this.platform.debug(JSON.stringify(ad, null, '  '));
+      this.platform.device(`ad: ${JSON.stringify(ad)}`);
+    };
+    switchbot
+      .startScan({
+        id: this.device.bleMac,
+      })
+      .then(() => {
+        return switchbot.wait(this.platform.config.options!.refreshRate! * 1000);
+      })
+      .then(() => {
+        switchbot.stopScan();
+      })
+      .catch(async (error: any) => {
+        this.platform.log.error(error);
+        await this.openAPIRefreshStatus();
+      });
+    setInterval(() => {
+      this.platform.log.info('Start scan ' + this.device.deviceName + '(' + this.device.bleMac + ')');
+      switchbot
+        .startScan({
+          mode: 'T',
+          id: bleMac,
+        })
+        .then(() => {
+          return switchbot.wait(this.platform.config.options!.refreshRate! * 1000);
+        })
+        .then(() => {
+          switchbot.stopScan();
+          this.platform.log.info('Stop scan ' + this.device.deviceName + '(' + this.device.bleMac + ')');
+        })
+        .catch(async (error: any) => {
+          this.platform.log.error(error);
+          await this.openAPIRefreshStatus();
+        });
+    }, this.platform.config.options!.refreshRate! * 60000);
+  }
+
+  private async openAPIRefreshStatus() {
+    try {
+      this.deviceStatus = (await this.platform.axios.get(`${DeviceURL}/${this.device.deviceId}/status`)).data;
+      this.platform.device(`Camera ${this.accessory.displayName} refreshStatus: ${JSON.stringify(this.deviceStatus)}`);
+      this.parseStatus();
+      this.updateHomeKitCharacteristics();
+    } catch (e: any) {
+      this.platform.log.error(`IndoorCam ${this.accessory.displayName} failed to refresh status, Error Message: ${JSON.stringify(e.message)}`);
+      this.platform.debug(`IndoorCam ${this.accessory.displayName}, Error: ${JSON.stringify(e)}`);
+      this.apiError(e);
+    }
+  }
+
+  /**
+ * Pushes the requested changes to the SwitchBot API
+ * deviceType	commandType	  Command	    command parameter	  Description
+ * Camera   -    "command"     "turnOff"   "default"	  =        set to OFF state
+ * Camera   -    "command"     "turnOn"    "default"	  =        set to ON state
+ */
+  async pushChanges() {
+    const payload = {
+      commandType: 'command',
+      parameter: 'default',
+    } as any;
+
+    if (this.On) {
+      payload.command = 'turnOn';
+    } else {
+      payload.command = 'turnOff';
+    }
+
+    this.platform.log.info(
+      'Sending request for',
+      this.accessory.displayName,
+      'to SwitchBot API. command:',
+      payload.command,
+      'parameter:',
+      payload.parameter,
+      'commandType:',
+      payload.commandType,
+    );
+    this.platform.debug(`Camera ${this.accessory.displayName} pushchanges: ${JSON.stringify(payload)}`);
+
+    // Make the API request
+    const push: any = await this.platform.axios.post(`${DeviceURL}/${this.device.deviceId}/commands`, payload);
+    this.platform.debug(`Camera ${this.accessory.displayName} Changes pushed: ${JSON.stringify(push.data)}`);
+    this.statusCode(push);
+  }
+
+  updateHomeKitCharacteristics() {
+    if (this.On === undefined) {
+      this.platform.debug(`Camera ${this.accessory.displayName} On: ${this.On}`);
+    } else {
+      this.service.updateCharacteristic(this.platform.Characteristic.On, this.On);
+      this.platform.device(`Camera ${this.accessory.displayName} updateCharacteristic On: ${this.On}`);
+    }
+    if (this.OutletInUse === undefined) {
+      this.platform.debug(`Camera ${this.accessory.displayName} OutletInUse: ${this.OutletInUse}`);
+    } else {
+      this.service.updateCharacteristic(this.platform.Characteristic.OutletInUse, this.OutletInUse);
+      this.platform.device(`Camera ${this.accessory.displayName} updateCharacteristic OutletInUse: ${this.OutletInUse}`);
+    }
+  }
+
+  public apiError(e: any) {
+    this.service.updateCharacteristic(this.platform.Characteristic.On, e);
+    this.service.updateCharacteristic(this.platform.Characteristic.OutletInUse, e);
+  }
+
+
+  private statusCode(push: { data: { statusCode: any; }; }) {
+    switch (push.data.statusCode) {
+      case 151:
+        this.platform.log.error('Command not supported by this device type.');
+        break;
+      case 152:
+        this.platform.log.error('Device not found.');
+        break;
+      case 160:
+        this.platform.log.error('Command is not supported.');
+        break;
+      case 161:
+        this.platform.log.error('Device is offline.');
+        break;
+      case 171:
+        this.platform.log.error('Hub Device is offline.');
+        break;
+      case 190:
+        this.platform.log.error('Device internal error due to device states not synchronized with server. Or command fomrat is invalid.');
+        break;
+      case 100:
+        if (this.platform.config.options?.debug) {
+          this.platform.log.info('Command successfully sent.');
+        }
+        break;
+      default:
+        this.platform.debug('Unknown statusCode.');
+    }
+  }
+
+  /**
+   * Handle requests to set the value of the "On" characteristic
+   */
+  OnSet(value: CharacteristicValue) {
+    this.platform.debug(`Camera ${this.accessory.displayName} - Set On: ${value}`);
+
+    this.On = value;
+    this.doCameraUpdate.next();
+  }
+
+
+}