@switchbot/homebridge-switchbot 3.5.0-beta.57 → 3.5.0-beta.59

package/src/device/curtain.ts

@@ -6,14 +6,17 @@ import { hostname } from 'os';
 import { request } from 'undici';
 import { interval, Subject } from 'rxjs';
 import { deviceBase } from './device.js';
-import { SwitchBotPlatform } from '../platform.js';
+import { Devices } from '../settings.js';
 import { debounceTime, skipWhile, take, tap } from 'rxjs/operators';
-import { Service, PlatformAccessory, CharacteristicValue, CharacteristicChange } from 'homebridge';
-import { device, devicesConfig, serviceData, deviceStatus, Devices } from '../settings.js';
+
+import type { SwitchBotPlatform } from '../platform.js';
+import type { device, devicesConfig, serviceData, deviceStatus} from '../settings.js';
+import type { Service, PlatformAccessory, CharacteristicValue, CharacteristicChange } from 'homebridge';
 
 export class Curtain extends deviceBase {
   // Services
-  private WindowCovering!: {
+  private WindowCovering: {
+    Name: CharacteristicValue;
     Service: Service;
     PositionState: CharacteristicValue;
     TargetPosition: CharacteristicValue;
@@ -21,13 +24,16 @@ export class Curtain extends deviceBase {
     HoldPosition: CharacteristicValue;
   };
 
-  private Battery!: {
+  private Battery: {
+    Name: CharacteristicValue;
     Service: Service;
     BatteryLevel: CharacteristicValue;
     StatusLowBattery: CharacteristicValue;
+    ChargingState: CharacteristicValue;
   };
 
   private LightSensor?: {
+    Name: CharacteristicValue;
     Service: Service;
     CurrentAmbientLightLevel?: CharacteristicValue;
   };
@@ -55,49 +61,29 @@ export class Curtain extends deviceBase {
 
     // Initialize LightBulb property
     this.WindowCovering = {
-      Service: accessory.getService(this.hap.Service.WindowCovering) as Service,
-      PositionState: accessory.context.PositionState || this.hap.Characteristic.PositionState.STOPPED,
-      TargetPosition: accessory.context.TargetPosition || 100,
-      CurrentPosition: accessory.context.CurrentPosition || 100,
-      HoldPosition: accessory.context.HoldPosition || false,
-    };
-
-    // Initialize Battery property
-    this.Battery = {
-      Service: accessory.getService(this.hap.Service.Battery) as Service,
-      BatteryLevel: accessory.context.BatteryLevel || 100,
-      StatusLowBattery: accessory.context.StatusLowBattery || this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL,
+      Name: accessory.context.WindowCovering.Name ?? accessory.displayName,
+      Service: accessory.getService(this.hap.Service.WindowCovering) ?? accessory.addService(this.hap.Service.WindowCovering) as Service,
+      PositionState: accessory.context.PositionState ?? this.hap.Characteristic.PositionState.STOPPED,
+      TargetPosition: accessory.context.TargetPosition ?? 100,
+      CurrentPosition: accessory.context.CurrentPosition ?? 100,
+      HoldPosition: accessory.context.HoldPosition ?? false,
     };
 
-    // Initialize LightSensor property
-    if (!this.device.curtain?.hide_lightsensor) {
-      this.LightSensor = {
-        Service: accessory.getService(this.hap.Service.LightSensor) as Service,
-        CurrentAmbientLightLevel: accessory.context.CurrentAmbientLightLevel || 0.0001,
-      };
-    }
-
-    // Retrieve initial values and updateHomekit
-    this.refreshStatus();
-
-    // get the WindowCovering service if it exists, otherwise create a new WindowCovering service
-    // you can create multiple services for each accessory
-    const WindowCoveringService = `${accessory.displayName} ${device.deviceType}`;
-    (this.WindowCovering.Service = accessory.getService(this.hap.Service.WindowCovering)
-      || accessory.addService(this.hap.Service.WindowCovering)), WindowCoveringService;
-
-    this.WindowCovering.Service.setCharacteristic(this.hap.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.WindowCovering.Service.setCharacteristic(this.hap.Characteristic.PositionState, this.WindowCovering.PositionState);
+    // Initialize WindowCovering Service
+    this.WindowCovering.Service.
+      setCharacteristic(this.hap.Characteristic.Name, this.WindowCovering.Name)
+      .setCharacteristic(this.hap.Characteristic.ObstructionDetected, false)
+      .getCharacteristic(this.hap.Characteristic.PositionState)
+      .onGet(() => {
+        return this.WindowCovering.PositionState;
+      });
+    accessory.context.WindowCovering.Name = this.WindowCovering.Name;
 
+    // Initialize WindowCovering CurrentPosition
     this.WindowCovering.Service
       .getCharacteristic(this.hap.Characteristic.CurrentPosition)
       .setProps({
-        minStep: this.minStep(device),
+        minStep: Number(this.minStep(device)),
         minValue: 0,
         maxValue: 100,
         validValueRanges: [0, 100],
@@ -106,42 +92,83 @@ export class Curtain extends deviceBase {
         return this.WindowCovering.CurrentPosition;
       });
 
+    // Initialize WindowCovering TargetPosition
     this.WindowCovering.Service
       .getCharacteristic(this.hap.Characteristic.TargetPosition)
       .setProps({
-        minStep: this.minStep(device),
+        minStep: Number(this.minStep(device)),
         minValue: 0,
         maxValue: 100,
         validValueRanges: [0, 100],
       })
+      .onGet(() => {
+        return this.WindowCovering.TargetPosition;
+      })
       .onSet(this.TargetPositionSet.bind(this));
 
+    // Initialize WindowCovering TargetPosition
     this.WindowCovering.Service
       .getCharacteristic(this.hap.Characteristic.HoldPosition)
+      .onGet(() => {
+        return this.WindowCovering.HoldPosition;
+      })
       .onSet(this.HoldPositionSet.bind(this));
 
-    // Light Sensor Service
+    // Initialize Battery property
+    this.Battery = {
+      Name: accessory.context.Battery.Name ?? `${accessory.displayName} Battery`,
+      Service: accessory.getService(this.hap.Service.Battery) ?? accessory.addService(this.hap.Service.Battery) as Service,
+      BatteryLevel: accessory.context.BatteryLevel ?? 100,
+      StatusLowBattery: accessory.context.StatusLowBattery ?? this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL,
+      ChargingState: accessory.context.ChargingState ?? this.hap.Characteristic.ChargingState.NOT_CHARGING,
+    };
+
+    // Initialize Battery Service
+    this.Battery.Service
+      .setCharacteristic(this.hap.Characteristic.Name, this.Battery.Name)
+      .getCharacteristic(this.hap.Characteristic.BatteryLevel)
+      .onGet(() => {
+        return this.Battery.BatteryLevel;
+      });
+    accessory.context.Battery.Name = this.Battery.Name;
+
+    this.Battery.Service
+      .getCharacteristic(this.hap.Characteristic.StatusLowBattery)
+      .onGet(() => {
+        return this.Battery.StatusLowBattery;
+      });
+
+    this.Battery.Service
+      .getCharacteristic(this.hap.Characteristic.ChargingState)
+      .onGet(() => {
+        return this.Battery.ChargingState;
+      });
+
+    // Initialize LightSensor Service
     if (device.curtain?.hide_lightsensor) {
       this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Removing Light Sensor Service`);
       this.LightSensor!.Service = this.accessory.getService(this.hap.Service.LightSensor) as Service;
       accessory.removeService(this.LightSensor!.Service);
-    } else if (!this.LightSensor?.Service) {
-      this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Add Light Sensor Service`);
-      const LightSensorService = `${accessory.displayName} Light Sensor`;
-      (this.LightSensor!.Service = this.accessory.getService(this.hap.Service.LightSensor)
-        || this.accessory.addService(this.hap.Service.LightSensor)), LightSensorService;
-
-      this.LightSensor!.Service.setCharacteristic(this.hap.Characteristic.Name, LightSensorService);
     } else {
-      this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Light Sensor Service Not Added`);
-    }
+      this.LightSensor = {
+        Name: accessory.context.LightSensor.Name ?? `${accessory.displayName} Light Sensor`,
+        Service: accessory.getService(this.hap.Service.LightSensor) ?? this.accessory.addService(this.hap.Service.LightSensor) as Service,
+        CurrentAmbientLightLevel: accessory.context.CurrentAmbientLightLevel ?? 0.0001,
+      };
 
-    // Battery Service
-    const batteryService = `${accessory.displayName} Battery`;
-    (this.Battery.Service = this.accessory.getService(this.hap.Service.Battery)
-      || accessory.addService(this.hap.Service.Battery)), batteryService;
+      // Initialize LightSensor Characteristic
+      this.LightSensor.Service
+        .setCharacteristic(this.hap.Characteristic.Name, this.LightSensor.Name)
+        .setCharacteristic(this.hap.Characteristic.StatusActive, true)
+        .getCharacteristic(this.hap.Characteristic.CurrentAmbientLightLevel)
+        .onGet(() => {
+          return this.LightSensor!.CurrentAmbientLightLevel!;
+        });
+      accessory.context.LightSensor.Name = this.LightSensor.Name;
+    }
 
-    this.Battery.Service.setCharacteristic(this.hap.Characteristic.Name, `${accessory.displayName} Battery`);
+    // Retrieve initial values and updateHomekit
+    this.refreshStatus();
 
     // Update Homekit
     this.updateHomeKitCharacteristics();
@@ -343,30 +370,37 @@ export class Curtain extends deviceBase {
         case 3:
           this.LightSensor!.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * 2;
           this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel}`);
+          this.Battery.ChargingState = this.hap.Characteristic.ChargingState.CHARGING;
           break;
         case 4:
           this.LightSensor!.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * 3;
           this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel}`);
+          this.Battery.ChargingState = this.hap.Characteristic.ChargingState.CHARGING;
           break;
         case 5:
           this.LightSensor!.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * 4;
           this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel}`);
+          this.Battery.ChargingState = this.hap.Characteristic.ChargingState.CHARGING;
           break;
         case 6:
           this.LightSensor!.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * 5;
           this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel}`);
+          this.Battery.ChargingState = this.hap.Characteristic.ChargingState.CHARGING;
           break;
         case 7:
           this.LightSensor!.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * 6;
           this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel}`);
+          this.Battery.ChargingState = this.hap.Characteristic.ChargingState.CHARGING;
           break;
         case 8:
           this.LightSensor!.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * 7;
           this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel}`);
+          this.Battery.ChargingState = this.hap.Characteristic.ChargingState.CHARGING;
           break;
         case 9:
           this.LightSensor!.CurrentAmbientLightLevel = ((set_maxLux - set_minLux) / spaceBetweenLevels) * 8;
           this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} LightLevel: ${serviceData.lightLevel}`);
