@homebridge-plugins/homebridge-wemo 7.0.0

package/eslint.config.js

@@ -0,0 +1,50 @@
+import { antfu } from '@antfu/eslint-config'
+
+/** @type {typeof antfu} */
+export default antfu(
+  {
+    ignores: [],
+    jsx: false,
+    rules: {
+      'curly': ['error', 'multi-line'],
+      'new-cap': 'off',
+      'import/extensions': ['error', 'ignorePackages'],
+      'import/order': 0,
+      'jsdoc/check-alignment': 'warn',
+      'jsdoc/check-line-alignment': 'warn',
+      'jsdoc/require-returns-check': 0,
+      'jsdoc/require-returns-description': 0,
+      'no-undef': 'error',
+      'perfectionist/sort-exports': 'error',
+      'perfectionist/sort-imports': [
+        'error',
+        {
+          groups: [
+            'type',
+            'internal-type',
+            'builtin',
+            'external',
+            'internal',
+            ['parent-type', 'sibling-type', 'index-type'],
+            ['parent', 'sibling', 'index'],
+            'object',
+            'unknown',
+          ],
+          order: 'asc',
+          type: 'natural',
+          newlinesBetween: 'always',
+        },
+      ],
+      'perfectionist/sort-named-exports': 'error',
+      'perfectionist/sort-named-imports': 'error',
+      'quotes': ['error', 'single'],
+      'sort-imports': 0,
+      'style/brace-style': ['error', '1tbs', { allowSingleLine: true }],
+      'style/quote-props': ['error', 'consistent-as-needed'],
+      'test/no-only-tests': 'error',
+      'unicorn/no-useless-spread': 'error',
+      'unused-imports/no-unused-vars': ['error', { caughtErrors: 'none' }],
+    },
+    typescript: false,
+  },
+)

package/lib/connection/http.js

