@switchbot/homebridge-switchbot 5.0.0-beta.70 → 5.0.0-beta.71

package/src/devices-matter/BaseMatterAccessory.ts

@@ -1,302 +0,0 @@
-/**
- * Base Matter Accessory Class
- *
- * This base class implements the MatterAccessory interface and provides
- * common functionality that all Matter devices can use.
- *
- * Individual device types should extend this class and call super() with
- * the required configuration.
- */
-
-import type { API, EndpointType, Logger, MatterAccessory } from 'homebridge'
-
-import { deviceLoggingEnabled, deviceLoggingIsDebug, logDeviceStatusCode, rgb2hs } from '../utils.js'
-
-export interface BaseMatterAccessoryConfig {
-  uuid: string
-  displayName: string
-  deviceType: EndpointType
-  serialNumber: string
-  manufacturer: string
-  model: string
-  firmwareRevision: string
-  hardwareRevision: string
-  context?: Record<string, unknown>
-  clusters?: MatterAccessory['clusters']
-  handlers?: MatterAccessory['handlers']
-  parts?: MatterAccessory['parts']
-}
-
-/**
- * Base class for all Matter accessories
- * Implements the MatterAccessory interface and provides common methods
- */
-export abstract class BaseMatterAccessory implements MatterAccessory {
-  // Required MatterAccessory properties
-  public readonly uuid: string
-  public readonly displayName: string
-  public readonly deviceType: EndpointType
-  public readonly serialNumber: string
-  public readonly manufacturer: string
-  public readonly model: string
-  public readonly firmwareRevision: string
-  public readonly hardwareRevision: string
-  public readonly context: Record<string, unknown>
-  public readonly clusters?: MatterAccessory['clusters']
-  public readonly handlers?: MatterAccessory['handlers']
-  public readonly parts?: MatterAccessory['parts']
-
-  // Protected properties available to child classes
-  protected readonly api: API
-  protected readonly log: Logger
-
-  constructor(
-    api: API,
-    log: Logger,
-    config: BaseMatterAccessoryConfig,
-  ) {
-    this.api = api
-    this.log = log
-
-    // Set all required properties
-    this.uuid = config.uuid
-    this.displayName = config.displayName
-    this.deviceType = config.deviceType
-    this.serialNumber = config.serialNumber
-    this.manufacturer = config.manufacturer
-    this.model = config.model
-    this.firmwareRevision = config.firmwareRevision
-    this.hardwareRevision = config.hardwareRevision
-    this.clusters = config.clusters
-    this.handlers = config.handlers
-    this.parts = config.parts
-
-    // Set context with all metadata
-    this.context = {
-      serialNumber: this.serialNumber,
-      manufacturer: this.manufacturer,
-      model: this.model,
-      firmwareRevision: this.firmwareRevision,
-      hardwareRevision: this.hardwareRevision,
-      ...config.context,
-    }
-  }
-
-  /**
-   * Update the accessory state
-   * Helper method to update cluster attributes
-   */
-  protected async updateState(cluster: string, attributes: Record<string, unknown>): Promise<void> {
-    await this.api.matter.updateAccessoryState(this.uuid, cluster, attributes)
-    this.logDebug(`Updated ${cluster} state:`, attributes)
-  }
-
-  /**
-   * Log helper methods
-   */
-  // Generic logging delegation: prefer platform-provided log helpers in
-  // `this.context` (infoLog/debugLog/warnLog/errorLog) and fall back to the
-  // local `this.log` methods when not available.
-  protected logWith(level: 'info' | 'error' | 'debug' | 'warn', message: string, ...args: unknown[]): void {
-    const ctx: any = this.context as any
-    const map: Record<string, string> = {
-      info: 'infoLog',
-      error: 'errorLog',
-      debug: 'debugLog',
-      warn: 'warnLog',
-    }
-    const fn = ctx?.[map[level]]
-    if (typeof fn === 'function') {
-      fn(`[${this.displayName}] ${message}`, ...args)
-      return
-    }
-    const local = (this.log as any)[level]
-    if (typeof local === 'function') {
-      local.call(this.log, `[${this.displayName}] ${message}`, ...args)
-    }
-  }
-
-  protected logInfo(message: string, ...args: unknown[]): void {
-    this.logWith('info', message, ...args)
-  }
-
-  protected logError(message: string, ...args: unknown[]): void {
-    this.logWith('error', message, ...args)
-  }
-
-  protected logDebug(message: string, ...args: unknown[]): void {
-    this.logWith('debug', message, ...args)
-  }
-
-  protected logWarn(message: string, ...args: unknown[]): void {
-    this.logWith('warn', message, ...args)
-  }
-
-  /**
-   * Logging helpers parity: allow Matter accessories to ask whether device-level
-   * logging is enabled or in debug mode. These mirror the helpers used by the
-   * HAP/IR device bases so behavior is consistent across platforms.
-   */
-  public async loggingIsDebug(): Promise<boolean> {
-    const ctx: any = this.context as any
-    return deviceLoggingIsDebug(ctx?.deviceLogging)
-  }
-
-  public async enablingDeviceLogging(): Promise<boolean> {
-    const ctx: any = this.context as any
-    return deviceLoggingEnabled(ctx?.deviceLogging, ctx?.platformLogging)
-  }
-
-  /**
-   * Status code logging using shared helper
-   */
-  public async statusCode(statusCode: number, deviceId?: string, hubDeviceId?: string): Promise<void> {
-    await logDeviceStatusCode(
-      statusCode,
-      {
-        debugLog: this.logDebug.bind(this),
-        errorLog: this.logError.bind(this),
-        infoLog: this.logInfo.bind(this),
-      },
-      deviceId ?? (this.context as any)?.deviceId,
-      hubDeviceId ?? (this.context as any)?.hubDeviceId,
-    )
-  }
-
-  /**
-   * Convenience helpers that delegate OpenAPI/BLE commands to platform-provided
-   * functions that are injected into the accessory `context` by
-   * `platform-matter` when the accessory is created from a discovered device.
-   *
-   * These methods are intentionally thin wrappers — the platform controls
-   * retries, discovery and client lifecycle via the helper functions.
-   */
-  protected async sendOpenAPICommand(command: string, parameter = 'default'): Promise<any> {
-    const ctx: any = this.context as any
-    const fn = ctx?.sendOpenAPI
-    if (typeof fn === 'function') {
-      return fn(command, parameter)
-    }
-    throw new Error('OpenAPI helper not available')
-  }
-
-  protected async sendBLECommand(methodName: string, ...args: any[]): Promise<any> {
-    const ctx: any = this.context as any
-    const fn = ctx?.sendBLE
-    if (typeof fn === 'function') {
-      return fn(methodName, ...args)
-    }
-    throw new Error('BLE helper not available')
-  }
-
-  public async sendOnCommand(deviceId?: string): Promise<void> {
-    const ctx: any = this.context as any
-    const id = deviceId ?? ctx?.deviceId
-    try {
-      if (ctx?.connectionType === 'BLE') {
-        await this.sendBLECommand('turnOn')
-      } else {
-        await this.sendOpenAPICommand('turnOn')
-      }
-      // update our matter state
-      await this.updateState(this.api.matter.clusterNames.OnOff, { onOff: true })
-      this.logInfo(`sendOnCommand successful for ${id}`)
-    } catch (e: any) {
-      this.logError(`sendOnCommand failed for ${id}: ${String(e?.message ?? e)}`)
-      throw e
-    }
-  }
-
-  public async sendOffCommand(deviceId?: string): Promise<void> {
-    const ctx: any = this.context as any
-    const id = deviceId ?? ctx?.deviceId
-    try {
-      if (ctx?.connectionType === 'BLE') {
-        await this.sendBLECommand('turnOff')
-      } else {
-        await this.sendOpenAPICommand('turnOff')
-      }
-      await this.updateState(this.api.matter.clusterNames.OnOff, { onOff: false })
-      this.logInfo(`sendOffCommand successful for ${id}`)
-    } catch (e: any) {
-      this.logError(`sendOffCommand failed for ${id}: ${String(e?.message ?? e)}`)
-      throw e
-    }
-  }
-
-  public async sendSetBrightness(percent: number, deviceId?: string): Promise<void> {
-    const ctx: any = this.context as any
-    const id = deviceId ?? ctx?.deviceId
-    try {
-      if (ctx?.connectionType === 'BLE') {
-        await this.sendBLECommand('setBrightness', percent)
-      } else {
-        await this.sendOpenAPICommand('setBrightness', String(percent))
-      }
-      const level = Math.round((percent / 100) * 254)
-      await this.updateState(this.api.matter.clusterNames.LevelControl, { currentLevel: level })
-      this.logInfo(`sendSetBrightness successful for ${id}: ${percent}%`)
-    } catch (e: any) {
-      this.logError(`sendSetBrightness failed for ${id}: ${String(e?.message ?? e)}`)
-      throw e
-    }
-  }
-
-  public async sendSetColor(r: number, g: number, b: number, deviceId?: string): Promise<void> {
-    const ctx: any = this.context as any
-    const id = deviceId ?? ctx?.deviceId
-    try {
-      if (ctx?.connectionType === 'BLE') {
-        await this.sendBLECommand('setRGB', r, g, b)
-      } else {
-        await this.sendOpenAPICommand('setColor', `${r}:${g}:${b}`)
-      }
-      // Convert to hue/sat for matter state update
-      const [h, s] = rgb2hs(r, g, b)
-      await this.updateState(this.api.matter.clusterNames.ColorControl, { currentHue: Math.round((h / 360) * 254), currentSaturation: Math.round((s / 100) * 254) })
-      this.logInfo(`sendSetColor successful for ${id}: ${r},${g},${b}`)
-    } catch (e: any) {
-      this.logError(`sendSetColor failed for ${id}: ${String(e?.message ?? e)}`)
-      throw e
-    }
-  }
-
-  public async sendSetColorTemperature(kelvin: number, deviceId?: string): Promise<void> {
-    const ctx: any = this.context as any
-    const id = deviceId ?? ctx?.deviceId
-    try {
-      if (ctx?.connectionType === 'BLE') {
-        await this.sendBLECommand('setColorTemperature', kelvin)
-      } else {
-        await this.sendOpenAPICommand('setColorTemperature', `${kelvin}`)
-      }
-      const mireds = Math.round(1000000 / kelvin)
-      await this.updateState(this.api.matter.clusterNames.ColorControl, { colorTemperatureMireds: mireds })
-      this.logInfo(`sendSetColorTemperature successful for ${id}: ${kelvin}K`)
-    } catch (e: any) {
-      this.logError(`sendSetColorTemperature failed for ${id}: ${String(e?.message ?? e)}`)
-      throw e
-    }
-  }
-
-  /**
-   * Convert this class instance to a plain MatterAccessory object
-   * This is what gets registered with Homebridge
-   */
-  public toAccessory(): MatterAccessory {
-    return {
-      uuid: this.uuid,
-      displayName: this.displayName,
-      deviceType: this.deviceType,
-      serialNumber: this.serialNumber,
-      manufacturer: this.manufacturer,
-      model: this.model,
-      firmwareRevision: this.firmwareRevision,
-      hardwareRevision: this.hardwareRevision,
-      context: this.context,
-      clusters: this.clusters,
-      handlers: this.handlers,
-      parts: this.parts,
-    }
-  }
-}

