@switchbot/homebridge-switchbot 5.0.0-beta.43 → 5.0.0-beta.44

package/src/platform-hap.ts

@@ -606,6 +606,7 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
           'Plug Mini (JP)': Plug,
           'Smart Lock': Lock,
           'Smart Lock Pro': Lock,
+          'Smart Lock Ultra': Lock,
           'Color Bulb': ColorBulb,
           'K10+': RobotVacuumCleaner,
           'K10+ Pro': RobotVacuumCleaner,
@@ -728,12 +729,29 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
       const allowConfigOnly = Boolean(this.config.options?.allowConfigOnlyDevices)
       const devices = mergeByDeviceId(this.config.options.devices ?? [], devicesWithTemplates ?? [], allowConfigOnly)
 
+      // Apply global webhook option to devices that don't have their own webhook setting
+      if (this.config.options?.webhook === true) {
+        for (const device of devices) {
+          if (device.webhook === undefined) {
+            device.webhook = true
+            this.debugLog(`Applying global webhook option to device: ${device.deviceName ?? device.deviceId}`)
+          }
+        }
+      }
+
       this.debugLog(`SwitchBot Devices: ${JSON.stringify(devices)}`)
 
       for (const device of devices) {
         if (device.configDeviceName) {
           device.deviceName = device.configDeviceName
         }
+        // Log effective webhook setting for diagnostics
+        try {
+          const effectiveWebhook = device.webhook !== undefined ? device.webhook : (this.config.options?.webhook === true ? true : undefined)
+          this.debugLog(`Effective webhook for device ${device.deviceName ?? device.deviceId}: ${String(effectiveWebhook)}`)
+        } catch (e: any) {
+          this.debugLog(`Failed logging effective webhook for ${device.deviceName ?? device.deviceId}: ${e?.message ?? e}`)
+        }
         await this.createDevice(device)
       }
     }
@@ -773,11 +791,28 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
       const allowConfigOnly = Boolean(this.config.options?.allowConfigOnlyDevices)
       const devices = mergeByDeviceId(this.config.options.irdevices ?? [], devicesWithTemplates ?? [], allowConfigOnly)
 
+      // Apply global webhook option to IR devices that don't have their own webhook setting
+      if (this.config.options?.webhook === true) {
+        for (const device of devices) {
+          if (device.webhook === undefined) {
+            device.webhook = true
+            this.debugLog(`Applying global webhook option to IR device: ${device.deviceName ?? device.deviceId}`)
+          }
+        }
+      }
+
       this.debugLog(`IR Devices: ${JSON.stringify(devices)}`)
       for (const device of devices) {
         if (device.configDeviceName) {
           device.deviceName = device.configDeviceName
         }
+        // Log effective webhook setting for diagnostics (IR devices)
+        try {
+          const effectiveWebhook = device.webhook !== undefined ? device.webhook : (this.config.options?.webhook === true ? true : undefined)
+          this.debugLog(`Effective webhook for IR device ${device.deviceName ?? device.deviceId}: ${String(effectiveWebhook)}`)
+        } catch (e: any) {
+          this.debugLog(`Failed logging effective webhook for IR ${device.deviceName ?? device.deviceId}: ${e?.message ?? e}`)
+        }
         await this.createIRDevice(device)
       }
     }
@@ -819,6 +854,7 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
       'Plug Mini (JP)': this.createPlug.bind(this),
       'Smart Lock': this.createLock.bind(this),
       'Smart Lock Pro': this.createLock.bind(this),
+      'Smart Lock Ultra': this.createLock.bind(this),
       'Color Bulb': this.createColorBulb.bind(this),
       'K10+': this.createRobotVacuumCleaner.bind(this),
       'K10+ Pro': this.createRobotVacuumCleaner.bind(this),
@@ -1814,7 +1850,7 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
         existingAccessory.context.device = device
         existingAccessory.context.deviceId = device.deviceId
         existingAccessory.context.deviceType = device.deviceType
-        existingAccessory.context.model = device.deviceType === 'Smart Lock Pro' ? SwitchBotModel.LockPro : SwitchBotModel.Lock
+        existingAccessory.context.model = (device.deviceType === 'Smart Lock Pro' || device.deviceType === 'Smart Lock Ultra') ? SwitchBotModel.LockPro : SwitchBotModel.Lock
         existingAccessory.displayName = device.configDeviceName
           ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
           : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName)
