@homebridge-plugins/homebridge-wemo 7.0.0

package/lib/device/maker-garage.js

@@ -0,0 +1,426 @@
+import { parseStringPromise } from 'xml2js'
+
+import platformConsts from '../utils/constants.js'
+import { decodeXML, parseError, sleep } from '../utils/functions.js'
+import platformLang from '../utils/lang-en.js'
+
+export default class {
+  constructor(platform, accessory) {
+    // Set up variables from the platform
+    this.eveChar = platform.eveChar
+    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
+
+    // Set up custom variables for this device type
+    const deviceConf = platform.deviceConf[accessory.context.serialNumber] || {}
+    this.doorOpenTimer = deviceConf.makerTimer || platformConsts.defaultValues.makerTimer
+
+    // Some conversion objects
+    this.gStates = {
+      Open: 0,
+      Closed: 1,
+      Opening: 2,
+      Closing: 3,
+      Stopped: 4,
+    }
+
+    // If the accessory has a switch service then remove it
+    if (this.accessory.getService(this.hapServ.Switch)) {
+      this.accessory.removeService(this.accessory.getService(this.hapServ.Switch))
+    }
+
+    // If the accessory has a contact sensor service then remove it
+    if (this.accessory.getService(this.hapServ.ContactSensor)) {
+      this.accessory.removeService(this.accessory.getService(this.hapServ.ContactSensor))
+    }
+
+    // Add the garage door service if it doesn't already exist
+    this.service = this.accessory.getService(this.hapServ.GarageDoorOpener)
+    if (!this.service) {
+      this.service = this.accessory.addService(this.hapServ.GarageDoorOpener)
+      this.service.addCharacteristic(this.eveChar.LastActivation)
+      this.service.addCharacteristic(this.eveChar.ResetTotal)
+      this.service.addCharacteristic(this.eveChar.TimesOpened)
+    }
+
+    // Remove unused characteristics
+    if (this.service.testCharacteristic(this.hapChar.ContactSensorState)) {
+      this.service.removeCharacteristic(
+        this.service.getCharacteristic(this.hapChar.ContactSensorState),
+      )
+    }
+    if (this.service.testCharacteristic(this.eveChar.OpenDuration)) {
+      this.service.removeCharacteristic(this.service.getCharacteristic(this.eveChar.OpenDuration))
+    }
+    if (this.service.testCharacteristic(this.eveChar.ClosedDuration)) {
+      this.service.removeCharacteristic(this.service.getCharacteristic(this.eveChar.ClosedDuration))
+    }
+
+    // Add the set handler to the garage door reset total characteristic
+    this.service.getCharacteristic(this.eveChar.ResetTotal).onSet(() => {
+      this.service.updateCharacteristic(this.eveChar.TimesOpened, 0)
+    })
+
+    // Add the set handler to the target door state characteristic
+    this.service
+      .getCharacteristic(this.hapChar.TargetDoorState)
+      .removeOnSet()
+      .onSet(async value => this.internalStateUpdate(value))
+
+    // Pass the accessory to Fakegato to set up with Eve
+    this.accessory.eveService = new platform.eveService('door', this.accessory, {
+      log: () => {},
+    })
+    this.accessory.eveService.addEntry({
+      status: this.service.getCharacteristic(this.hapChar.CurrentDoorState).value === 0 ? 0 : 1,
+    })
+
+    // Output the customised options to the log
+    const opts = JSON.stringify({
+      makerTimer: this.doorOpenTimer,
+    })
+    platform.log('[%s] %s %s.', accessory.displayName, platformLang.devInitOpts, opts)
+
+    // This is to remove the 'No Response' message that is there before the plugin finds this device
+    this.service.updateCharacteristic(
+      this.hapChar.TargetDoorState,
+      this.accessory.context.cacheLastTargetState,
+    )
+
+    // 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 'Switch': {
+        if (attribute.value !== 0) {
+          this.externalStateUpdate()
+        }
+        break
+      }
+      case 'Sensor': {
+        this.externalSensorUpdate(attribute.value, true)
+        break
+      }
+      default:
+    }
+  }
+
+  async sendDeviceUpdate(value) {
+    // Log the sending update if debug is enabled
+    this.accessory.logDebug(`${platformLang.senUpd} ${JSON.stringify(value)}`)
+
+    // Send the update
+    await this.platform.httpClient.sendDeviceUpdate(
+      this.accessory,
+      'urn:Belkin:service:basicevent:1',
+      'SetBinaryState',
+      value,
+    )
+  }
+
+  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 })
+      const attributes = {}
+      Object.keys(result.attributeList.attribute).forEach((key) => {
+        const attribute = result.attributeList.attribute[key]
+        attributes[attribute.name] = Number.parseInt(attribute.value, 10)
+      })
+
+      // Only send the required attributes to the receiveDeviceUpdate function
+      if (attributes.SwitchMode === 0) {
+        this.accessory.logWarn(platformLang.makerNeedMMode)
+        return
+      }
+      if (attributes.SensorPresent === 1) {
+        this.sensorPresent = true
+        this.externalSensorUpdate(attributes.Sensor)
+      } else {
+        this.sensorPresent = false
+      }
+    } catch (err) {
+      const eText = parseError(err, [
+        platformLang.timeout,
+        platformLang.timeoutUnreach,
+        platformLang.noService,
+      ])
+      this.accessory.logDebugWarn(`${platformLang.rduErr} ${eText}`)
+    }
+  }
+
+  async internalStateUpdate(value) {
+    const prevTarg = this.service.getCharacteristic(this.hapChar.TargetDoorState).value
+    const prevCurr = this.service.getCharacteristic(this.hapChar.CurrentDoorState).value
+    try {
+      // Checks to see if the new required movement is already happening
+      if (this.isMoving) {
+        if (value === this.gStates.Closed && prevCurr === this.gStates.Closing) {
+          this.accessory.log(platformLang.makerClosing)
+          return
+        }
+        if (value === this.gStates.Open && prevCurr === this.gStates.Opening) {
+          this.accessory.log(platformLang.makerOpening)
+          return
+        }
+      } else if (value === this.gStates.Closed && prevCurr === this.gStates.Closed) {
+        this.accessory.log(platformLang.makerClosed)
+        return
+      } else if (value === this.gStates.Open && prevCurr === this.gStates.Open) {
+        this.accessory.log(platformLang.makerOpen)
+        return
+      }
+
+      // Required movement isn't already in progress so make the new movement happen
+      this.homekitTriggered = true
+
+      // Send the update
+      await this.sendDeviceUpdate({
+        BinaryState: 1,
+      })
+
+      // Log the change if appropriate
+      this.accessory.log(`${platformLang.tarState} [${value ? platformLang.labelClosed : platformLang.labelOpen}]`)
+
+      // Call the function to set the door moving
+      this.accessory.context.cacheLastTargetState = value
+      this.setDoorMoving(value, true)
+    } catch (err) {
+      this.accessory.logWarn(`${platformLang.cantUpd} ${parseError(err)}`)
+
+      // Throw a 'no response' error and set a timeout to revert this after 2 seconds
+      setTimeout(() => {
+        this.service.updateCharacteristic(this.hapChar.TargetDoorState, prevTarg)
+        this.accessory.context.cacheLastTargetState = prevTarg
+      }, 2000)
+      throw new this.hapErr(-70402)
+    }
+  }
+
+  externalStateUpdate() {
+    try {
+      // We want to ignore update notifications from when controlled through HomeKit
+      if (this.homekitTriggered) {
+        this.homekitTriggered = false
+        return
+      }
+
+      // The change of state must have been triggered externally
+      const target = this.service.getCharacteristic(this.hapChar.TargetDoorState).value
+      const state = 1 - target
+      this.accessory.log(
+        `${platformLang.tarState} [${state === 1 ? platformLang.labelClosed : platformLang.labelOpen}] [${platformLang.makerTrigExt}]`,
+      )
+
+      // Update the new target state HomeKit characteristic
+      this.service.updateCharacteristic(this.hapChar.TargetDoorState, state)
+      this.accessory.context.cacheLastTargetState = state
+
+      // If the door has been opened externally then update the Eve-only characteristics
+      if (state === 0) {
+        this.accessory.eveService.addEntry({ status: 0 })
+        this.service.updateCharacteristic(
+          this.eveChar.LastActivation,
+          Math.round(new Date().valueOf() / 1000) - this.accessory.eveService.getInitialTime(),
+        )
+        this.service.updateCharacteristic(
+          this.eveChar.TimesOpened,
+          this.service.getCharacteristic(this.eveChar.TimesOpened).value + 1,
+        )
+      }
+      this.setDoorMoving(state)
+    } catch (err) {
+      this.accessory.logWarn(`${platformLang.cantUpd} ${parseError(err)}`)
+    }
+  }
+
+  externalSensorUpdate(state, wasTriggered) {
+    try {
+      // 0->1 and 1->0 reverse values to match HomeKit needs
+      const value = 1 - state
+      const target = this.service.getCharacteristic(this.hapChar.TargetDoorState).value
+      if (target === 0) {
+        // CASE target is to OPEN
+        if (value === 0) {
+          // Garage door HK target state is OPEN and the sensor has reported OPEN
+          if (this.isMoving) {
+            // Garage door is in the process of opening
+            this.service.updateCharacteristic(this.hapChar.CurrentDoorState, this.gStates.Opening)
+            this.accessory.eveService.addEntry({ status: 0 })
+            this.service.updateCharacteristic(
+              this.eveChar.LastActivation,
+              Math.round(new Date().valueOf() / 1000) - this.accessory.eveService.getInitialTime(),
+            )
+            this.service.updateCharacteristic(
+              this.eveChar.TimesOpened,
+              this.service.getCharacteristic(this.eveChar.TimesOpened).value + 1,
+            )
+
+            // Log the change if appropriate
+            this.accessory.log(`${platformLang.curState} [${platformLang.labelOpening}]`)
+          } else {
+            // Garage door is open and not moving
+            this.service.updateCharacteristic(this.hapChar.CurrentDoorState, this.gStates.Open)
+
+            // Log the change if appropriate
+            this.accessory.log(`${platformLang.curState} [${platformLang.labelOpen}]`)
+          }
+        } else {
+          // Garage door HK target state is OPEN and the sensor has reported CLOSED
+          // Must have been triggered externally
+          this.isMoving = false
+          this.service.updateCharacteristic(this.hapChar.TargetDoorState, this.gStates.Closed)
+          this.accessory.context.cacheLastTargetState = this.gStates.Closed
+          this.service.updateCharacteristic(this.hapChar.CurrentDoorState, this.gStates.Closed)
+          this.accessory.eveService.addEntry({ status: 1 })
+
+          // Log the change if appropriate
+          this.accessory.log(`${platformLang.curState} [${platformLang.labelClosed}] [${platformLang.makerTrigExt}]`)
+        }
+      } else if (value === 1) {
+        // Garage door HK target state is CLOSED and the sensor has reported CLOSED
+        this.isMoving = false
+        if (this.movingTimer) {
+          clearTimeout(this.movingTimer)
+          this.movingTimer = false
+        }
+
+        // Update the HomeKit characteristics
+        this.service.updateCharacteristic(this.hapChar.CurrentDoorState, this.gStates.Closed)
+        this.accessory.eveService.addEntry({ status: 1 })
+
+        // Log the change if appropriate
+        this.accessory.log(`${platformLang.curState} [${platformLang.labelClosed}]`)
+      } else {
+        // Garage door HK target state is CLOSED but the sensor has reported OPEN
+        // Must have been triggered externally
+        this.service.updateCharacteristic(this.hapChar.TargetDoorState, this.gStates.Open)
+        this.accessory.context.cacheLastTargetState = this.gStates.Open
+        this.accessory.eveService.addEntry({ status: 0 })
+        this.service.updateCharacteristic(
+          this.eveChar.LastActivation,
+          Math.round(new Date().valueOf() / 1000) - this.accessory.eveService.getInitialTime(),
+        )
+        this.service.updateCharacteristic(
+          this.eveChar.TimesOpened,
+          this.service.getCharacteristic(this.eveChar.TimesOpened).value + 1,
+        )
+
+        // Log the change if appropriate
+        this.accessory.log(`${platformLang.tarState} [${platformLang.labelOpen}] [${platformLang.makerTrigExt}]`)
+        if (wasTriggered) {
+          this.setDoorMoving(0)
+        }
+      }
+    } catch (err) {
+      this.accessory.logWarn(`${platformLang.cantUpd} ${parseError(err)}`)
+    }
+  }
+
+  async setDoorMoving(targetDoorState, homekitTriggered) {
+    // If a moving timer already exists then stop it
+    if (this.movingTimer) {
+      clearTimeout(this.movingTimer)
+      this.movingTimer = false
+    }
+
+    // The door must have stopped
+    if (this.isMoving) {
+      this.isMoving = false
+      this.service.updateCharacteristic(this.hapChar.CurrentDoorState, 4)
+      this.accessory.log(`${platformLang.curState} [${platformLang.labelStopped}]`)
+
+      // Toggle TargetDoorState after receiving a stop
+      await sleep(500)
+      const target = targetDoorState === this.gStates.Open ? this.gStates.Closed : this.gStates.Open
+      this.service.updateCharacteristic(this.hapChar.TargetDoorState, target)
+      this.accessory.context.cacheLastTargetState = target
+      return
+    }
+
+    // Set the moving flag to true
+    this.isMoving = true
+    if (homekitTriggered) {
+      // CASE: triggered through HomeKit
+      const curState = this.service.getCharacteristic(this.hapChar.CurrentDoorState).value
+      if (targetDoorState === this.gStates.Closed) {
+        // CASE: triggered through HomeKit and requested to CLOSE
+        if (curState !== this.gStates.Closed) {
+          this.service.updateCharacteristic(this.hapChar.CurrentDoorState, this.gStates.Closing)
+
+          // Log the change if appropriate
+          this.accessory.log(`${platformLang.curState} [${platformLang.labelClosing}]`)
+        }
+      } else if (
+        curState === this.gStates.Stopped
+        || (curState !== this.gStates.Open && !this.sensorPresent)
+      ) {
+        // CASE: triggered through HomeKit and requested to OPEN
+        this.service.updateCharacteristic(this.hapChar.CurrentDoorState, this.gStates.Opening)
+        this.accessory.eveService.addEntry({ status: 0 })
+        this.service.updateCharacteristic(
+          this.eveChar.LastActivation,
+          Math.round(new Date().valueOf() / 1000) - this.accessory.eveService.getInitialTime(),
+        )
+        this.service.updateCharacteristic(
+          this.eveChar.TimesOpened,
+          this.service.getCharacteristic(this.eveChar.TimesOpened).value + 1,
+        )
+
+        // Log the change if appropriate
+        this.accessory.log(`${platformLang.curState} [${platformLang.labelOpening}]`)
+      }
+    }
+
+    // Set up the moving timer
+    this.movingTimer = setTimeout(() => {
+      this.movingTimer = false
+      this.isMoving = false
+      const target = this.service.getCharacteristic(this.hapChar.TargetDoorState).value
+      if (!this.sensorPresent) {
+        this.service.updateCharacteristic(
+          this.hapChar.CurrentDoorState,
+          target === 1 ? this.gStates.Closed : this.gStates.Open,
+        )
+
+        // Log the change if appropriate
+        this.accessory.log(`${platformLang.curState} [${target === 1 ? platformLang.labelClosed : platformLang.labelOpen}]`)
+        return
+      }
+      if (target === 1) {
+        this.accessory.eveService.addEntry({ status: 1 })
+      }
+
+      // Request a device update at the end of the timer
+      this.requestDeviceUpdate()
+    }, this.doorOpenTimer * 1000)
+  }
+}