package/src/devices-matter/ColorLightAccessory.ts

@@ -1,110 +0,0 @@
-/**
- * Color Light Accessory Class (HS only)
- * Hue and Saturation color control
- */
-
-import type { API, Logger, MatterRequests } from 'homebridge'
-
-import { hs2rgb } from '../utils.js'
-import { BaseMatterAccessory } from './BaseMatterAccessory.js'
-
-export class ColorLightAccessory extends BaseMatterAccessory {
-  constructor(api: API, log: Logger, opts?: Partial<import('./BaseMatterAccessory').BaseMatterAccessoryConfig & { deviceId?: string }>) {
-    const serialNumber = opts?.serialNumber ?? 'LIGHT-004'
-    const displayName = opts?.displayName ?? 'Colour Light (HS)'
-    const manufacturer = opts?.manufacturer ?? 'Homebridge Matter'
-    const model = opts?.model ?? 'HB-MATTER-LIGHT-COLOUR-HS'
-    const firmwareRevision = opts?.firmwareRevision ?? '2.0.0'
-    const hardwareRevision = opts?.hardwareRevision ?? '1.0.0'
-
-    const clusters = opts?.clusters ?? {
-      onOff: { onOff: false },
-      levelControl: { currentLevel: 127, minLevel: 1, maxLevel: 254 },
-      colorControl: {
-        colorMode: api.matter.types.ColorControl.ColorMode.CurrentHueAndCurrentSaturation,
-        currentHue: 0,
-        currentSaturation: 254,
-        currentX: 41942,
-        currentY: 21626,
-      },
-    }
-
-    const handlers = opts?.handlers ?? {
-      onOff: { on: async () => this.handleOn(), off: async () => this.handleOff() },
-      levelControl: { moveToLevelWithOnOff: async (request: MatterRequests.MoveToLevel) => this.handleSetLevel(request) },
-      colorControl: {
-        moveToColorLogic: async (request: MatterRequests.MoveToColor) => this.handleSetColor(request),
-        moveToHueAndSaturationLogic: async (request: MatterRequests.MoveToHueAndSaturation) => this.handleSetHueSaturation(request),
-      },
-    }
-
-    super(api, log, {
-      uuid: opts?.uuid ?? api.matter.uuid.generate(serialNumber),
-      displayName,
-      deviceType: api.matter.deviceTypes.ExtendedColorLight,
-      serialNumber,
-      manufacturer,
-      model,
-      firmwareRevision,
-      hardwareRevision,
-      clusters,
-      handlers,
-      context: { deviceId: opts?.deviceId, ...(opts?.context ?? {}) },
-    })
-
-    this.logInfo('initialized.')
-  }
-
-  private async handleOn(): Promise<void> {
-    this.logInfo('turning on.')
-    await this.sendOnCommand()
-  }
-
-  private async handleOff(): Promise<void> {
-    this.logInfo('turning off.')
-    await this.sendOffCommand()
-  }
-
-  private async handleSetLevel(request: MatterRequests.MoveToLevel): Promise<void> {
-    this.logInfo(`MoveToLevel request: ${JSON.stringify(request)}`)
-    const { level } = request
-    const brightnessPercent = Math.round((level / 254) * 100)
-    await this.sendSetBrightness(brightnessPercent)
-  }
-
-  private async handleSetColor(request: MatterRequests.MoveToColor): Promise<void> {
-    this.logInfo(`MoveToColor request: ${JSON.stringify(request)}`)
-    const { colorX, colorY } = request
-    const hueApprox = Math.round((colorX / 65535) * 360)
-    const satApprox = Math.round((colorY / 65535) * 100)
-    const [r, g, b] = hs2rgb(hueApprox, satApprox)
-    await this.sendSetColor(r, g, b)
-  }
-
-  private async handleSetHueSaturation(request: MatterRequests.MoveToHueAndSaturation): Promise<void> {
-    this.logInfo(`MoveToHueAndSaturation request: ${JSON.stringify(request)}`)
-    const { hue, saturation } = request
-    const hueDegrees = Math.round((hue / 254) * 360)
-    const saturationPercent = Math.round((saturation / 254) * 100)
-    const [r, g, b] = hs2rgb(hueDegrees, saturationPercent)
-    await this.sendSetColor(r, g, b)
-  }
-
-  public updateOnOffState(isOn: boolean): void {
-    this.updateState(this.api.matter.clusterNames.OnOff, { onOff: isOn })
-  }
-
-  public updateBrightness(percent: number): void {
-    const matterLevel = Math.max(1, Math.round((percent / 100) * 254))
-    this.updateState(this.api.matter.clusterNames.LevelControl, { currentLevel: matterLevel })
-  }
-
-  public updateHueSaturation(hue: number, saturation: number): void {
-    const matterHue = Math.round((hue / 360) * 254)
-    const matterSat = Math.round((saturation / 100) * 254)
-    this.updateState(this.api.matter.clusterNames.ColorControl, {
-      currentHue: matterHue,
-      currentSaturation: matterSat,
-    })
-  }
-}

