@switchbot/homebridge-switchbot 5.0.3 → 5.0.4

package/src/devices/genericDevice.ts

@@ -483,6 +483,38 @@ export class GenericDevice extends DeviceBase {
 export class BotDevice extends GenericDevice {}
 
 export class CurtainDevice extends GenericDevice {
+  private lastKnownPosition = 0
+  private lastTargetPosition = 0
+  private positionState = 2
+  private preferLocalPositionUntil = 0
+
+  private clampHomeKitPosition(position: number): number {
+    return Math.max(0, Math.min(100, Math.round(Number(position))))
+  }
+
+  private toHomeKitPosition(switchBotPosition: number): number {
+    return 100 - this.clampHomeKitPosition(switchBotPosition)
+  }
+
+  private toSwitchBotPosition(homeKitPosition: number): number {
+    return 100 - this.clampHomeKitPosition(homeKitPosition)
+  }
+
+  private async getPositionForHomeKit(): Promise<number> {
+    if (Date.now() < this.preferLocalPositionUntil) {
+      return this.lastKnownPosition
+    }
+    const state = await Promise.race([
+      this.getState(),
+      new Promise(resolve => setTimeout(resolve, 1000)),
+    ])
+    if (typeof state?.position === 'number') {
+      this.lastKnownPosition = this.toHomeKitPosition(Number(state.position))
+      this.lastTargetPosition = this.lastKnownPosition
+    }
+    return this.lastKnownPosition
+  }
+
   createHAPAccessory(api: any) {
     return {
       services: [
@@ -491,18 +523,27 @@ export class CurtainDevice extends GenericDevice {
           characteristics: {
             CurrentPosition: {
               get: async () => {
-                const s = await this.getState()
-                return typeof s.position === 'number' ? s.position : 0
+                return this.getPositionForHomeKit()
               },
             },
+            PositionState: {
+              get: async () => this.positionState,
+            },
             TargetPosition: {
               get: async () => {
-                const s = await this.getState()
-                return typeof s.position === 'number' ? s.position : 0
+                await this.getPositionForHomeKit()
+                return this.lastTargetPosition
               },
               set: async (v: any) => {
-                await this.setState({ position: Number(v) })
+                const position = this.clampHomeKitPosition(Number(v))
+                this.lastTargetPosition = position
+                this.positionState = position > this.lastKnownPosition ? 1 : position < this.lastKnownPosition ? 0 : 2
+                await this.setState({ position: this.toSwitchBotPosition(position) })
+                this.lastKnownPosition = position
+                this.preferLocalPositionUntil = Date.now() + 30000
+                this.positionState = 2
               },
+              refreshAfterSet: ['CurrentPosition', 'TargetPosition', 'PositionState'],
             },
           },
         },
@@ -1306,6 +1347,161 @@ export class MeterDevice extends GenericDevice {
 }
 
 export class WaterDetectorDevice extends GenericDevice {
+  private _leakRefreshing = false
+  private _leakRefreshTs = 0
+  private lastLeakDetected?: boolean
+  private readonly LEAK_REFRESH_TTL_MS = 30_000
+
+  private lastBatteryLevel?: number
+  private _batteryRefreshing = false
+  private _batteryRefreshTs = 0
+  private readonly BATTERY_REFRESH_TTL_MS = 30_000
+
+  async init(): Promise<void> {
+    await super.init()
+    await this._refreshLeakState(!this.client)
+    await this._refreshBattery()
+  }
+
+  private normalizeLeakDetected(state: any): boolean | undefined {
+    if (typeof state?.leak === 'boolean') {
+      return state.leak
+    }
+    if (typeof state?.waterLeakDetected === 'boolean') {
+      return state.waterLeakDetected
+    }
+    if (typeof state?.body?.waterLeakDetected === 'boolean') {
+      return state.body.waterLeakDetected
+    }
+    const status = state?.status ?? state?.body?.status
+    if (typeof status === 'number') {
+      return status === 1
+    }
+    if (typeof status === 'string') {
+      return ['1', 'leak', 'leaked', 'detected', 'water_leak_detected'].includes(status.toLowerCase())
+    }
+    return undefined
+  }
+
+  private normalizeBatteryLevel(state: any): number | undefined {
+    const raw = state?.battery ?? state?.body?.battery
+    if (typeof raw !== 'number' || !Number.isFinite(raw)) {
+      return undefined
+    }
+    return Math.max(0, Math.min(100, raw))
+  }
+
+  private async getOpenAPIStatus(): Promise<any> {
+    const token = this.cfg?.openApiToken
+    const secret = this.cfg?.openApiSecret
+    if (!token || !secret) {
+      return undefined
+    }
+
+    try {
+      const { OpenAPIClient } = await import('node-switchbot')
+      const apiClient = new OpenAPIClient(token, secret)
+      return await apiClient.getStatus(this.opts.id)
+    } catch (e) {
+      this.log?.debug?.(`[WaterDetector] direct OpenAPI refresh failed: ${(e as Error)?.message}`)
+    }
+
+    return undefined
+  }
+
+  private async readLeakDetected(fallbackToDeviceState = true): Promise<boolean | undefined> {
+    const status = await this.getOpenAPIStatus()
+    if (status) {
+      const leak = this.normalizeLeakDetected(status)
+      if (typeof leak === 'boolean') {
+        return leak
+      }
+    }
+    if (!fallbackToDeviceState) {
+      return undefined
+    }
+
+    try {
+      return this.normalizeLeakDetected(await this.getState())
+    } catch (e) {
+      this.log?.debug?.(`[WaterDetector] leak refresh failed: ${(e as Error)?.message}`)
+    }
+
+    return undefined
+  }
+
+  private async readBatteryLevel(): Promise<number | undefined> {
+    const status = await this.getOpenAPIStatus()
+    if (status) {
+      const battery = this.normalizeBatteryLevel(status)
+      if (typeof battery === 'number') {
+        return battery
+      }
+    }
+
+    return undefined
+  }
+
+  private async _refreshLeakState(fallbackToDeviceState = true): Promise<void> {
+    if (this._leakRefreshing) {
+      return
+    }
+    this._leakRefreshing = true
+    try {
+      const leakDetected = await this.readLeakDetected(fallbackToDeviceState)
+      if (typeof leakDetected === 'boolean') {
+        this.lastLeakDetected = leakDetected
+        this._leakRefreshTs = Date.now()
+      }
+    } catch (e) {
+      this.log?.debug?.(`[WaterDetector] leak refresh failed: ${(e as Error)?.message}`)
+    } finally {
+      this._leakRefreshing = false
+    }
+  }
+
+  private async _refreshBattery(): Promise<void> {
+    if (this._batteryRefreshing) {
+      return
+    }
+    this._batteryRefreshing = true
+    try {
+      const battery = await this.readBatteryLevel()
+      if (typeof battery === 'number') {
+        this.lastBatteryLevel = battery
+        this._batteryRefreshTs = Date.now()
+      }
+    } catch (e) {
+      this.log?.debug?.(`[WaterDetector] battery refresh failed: ${(e as Error)?.message}`)
+    } finally {
+      this._batteryRefreshing = false
+    }
+  }
+
+  private getLeakDetectedFast(api: any): number {
+    if (Date.now() - this._leakRefreshTs >= this.LEAK_REFRESH_TTL_MS) {
+      this._refreshLeakState().catch(() => undefined)
+    }
+    if (typeof this.lastLeakDetected === 'boolean') {
+      return this.lastLeakDetected ? 1 : 0
+    }
+    throw new api.hap.HapStatusError(api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE)
+  }
+
+  // Returns the cached battery level immediately and triggers a background
+  // refresh if the cache is stale. Throws HapStatusError on true cold start
+  // so HomeKit shows "Not Available" rather than fabricating a misleading
+  // value or timing out (which surfaces as 0% in the Home app).
+  private getBatteryFast(api: any): number {
+    if (Date.now() - this._batteryRefreshTs >= this.BATTERY_REFRESH_TTL_MS) {
+      this._refreshBattery().catch(() => undefined)
+    }
+    if (typeof this.lastBatteryLevel === 'number') {
+      return this.lastBatteryLevel
+    }
+    throw new api.hap.HapStatusError(api.hap.HAPStatus.SERVICE_COMMUNICATION_FAILURE)
+  }
+
   createHAPAccessory(api: any) {
     return {
       services: [
@@ -1313,11 +1509,25 @@ export class WaterDetectorDevice extends GenericDevice {
           type: 'LeakSensor',
           characteristics: {
             LeakDetected: {
-              get: async () => {
-                const s = await this.getState()
-                return s && s.leak ? 1 : 0
+              get: () => this.getLeakDetectedFast(api),
+            },
+          },
+        },
+        {
+          type: 'Battery',
+          characteristics: {
+            BatteryLevel: {
+              get: () => this.getBatteryFast(api),
+            },
+            StatusLowBattery: {
+              get: () => {
+                const b = this.getBatteryFast(api)
+                return b < 20 ? 1 : 0
               },
             },
+            ChargingState: {
+              get: () => 2,
+            },
           },
         },
       ],

package/test/device/deviceFactory.spec.ts

@@ -30,4 +30,13 @@ describe('createDevice', () => {
     const result = await createDevice({ id: 'xyz', type: 'UnknownType' }, dummyConfig as any, false)
     expect(result.instance.constructor.name).toBe('GenericDevice')
   })
+
+  it('should create a WaterDetectorDevice for normalized "waterdetector" type', async () => {
+    // normalizeTypeForMatter() returns 'waterdetector' (no space) for water detector variants.
+    // This regression test ensures the no-space key is mapped so devices aren't silently
+    // downgraded to GenericDevice (which would expose a bogus Switch service).
+    const result = await createDevice({ id: 'wd1', type: 'waterdetector' }, dummyConfig as any, false)
+    expect(result.instance).toBeDefined()
+    expect(result.instance.constructor.name).toBe('WaterDetectorDevice')
+  })
 })

package/test/device/water-detector-battery.spec.ts

@@ -0,0 +1,81 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { WaterDetectorDevice } from '../../src/devices/genericDevice'
+
+const openApiMocks = vi.hoisted(() => {
+  const getStatus = vi.fn()
+  return {
+    getStatus,
+    // Use a function implementation so the mock is constructible with `new OpenAPIClient()`
+    // eslint-disable-next-line prefer-arrow-callback
+    OpenAPIClient: vi.fn().mockImplementation(function () { return { getStatus } }),
+
+  }
+})
+
+vi.mock('node-switchbot', () => ({
+  OpenAPIClient: openApiMocks.OpenAPIClient,
+}))
+
+const mockLogger = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() }
+
+const mockApi = {
+  hap: {
+    HapStatusError: class HapStatusError extends Error {
+      constructor(readonly status: number) {
+        super(`HAP ${status}`)
+      }
+    },
+    HAPStatus: {
+      SERVICE_COMMUNICATION_FAILURE: -70402,
+    },
+  },
+}
+
+function makeDevice(config: Record<string, unknown> = {}) {
+  return new WaterDetectorDevice(
+    { id: 'wd1', type: 'waterdetector', name: 'Fridge', log: mockLogger, blePollingEnabled: false },
+    { log: mockLogger, openApiToken: 'token', openApiSecret: 'secret', ...config } as any,
+  )
+}
+
+function getBatteryService(device: WaterDetectorDevice) {
+  const accessory = device.createHAPAccessory(mockApi)
+  return accessory.services.find((service: any) => service.type === 'Battery')
+}
+
+describe('water detector device battery service', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    openApiMocks.getStatus.mockResolvedValue({ battery: 87 })
+  })
+
+  it('adds a Battery service to the HAP accessory descriptor', () => {
+    const batteryService = getBatteryService(makeDevice())
+
+    expect(batteryService).toBeDefined()
+    expect(batteryService.characteristics.BatteryLevel).toBeDefined()
+    expect(batteryService.characteristics.StatusLowBattery).toBeDefined()
+    expect(batteryService.characteristics.ChargingState).toBeDefined()
+  })
+
+  it('warms the battery cache from direct OpenAPI status', async () => {
+    const device = makeDevice()
+
+    await device.init()
+
+    const batteryService = getBatteryService(device)
+    expect(openApiMocks.OpenAPIClient).toHaveBeenCalledWith('token', 'secret')
+    expect(openApiMocks.getStatus).toHaveBeenCalledWith('wd1')
+    expect(batteryService.characteristics.BatteryLevel.get()).toBe(87)
+    expect(batteryService.characteristics.StatusLowBattery.get()).toBe(0)
+    expect(batteryService.characteristics.ChargingState.get()).toBe(2)
+  })
+
+  it('does not fabricate a battery level before one is cached', () => {
+    const device = makeDevice({ openApiSecret: undefined })
+    const batteryService = getBatteryService(device)
+
+    expect(() => batteryService.characteristics.BatteryLevel.get()).toThrow('HAP -70402')
+  })
+})

package/test/device/water-detector-leak.spec.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest'
+
+import { WaterDetectorDevice } from '../../src/devices/genericDevice'
+
+const mockLogger = { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} }
+
+const mockApi = {
+  hap: {
+    HapStatusError: class HapStatusError extends Error {
+      constructor(public status: number) {
+        super(`HAP status ${status}`)
+      }
+    },
+    HAPStatus: {
+      SERVICE_COMMUNICATION_FAILURE: -70402,
+    },
+  },
+}
+
+describe('water detector device leak state', () => {
+  it('warms leak state and serves LeakDetected synchronously from cache', async () => {
+    let reads = 0
+    const device = new WaterDetectorDevice({ id: 'wd1', type: 'waterdetector' }, { log: mockLogger })
+    device.getState = async () => {
+      reads += 1
+      return { waterLeakDetected: true }
+    }
+
+    await device.init()
+    const leakDetected = device.createHAPAccessory(mockApi).services[0].characteristics.LeakDetected.get()
+
+    expect(leakDetected).toBe(1)
+    expect(leakDetected).not.toBeInstanceOf(Promise)
+    expect(reads).toBe(1)
+  })
+
+  it('throws a HAP communication failure instead of blocking when no leak state is cached', () => {
+    const device = new WaterDetectorDevice({ id: 'wd1', type: 'waterdetector' }, { log: mockLogger })
+    device.getState = async () => ({ waterLeakDetected: false })
+
+    expect(() => device.createHAPAccessory(mockApi).services[0].characteristics.LeakDetected.get()).toThrow('HAP status -70402')
+  })
+})