+          this.Battery.ChargingState = this.hap.Characteristic.ChargingState.CHARGING;
           break;
         case 10:
         default:
@@ -439,12 +473,13 @@ export class Curtain extends deviceBase {
       const set_minLux = await this.minLux();
       const set_maxLux = await this.maxLux();
       switch (deviceStatus.body.brightness) {
-        case 'dim':
-          this.LightSensor!.CurrentAmbientLightLevel = set_minLux;
-          break;
         case 'bright':
-        default:
           this.LightSensor!.CurrentAmbientLightLevel = set_maxLux;
+          this.Battery.ChargingState = this.hap.Characteristic.ChargingState.CHARGING;
+          break;
+        case 'dim':
+        default:
+          this.LightSensor!.CurrentAmbientLightLevel = set_minLux;
       }
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName}`
         + ` CurrentAmbientLightLevel: ${this.LightSensor!.CurrentAmbientLightLevel}`);
@@ -841,6 +876,17 @@ export class Curtain extends deviceBase {
       this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
         + ` StatusLowBattery: ${this.Battery.StatusLowBattery}`);
     }
+    if (this.Battery.ChargingState === undefined) {
+      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} ChargingState: ${this.Battery.ChargingState}`);
+    } else {
+      if (this.device.mqttURL) {
+        this.mqttPublish('ChargingState', this.Battery.ChargingState.toString());
+      }
+      this.accessory.context.ChargingState = this.Battery.ChargingState;
+      this.Battery.Service.updateCharacteristic(this.hap.Characteristic.ChargingState, this.Battery.ChargingState);
+      this.debugLog(`${this.device.deviceType}: ${this.accessory.displayName} updateCharacteristic`
+        + ` ChargingState: ${this.Battery.ChargingState}`);
+    }
   }
 
   async BLEPushConnection() {
@@ -906,7 +952,7 @@ export class Curtain extends deviceBase {
     }
   }
 