package/src/devices-matter/ColorTemperatureLightAccessory.ts

@@ -1,90 +0,0 @@
-/**
- * Color Temperature Light Accessory Class
- */
-
-import type { API, Logger, MatterRequests } from 'homebridge'
-
-import { BaseMatterAccessory } from './BaseMatterAccessory.js'
-
-export class ColorTemperatureLightAccessory extends BaseMatterAccessory {
-  constructor(api: API, log: Logger, opts?: Partial<import('./BaseMatterAccessory').BaseMatterAccessoryConfig & { deviceId?: string }>) {
-    const serialNumber = opts?.serialNumber ?? 'LIGHT-003'
-    const displayName = opts?.displayName ?? 'Colour Temperature Light'
-    const manufacturer = opts?.manufacturer ?? 'Homebridge Matter'
-    const model = opts?.model ?? 'HB-MATTER-LIGHT-COLOUR-TEMP'
-    const firmwareRevision = opts?.firmwareRevision ?? '2.0.0'
-    const hardwareRevision = opts?.hardwareRevision ?? '1.0.0'
-
-    const clusters = opts?.clusters ?? {
-      onOff: { onOff: false },
-      levelControl: { currentLevel: 127, minLevel: 1, maxLevel: 254 },
-      colorControl: {
-        colorMode: api.matter.types.ColorControl.ColorMode.ColorTemperatureMireds,
-        colorTemperatureMireds: 250,
-        colorTempPhysicalMinMireds: 147,
-        colorTempPhysicalMaxMireds: 454,
-        coupleColorTempToLevelMinMireds: 147,
-      },
-    }
-
-    const handlers = opts?.handlers ?? {
-      onOff: { on: async () => this.handleOn(), off: async () => this.handleOff() },
-      levelControl: { moveToLevelWithOnOff: async (request: MatterRequests.MoveToLevel) => this.handleSetLevel(request) },
-      colorControl: { moveToColorTemperatureLogic: async (request: MatterRequests.MoveToColorTemperature) => this.handleSetColorTemperature(request) },
-    }
-
-    super(api, log, {
-      uuid: opts?.uuid ?? api.matter.uuid.generate(serialNumber),
-      displayName,
-      deviceType: api.matter.deviceTypes.ColorTemperatureLight,
-      serialNumber,
-      manufacturer,
-      model,
-      firmwareRevision,
-      hardwareRevision,
-      clusters,
-      handlers,
-      context: { deviceId: opts?.deviceId, ...(opts?.context ?? {}) },
-    })
-
-    this.logInfo('initialized.')
-  }
-
-  private async handleOn(): Promise<void> {
-    this.logInfo('turning on.')
-    await this.sendOnCommand()
-  }
-
-  private async handleOff(): Promise<void> {
-    this.logInfo('turning off.')
-    await this.sendOffCommand()
-  }
-
-  private async handleSetLevel(request: MatterRequests.MoveToLevel): Promise<void> {
-    this.logInfo(`MoveToLevel request: ${JSON.stringify(request)}`)
-    const { level } = request
-    const brightnessPercent = Math.round((level / 254) * 100)
-    await this.sendSetBrightness(brightnessPercent)
-  }
-
-  private async handleSetColorTemperature(request: MatterRequests.MoveToColorTemperature): Promise<void> {
-    this.logInfo(`MoveToColorTemperature request: ${JSON.stringify(request)}`)
-    const { colorTemperatureMireds } = request
-    const kelvin = Math.round(1000000 / colorTemperatureMireds)
-    await this.sendSetColorTemperature(kelvin)
-  }
-
-  public updateOnOffState(isOn: boolean): void {
-    this.updateState(this.api.matter.clusterNames.OnOff, { onOff: isOn })
-  }
-
-  public updateBrightness(percent: number): void {
-    const matterLevel = Math.max(1, Math.round((percent / 100) * 254))
-    this.updateState(this.api.matter.clusterNames.LevelControl, { currentLevel: matterLevel })
-  }
-
-  public updateColorTemperature(kelvin: number): void {
-    const mireds = Math.round(1000000 / kelvin)
-    this.updateState(this.api.matter.clusterNames.ColorControl, { colorTemperatureMireds: mireds })
-  }
-}