package/lib/device/maker-switch.js

@@ -0,0 +1,202 @@
+import { 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
+
+    // Set up custom variables for this device type
+    const deviceConf = platform.deviceConf[accessory.context.serialNumber] || {}
+    this.reversePolarity = deviceConf.reversePolarity
+
+    // If the accessory has a garage door service then remove it
+    if (this.accessory.getService(this.hapServ.GarageDoorOpener)) {
+      this.accessory.removeService(this.accessory.getService(this.hapServ.GarageDoorOpener))
+    }
+
+    // Add the switch service if it doesn't already exist
+    this.service = this.accessory.getService(this.hapServ.Switch)
+      || this.accessory.addService(this.hapServ.Switch)
+
+    // This is used to remove any no response status on startup
+    this.service.updateCharacteristic(
+      this.hapChar.On,
+      this.service.getCharacteristic(this.hapChar.On).value || false,
+    )
+
+    // Add the set handler to the switch on/off characteristic
+    this.service
+      .getCharacteristic(this.hapChar.On)
+      .removeOnSet()
+      .onSet(async value => this.internalStateUpdate(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 'Switch': {
+        const hkValue = attribute.value === 1
+        this.externalStateUpdate(hkValue)
+        break
+      }
+      case 'Sensor':
+        this.externalSensorUpdate(attribute.value)
+        break
+      default:
+    }
+  }
+
+  async sendDeviceUpdate(value) {
+    // Log the sending update if debug is enabled
+    this.accessory.logDebug(`${platformLang.senUpd} ${JSON.stringify(value)}`)
+
+    // Send the update
+    await this.platform.httpClient.sendDeviceUpdate(
+      this.accessory,
+      'urn:Belkin:service:basicevent:1',
+      'SetBinaryState',
+      value,
+    )
+  }
+
+  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 })
+      const attributes = {}
+      Object.keys(result.attributeList.attribute).forEach((key) => {
+        const attribute = result.attributeList.attribute[key]
+        attributes[attribute.name] = Number.parseInt(attribute.value, 10)
+      })
+
+      // Only send the required attributes to the receiveDeviceUpdate function
+      if (attributes.Switch) {
+        this.externalStateUpdate(attributes.Switch === 1)
+      }
+
+      // Check to see if the accessory has a contact sensor
+      const contactSensor = this.accessory.getService(this.hapServ.ContactSensor)
+      if (attributes.SensorPresent === 1) {
+        // Add a contact sensor service if the physical device has one
+        if (!contactSensor) {
+          this.accessory.addService(this.hapServ.ContactSensor)
+        }
+        if (attributes.Sensor) {
+          this.externalSensorUpdate(attributes.Sensor)
+        }
+      } else if (contactSensor) {
+        // Remove the contact sensor service if the physical device doesn't have one
+        this.accessory.removeService(contactSensor)
+      }
+    } catch (err) {
+      const eText = parseError(err, [
+        platformLang.timeout,
+        platformLang.timeoutUnreach,
+        platformLang.noService,
+      ])
+      this.accessory.logDebugWarn(`${platformLang.rduErr} ${eText}`)
+    }
+  }
+
+  async internalStateUpdate(value) {
+    try {
+      // Send the update
+      await this.sendDeviceUpdate({
+        BinaryState: value ? 1 : 0,
+      })
+
+      // Update the cache and log if appropriate
+      this.cacheState = value
+      this.accessory.log(`${platformLang.curState} [${value ? 'on' : 'off'}]`)
+    } catch (err) {
+      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)
+    }
+  }
+
+  externalStateUpdate(value) {
+    try {
+      // Don't continue if the value is the same as before
+      if (value === this.cacheState) {
+        return
+      }
+
+      // Update the HomeKit characteristic
+      this.service.updateCharacteristic(this.hapChar.On, value)
+
+      // Update the cache and log if appropriate
+      this.cacheState = value
+      this.accessory.log(`${platformLang.curState} [${value ? 'on' : 'off'}]`)
+    } catch (err) {
+      this.accessory.logWarn(`${platformLang.cantUpd} ${parseError(err)}`)
+    }
+  }
+
+  externalSensorUpdate(value) {
+    try {
+      // Reverse the polarity if enabled by user
+      if (this.reversePolarity) {
+        value = 1 - value
+      }
+
+      // Don't continue if the sensor value is the same as before
+      if (value === this.cacheContact) {
+        return
+      }
+
+      // Update the HomeKit characteristic
+      this.accessory
+        .getService(this.hapServ.ContactSensor)
+        .updateCharacteristic(this.hapChar.ContactSensorState, value)
+
+      // Update the cache and log the change if appropriate
+      this.cacheContact = value
+      this.accessory.log(`${platformLang.curCont} [${value === 1 ? platformLang.detectedNo : platformLang.detectedYes}]`)
+    } catch (err) {
+      this.accessory.logWarn(`${platformLang.cantUpd} ${parseError(err)}`)
+    }
+  }
+}