-  minStep(device: device & devicesConfig): number {
+  async minStep(device: device & devicesConfig): Promise<number> {
     let set_minStep: number;
     if (device.curtain?.set_minStep) {
       set_minStep = device.curtain?.set_minStep;
@@ -948,11 +994,12 @@ export class Curtain extends deviceBase {
     this.WindowCovering.Service.updateCharacteristic(this.hap.Characteristic.CurrentPosition, e);
     this.WindowCovering.Service.updateCharacteristic(this.hap.Characteristic.PositionState, e);
     this.WindowCovering.Service.updateCharacteristic(this.hap.Characteristic.TargetPosition, e);
+    this.Battery.Service.updateCharacteristic(this.hap.Characteristic.BatteryLevel, e);
+    this.Battery.Service.updateCharacteristic(this.hap.Characteristic.StatusLowBattery, e);
+    this.Battery.Service.updateCharacteristic(this.hap.Characteristic.ChargingState, e);
     if (!this.device.curtain?.hide_lightsensor) {
       this.LightSensor!.Service.updateCharacteristic(this.hap.Characteristic.CurrentAmbientLightLevel, e);
+      this.LightSensor!.Service.updateCharacteristic(this.hap.Characteristic.StatusActive, e);
     }
-    this.Battery.Service.updateCharacteristic(this.hap.Characteristic.BatteryLevel, e);
-    this.Battery.Service.updateCharacteristic(this.hap.Characteristic.StatusLowBattery, e);
-    //throw new this.platform.api.hap.HapStatusError(HAPStatus.SERVICE_COMMUNICATION_FAILURE);
   }
 }

package/src/device/device.ts

@@ -2,15 +2,16 @@
  *
  * device.ts: @switchbot/homebridge-switchbot.
  */
-import { API, HAP, Logging, PlatformAccessory } from 'homebridge';
 
 import { hostname } from 'os';
-import { MqttClient } from 'mqtt';
 import asyncmqtt from 'async-mqtt';
-import { SwitchBotPlatform } from '../platform.js';
-import { SwitchBotPlatformConfig, device, devicesConfig } from '../settings.js';
 import { BlindTiltMappingMode, SwitchBotModel, SwitchBotBLEModel, sleep } from '../utils.js';
 
+import type { MqttClient } from 'mqtt';
+import type { SwitchBotPlatform } from '../platform.js';
+import type { API, HAP, Logging, PlatformAccessory } from 'homebridge';
+import type { SwitchBotPlatformConfig, device, devicesConfig } from '../settings.js';
+
 export abstract class deviceBase {
   public readonly api: API;
   public readonly log: Logging;
@@ -564,15 +565,13 @@ export abstract class deviceBase {
   }
 
   async statusCode(statusCode: number): Promise<void> {
-    switch (statusCode) {
-      case 171:
-        switch (this.device.deviceId) {
-          case this.device.hubDeviceId:
-          case '000000000000':
-            statusCode = 161;
-            break;
-        }
-        break;
+    if (statusCode === 171) {
+      if (this.device.deviceId === this.device.hubDeviceId) {
+        statusCode = 161;
+      }
+      if (this.device.deviceId === '000000000000') {
+        statusCode = 161;
+      }
     }
     switch (statusCode) {
       case 151:

package/src/device/fan.ts

@@ -4,14 +4,17 @@
  */
 import { request } from 'undici';
 import { deviceBase } from './device.js';
-import { SwitchBotPlatform } from '../platform.js';
+import { Devices } from '../settings.js';
 import { Subject, debounceTime, interval, skipWhile, take, tap } from 'rxjs';
-import { CharacteristicValue, PlatformAccessory, Service } from 'homebridge';
-import { device, devicesConfig, serviceData, deviceStatus, Devices } from '../settings.js';
+
+import type { SwitchBotPlatform } from '../platform.js';
+import type { CharacteristicValue, PlatformAccessory, Service } from 'homebridge';
+import type { device, devicesConfig, serviceData, deviceStatus} from '../settings.js';
 
 export class Fan extends deviceBase {
   // Services
   private Fan: {
+    Name: CharacteristicValue;
     Service: Service;
     Active: CharacteristicValue;
     SwingMode: CharacteristicValue;
@@ -19,6 +22,7 @@ export class Fan extends deviceBase {
   };
 
   private Battery: {
+    Name: CharacteristicValue;
     Service: Service;
     BatteryLevel: CharacteristicValue;
     StatusLowBattery: CharacteristicValue;
@@ -39,42 +43,75 @@ export class Fan extends deviceBase {
     this.doPlugUpdate = new Subject();
     this.plugUpdateInProgress = false;
 
-    // Initialize Fan property
+    // Initialize Fan Service
     this.Fan = {
-      Service: accessory.getService(this.hap.Service.Fanv2) as Service,
-      Active: accessory.context.Active || this.hap.Characteristic.Active.INACTIVE,
-      SwingMode: accessory.context.SwingMode || this.hap.Characteristic.SwingMode.SWING_DISABLED,
-      RotationSpeed: accessory.context.RotationSpeed || 0,
+      Name: accessory.context.Fan.Name ?? accessory.displayName,
+      Service: accessory.getService(this.hap.Service.Fanv2) ?? accessory.addService(this.hap.Service.Fanv2) as Service,
+      Active: accessory.context.Active ?? this.hap.Characteristic.Active.INACTIVE,
+      SwingMode: accessory.context.SwingMode ?? this.hap.Characteristic.SwingMode.SWING_DISABLED,
+      RotationSpeed: accessory.context.RotationSpeed ?? 0,
     };
 
+    // Initialize Fan Service
+    this.Fan.Service
+      .setCharacteristic(this.hap.Characteristic.Name, this.Fan.Name)
+      .getCharacteristic(this.hap.Characteristic.Active)
+      .onGet(() => {
+        return this.Fan.Active;
+      })
+      .onSet(this.ActiveSet.bind(this));
+
+    // Initialize Fan RotationSpeed Characteristic
+    this.Fan.Service
+      .getCharacteristic(this.hap.Characteristic.RotationSpeed)
+      .onGet(() => {
+        return this.Fan.RotationSpeed;
+      })
+      .onSet(this.RotationSpeedSet.bind(this));
+
+    // Initialize Fan SwingMode Characteristic
+    this.Fan.Service.getCharacteristic(this.hap.Characteristic.SwingMode)
+      .onGet(() => {
+        return this.Fan.SwingMode;
+      })
+      .onSet(this.SwingModeSet.bind(this));
+    accessory.context.Fan.Name = this.Fan.Name;
+
     // Initialize Battery property
     this.Battery = {
-      Service: accessory.getService(this.hap.Service.Battery) as Service,
-      BatteryLevel: accessory.context.BatteryLevel || 100,
-      StatusLowBattery: accessory.context.StatusLowBattery || this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL,
-      ChargingState: accessory.context.ChargingState || this.hap.Characteristic.ChargingState.NOT_CHARGING,
+      Name: accessory.context.Battery.Name ?? accessory.displayName,
+      Service: accessory.getService(this.hap.Service.Battery) ?? accessory.addService(this.hap.Service.Battery) as Service,
+      BatteryLevel: accessory.context.BatteryLevel ?? 100,
+      StatusLowBattery: accessory.context.StatusLowBattery ?? this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL,
+      ChargingState: accessory.context.ChargingState ?? this.hap.Characteristic.ChargingState.NOT_CHARGING,
     };
 
+    // Initialize Battery Service
+    this.Battery.Service
+      .setCharacteristic(this.hap.Characteristic.Name, this.Battery.Name)
+      .getCharacteristic(this.hap.Characteristic.BatteryLevel)
+      .onGet(() => {
+        return this.Battery.BatteryLevel;
+      });
+
+    // Initialize Battery ChargingState Characteristic
+    this.Battery.Service
+      .getCharacteristic(this.hap.Characteristic.ChargingState)
+      .onGet(() => {
+        return this.Battery.ChargingState;
+      });
+
+    // Initialize Battery StatusLowBattery Characteristic
+    this.Battery.Service
+      .getCharacteristic(this.hap.Characteristic.StatusLowBattery)
+      .onGet(() => {
+        return this.Battery.StatusLowBattery;
+      });
+    accessory.context.Battery.Name = this.Battery.Name;
+
     // Retrieve initial values and updateHomekit
     this.refreshStatus();
 
-    // get the Fan service if it exists, otherwise create a new Fanv2 service
-    // you can create multiple services for each accessory
-    const FanService = `${accessory.displayName} ${device.deviceType}`;
-    (this.Fan.Service = accessory.getService(this.hap.Service.Fanv2)
-      || accessory.addService(this.hap.Service.Fanv2)), FanService;
-
-    this.Fan.Service.setCharacteristic(this.hap.Characteristic.Name, accessory.displayName);
-    // each service must implement at-minimum the "required characteristics" for the given service type
-    // see https://developers.homebridge.io/#/service/Fanv2
-
-    // create handlers for required characteristics
-    this.Fan.Service.getCharacteristic(this.hap.Characteristic.Active).onSet(this.ActiveSet.bind(this));
-    // create handlers for required characteristics
-    this.Fan.Service.getCharacteristic(this.hap.Characteristic.RotationSpeed).onSet(this.RotationSpeedSet.bind(this));
-    // create handlers for required characteristics
-    this.Fan.Service.getCharacteristic(this.hap.Characteristic.SwingMode).onSet(this.SwingModeSet.bind(this));
-
     // Update Homekit
     this.updateHomeKitCharacteristics();
 

package/src/device/hub.ts

@@ -2,26 +2,32 @@
  *
  * hub.ts: @switchbot/homebridge-switchbot.
  */
-import { Subject, interval, skipWhile } from 'rxjs';
+import { Units } from 'homebridge';
 import { deviceBase } from './device.js';
-import { SwitchBotPlatform } from '../platform.js';
-import { Devices, device, deviceStatus, devicesConfig } from '../settings.js';
-import { CharacteristicValue, PlatformAccessory, Service, Units } from 'homebridge';
+import { Devices } from '../settings.js';
 import { convertUnits } from '../utils.js';
+import { Subject, interval, skipWhile } from 'rxjs';
+
+import type { SwitchBotPlatform } from '../platform.js';
+import type { device, deviceStatus, devicesConfig } from '../settings.js';
+import type { CharacteristicValue, PlatformAccessory, Service } from 'homebridge';
 
 export class Hub extends deviceBase {
   // Services
   private LightSensor?: {
+    Name: CharacteristicValue;
     Service: Service;
     CurrentAmbientLightLevel: CharacteristicValue;
   };
 
   private HumiditySensor?: {
+    Name: CharacteristicValue;
     Service: Service;
     CurrentRelativeHumidity: CharacteristicValue;
   };
 
   private TemperatureSensor?: {
+    Name: CharacteristicValue;
     Service: Service;
     CurrentTemperature: CharacteristicValue;
   };
@@ -40,46 +46,21 @@ export class Hub extends deviceBase {
     this.doHubUpdate = new Subject();
     this.hubUpdateInProgress = false;
 
-    // Initialize Temperature Sensor property
-    if (!device.hub?.hide_temperature) {
-      this.TemperatureSensor = {
-        Service: accessory.getService(this.hap.Service.TemperatureSensor) as Service,
-        CurrentTemperature: accessory.context.CurrentTemperature || 0,
-      };
-    }
-
-    // Initialize Humidity Sensor property
-    if (!device.hub?.hide_humidity) {
-      this.HumiditySensor = {
-        Service: accessory.getService(this.hap.Service.HumiditySensor) as Service,
-        CurrentRelativeHumidity: accessory.context.CurrentRelativeHumidity || 0,
-      };
-    }
-
-    // Initialize Light Sensor property
-    if (!device.hub?.hide_lightsensor) {
-      this.LightSensor = {
-        Service: accessory.getService(this.hap.Service.LightSensor) as Service,
-        CurrentAmbientLightLevel: accessory.context.CurrentAmbientLightLevel || 0.0001,
-      };
-    }
-
-    // Retrieve initial values and updateHomekit
-    this.refreshStatus();
-
-    // Temperature Sensor Service
+    // Initialize Temperature Sensor Service
     if (device.hub?.hide_temperature) {
       this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Removing Temperature Sensor Service`);
       this.TemperatureSensor!.Service = this.accessory.getService(this.hap.Service.TemperatureSensor) as Service;
       accessory.removeService(this.TemperatureSensor!.Service);
-    } else if (!this.TemperatureSensor?.Service) {
-      this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Add Temperature Sensor Service`);
-      const TemperatureSensorService = `${accessory.displayName} Temperature Sensor`;
-      (this.TemperatureSensor!.Service = this.accessory.getService(this.hap.Service.TemperatureSensor)
-        || this.accessory.addService(this.hap.Service.TemperatureSensor)), TemperatureSensorService;
-
-      this.TemperatureSensor!.Service.setCharacteristic(this.hap.Characteristic.Name, TemperatureSensorService);
-      this.TemperatureSensor!.Service
+    } else {
+      this.TemperatureSensor = {
+        Name: accessory.context.TemperatureSensor.Name ?? `${accessory.displayName} Temperature Sensor`,
+        Service: accessory.getService(this.hap.Service.TemperatureSensor) ?? this.accessory.addService(this.hap.Service.TemperatureSensor) as Service,
+        CurrentTemperature: accessory.context.CurrentTemperature ?? 0,
+      };
+
+      // Initialize Temperature Sensor Characteristic
+      this.TemperatureSensor.Service
+        .setCharacteristic(this.hap.Characteristic.Name, this.TemperatureSensor.Name)
         .getCharacteristic(this.hap.Characteristic.CurrentTemperature)
         .setProps({
           unit: Units['CELSIUS'],
@@ -91,23 +72,24 @@ export class Hub extends deviceBase {
         .onGet(() => {
           return this.TemperatureSensor!.CurrentTemperature;
         });
-    } else {
-      this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Temperature Sensor Service Not Added`);
+      accessory.context.TemperatureSensor.Name = this.TemperatureSensor.Name;
     }
 
-    // Humidity Sensor Service
+    // Initialize Humidity Sensor Service
     if (device.hub?.hide_humidity) {
       this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Removing Humidity Sensor Service`);
       this.HumiditySensor!.Service = this.accessory.getService(this.hap.Service.HumiditySensor) as Service;
       accessory.removeService(this.HumiditySensor!.Service);
-    } else if (!this.HumiditySensor?.Service) {
-      this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Add Humidity Sensor Service`);
-      const HumiditySensorService = `${accessory.displayName} Humidity Sensor`;
-      (this.HumiditySensor!.Service = this.accessory.getService(this.hap.Service.HumiditySensor)
-        || this.accessory.addService(this.hap.Service.HumiditySensor)), HumiditySensorService;
+    } else {
+      this.HumiditySensor = {
+        Name: accessory.context.HumiditySensor.Name ?? `${accessory.displayName} Humidity Sensor`,
+        Service: accessory.getService(this.hap.Service.HumiditySensor) ?? this.accessory.addService(this.hap.Service.HumiditySensor) as Service,
+        CurrentRelativeHumidity: accessory.context.CurrentRelativeHumidity ?? 0,
+      };
 
-      this.HumiditySensor!.Service.setCharacteristic(this.hap.Characteristic.Name, HumiditySensorService);
+      // Initialize Humidity Sensor Characteristics
       this.HumiditySensor!.Service
+        .setCharacteristic(this.hap.Characteristic.Name, this.HumiditySensor.Name)
         .getCharacteristic(this.hap.Characteristic.CurrentRelativeHumidity)
         .setProps({
           minStep: 0.1,
@@ -115,26 +97,37 @@ export class Hub extends deviceBase {
         .onGet(() => {
           return this.HumiditySensor!.CurrentRelativeHumidity;
         });
-    } else {
-      this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Humidity Sensor Service Not Added`);
+      accessory.context.HumiditySensor.Name = this.HumiditySensor.Name;
     }
 
-    // Light Sensor Service
+    // Initialize Light Sensor Service
     if (device.hub?.hide_lightsensor) {
       this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Removing Light Sensor Service`);
       this.LightSensor!.Service = this.accessory.getService(this.hap.Service.LightSensor) as Service;
       accessory.removeService(this.LightSensor!.Service);
-    } else if (!this.LightSensor?.Service) {
-      this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Add Light Sensor Service`);
-      const LightSensorService = `${accessory.displayName} Light Sensor`;
-      (this.LightSensor!.Service = this.accessory.getService(this.hap.Service.LightSensor)
-        || this.accessory.addService(this.hap.Service.LightSensor)), LightSensorService;
-
-      this.LightSensor!.Service.setCharacteristic(this.hap.Characteristic.Name, LightSensorService);
     } else {
-      this.debugLog(`${this.device.deviceType}: ${accessory.displayName} Light Sensor Service Not Added`);
+      this.LightSensor = {
+        Name: accessory.context.LightSensor.Name ?? `${accessory.displayName} Light Sensor`,
+        Service: accessory.getService(this.hap.Service.LightSensor) ?? this.accessory.addService(this.hap.Service.LightSensor) as Service,
+        CurrentAmbientLightLevel: accessory.context.CurrentAmbientLightLevel ?? 0.0001,
+      };
+
+      // Initialize Light Sensor Characteristics
+      this.LightSensor!.Service
+        .setCharacteristic(this.hap.Characteristic.Name, this.LightSensor.Name)
+        .getCharacteristic(this.hap.Characteristic.CurrentAmbientLightLevel)
+        .setProps({
+          minStep: 1,
+        })
+        .onGet(() => {
+          return this.LightSensor!.CurrentAmbientLightLevel;
+        });
+      accessory.context.LightSensor.Name = this.LightSensor.Name;
     }
 
+    // Retrieve initial values and updateHomekit
+    this.refreshStatus();
+
     // Retrieve initial values and update Homekit
     this.updateHomeKitCharacteristics();