@switchbot/homebridge-switchbot 5.0.0-beta.6 → 5.0.0-beta.60

package/src/devices-hap/device.ts

@@ -14,7 +14,7 @@ import { hostname } from 'node:os'
 
 import { SwitchBotBLEModel, SwitchBotBLEModelFriendlyName, SwitchBotBLEModelName, SwitchBotModel } from 'node-switchbot'
 
-import { formatDeviceIdAsMac, safeStringify, sleep } from '../utils.js'
+import { deviceLoggingEnabled, deviceLoggingIsDebug, formatDeviceIdAsMac, isSuccessfulStatusCode, logDeviceStatusCode, safeStringify, sleep } from '../utils.js'
 
 export abstract class deviceBase {
   public readonly api: API
@@ -147,7 +147,9 @@ export abstract class deviceBase {
       device.scanDuration !== 0 && { scanDuration: device.scanDuration },
       device.offline === true && { offline: device.offline },
       device.maxRetry !== 0 && { maxRetry: device.maxRetry },
-      device.webhook === true && { webhook: device.webhook },
+      (device.webhook === true || (device.webhook === undefined && this.config.options?.webhook === true)) && {
+        webhook: device.webhook !== undefined ? device.webhook : this.config.options?.webhook,
+      },
       device.connectionType !== '' && { connectionType: device.connectionType },
       device.disablePlatformBLE !== false && { disablePlatformBLE: device.disablePlatformBLE },
       device.external === true && { external: device.external },
@@ -288,11 +290,7 @@ export abstract class deviceBase {
       this.device.bleMac = formattedDeviceId
       this.debugLog(`bleMac: ${this.device.bleMac}`)
       this.historyService = device.history
-        ? new this.platform.fakegatoAPI('room', accessory, {
-          log: this.platform.log,
-          storage: 'fs',
-          filename: `${hostname().split('.')[0]}_${this.device.bleMac}_persist.json`,
-        })
+        ? new this.platform.fakegatoAPI('room', accessory, { log: this.platform.log, storage: 'fs', filename: `${hostname().split('.')[0]}_${this.device.bleMac}_persist.json` })
         : null
     } catch (error) {
       this.errorLog(`failed to format device ID as MAC, Error: ${error}`)
@@ -377,8 +375,12 @@ export abstract class deviceBase {
     return { body: response, statusCode }
   }
 
-  async successfulStatusCodes<T extends { statusCode: number }>(deviceStatus: T) {
-    return (deviceStatus.statusCode === 200 || deviceStatus.statusCode === 100)
+  /**
+   * Check if status code indicates success (100 or 200)
+   * @deprecated Use isSuccessfulStatusCode from utils.ts instead
+   */
+  async successfulStatusCodes<T extends { statusCode: number }>(deviceStatus: T): Promise<boolean> {
+    return isSuccessfulStatusCode(deviceStatus.statusCode)
   }
 
   /**
@@ -584,6 +586,12 @@ export abstract class deviceBase {
         bleModelName: SwitchBotBLEModelName.LockPro,
         bleModelFriendlyName: SwitchBotBLEModelFriendlyName.LockPro,
       },
+      'Smart Lock Ultra': {
+        model: SwitchBotModel.LockPro,
+        bleModel: SwitchBotBLEModel.LockPro,
+        bleModelName: SwitchBotBLEModelName.LockPro,
+        bleModelFriendlyName: SwitchBotBLEModelFriendlyName.LockPro,
+      },
       'Color Bulb': {
         model: SwitchBotModel.ColorBulb,
         bleModel: SwitchBotBLEModel.ColorBulb,
@@ -709,103 +717,174 @@ export abstract class deviceBase {
       .updateValue(deviceVersion)
     accessory.context.version = deviceVersion
     this.debugSuccessLog(`version: ${accessory.context.version}`)
+
+    // Expose effective webhook setting on accessory context (parity with Matter)
+    try {
+      const effectiveWebhook = device.webhook !== undefined ? device.webhook : (this.config.options?.webhook === true ? true : undefined)
+      if (effectiveWebhook !== undefined) {
+        accessory.context.webhook = effectiveWebhook
+        this.debugLog(`Effective webhook for ${device.deviceId}: ${String(effectiveWebhook)}`)
+      }
+    } catch (e: any) {
+      this.debugLog(`Failed to set webhook context for ${device.deviceId}: ${e?.message ?? e}`)
+    }
   }
 
   async statusCode(statusCode: number): Promise<void> {
-    const statusMessages = {
-      151: 'Command not supported by this deviceType',
-      152: 'Device not found',
-      160: 'Command is not supported',
-      161: 'Device is offline',
-      171: `Hub Device is offline. Hub: ${this.device.hubDeviceId}`,
-      190: 'Device internal error due to device states not synchronized with server, or command format is invalid',
-      100: 'Command successfully sent',
-      200: 'Request successful',
-      400: 'Bad Request, an invalid payload request',
-      401: 'Unauthorized, Authorization for the API is required, but the request has not been authenticated',
-      403: 'Forbidden, The request has been authenticated but does not have appropriate permissions, or a requested resource is not found',
-      404: 'Not Found, Specifies the requested path does not exist',
-      406: 'Not Acceptable, a MIME type has been requested via the Accept header for a value not supported by the server',
-      415: 'Unsupported Media Type, a contentType header has been defined that is not supported by the server',
-      422: 'Unprocessable Entity: The server cannot process the request, often due to exceeded API limits.',
-      429: 'Too Many Requests, exceeded the number of requests allowed for a given time window',
-      500: 'Internal Server Error, An unexpected error occurred. These errors should be rare',
-    }
-    if (statusCode === 171 && (this.device.hubDeviceId === this.device.deviceId || this.device.hubDeviceId === '000000000000')) {
-      this.debugErrorLog(`statusCode 171 changed to 161: hubDeviceId ${this.device.hubDeviceId} matches deviceId ${this.device.deviceId}, device is its own hub.`)
-      statusCode = 161
-    }
-    const logMessage = statusMessages[statusCode] || `Unknown statusCode: ${statusCode}, Submit Bugs Here: https://tinyurl.com/SwitchBotBug`
-    const logMethod = [100, 200].includes(statusCode) ? 'debugLog' : statusMessages[statusCode] ? 'errorLog' : 'infoLog'
-    this[logMethod](`${logMessage}, statusCode: ${statusCode}`)
+    await logDeviceStatusCode(
+      statusCode,
+      {
+        debugLog: this.debugLog.bind(this),
+        debugErrorLog: this.debugErrorLog.bind(this),
+        errorLog: this.errorLog.bind(this),
+        infoLog: this.infoLog.bind(this),
+      },
+      this.device.deviceId,
+      this.device.hubDeviceId,
+    )
   }
 
   /**
    * Logging for Device
+   * Modernized logging methods with improved type safety and formatting
    */
-  infoLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
-      this.log.info(`${this.device.deviceType}: ${this.accessory.displayName}`, String(...log))
+  infoLog(message: string, ...args: unknown[]): void {
+    if (!this.enablingDeviceLogging()) {
+      return
     }
+    const prefix = `${this.device.deviceType}: ${this.accessory.displayName}`
+    this.logWith('info', prefix, undefined, this.formatLogMessage(message, ...args))
   }
 
-  successLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
-      this.log.success(`${this.device.deviceType}: ${this.accessory.displayName}`, String(...log))
+  successLog(message: string, ...args: unknown[]): void {
+    if (!this.enablingDeviceLogging()) {
+      return
     }
+    const prefix = `${this.device.deviceType}: ${this.accessory.displayName}`
+    this.logWith('success', prefix, undefined, this.formatLogMessage(message, ...args))
   }
 
-  debugSuccessLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
-      if (this.loggingIsDebug()) {
-        this.log.success(`[DEBUG] ${this.device.deviceType}: ${this.accessory.displayName}`, String(...log))
-      }
+  debugSuccessLog(message: string, ...args: unknown[]): void {
+    if (!this.enablingDeviceLogging() || !this.loggingIsDebug()) {
+      return
     }
+    const prefix = `[DEBUG] ${this.device.deviceType}: ${this.accessory.displayName}`
+    this.logWith('success', prefix, 'debugSuccessLog', this.formatLogMessage(message, ...args))
   }
 
-  warnLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
-      this.log.warn(`${this.device.deviceType}: ${this.accessory.displayName}`, String(...log))
+  warnLog(message: string, ...args: unknown[]): void {
+    if (!this.enablingDeviceLogging()) {
+      return
     }
+    const prefix = `${this.device.deviceType}: ${this.accessory.displayName}`
+    this.logWith('warn', prefix, undefined, this.formatLogMessage(message, ...args))
   }
 
-  debugWarnLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
-      if (this.loggingIsDebug()) {
-        this.log.warn(`[DEBUG] ${this.device.deviceType}: ${this.accessory.displayName}`, String(...log))
-      }
+  debugWarnLog(message: string, ...args: unknown[]): void {
+    if (!this.enablingDeviceLogging() || !this.loggingIsDebug()) {
+      return
     }
+    const prefix = `[DEBUG] ${this.device.deviceType}: ${this.accessory.displayName}`
+    this.logWith('warn', prefix, 'debugWarnLog', this.formatLogMessage(message, ...args))
   }
 
-  errorLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
-      this.log.error(`${this.device.deviceType}: ${this.accessory.displayName}`, String(...log))
+  errorLog(message: string, ...args: unknown[]): void {
+    if (!this.enablingDeviceLogging()) {
+      return
     }
+    const prefix = `${this.device.deviceType}: ${this.accessory.displayName}`
+    this.logWith('error', prefix, undefined, this.formatLogMessage(message, ...args))
   }
 
-  debugErrorLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
-      if (this.loggingIsDebug()) {
-        this.log.error(`[DEBUG] ${this.device.deviceType}: ${this.accessory.displayName}`, String(...log))
-      }
+  debugErrorLog(message: string, ...args: unknown[]): void {
+    if (!this.enablingDeviceLogging() || !this.loggingIsDebug()) {
+      return
     }
+    const prefix = `[DEBUG] ${this.device.deviceType}: ${this.accessory.displayName}`
+    this.logWith('error', prefix, 'debugErrorLog', this.formatLogMessage(message, ...args))
   }
 
-  debugLog(...log: any[]): void {
-    if (this.enablingDeviceLogging()) {
-      if (this.deviceLogging === 'debug') {
-        this.log.info(`[DEBUG] ${this.device.deviceType}: ${this.accessory.displayName}`, String(...log))
-      } else if (this.deviceLogging === 'debugMode') {
-        this.log.debug(`${this.device.deviceType}: ${this.accessory.displayName}`, String(...log))
+  debugLog(message: string, ...args: unknown[]): void {
+    if (!this.enablingDeviceLogging()) {
+      return
+    }
+    // debug behaves differently depending on debug vs debugMode
+    const prefix = this.deviceLogging === 'debug'
+      ? `[DEBUG] ${this.device.deviceType}: ${this.accessory.displayName}`
+      : `${this.device.deviceType}: ${this.accessory.displayName}`
+    this.logWith('debug', prefix, 'debugLog', this.formatLogMessage(message, ...args))
+  }
+
+  /**
+   * Format log message with arguments - handles both legacy and modern patterns
+   */
+  private formatLogMessage(message: string | any, ...args: unknown[]): string {
+    // Handle legacy String(...log) pattern for backward compatibility
+    if (typeof message !== 'string' && args.length === 0) {
+      return String(message)
+    }
+
+    // Modern pattern: format message with arguments
+    if (args.length === 0) {
+      return String(message)
+    }
+
+    // Format arguments similar to how platform logging works
+    const formattedArgs = args.map((arg) => {
+      if (typeof arg === 'string') {
+        return arg
+      }
+      try {
+        return JSON.stringify(arg)
+      } catch {
+        return String(arg)
+      }
+    })
+
+    return args.length > 0 ? `${message} ${formattedArgs.join(' ')}` : String(message)
+  }
+
+  // Generic logger used by device log helpers. Attempts to call a platform
+  // helper method first (if present), then falls back to the local logger.
+  protected logWith(level: string, message: string, platformMethodName?: string, payload?: string): void {
+    const method = platformMethodName ?? `${level}Log`
+    const pFn = (this.platform as any)?.[method]
+    if (typeof pFn === 'function') {
+      try {
+        // Forward both a short message (title) and optional payload to the
+        // platform logger so it can format/attach metadata consistently.
+        if (payload !== undefined) {
+          pFn(message, payload)
+        } else {
+          pFn(message)
+        }
+        return
+      } catch (_err) {
+        // fallthrough to local logger
+      }
+    }
+    const map: Record<string, string> = {
+      info: 'info',
+      success: 'success',
+      debug: 'debug',
+      warn: 'warn',
+      error: 'error',
+    }
+    const local = (this.log as any)[map[level] ?? level]
+    if (typeof local === 'function') {
+      if (payload !== undefined) {
+        local.call(this.log, message, payload)
+      } else {
+        local.call(this.log, message)
       }
     }
   }
 
   loggingIsDebug(): boolean {
-    return this.deviceLogging === 'debugMode' || this.deviceLogging === 'debug'
+    return deviceLoggingIsDebug(this.deviceLogging)
   }
 
   enablingDeviceLogging(): boolean {
-    return this.deviceLogging === 'debugMode' || this.deviceLogging === 'debug' || this.deviceLogging === 'standard'
+    return deviceLoggingEnabled(this.deviceLogging, this.platform.platformLogging)
   }
 }

package/src/devices-hap/fan.ts

@@ -329,7 +329,7 @@ export class Fan extends deviceBase {
         // Update HomeKit
         if (serviceData.model === SwitchBotBLEModel.Unknown && SwitchBotBLEModelName.Unknown) {
           this.serviceData = serviceData
-          if (serviceData !== undefined || serviceData !== null) {
+          if (serviceData !== undefined && serviceData !== null) {
             await this.BLEparseStatus()
             await this.updateHomeKitCharacteristics()
           } else {
@@ -355,7 +355,7 @@ export class Fan extends deviceBase {
         this.platform.bleEventHandler[this.device.bleMac] = async (context: batteryCirculatorFanServiceData) => {
           try {
             this.serviceData = context
-            if (context !== undefined || context !== null) {
+            if (context !== undefined && context !== null) {
               this.debugLog(`received BLE: ${JSON.stringify(context)}`)
               await this.BLEparseStatus()
               await this.updateHomeKitCharacteristics()
@@ -400,7 +400,7 @@ export class Fan extends deviceBase {
       this.platform.webhookEventHandler[this.device.deviceId] = async (context: batteryCirculatorFanWebhookContext) => {
         try {
           this.webhookContext = context
-          if (context !== undefined || context !== null) {
+          if (context !== undefined && context !== null) {
             this.debugLog(`received Webhook: ${JSON.stringify(context)}`)
             await this.parseStatusWebhook()
             await this.updateHomeKitCharacteristics()
@@ -468,13 +468,18 @@ export class Fan extends deviceBase {
           switchBotBLE
             .discover({ model: this.device.bleModel, id: this.device.bleMac })
             .then(async (device_list: SwitchbotDevice[]) => {
+              this.debugLog(`device_list: ${JSON.stringify(device_list)}`)
               return await this.retryBLE({
                 max: this.maxRetryBLE(),
                 fn: async () => {
-                  if (this.Fan.Active) {
-                    return await (device_list[0] as any).turnOn()
+                  if (Array.isArray(device_list) && device_list.length > 0) {
+                    if (this.Fan.Active) {
+                      return await (device_list[0] as any).turnOn()
+                    } else {
+                      return await (device_list[0] as any).turnOff()
+                    }
                   } else {
-                    return await (device_list[0] as any).turnOff()
+                    throw new Error('No devices found during discovery.')
                   }
                 },
               })

package/src/devices-hap/hub.ts

@@ -211,8 +211,9 @@ export class Hub extends deviceBase {
 
     // CurrentTemperature
     if (!(this.device as hubConfig).hide_temperature && this.TemperatureSensor?.Service) {
-      this.TemperatureSensor.CurrentTemperature = this.deviceStatus.temperature
-      this.debugLog(`CurrentTemperature: ${this.TemperatureSensor.CurrentTemperature}°c`)
+      // OpenAPI returns Celsius; convert if user configured a different unit
+      this.TemperatureSensor.CurrentTemperature = convertUnits(this.deviceStatus.temperature, 'CELSIUS', (this.device as hubConfig).convertUnitTo)
+      this.debugLog(`CurrentTemperature: ${this.TemperatureSensor.CurrentTemperature}`)
     }
 
     // LightSensor
@@ -297,7 +298,7 @@ export class Hub extends deviceBase {
         if ((serviceData.model === SwitchBotBLEModel.Hub2 && serviceData.modelName === SwitchBotBLEModelName.Hub2)
           || (serviceData.model === SwitchBotBLEModel.Hub3 && serviceData.modelName === SwitchBotBLEModelName.Hub3)) {
           this.serviceData = serviceData
-          if (serviceData !== undefined || serviceData !== null) {
+          if (serviceData !== undefined && serviceData !== null) {
             await this.BLEparseStatus()
             await this.updateHomeKitCharacteristics()
           } else {
@@ -323,7 +324,7 @@ export class Hub extends deviceBase {
         this.platform.bleEventHandler[this.device.bleMac] = async (context: hub2ServiceData) => {
           try {
             this.serviceData = context
-            if (context !== undefined || context !== null) {
+            if (context !== undefined && context !== null) {
               this.debugLog(`received BLE: ${JSON.stringify(context)}`)
               await this.BLEparseStatus()
               await this.updateHomeKitCharacteristics()
@@ -368,7 +369,7 @@ export class Hub extends deviceBase {
       this.platform.webhookEventHandler[this.device.deviceId] = async (context: hub2WebhookContext) => {
         try {
           this.webhookContext = context
-          if (context !== undefined || context !== null) {
+          if (context !== undefined && context !== null) {
             this.debugLog(`received Webhook: ${JSON.stringify(context)}`)
             await this.parseStatusWebhook()
             await this.updateHomeKitCharacteristics()

package/src/devices-hap/humidifier.ts

@@ -42,6 +42,12 @@ export class Humidifier extends deviceBase {
     CurrentTemperature: CharacteristicValue
   }
 
+  private DryingFilterSwitch?: {
+    Name: CharacteristicValue
+    Service: Service
+    On: CharacteristicValue
+  }
+
   // OpenAPI
   deviceStatus!: humidifierStatus | humidifier2Status
 
@@ -132,6 +138,31 @@ export class Humidifier extends deviceBase {
       })
     }
 
+    // Initialize optional Drying Filter Switch (Humidifier2 only)
+    if ((device as humidifierConfig).configDeviceType === 'Humidifier2' && (device as humidifierConfig).activate_dryingfilter) {
+      accessory.context.DryingFilterSwitch = accessory.context.DryingFilterSwitch ?? {}
+      this.DryingFilterSwitch = {
+        Name: `${accessory.displayName} Drying Filter`,
+        Service: accessory.getService(`${accessory.displayName} Drying Filter`) ?? accessory.addService(this.hap.Service.Switch, `${accessory.displayName} Drying Filter`, 'DryingFilterSwitch') as Service,
+        On: false,
+      }
+      accessory.context.DryingFilterSwitch = this.DryingFilterSwitch as object
+
+      this.DryingFilterSwitch.Service.setCharacteristic(this.hap.Characteristic.Name, this.DryingFilterSwitch.Name)
+        .getCharacteristic(this.hap.Characteristic.On)
+        .onGet(() => {
+          return this.DryingFilterSwitch!.On
+        })
+        .onSet(this.DryingFilterOnSet.bind(this))
+      this.debugLog('Initialized Drying Filter Switch Service')
+    } else {
+      const svc = this.accessory.getServiceById(this.hap.Service.Switch, 'DryingFilterSwitch')
+      if (svc) {
+        this.debugLog('Removing Drying Filter Switch Service')
+        this.accessory.removeService(svc)
+      }
+    }
+
     // Retrieve initial values and updateHomekit
     try {
       this.debugLog('Retrieve initial values and update Homekit')
@@ -326,7 +357,7 @@ export class Humidifier extends deviceBase {
         // Update HomeKit
         if (serviceData.model === SwitchBotBLEModel.Humidifier && serviceData.modelName === SwitchBotBLEModelName.Humidifier) {
           this.serviceData = serviceData
-          if (serviceData !== undefined || serviceData !== null) {
+          if (serviceData !== undefined && serviceData !== null) {
             await this.BLEparseStatus()
             await this.updateHomeKitCharacteristics()
           } else {
@@ -352,7 +383,7 @@ export class Humidifier extends deviceBase {
         this.platform.bleEventHandler[this.device.bleMac] = async (context: humidifierServiceData | humidifier2ServiceData) => {
           try {
             this.serviceData = context
-            if (context !== undefined || context !== null) {
+            if (context !== undefined && context !== null) {
               this.debugLog(`received BLE: ${JSON.stringify(context)}`)
               await this.BLEparseStatus()
               await this.updateHomeKitCharacteristics()
@@ -397,7 +428,7 @@ export class Humidifier extends deviceBase {
       this.platform.webhookEventHandler[this.device.deviceId] = async (context: humidifierWebhookContext | humidifier2WebhookContext) => {
         try {
           this.webhookContext = context
-          if (context !== undefined || context !== null) {
+          if (context !== undefined && context !== null) {
             this.debugLog(`received Webhook: ${JSON.stringify(context)}`)
             await this.parseStatusWebhook()
             await this.updateHomeKitCharacteristics()
@@ -446,7 +477,17 @@ export class Humidifier extends deviceBase {
           switchBotBLE
             .discover({ model: this.device.bleModel, quick: true, id: this.device.bleMac })
             .then(async (device_list: SwitchbotDevice[]) => {
-              return await (device_list[0] as WoHumi).percentage(Number(this.HumidifierDehumidifier.RelativeHumidityHumidifierThreshold))
+              this.debugLog(`device_list: ${JSON.stringify(device_list)}`)
+              return await this.retryBLE({
+                max: this.maxRetryBLE(),
+                fn: async () => {
+                  if (device_list.length > 0) {
+                    return await (device_list[0] as WoHumi).percentage(Number(this.HumidifierDehumidifier.RelativeHumidityHumidifierThreshold))
+                  } else {
+                    throw new Error('No devices found during discovery.')
+                  }
+                },
+              })
             })
             .then(async () => {
               this.successLog(`RelativeHumidityHumidifierThreshold: ${this.HumidifierDehumidifier.RelativeHumidityHumidifierThreshold} sent over BLE, sent successfully`)
@@ -630,6 +671,58 @@ export class Humidifier extends deviceBase {
     if (!(this.device as humidifierConfig).hide_temperature && this.TemperatureSensor?.Service) {
       await this.updateCharacteristic(this.TemperatureSensor.Service, this.hap.Characteristic.CurrentTemperature, this.TemperatureSensor.CurrentTemperature, 'CurrentTemperature')
     }
+    // DryingFilter switch is momentary; ensure it reflects current cached state
+    if (this.DryingFilterSwitch?.Service) {
+      await this.updateCharacteristic(this.DryingFilterSwitch.Service, this.hap.Characteristic.On, this.DryingFilterSwitch.On, 'DryingFilter.On')
+    }
+  }
+
+  /**
+   * Handle requests to set the Drying Filter switch (Humidifier2 only)
+   */
+  async DryingFilterOnSet(value: CharacteristicValue): Promise<void> {
+    if (!this.DryingFilterSwitch?.Service) {
+      this.debugLog('DryingFilterOnSet called but service not initialized')
+      return
+    }
+    this.DryingFilterSwitch.On = value
+    if (value !== true) {
+      // Switch is momentary; ignore turning off manually
+      this.debugLog('Drying Filter switch set to false (ignored)')
+      return
+    }
+
+    this.infoLog('Trigger Drying Filter mode')
+    if (this.OpenAPI && this.platform.config.credentials?.token) {
+      const bodyChange: bodyChange = {
+        command: 'setMode',
+        parameter: '8',
+        commandType: 'command',
+      }
+      this.debugLog(`DryingFilterOnSet, SwitchBot OpenAPI bodyChange: ${JSON.stringify(bodyChange)}`)
+      try {
+        const deviceStatus = await this.pushChangeRequest(bodyChange)
+        this.debugLog(`statusCode: ${deviceStatus.statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`)
+        if (await this.successfulStatusCodes(deviceStatus)) {
+          this.debugSuccessLog(`statusCode: ${deviceStatus.statusCode}, deviceStatus: ${JSON.stringify(deviceStatus)}`)
+        } else {
+          await this.statusCode(deviceStatus.statusCode)
+        }
+      } catch (e: any) {
+        await this.apiError(e)
+        this.errorLog(`failed DryingFilterOnSet with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`)
+      }
+    } else {
+      this.debugWarnLog('Drying Filter requires OpenAPI; BLE not supported for this action')
+    }
+
+    // Auto-reset the momentary switch back to off after a short delay
+    setTimeout(async () => {
+      if (this.DryingFilterSwitch) {
+        this.DryingFilterSwitch.On = false
+        await this.updateHomeKitCharacteristics()
+      }
+    }, 1500)
   }
 
   async BLEPushConnection() {

package/src/devices-hap/iosensor.ts

@@ -178,27 +178,41 @@ export class IOSensor extends deviceBase {
   async BLEparseStatus(): Promise<void> {
     this.debugLog('BLEparseStatus')
     this.debugLog(`(battery, temperature, humidity) = BLE:(${this.serviceData.battery}, ${this.serviceData.celsius}, ${this.serviceData.humidity}), current:(${this.Battery.BatteryLevel}, ${this.TemperatureSensor?.CurrentTemperature}, ${this.HumiditySensor?.CurrentRelativeHumidity})`)
+
     // Battery Info
     if ('battery' in this.serviceData) {
-      // BatteryLevel
-      this.Battery.BatteryLevel = this.serviceData.battery
-      this.debugLog(`BatteryLevel: ${this.Battery.BatteryLevel}`)
-      // StatusLowBattery
-      this.Battery.StatusLowBattery = this.Battery.BatteryLevel < 10
-        ? this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW
-        : this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL
-      this.debugLog(`StatusLowBattery: ${this.Battery.StatusLowBattery}`)
+      if (typeof this.serviceData.battery === 'number') {
+        this.Battery.BatteryLevel = this.serviceData.battery
+        this.debugLog(`BatteryLevel: ${this.Battery.BatteryLevel}`)
+        this.Battery.StatusLowBattery = this.Battery.BatteryLevel < 10
+          ? this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW
+          : this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL
+        this.debugLog(`StatusLowBattery: ${this.Battery.StatusLowBattery}`)
+      } else {
+        this.debugWarnLog(`BLE battery is undefined; skipping battery update.`)
+      }
     }
+
     // CurrentRelativeHumidity
     if (!(this.device as indoorOutdoorSensorConfig).hide_humidity && this.HumiditySensor?.Service) {
-      this.HumiditySensor.CurrentRelativeHumidity = validHumidity(this.serviceData.humidity, 0, 100)
-      this.debugLog(`CurrentRelativeHumidity: ${this.HumiditySensor.CurrentRelativeHumidity}%`)
+      if (typeof this.serviceData.humidity === 'number') {
+        this.HumiditySensor.CurrentRelativeHumidity = validHumidity(this.serviceData.humidity, 0, 100)
+        this.debugLog(`CurrentRelativeHumidity: ${this.HumiditySensor.CurrentRelativeHumidity}%`)
+      } else {
+        this.debugWarnLog(`BLE humidity is undefined; skipping humidity update.`)
+      }
     }
+
     // Current Temperature
     if (!(this.device as indoorOutdoorSensorConfig).hide_temperature && this.TemperatureSensor?.Service) {
-      const CELSIUS = this.serviceData.celsius < 0 ? 0 : this.serviceData.celsius > 100 ? 100 : this.serviceData.celsius
-      this.TemperatureSensor.CurrentTemperature = CELSIUS
-      this.debugLog(`Temperature: ${this.TemperatureSensor.CurrentTemperature}°c`)
+      if (typeof this.serviceData.celsius === 'number') {
+        const c = this.serviceData.celsius
+        const CELSIUS = c < 0 ? 0 : c > 100 ? 100 : c
+        this.TemperatureSensor.CurrentTemperature = CELSIUS
+        this.debugLog(`Temperature: ${this.TemperatureSensor.CurrentTemperature}°c`)
+      } else {
+        this.debugWarnLog(`BLE temperature is undefined; skipping temperature update.`)
+      }
     }
   }
 
@@ -224,8 +238,9 @@ export class IOSensor extends deviceBase {
 
     // Current Temperature
     if (!(this.device as indoorOutdoorSensorConfig).hide_temperature && this.TemperatureSensor?.Service) {
-      this.TemperatureSensor.CurrentTemperature = this.deviceStatus.temperature
-      this.debugLog(`CurrentTemperature: ${this.TemperatureSensor.CurrentTemperature}°c`)
+      // OpenAPI returns Celsius; convert if user configured a different unit
+      this.TemperatureSensor.CurrentTemperature = convertUnits(this.deviceStatus.temperature as number, 'CELSIUS', (this.device as indoorOutdoorSensorConfig).convertUnitTo)
+      this.debugLog(`CurrentTemperature: ${this.TemperatureSensor.CurrentTemperature}`)
     }
 
     // Firmware Version
@@ -252,12 +267,12 @@ export class IOSensor extends deviceBase {
       this.warnLog(`received a non-CELSIUS Webhook scale: ${this.webhookContext.scale}, Use the *convertUnitsTo* config under Hub settings, if displaying incorrectly in HomeKit.`)
     }
     // CurrentRelativeHumidity
-    if ((this.device as indoorOutdoorSensorConfig).hide_humidity && this.HumiditySensor?.Service) {
+    if (!(this.device as indoorOutdoorSensorConfig).hide_humidity && this.HumiditySensor?.Service) {
       this.HumiditySensor.CurrentRelativeHumidity = this.webhookContext.humidity
       this.debugLog(`CurrentRelativeHumidity: ${this.HumiditySensor.CurrentRelativeHumidity}%`)
     }
     // CurrentTemperature
-    if ((this.device as indoorOutdoorSensorConfig).hide_temperature && this.TemperatureSensor?.Service) {
+    if (!(this.device as indoorOutdoorSensorConfig).hide_temperature && this.TemperatureSensor?.Service) {
       this.TemperatureSensor.CurrentTemperature = convertUnits(this.webhookContext.temperature, this.webhookContext.scale, (this.device as indoorOutdoorSensorConfig).convertUnitTo)
       this.debugLog(`CurrentTemperature: ${this.TemperatureSensor.CurrentTemperature}°c`)
     }
@@ -290,7 +305,7 @@ export class IOSensor extends deviceBase {
         // Update HomeKit
         if (serviceData.model === SwitchBotBLEModel.OutdoorMeter && serviceData.modelName === SwitchBotBLEModelName.OutdoorMeter) {
           this.serviceData = serviceData
-          if (serviceData !== undefined || serviceData !== null) {
+          if (serviceData !== undefined && serviceData !== null) {
             await this.BLEparseStatus()
             await this.updateHomeKitCharacteristics()
           } else {
@@ -316,7 +331,7 @@ export class IOSensor extends deviceBase {
         this.platform.bleEventHandler[this.device.bleMac] = async (context: outdoorMeterServiceData) => {
           try {
             this.serviceData = context
-            if (context !== undefined || context !== null) {
+            if (context !== undefined && context !== null) {
               this.debugLog(`received BLE: ${JSON.stringify(context)}`)
               await this.BLEparseStatus()
               await this.updateHomeKitCharacteristics()
@@ -351,7 +366,7 @@ export class IOSensor extends deviceBase {
       }
     } catch (e: any) {
       await this.apiError(e)
-      this.errorLog(`failed openAPIRefreshStatus with ${this.device.connectionType} Connection, Error Message: ${JSON.stringify(e.message)}`)
+      this.errorLog(`failed openAPIRefreshStatus with ${this.device.connectionType} Connection, Error: ${e.message ?? e}`)
     }
   }
 
@@ -361,7 +376,7 @@ export class IOSensor extends deviceBase {
       this.platform.webhookEventHandler[this.device.deviceId] = async (context: outdoorMeterWebhookContext) => {
         try {
           this.webhookContext = context
-          if (context !== undefined || context !== null) {
+          if (context !== undefined && context !== null) {
             this.debugLog(`received Webhook: ${JSON.stringify(context)}`)
             await this.parseStatusWebhook()
             await this.updateHomeKitCharacteristics()