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

package/src/deviceFactory.ts

@@ -0,0 +1,122 @@
+import type { SwitchBotPluginConfig, DeviceType } from './settings.js'
+import { SwitchBotClient } from './switchbotClient.js'
+import {
+  GenericDevice,
+  BotDevice,
+  CurtainDevice,
+  FanDevice,
+  LightDevice,
+  LightStripDevice,
+  MotionSensorDevice,
+  ContactSensorDevice,
+  VacuumDevice,
+  LockDevice,
+  HumidifierDevice,
+  TemperatureSensorDevice,
+  RelaySwitchDevice,
+  RelaySwitch1PMDevice,
+  PlugDevice,
+  PlugMiniDevice,
+  BlindTiltDevice,
+  Curtain3Device,
+  RollerShadeDevice,
+  Hub2Device,
+  MeterDevice,
+  WaterDetectorDevice,
+  SmartFanDevice,
+  StripLightDevice,
+  WalletFinderDevice,
+  WoSweeperDevice,
+  WoSweeperMiniDevice,
+  WoSweeperMiniProDevice,
+} from './devices/genericDevice.js'
+
+export interface DeviceOptions {
+  id: string
+  type: DeviceType
+  name?: string
+  [key: string]: any
+}
+
+const DEVICE_CLASS_MAP: Record<string, any> = {
+  bot: BotDevice,
+  curtain: CurtainDevice,
+  fan: FanDevice,
+  light: LightDevice,
+  lightstrip: LightStripDevice,
+  motion: MotionSensorDevice,
+  contact: ContactSensorDevice,
+  vacuum: VacuumDevice,
+  lock: LockDevice,
+  humidifier: HumidifierDevice,
+  temperature: TemperatureSensorDevice,
+  'relay switch 1': RelaySwitchDevice,
+  'relay switch 1pm': RelaySwitch1PMDevice,
+  plug: PlugDevice,
+  'plug mini (jp)': PlugMiniDevice,
+  'plug mini (us)': PlugMiniDevice,
+  'blind tilt': BlindTiltDevice,
+  curtain3: Curtain3Device,
+  'worollershade': RollerShadeDevice,
+  'wo rollershade': RollerShadeDevice,
+  'roller shade': RollerShadeDevice,
+  'rollershade': RollerShadeDevice,
+  'hub 2': Hub2Device,
+  meter: MeterDevice,
+  'meterplus': MeterDevice,
+  'meter plus (jp)': MeterDevice,
+  'meterpro': MeterDevice,
+  'meterpro(co2)': MeterDevice,
+  'water detector': WaterDetectorDevice,
+  'smart fan': SmartFanDevice,
+  'strip light': StripLightDevice,
+  'walletfinder': WalletFinderDevice,
+  'wosweeper': WoSweeperDevice,
+  'wosweepermini': WoSweeperMiniDevice,
+  'wosweeperminipro': WoSweeperMiniProDevice,
+  'k10+': WoSweeperDevice,
+  'k10+ pro': WoSweeperDevice,
+  'k10+ pro (wosweeperminipro)': WoSweeperMiniProDevice,
+}
+
+function classForType(type: string) {
+  const key = (type || '').toLowerCase()
+  return DEVICE_CLASS_MAP[key] ?? GenericDevice
+}
+
+export async function createDevice(opts: DeviceOptions, cfg: SwitchBotPluginConfig, useMatter: boolean) {
+  // Reuse existing client when provided via config to avoid creating
+  // a new SwitchBotClient per device (which can be expensive).
+  let client: any = (cfg as any)?._client ?? null
+  if (!client) {
+    client = new SwitchBotClient(cfg)
+    await client.init()
+  }
+
+  // Pass client via config so devices can access it
+  const mergedCfg = { ...(cfg as any), _client: client }
+
+  const DeviceCtor = classForType(opts.type)
+  const device = new DeviceCtor(opts, mergedCfg)
+  await device.init()
+
+  // Attach a simple getState delegator to the client where appropriate
+  const originalGetState = device.getState.bind(device)
+  device.getState = async () => {
+    try {
+      // Prefer client-backed getDevice when available
+      const dev = await client.getDevice(opts.id)
+      if (dev) return dev
+    } catch (e) {
+      // ignore and fallback to device implementation
+    }
+    return originalGetState()
+  }
+
+  // Provide accessory factory based on platform selection
+  return {
+    instance: device,
+    createAccessory: (api: any) => (useMatter ? device.createMatterAccessory(api) : device.createHAPAccessory(api)),
+    protocol: useMatter ? 'matter' : 'hap',
+  }
+}