@@ -0,0 +1,174 @@
+import axios from 'axios'
+import PQueue from 'p-queue'
+import { parseStringPromise } from 'xml2js'
+import xmlbuilder from 'xmlbuilder'
+
+import { decodeXML, hasProperty, parseError } from '../utils/functions.js'
+import platformLang from '../utils/lang-en.js'
+
+export default class {
+  constructor(platform) {
+    // Set up global vars from the platform
+    this.platform = platform
+    this.queue = new PQueue({
+      concurrency: 1,
+      interval: 250,
+      intervalCap: 1,
+      timeout: 9000,
+      throwOnTimeout: true,
+    })
+  }
+
+  async sendDeviceUpdate(accessory, serviceType, action, body) {
+    try {
+      return await this.queue.add(async () => {
+        // Check the device has this service (it should have)
+        if (
+          !accessory.context.serviceList[serviceType]
+          || !accessory.context.serviceList[serviceType].controlURL
+        ) {
+          throw new Error(platformLang.noService)
+        }
+
+        // Generate the XML to send to the device
+        const xml = xmlbuilder
+          .create('s:Envelope', {
+            version: '1.0',
+            encoding: 'utf-8',
+            allowEmpty: true,
+          })
+          .att('xmlns:s', 'http://schemas.xmlsoap.org/soap/envelope/')
+          .att('s:encodingStyle', 'http://schemas.xmlsoap.org/soap/encoding/')
+          .ele('s:Body')
+          .ele(`u:${action}`)
+          .att('xmlns:u', serviceType)
+
+        // Send the request to the device
+        const hostPort = `http://${accessory.context.ipAddress}:${accessory.context.port}`
+        const res = await axios({
+          url: hostPort + accessory.context.serviceList[serviceType].controlURL,
+          method: 'post',
+          headers: {
+            'SOAPACTION': `"${serviceType}#${action}"`,
+            'Content-Type': 'text/xml; charset="utf-8"',
+          },
+          data: (body ? xml.ele(body) : xml).end(),
+          timeout: 10000,
+        })
+
+        // Parse the response from the device
+        const xmlRes = res.data
+        const response = await parseStringPromise(xmlRes, {
+          explicitArray: false,
+        })
+
+        if (!accessory.context.httpOnline) {
+          this.platform.updateHTTPStatus(accessory, true)
+        }
+
+        // Return the parsed response
+        return response['s:Envelope']['s:Body'][`u:${action}Response`]
+      })
+    } catch (err) {
+      const eText = parseError(err)
+      if (['at Object.<anonymous>', 'EHOSTUNREACH'].some(el => eText.includes(el))) {
+        // Device disconnected from network
+        if (accessory.context.httpOnline) {
+          this.platform.updateHTTPStatus(accessory, false)
+        }
+        throw new Error(
+          eText.includes('EHOSTUNREACH') ? platformLang.timeoutUnreach : platformLang.timeout,
+        )
+      }
+      throw err
+    }
+  }
+
+  async receiveDeviceUpdate(accessory, body) {
+    try {
+      accessory.logDebug(`${platformLang.incKnown}:\n${body.trim()}`)
+
+      // Convert the XML to JSON
+      const json = await parseStringPromise(body, { explicitArray: false })
+
+      // Loop through the JSON for the necessary information
+
+      for (const prop in json['e:propertyset']['e:property']) {
+        if (hasProperty(json['e:propertyset']['e:property'], prop)) {
+          const data = json['e:propertyset']['e:property'][prop]
+          switch (prop) {
+            case 'BinaryState':
+              try {
+                accessory.control.receiveDeviceUpdate({
+                  name: 'BinaryState',
+                  value: Number.parseInt(data.substring(0, 1), 10),
+                })
+              } catch (err) {
+                accessory.logWarn(`${prop} ${platformLang.proEr} ${parseError(err)}`)
+              }
+              break
+            case 'Brightness':
+              try {
+                accessory.control.receiveDeviceUpdate({
+                  name: 'Brightness',
+                  value: Number.parseInt(data, 10),
+                })
+              } catch (err) {
+                accessory.logWarn(`${prop} ${platformLang.proEr} ${parseError(err)}`)
+              }
+              break
+            case 'InsightParams': {
+              try {
+                const params = data.split('|')
+                accessory.control.receiveDeviceUpdate({
+                  name: 'InsightParams',
+                  value: {
+                    state: Number.parseInt(params[0], 10),
+                    power: Number.parseInt(params[7], 10),
+                    todayWm: Number.parseFloat(params[8]),
+                    todayOnSeconds: Number.parseFloat(params[3]),
+                  },
+                })
+              } catch (err) {
+                accessory.logWarn(`${prop} ${platformLang.proEr} ${parseError(err)}`)
+              }
+              break
+            }
+            case 'attributeList':
+              try {
+                const decoded = decodeXML(data)
+                const xml = `<attributeList>${decoded}</attributeList>`
+
+                const result = await parseStringPromise(xml, { explicitArray: true })
+                result.attributeList.attribute.forEach((attribute) => {
+                  accessory.control.receiveDeviceUpdate({
+                    name: attribute.name[0],
+                    value: Number.parseInt(attribute.value[0], 10),
+                  })
+                })
+              } catch (err) {
+                accessory.logWarn(`${prop} ${platformLang.proEr} ${parseError(err)}`)
+              }
+              break
+            case 'StatusChange':
+              try {
+                const xml = await parseStringPromise(data, { explicitArray: false })
+                accessory.control.receiveDeviceUpdate(xml.StateEvent.DeviceID._, {
+                  name: xml.StateEvent.CapabilityId,
+                  value: xml.StateEvent.Value,
+                })
+              } catch (err) {
+                accessory.logWarn(`${prop} ${platformLang.proEr} ${parseError(err)}`)
+              }
+              break
+            default:
+              return
+          }
+        }
+      }
+    } catch (err) {
+      // Catch any errors during this process
+      accessory.logWarn(`${platformLang.incFail} ${parseError(err)}`)
+    }
+  }
+}

package/lib/connection/upnp.js