@@ -1840,7 +1876,7 @@ export class SwitchBotHAPPlatform implements DynamicPlatformPlugin {
       accessory.context.device = device
       accessory.context.deviceId = device.deviceId
       accessory.context.deviceType = device.deviceType
-      accessory.context.model = device.deviceType === 'Smart Lock Pro' ? SwitchBotModel.LockPro : SwitchBotModel.Lock
+      accessory.context.model = (device.deviceType === 'Smart Lock Pro' || device.deviceType === 'Smart Lock Ultra') ? SwitchBotModel.LockPro : SwitchBotModel.Lock
       accessory.displayName = device.configDeviceName
         ? await this.validateAndCleanDisplayName(device.configDeviceName, 'configDeviceName', device.configDeviceName)
         : await this.validateAndCleanDisplayName(device.deviceName, 'deviceName', device.deviceName)

package/src/platform-matter.ts

@@ -445,6 +445,16 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
     const allowConfigOnly = Boolean(this.config.options?.allowConfigOnlyDevices)
     const merged = mergeByDeviceId(this.config.options?.devices ?? [], devicesWithTemplates ?? [], allowConfigOnly)
 
+    // Apply global webhook setting if not explicitly set on individual devices
+    if (this.config.options?.webhook === true) {
+      merged.forEach((device: any) => {
+        if (device.webhook === undefined) {
+          device.webhook = true
+          this.debugLog(`Applied global webhook setting to Matter device: ${device.deviceId}`)
+        }
+      })
+    }
+
     return merged
   }
 
@@ -483,6 +493,16 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
     type IRMerged = irdevice & irDevicesConfig
     const merged = mergeByDeviceId(this.config.options?.irdevices ?? [], devicesWithTemplates ?? [], allowConfigOnly) as IRMerged[]
 
+    // Apply global webhook setting if not explicitly set on individual IR devices
+    if (this.config.options?.webhook === true) {
+      merged.forEach((device: any) => {
+        if (device.webhook === undefined) {
+          device.webhook = true
+          this.debugLog(`Applied global webhook setting to Matter IR device: ${device.deviceId}`)
+        }
+      })
+    }
+
     return merged as unknown as irdevice[]
   }
 
@@ -534,9 +554,20 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
         // so accessories can decide how verbose they should be.
         deviceLogging: (dev as any)?.logging,
         platformLogging: this.platformLogging,
+        // Expose effective webhook setting for parity with HAP base device logic
+        // Prefer explicit per-device setting; otherwise fall back to global option
+        webhook: (dev as any)?.webhook !== undefined ? (dev as any).webhook : (this.config.options?.webhook === true ? true : undefined),
       },
     }
 
+    // Log effective webhook for diagnostics
+    try {
+      const effectiveWebhook = (dev as any)?.webhook !== undefined ? (dev as any).webhook : (this.config.options?.webhook === true ? true : undefined)
+      this.debugLog(`Effective webhook for Matter device ${displayName} (${dev.deviceId}): ${String(effectiveWebhook)}`)
+    } catch (e: any) {
+      this.debugLog(`Failed logging effective webhook for Matter device ${displayName} (${dev.deviceId}): ${e?.message ?? e}`)
+    }
+
     // Build platform-side helpers using shared factories so they can be reused/tested
     const sendOpenAPI = makeOpenAPISender(this.retryCommand.bind(this), dev, { maxRetries: this.config.options?.maxRetries ?? 1, delayBetweenRetries: this.config.options?.delayBetweenRetries ?? 1000 })
     const sendBLE = makeBLESender(this.switchBotBLE, dev, { bleRetries: (this.config.options as any)?.bleRetries ?? 2, bleRetryDelay: (this.config.options as any)?.bleRetryDelay ?? 500 })
@@ -612,6 +643,7 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
       // Locks
       'Smart Lock': DoorLockAccessory,
       'Smart Lock Pro': DoorLockAccessory,
+      'Smart Lock Ultra': DoorLockAccessory,
 
       // Sensors
       'Motion Sensor': OccupancySensorAccessory,
@@ -1512,6 +1544,38 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
         }
       }
 