package/src/devices-matter/ContactSensorAccessory.ts

@@ -1,41 +0,0 @@
-/**
- * Contact Sensor Accessory Class
- */
-
-import type { API, Logger } from 'homebridge'
-
-import { BaseMatterAccessory } from './BaseMatterAccessory.js'
-
-export class ContactSensorAccessory extends BaseMatterAccessory {
-  constructor(api: API, log: Logger, opts?: Partial<import('./BaseMatterAccessory').BaseMatterAccessoryConfig & { deviceId?: string }>) {
-    const serialNumber = opts?.serialNumber ?? 'SENSOR-001'
-    const displayName = opts?.displayName ?? 'Contact Sensor'
-    const manufacturer = opts?.manufacturer ?? 'Homebridge Matter'
-    const model = opts?.model ?? 'HB-MATTER-SENSOR-CONTACT'
-    const firmwareRevision = opts?.firmwareRevision ?? '2.0.0'
-    const hardwareRevision = opts?.hardwareRevision ?? '1.0.0'
-
-    const clusters = opts?.clusters ?? { booleanState: { stateValue: true } }
-
-    super(api, log, {
-      uuid: opts?.uuid ?? api.matter.uuid.generate(serialNumber),
-      displayName,
-      deviceType: api.matter.deviceTypes.ContactSensor,
-      serialNumber,
-      manufacturer,
-      model,
-      firmwareRevision,
-      hardwareRevision,
-      clusters,
-      context: { deviceId: opts?.deviceId, ...(opts?.context ?? {}) },
-    })
-
-    this.logInfo('initialized.')
-  }
-
-  public updateContactState(isOpen: boolean): void {
-    // Matter BooleanState: false = open/triggered, true = closed/normal (inverted!)
-    this.updateState(this.api.matter.clusterNames.BooleanState, { stateValue: !isOpen })
-    this.logInfo(`contact state: ${isOpen ? 'OPEN' : 'CLOSED'}.`)
-  }
-}