@@ -0,0 +1,155 @@
+import { request } from 'node:http'
+
+import platformConsts from '../utils/constants.js'
+import { parseError } from '../utils/functions.js'
+import platformLang from '../utils/lang-en.js'
+
+export default class {
+  constructor(platform, accessory) {
+    // Set up global vars from the platform
+    this.platform = platform
+    this.upnpInterval = platform.config.upnpInterval
+    this.upnpIntervalMilli = this.upnpInterval * 1000
+
+    // Set up other variables we need
+    this.accessory = accessory
+    this.services = accessory.context.serviceList
+    this.subs = {}
+  }
+
+  startSubscriptions() {
+    // Subscribe to each of the services that the device supports, that the plugin uses
+    Object.keys(this.services)
+      .filter(el => platformConsts.servicesToSubscribe.includes(el))
+      .forEach((service) => {
+        // Subscript to the service
+        this.subs[service] = {}
+        this.subscribe(service)
+      })
+  }
+
+  stopSubscriptions() {
+    Object.entries(this.subs).forEach((entry) => {
+      const [serviceType, sub] = entry
+      if (sub.timeout) {
+        clearTimeout(sub.timeout)
+      }
+      if (sub.status) {
+        this.unsubscribe(serviceType)
+      }
+    })
+    this.accessory.logDebugWarn(platformLang.stoppedSubs)
+  }
+
+  subscribe(serviceType) {
+    try {
+      // Check to see an already sent request is still pending
+      if (this.subs[serviceType].status === 'PENDING') {
+        this.accessory.logDebug(`[${serviceType}] ${platformLang.subPending}`)
+        return
+      }
+
+      // Set up the options for the subscription request
+      const timeout = this.upnpInterval + 10
+      const options = {
+        host: this.accessory.context.ipAddress,
+        port: this.accessory.context.port,
+        path: this.services[serviceType].eventSubURL,
+        method: 'SUBSCRIBE',
+        headers: { TIMEOUT: `Second-${timeout}` },
+      }
+
+      // The remaining options depend on whether the subscription already exists
+      if (this.subs[serviceType].status) {
+        // Subscription already exists so renew
+        options.headers.SID = this.subs[serviceType].status
+      } else {
+        // Subscription doesn't exist yet to set up for new subscription
+        this.subs[serviceType].status = 'PENDING'
+        this.accessory.logDebug(`[${serviceType}] ${platformLang.subInit}`)
+        options.headers.CALLBACK = `<http://${this.accessory.context.cbURL}/${this.accessory.UUID}>`
+        options.headers.NT = 'upnp:event'
+      }
+
+      // Execute the subscription request
+      const req = request(options, (res) => {
+        if (res.statusCode === 200) {
+          // Subscription request successful
+          this.subs[serviceType].status = res.headers.sid
+
+          // Renew subscription after 150 seconds
+          this.subs[serviceType].timeout = setTimeout(
+            () => this.subscribe(serviceType),
+            this.upnpIntervalMilli,
+          )
+        } else {
+          // Subscription request failure
+          this.accessory.logDebugWarn(`[${serviceType}] ${platformLang.subError} [${res.statusCode}]`)
+          this.subs[serviceType].status = null
+
+          // Try to recover from a failed subscription after 10 seconds
+          this.subs[serviceType].timeout = setTimeout(() => this.subscribe(serviceType), 10000)
+        }
+      })
+
+      // Listen for errors on the subscription
+      req.removeAllListeners('error')
+      req.on('error', (err) => {
+        if (!err) {
+          return
+        }
+
+        // Stop the subscriptions
+        this.stopSubscriptions()
+
+        // Use the platform function to disable the upnp client for this accessory
+        this.platform.disableUPNP(this.accessory, err)
+      })
+      req.end()
+    } catch (err) {
+      // Catch any errors during the process
+      this.accessory.logDebugWarn(`[${serviceType}] ${platformLang.subscribeError} ${parseError(err)}`)
+    }
+  }
+
+  unsubscribe(serviceType) {
+    try {
+      // Check to see an already sent request is still pending
+      if (!this.subs[serviceType] || this.subs[serviceType].status === 'PENDING') {
+        return
+      }
+
+      // Set up the options for the subscription request
+      const options = {
+        host: this.accessory.context.ipAddress,
+        port: this.accessory.context.port,
+        path: this.services[serviceType].eventSubURL,
+        method: 'UNSUBSCRIBE',
+        headers: { SID: this.subs[serviceType].status },
+      }
+
+      // Execute the subscription request
+      const req = request(options, (res) => {
+        if (res.statusCode === 200) {
+          // Unsubscribed
+          this.accessory.logDebug(`[${serviceType}] unsubscribe successful`)
+        } else {
+          // Subscription request failure
+          this.accessory.logDebugWarn(`[${serviceType}] ${platformLang.unsubFail} [${res.statusCode}]`)
+        }
+      })
+
+      // Listen for errors on the subscription
+      req.removeAllListeners('error')
+      req.on('error', (err) => {
+        if (!err) {
+          return
+        }
+        this.accessory.logDebugWarn(`[${serviceType}] ${platformLang.unsubFail} [${err.message}]`)
+      })
+      req.end()
+    } catch (err) {
+      this.accessory.logDebugWarn(`[${serviceType}] ${platformLang.unsubFail} [${parseError(err)}]`)
+    }
+  }
+}

package/lib/device/coffee.js