package/src/devices/deviceBase.ts

@@ -0,0 +1,141 @@
+import type { SwitchBotPluginConfig } from '../settings'
+
+import { MATTER_ATTRIBUTE_IDS, MATTER_CLUSTER_IDS } from '../utils'
+
+export interface DeviceOptions {
+  id: string
+  type: string
+  name?: string
+  [key: string]: any
+}
+
+export abstract class DeviceBase {
+  protected opts: DeviceOptions
+  protected cfg: SwitchBotPluginConfig
+  protected client: any | null
+
+  constructor(opts: DeviceOptions, cfg: SwitchBotPluginConfig) {
+    this.opts = opts
+    this.cfg = cfg
+    this.client = (cfg as any)?._client ?? null
+  }
+
+  // Initialize any connections/resources
+  async init(): Promise<void> {}
+
+  // Return current device state from SwitchBot or cache
+  abstract getState(): Promise<any>
+
+  // Apply a state change to the device
+  abstract setState(change: any): Promise<any>
+
+  /**
+   * Create and return a HAP accessory descriptor.
+   *
+   * This method returns a descriptor object (not a platformAccessory instance).
+   * The platform will use this descriptor to construct a real HAP accessory.
+   *
+   * Default descriptor provides a simple Switch service with an `On` characteristic
+   * backed by `getState()` / `setState()` so most simple devices work out of the box.
+   *
+   * If the Homebridge `api` is passed, `Service` and `Characteristic` constructors
+   * are included under `_resolved` for callers that need them.
+   *
+   * @example
+   * {
+   *   id: 'd1',
+   *   name: 'My Device',
+   *   protocol: 'hap',
+   *   services: [ { type: 'Switch', characteristics: { On: { get: async ()=>true, set: async v=>{} } } } ]
+   * }
+   */
+  createHAPAccessory(api: any): any {
+    const base: any = {
+      id: this.opts.id,
+      name: this.opts.name ?? this.opts.type,
+      protocol: 'hap',
+      services: [
+        {
+          type: 'Switch',
+          characteristics: {
+            On: {
+              get: async () => {
+                const s = await this.getState()
+                return !!(s && (s.on === true || s.state === 'on' || s.power === 'on'))
+              },
+              set: async (v: any) => {
+                await this.setState({ on: !!v })
+              },
+            },
+          },
+        },
+      ],
+    }
+
+    try {
+      const hap = api?.hap
+      if (hap && hap.Service && hap.Characteristic) {
+        base._resolved = { Service: hap.Service, Characteristic: hap.Characteristic }
+      }
+    } catch (e) {
+      // ignore
+    }
+
+    return base
+  }
+
+  /**
+   * Create and return a Matter accessory descriptor.
+   *
+   * Returns a descriptor containing `clusters` and attribute read/write handlers
+   * which the platform will serialize when registering Matter accessories. The
+   * default provides an `OnOff` cluster wired to `getState()` / `setState()`.
+   *
+   * If the Homebridge `api` provides a `matter` namespace it is attached under
+   * `_resolved.matter` for callers that need direct access to the Matter API.
+   */
+  createMatterAccessory(api: any): any {
+    const base: any = {
+      id: this.opts.id,
+      name: this.opts.name ?? this.opts.type,
+      protocol: 'matter',
+      clusters: [
+        {
+          type: 'OnOff',
+          clusterId: MATTER_CLUSTER_IDS.OnOff,
+          attributes: {
+            onOff: {
+              read: async () => {
+                const s = await this.getState()
+                return !!(s && (s.on === true || s.state === 'on' || s.power === 'on'))
+              },
+              write: async (v: any) => this.setState({ on: !!v }),
+            },
+            [MATTER_ATTRIBUTE_IDS.OnOff.OnOff]: {
+              read: async () => {
+                const s = await this.getState()
+                return !!(s && (s.on === true || s.state === 'on' || s.power === 'on'))
+              },
+              write: async (v: any) => this.setState({ on: !!v }),
+            },
+          },
+        },
+      ],
+    }
+
+    try {
+      const matter = api?.matter
+      if (matter) {
+        base._resolved = {
+          matter,
+        }
+      }
+    } catch (e) {
+      // ignore
+    }
+
+    return base
+  }
+
+  async destroy(): Promise<void> {}
+}