+      // Robot vacuum: some firmwares expose 'taskType' or 'task' with similar semantics
+      // to runState (e.g., 'cleaning', 'mapping', 'idle'). Map to rvcRunMode accordingly.
+      if (status?.taskType !== undefined || status?.task_type !== undefined || status?.task !== undefined) {
+        try {
+          const raw = status?.taskType ?? status?.task_type ?? status?.task
+          let mode: number | undefined
+          if (typeof raw === 'number') {
+            mode = Number(raw)
+          } else if (typeof raw === 'string') {
+            const s = raw.toLowerCase()
+            if (s.includes('clean')) {
+              mode = 1 // Cleaning
+            } else if (s.includes('map')) {
+              mode = 2 // Mapping
+            } else if (s.includes('idle') || s.includes('stop') || s.includes('dock') || s.includes('charge') || s.includes('docked')) {
+              mode = 0 // Idle
+            } else {
+              const n = Number(raw)
+              if (!Number.isNaN(n)) {
+                mode = n
+              }
+            }
+          }
+
+          if (mode !== undefined) {
+            await safeUpdate('rvcRunMode', { currentMode: Number(mode) }, 'updateRunMode')
+          }
+        } catch (e: any) {
+          this.debugLog(`Failed to apply taskType for ${dev.deviceId}: ${e?.message ?? e}`)
+        }
+      }
+
       // Brightness
       if (status?.brightness !== undefined) {
         const rawBrightness = Number(status.brightness)
@@ -1572,7 +1636,8 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
 
       // Battery/powerSource (support many possible field names)
       // Note: Some device types like WindowBlind don't support PowerSource cluster
-      if (status?.battery !== undefined || status?.batt !== undefined || status?.batteryLevel !== undefined || status?.batteryPercentage !== undefined || status?.battery_level !== undefined) {
+      if (status?.battery !== undefined || status?.batt !== undefined || status?.batteryLevel !== undefined || status?.batteryPercentage !== undefined || status?.battery_level !== undefined
+        || status?.baseBattery !== undefined || status?.base_battery !== undefined || status?.stationBattery !== undefined || status?.waterBaseBattery !== undefined || status?.dockBattery !== undefined) {
         // Skip battery updates for device types that don't support PowerSource cluster
         const deviceType = String(status?.deviceType ?? dev?.deviceType ?? '')
         const unsupportedTypes = ['Curtain', 'Curtain2', 'Curtain3', 'Curtain 2', 'Blind Tilt']
@@ -1581,7 +1646,10 @@ export class SwitchBotMatterPlatform implements DynamicPlatformPlugin {
           this.debugLog(`Device ${dev.deviceId} type ${deviceType} does not support PowerSource cluster, skipping battery update`)
         } else {
           try {
-            const percentage = Number(status?.battery ?? status?.batt ?? status?.batteryPercentage ?? status?.batteryLevel ?? status?.battery_level)
+            const percentage = Number(
+              status?.battery ?? status?.batt ?? status?.batteryPercentage ?? status?.batteryLevel ?? status?.battery_level
+              ?? status?.baseBattery ?? status?.base_battery ?? status?.stationBattery ?? status?.waterBaseBattery ?? status?.dockBattery,
+            )
             const batPercentRemaining = Math.max(0, Math.min(200, Math.round(percentage * 2)))
             let batChargeLevel = 0
             if (percentage < 20) {

package/src/settings.ts

@@ -53,6 +53,12 @@ export interface options {
   disableLogsforOpenAPI?: boolean
   hostname?: string
   webhookURL?: string
+  /**
+   * When true, enables webhook support for all devices by default.
+   * Individual devices can override this with their own webhook setting.
+   * Requires webhookURL to be configured.
+   */
+  webhook?: boolean
   maxRetries?: number
   delayBetweenRetries?: number
   refreshRate?: number
@@ -178,6 +184,11 @@ export interface humidifierConfig extends BaseDeviceConfig {
   hide_temperature?: boolean
   convertUnitTo?: string
   set_minStep?: number
+  /**
+   * When true (Humidifier2 only), exposes a Switch service in HomeKit
+   * to trigger the built-in Drying Filter mode via OpenAPI (setMode 8).
+   */
+  activate_dryingfilter?: boolean
 };
 
 export interface curtainConfig extends BaseDeviceConfig {
@@ -253,7 +264,7 @@ export interface ceilingLightConfig extends BaseDeviceConfig {
 };
 
 export interface lockConfig extends BaseDeviceConfig {
-  configDeviceType: 'Smart Lock' | 'Smart Lock Pro'
+  configDeviceType: 'Smart Lock' | 'Smart Lock Pro' | 'Smart Lock Ultra'
   hide_contactsensor?: boolean
   activate_latchbutton?: boolean
 };

package/src/test/hap/device-webhook-context.test.ts

@@ -0,0 +1,136 @@
+/* eslint-disable import/first */
+import { describe, expect, it, vi } from 'vitest'
+// Mock modules used by HAP device base occasionally via platform
+vi.mock('fakegato-history', () => ({ default: () => ({}) }))
+vi.mock('homebridge-lib/EveHomeKitTypes', () => ({ EveHomeKitTypes: class { constructor() {} } }))
+
+import { deviceBase } from '../../devices-hap/device.js'
+
+// Minimal HAP stub to satisfy deviceBase constructor operations
+function makeHapStub() {
+  class Service {
+    private _chars: Record<string, any> = {}
+    setCharacteristic(k: any, v: any) {
+      this._chars[k] = v
+      return this
+    }
+
+    getCharacteristic(k: any) {
+      return {
+        updateValue: (v: any) => {
+          this._chars[k] = v
+          return this
+        },
+      } as any
+    }
+  }
+  const Characteristic: any = {
+    Manufacturer: 'Manufacturer',
+    AppMatchingIdentifier: 'AppMatchingIdentifier',
+    Name: 'Name',
+    ConfiguredName: 'ConfiguredName',
+    Model: 'Model',
+    ProductData: 'ProductData',
+    SerialNumber: 'SerialNumber',
+    HardwareRevision: 'HardwareRevision',
+    SoftwareRevision: 'SoftwareRevision',
+    FirmwareRevision: 'FirmwareRevision',
+    On: 'On',
+  }
+  ;(Service as any).AccessoryInformation = class extends Service {}
+  ;(Service as any).Outlet = class extends Service {}
+  return { Service, Characteristic, Categories: { OUTLET: 7 } }
+}
+
+// Minimal PlatformAccessory stub
+function makeAccessoryStub(hap: any, name = 'Test Accessory') {
+  const services: any[] = []
+  return {
+    displayName: name,
+    category: 0,
+    context: {},
+    getService(cls: any) {
+      // find existing or create
+      const svc = services.find(s => s instanceof cls)
+      if (svc) {
+        return svc
+      }
+      const s = new cls()
+      services.push(s)
+      return s
+    },
+    addService(cls: any) {
+      const s = new cls()
+      services.push(s)
+      return s
+    },
+  }
+}
+
+// Minimal SwitchBotHAPPlatform-like stub with required surface
+function makePlatformStub(options: any, hap: any) {
+  const log = { info: vi.fn(), warn: vi.fn(), debug: vi.fn(), error: vi.fn(), success: vi.fn() }
+  return {
+    api: { hap },
+    log,
+    config: { options, credentials: {} },
+    debugMode: false,
+    // logging helpers used by deviceBase
+    infoLog: () => {},
+    successLog: () => {},
+    debugSuccessLog: () => {},
+    warnLog: () => {},
+    debugWarnLog: () => {},
+    errorLog: () => {},
+    debugErrorLog: () => {},
+    debugLog: () => {},
+    loggingIsDebug: async () => false,
+    enablingPlatformLogging: async () => true,
+    connectBLE: vi.fn(),
+    bleEventHandler: {},
+    webhookEventHandler: {},
+  }
+}
+
+// Create a tiny concrete subclass to instantiate deviceBase
+class TestHAPDevice extends deviceBase {
+  // Override any methods that may be invoked by tests if needed
+}
+
+describe('hap device base webhook context', () => {
+  it('sets accessory.context.webhook=true when global webhook is enabled and device.webhook is undefined', async () => {
+    const hap = makeHapStub()
+    const accessory: any = makeAccessoryStub(hap, 'Plug Device')
+    const platform: any = makePlatformStub({ webhook: true, logging: 'debug' }, hap)
+
+    const dev: any = {
+      deviceId: 'DEV-HAP-1',
+      deviceType: 'Plug',
+      connectionType: 'OpenAPI',
+      // webhook intentionally undefined
+    }
+
+    const d = new TestHAPDevice(platform, accessory, dev)
+    // Assert context
+    expect(accessory.context.webhook).toBe(true)
+    // ensure no unused var warning
+    expect(d).toBeDefined()
+  })
+
+  it('keeps accessory.context.webhook=false when device.webhook=false even if global is true', async () => {
+    const hap = makeHapStub()
+    const accessory: any = makeAccessoryStub(hap, 'Plug Device 2')
+    const platform: any = makePlatformStub({ webhook: true, logging: 'debug' }, hap)
+
+    const dev: any = {
+      deviceId: 'DEV-HAP-2',
+      deviceType: 'Plug',
+      connectionType: 'OpenAPI',
+      webhook: false,
+    }
+
+    const d = new TestHAPDevice(platform, accessory, dev)
+    expect(accessory.context.webhook).toBe(false)
+    expect(d).toBeDefined()
+  })
+})

package/src/test/matter/platform-matter.webhook.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest'
+
+import { SwitchBotMatterPlatform } from '../../platform-matter.js'
+import { makeApiStub, makeLogStub } from '../helpers/platform-fixtures.js'
+
+/**
+ * Verify that Matter accessories receive the effective webhook flag
+ * in their context when a global webhook option is enabled and the
+ * per-device webhook setting is undefined.
+ */
+describe('platform-matter webhook context propagation', () => {
+  it('sets context.webhook=true when global webhook is enabled and device.webhook is undefined', async () => {
+    const api: any = makeApiStub()
+    const log: any = makeLogStub()
+
+    const platform = new SwitchBotMatterPlatform(log as any, {
+      name: 'SwitchBot',
+      options: { webhook: true },
+    } as any, api)
+
+    // Minimal device that maps to a known Matter accessory constructor
+    const dev: any = {
+      deviceId: 'DEV-WH-1',
+      deviceName: 'Webhook Plug',
+      deviceType: 'Plug',
+      // webhook intentionally undefined to test fallback
+    }
+
+    const acc = await (platform as any).createAccessoryFromDevice(dev)
+    expect(acc).toBeDefined()
+    expect((acc as any).context?.webhook).toBe(true)
+  })
+
+  it('keeps explicit device.webhook=false even when global webhook is true', async () => {
+    const api: any = makeApiStub()
+    const log: any = makeLogStub()
+
+    const platform = new SwitchBotMatterPlatform(log as any, {
+      name: 'SwitchBot',
+      options: { webhook: true },
+    } as any, api)
+
+    const dev: any = {
+      deviceId: 'DEV-WH-2',
+      deviceName: 'No Webhook Plug',
+      deviceType: 'Plug',
+      webhook: false,
+    }
+
+    const acc = await (platform as any).createAccessoryFromDevice(dev)
+    expect(acc).toBeDefined()
+    expect((acc as any).context?.webhook).toBe(false)
+  })
+})

package/src/utils.ts

@@ -49,12 +49,22 @@ export function validHumidity(humidity: number, min?: number, max?: number): num
  * Converts the value to celsius if the temperature units are in Fahrenheit
  */
 export function convertUnits(value: number, unit: string, convert?: string): number {
-  if (unit === 'CELSIUS' && convert === 'CELSIUS') {
+  // Convert only when source unit differs from target unit.
+  // Supported values for unit/convert: 'CELSIUS' | 'FAHRENHEIT'
+  if (!convert || unit === convert) {
+    return value
+  }
+
+  if (unit === 'CELSIUS' && convert === 'FAHRENHEIT') {
     return Math.round((value * 9) / 5 + 32)
-  } else if (unit === 'FAHRENHEIT' && convert === 'FAHRENHEIT') {
-    // celsius should be to the nearest 0.5 degree
-    return Math.round((5 / 9) * (value - 32) * 2) / 2
   }
+
+  if (unit === 'FAHRENHEIT' && convert === 'CELSIUS') {
+    // Celsius should be to the nearest 0.5 degree
+    return Math.round(((value - 32) * 5) / 9 * 2) / 2
+  }
+
+  // Unknown unit combination: return as-is
   return value
 }