@@ -0,0 +1,167 @@
+import { Builder, parseStringPromise } from 'xml2js'
+
+import { decodeXML, parseError } from '../utils/functions.js'
+import platformLang from '../utils/lang-en.js'
+
+export default class {
+  constructor(platform, accessory) {
+    // Set up variables from the platform
+    this.hapChar = platform.api.hap.Characteristic
+    this.hapErr = platform.api.hap.HapStatusError
+    this.hapServ = platform.api.hap.Service
+    this.platform = platform
+
+    // Set up variables from the accessory
+    this.accessory = accessory
+
+    // Add the switch service if it doesn't already exist
+    this.service = this.accessory.getService(this.hapServ.Switch)
+      || this.accessory.addService(this.hapServ.Switch)
+
+    // Add the set handler to the outlet on/off characteristic
+    this.service
+      .getCharacteristic(this.hapChar.On)
+      .removeOnSet()
+      .onSet(async value => this.internalModeUpdate(value))
+
+    // Output the customised options to the log
+    const opts = JSON.stringify({
+    })
+    platform.log('[%s] %s %s.', accessory.displayName, platformLang.devInitOpts, opts)
+
+    // Request a device update immediately
+    this.requestDeviceUpdate()
+
+    // Start a polling interval if the user has disabled upnp
+    if (this.accessory.context.connection === 'http') {
+      this.pollingInterval = setInterval(
+        () => this.requestDeviceUpdate(),
+        platform.config.pollingInterval * 1000,
+      )
+    }
+  }
+
+  receiveDeviceUpdate(attribute) {
+    // Log the receiving update if debug is enabled
+    this.accessory.logDebug(`${platformLang.recUpd} [${attribute.name}: ${JSON.stringify(attribute.value)}]`)
+
+    // Check which attribute we are getting
+    switch (attribute.name) {
+      case 'Mode':
+        this.externalModeUpdate(attribute.value)
+        break
+      default:
+    }
+  }
+
+  async sendDeviceUpdate(attributes) {
+    // Log the sending update if debug is enabled
+    this.accessory.log(`${platformLang.senUpd} ${JSON.stringify(attributes)}`)
+
+    // Generate the XML to send
+    const builder = new Builder({
+      rootName: 'attribute',
+      headless: true,
+      renderOpts: { pretty: false },
+    })
+    const xmlAttributes = Object.keys(attributes)
+      .map(attributeKey => builder.buildObject({
+        name: attributeKey,
+        value: attributes[attributeKey],
+      }))
+      .join('')
+
+    // Send the update
+    await this.platform.httpClient.sendDeviceUpdate(
+      this.accessory,
+      'urn:Belkin:service:deviceevent:1',
+      'SetAttributes',
+      {
+        attributeList: { '#text': xmlAttributes },
+      },
+    )
+  }
+
+  async requestDeviceUpdate() {
+    try {
+      // Request the update
+      const data = await this.platform.httpClient.sendDeviceUpdate(
+        this.accessory,
+        'urn:Belkin:service:deviceevent:1',
+        'GetAttributes',
+      )
+
+      // Parse the response
+      const decoded = decodeXML(data.attributeList)
+      const xml = `<attributeList>${decoded}</attributeList>`
+      const result = await parseStringPromise(xml, { explicitArray: false })
+      Object.keys(result.attributeList.attribute).forEach((key) => {
+        // Only send the required attributes to the receiveDeviceUpdate function
+        switch (result.attributeList.attribute[key].name) {
+          case 'Mode':
+            this.receiveDeviceUpdate({
+              name: result.attributeList.attribute[key].name,
+              value: Number.parseInt(result.attributeList.attribute[key].value, 10),
+            })
+            break
+          default:
+        }
+      })
+    } catch (err) {
+      const eText = parseError(err, [
+        platformLang.timeout,
+        platformLang.timeoutUnreach,
+        platformLang.noService,
+      ])
+      this.accessory.logDebugWarn(`${platformLang.rduErr} ${eText}`)
+    }
+  }
+
+  async internalModeUpdate(value) {
+    try {
+      // Coffee maker cannot be turned off remotely
+      if (!value) {
+        throw new Error('coffee maker cannot be turned off remotely')
+      }
+
+      // Send the update to turn ON
+      await this.sendDeviceUpdate({ Mode: 4 })
+
+      // Update the cache value and log the change if appropriate
+      this.cacheState = true
+      this.accessory.log(`${platformLang.curState} [on]`)
+    } catch (err) {
+      // Catch any errors
+      const eText = parseError(err, [platformLang.timeout, platformLang.timeoutUnreach])
+      this.accessory.logWarn(`${platformLang.cantCtl} ${eText}`)
+
+      // Throw a 'no response' error and set a timeout to revert this after 2 seconds
+      setTimeout(() => {
+        this.service.updateCharacteristic(this.hapChar.On, this.cacheState)
+      }, 2000)
+      throw new this.hapErr(-70402)
+    }
+  }
+
+  externalModeUpdate(value) {
+    try {
+      // Value of 4 means brewing (ON) otherwise (OFF)
+      value = value === 4
+
+      // Check to see if the cache value is different
+      if (value === this.cacheState) {
+        return
+      }
+
+      // Update the HomeKit characteristics
+      this.service.updateCharacteristic(this.hapChar.On, value)
+
+      // Update the cache value and log the change if appropriate
+      this.cacheState = value
+      this.accessory.log(`${platformLang.curState} [${value ? 'on' : 'off'}]`)
+    } catch (err) {
+      // Catch any errors
+      this.accessory.logWarn(`${platformLang.cantUpd} ${parseError(err)}`)
+    }
+  }
+}