homebridge-nb 1.4.4 → 1.4.6

package/config.schema.json

@@ -38,6 +38,10 @@
         "minimum": 0,
         "maximum": 2000
       },
+      "removeStaleAccessories": {
+        "description": "Remove stale accessories, whose devices are no longer exposed by a Nuki bridge.",
+        "type": "boolean"
+      },
       "timeout": {
         "description": "The timeout in seconds to wait for a response from a Nuki bridge.  Default: 15.",
         "type": "integer",
@@ -80,8 +84,9 @@
           ]
         },
         "openerResetTimeout",
-        "timeout",
-        "port"
+        "port",
+        "removeStaleAccessories",
+        "timeout"
       ]
     }
   ]

package/lib/NbAccessory/Bridge.js

@@ -0,0 +1,321 @@
+// homebridge-nb/lib/NbAccessory/Bridge.js
+// Copyright © 2020-2023 Erik Baauw. All rights reserved.
+//
+// Homebridge plug-in for Nuki Bridge.
+
+'use strict'
+
+const { AccessoryDelegate, ServiceDelegate, toHexString } = require('homebridge-lib')
+const NbAccessory = require('../NbAccessory')
+const NbService = require('../NbService')
+const { NbClient } = require('hb-nb-tools')
+
+class Bridge extends AccessoryDelegate {
+  constructor (platform, context) {
+    super(platform, {
+      id: context.id,
+      name: context.name,
+      category: platform.Accessory.Categories.RANGE_EXTENDER,
+      model: 'Bridge',
+      firmware: context.firmware
+    })
+    this.id = context.id
+    this.context.host = context.host
+    this.context.token = context.token
+    this.context.firmware = context.firmware
+    this.log(
+      'Nuki Bridge v%s %s at %s', context.firmware, context.id, context.host
+    )
+    this.on('shutdown', this.shutdown)
+    this.heartbeatEnabled = true
+    this.once('heartbeat', this.init)
+
+    this.smartLocks = {}
+    this.doorSensors = {}
+    this.keypads = {}
+    this.openers = {}
+    this.service = new NbService.Bridge(this)
+    this.manageLogLevel(this.service.characteristicDelegate('logLevel'))
+    this.dummyService = new ServiceDelegate.Dummy(this)
+
+    this.client = new NbClient({
+      host: this.context.host,
+      timeout: platform.config.timeout,
+      token: this.context.token
+    })
+    this.client
+      .on('error', (error) => {
+        this.log(
+          'request %d: %s %s', error.request.id,
+          error.request.method, error.request.resource
+        )
+        this.warn('request %d: error: %s', error.request.id, error)
+      })
+      .on('request', (request) => {
+        this.debug(
+          'request %d: %s %s', request.id, request.method, request.resource
+        )
+        this.vdebug(
+          'request %d: %s %s', request.id, request.method, request.url
+        )
+      })
+      .on('response', (response) => {
+        this.vdebug(
+          'request %d: response: %j', response.request.id, response.body
+        )
+        this.debug(
+          'request %d: %s %s', response.request.id,
+          response.statusCode, response.statusMessage
+        )
+      })
+      .on('event', (event) => {
+        this.debug('event: %j', event)
+        const id = event.nukiId.toString(16).toUpperCase()
+        switch (event.deviceType) {
+          case NbClient.DeviceTypes.SMARTLOCK:
+          case NbClient.DeviceTypes.SMARTDOOR:
+          case NbClient.DeviceTypes.SMARTLOCK3:
+            if (this.smartLocks[id] != null) {
+              this.smartLocks[id].update(event)
+            }
+            if (this.doorSensors[id + '-S'] != null) {
+              this.doorSensors[id + '-S'].update(event)
+            }
+            break
+          case NbClient.DeviceTypes.OPENER:
+            if (this.openers[id] != null) {
+              this.openers[id].update(event)
+            }
+            break
+          default:
+            break
+        }
+      })
+  }
+
+  get host () { return this.context.host }
+  set host (value) {
+    if (value !== this.context.host) {
+      this.debug('now at %s', value)
+      this.client.host = value
+      this.context.host = value
+      this.once('heartbeat', this.init)
+    }
+  }
+
+  async init (beat) {
+    try {
+      await this.client.init()
+      this.values.firmware = this.client.firmware
+      this.context.firmware = this.values.firmware
+      if (this.values.firmware !== this.platform.packageJson.engines.nuki) {
+        this.warn(
+          'recommended version: Nuki Bridge v%s',
+          this.platform.packageJson.engines.nuki
+        )
+      }
+      switch (this.client.encryption) {
+        case 'none':
+          this.warn('using plain-text tokens')
+          break
+        case 'hashedToken':
+          this.warn('using deprecated hashed tokens')
+          break
+        default:
+          break
+      }
+    } catch (error) {
+      return
+    }
+    if (this.context.callbackUrl) {
+      this.warn('unclean shutdown - checking for stale subscriptions')
+      try {
+        const response = await this.client.callbackList()
+        for (const callback of response.body.callbacks) {
+          if (callback.url === this.context.callbackUrl) {
+            this.log('remove stale subscription')
+            await this.client.callbackRemove(callback.id)
+          }
+        }
+      } catch (error) {
+        this.warn(error)
+      }
+    }
+    this.context.callbackUrl = await this.platform.addClient(this.client)
+    this.initialBeat = beat
+    try {
+      await this.heartbeat(beat)
+    } catch (error) {}
+    this.on('heartbeat', this.heartbeat)
+    this.debug('initialised')
+    this.emit('initialised')
+  }
+
+  async checkSubscription () {
+    if (this.callbackId == null) {
+      this.log('subscribe to event notifications')
+      const response = await this.client.callbackAdd(this.context.callbackUrl)
+      if (!response.body.success) {
+        this.error(response.body.message)
+        return
+      }
+    }
+    const response = await this.client.callbackList()
+    for (const callback of response.body.callbacks) {
+      if (callback.url === this.context.callbackUrl) {
+        this.debug('subscription: %j', callback)
+        this.callbackId = callback.id
+        return
+      }
+    }
+    if (this.callbackId != null) {
+      this.warn('lost subscription to event notifications')
+      this.callbackId = null
+    }
+    return this.checkSubscription()
+  }
+
+  async shutdown () {
+    if (this.client != null) {
+      const response = await this.client.callbackList()
+      for (const callback of response.body.callbacks) {
+        if (callback.url === this.context.callbackUrl) {
+          try {
+            this.log('unsubscribe from event notifications')
+            await this.client.callbackRemove(callback.id)
+          } catch (error) {
+            this.error(error)
+          }
+        }
+      }
+      this.platform.removeClient(this.client)
+      delete this.context.callbackUrl
+    }
+  }
+
+  addDoorSensor (id, context) {
+    this.doorSensors[id] = new NbAccessory.DoorSensor(this, context)
+  }
+
+  addKeypad (id, context) {
+    this.keypads[id] = new NbAccessory.Keypad(this, context)
+  }
+
+  addOpener (id, context) {
+    this.openers[id] = new NbAccessory.Opener(this, context)
+  }
+
+  addSmartLock (id, context) {
+    this.smartLocks[id] = new NbAccessory.SmartLock(this, context)
+  }
+
+  checkDoorSensor (id, device) {
+    if (
+      device.lastKnownState.doorsensorState != null &&
+      device.lastKnownState.doorsensorState !== NbClient.DoorSensorStates.DEACTIVATED
+    ) {
+      if (this.doorSensors[id + '-S'] == null) {
+        this.addDoorSensor(id + '-S', { id: id + '-S', device })
+      }
+      this.doorSensors[id + '-S'].context.device = device
+      this.doorSensors[id + '-S'].update(device.lastKnownState)
+    } else if (this.doorSensors[id + '-S'] != null) {
+      this.doorSensors[id + '-S'].destroy()
+      delete this.doorSensors[id + '-S']
+    }
+  }
+
+  checkKeypad (id, device) {
+    if (device.lastKnownState.keypadBatteryCritical != null) {
+      if (this.keypads[id + '-K'] == null) {
+        this.addKeypad(id + '-K', { id: id + '-K', device })
+      }
+      this.keypads[id + '-K'].context.device = device
+      this.keypads[id + '-K'].update(device.lastKnownState)
+    } else if (this.keypads[id + '-K'] != null) {
+      this.keypads[id + '-K'].destroy()
+      delete this.keypads[id + '-K']
+    }
+  }
+
+  checkFirmware (info) {
+    if (this.values.firmware !== info.versions.firmwareVersion) {
+      this.values.firmware = info.versions.firmwareVersion
+      this.context.firmware = this.values.firmware
+      if (this.values.firmware !== this.platform.packageJson.engines.nuki) {
+        this.warn(
+          'recommended version: Nuki Bridge v%s',
+          this.platform.packageJson.engines.nuki
+        )
+      }
+    }
+  }
+
+  async heartbeat (beat) {
+    if ((beat - this.initialBeat) % this.service.values.heartrate === 0) {
+      try {
+        await this.checkSubscription()
+        let response = await this.client.info()
+        this.debug('bridge: %j', response.body)
+        this.checkFirmware(response.body)
+        this.service.update(response.body)
+        response = await this.client.list()
+        for (const device of response.body) {
+          try {
+            this.debug('device: %j', device)
+            if (device.firmwareVersion == null) { // Issue 93.
+              continue
+            }
+            const id = toHexString(device.nukiId, 8)
+            if (!this.platform.isWhitelisted(id)) {
+              continue
+            }
+            switch (device.deviceType) {
+              case NbClient.DeviceTypes.SMARTLOCK:
+              case NbClient.DeviceTypes.SMARTDOOR:
+              case NbClient.DeviceTypes.SMARTLOCK3:
+                if (device.lastKnownState == null) {
+                  this.warn('%s: no last known state', id)
+                  continue
+                }
+                if (device.name == null || device.name === '') {
+                  device.name = 'Nuki_' + id
+                }
+                if (this.smartLocks[id] == null) {
+                  this.addSmartLock(id, { id, device })
+                }
+                this.smartLocks[id].context.device = device
+                this.smartLocks[id].update(device.lastKnownState)
+                this.checkDoorSensor(id, device)
+                this.checkKeypad(id, device)
+                break
+              case NbClient.DeviceTypes.OPENER:
+                if (device.lastKnownState == null) {
+                  this.warn('%s: no last known state', id)
+                  continue
+                }
+                if (device.name == null || device.name === '') {
+                  device.name = 'Nuki_Opener_' + id
+                }
+                if (this.openers[id] == null) {
+                  this.addOpener(id, { id, device })
+                }
+                this.openers[id].context.device = device
+                this.openers[id].update(device.lastKnownState)
+                this.checkKeypad(id, device)
+                break
+              default:
+                break
+            }
+          } catch (error) {
+            this.warn('heartbeat error: %s', error)
+          }
+        }
+      } catch (error) {
+        this.warn('heartbeat error: %s', error)
+      }
+    }
+  }
+}
+
+module.exports = Bridge

package/lib/NbAccessory/DoorSensor.js

@@ -0,0 +1,57 @@
+// homebridge-nb/lib/NbAccessory/DoorSensor.js
+// Copyright © 2020-2023 Erik Baauw. All rights reserved.
+//
+// Homebridge plug-in for Nuki Bridge.
+
+'use strict'
+
+const { ServiceDelegate } = require('homebridge-lib')
+const NbAccessory = require('.')
+const NbService = require('../NbService')
+
+class DoorSensor extends NbAccessory {
+  constructor (bridge, params) {
+    params.category = bridge.Accessory.Categories.DOOR
+    params.model = 'Door Sensor'
+    super(bridge, {
+      id: params.id,
+      name: params.device.name + ' Sensor',
+      device: params.device,
+      category: bridge.Accessory.Categories.DOOR,
+      model: 'Door Sensor'
+    })
+    this.service = new NbService.DoorSensor(this)
+    if (params.device.lastKnownState.doorsensorBatteryCritical) {
+      this.batteryService = new ServiceDelegate.Battery(this, {
+        statusLowBattery: params.device.lastKnownState.doorsensorBatteryCritical
+          ? this.Characteristics.hap.StatusLowBattery.BATTERY_LEVEL_LOW
+          : this.Characteristics.hap.StatusLowBattery.BATTERY_LEVEL_NORMAL
+      })
+    }
+    this.historyService = new ServiceDelegate.History(this, {
+      contactDelegate: this.service.characteristicDelegate('contact'),
+      lastContactDelegate: this.service.characteristicDelegate('lastActivation'),
+      timesOpenedDelegate: this.service.characteristicDelegate('timesOpened')
+    })
+  }
+
+  update (state) {
+    this.service.update(state)
+    if (state.doorsensorBatteryCritical != null) {
+      this.batteryService.values.statusLowBattery = state.doorsensorBatteryCritical
+        ? this.Characteristics.hap.StatusLowBattery.BATTERY_LEVEL_LOW
+        : this.Characteristics.hap.StatusLowBattery.BATTERY_LEVEL_NORMAL
+    }
+  }
+
+  async identify () {
+    try {
+      const response = await this.client.lockState(
+        this.id, this.context.deviceType
+      )
+      this.update(response.body)
+    } catch (error) { this.error(error) }
+  }
+}
+
+module.exports = DoorSensor

package/lib/NbAccessory/Keypad.js

@@ -0,0 +1,48 @@
+// homebridge-nb/lib/NbAccessory/Keypad.js
+// Copyright © 2020-2023 Erik Baauw. All rights reserved.
+//
+// Homebridge plug-in for Nuki Bridge.
+
+'use strict'
+
+const { ServiceDelegate } = require('homebridge-lib')
+const NbAccessory = require('../NbAccessory')
+
+class Keypad extends NbAccessory {
+  constructor (bridge, params) {
+    params.category = bridge.Accessory.Categories.DOOR_LOCK
+    params.model = 'Keypad'
+    super(bridge, {
+      id: params.id,
+      name: params.device.name + ' Keypad',
+      device: params.device,
+      category: bridge.Accessory.Categories.PROGRAMMABLE_SWITCH,
+      model: 'Keypad'
+    })
+    this.service = new ServiceDelegate.Dummy(this)
+    this.batteryService = new ServiceDelegate.Battery(this, {
+      statusLowBattery: params.device.lastKnownState.keypadBatteryCritical
+        ? this.Characteristics.hap.StatusLowBattery.BATTERY_LEVEL_LOW
+        : this.Characteristics.hap.StatusLowBattery.BATTERY_LEVEL_NORMAL
+    })
+  }
+
+  update (state) {
+    if (state.doorsensorBatteryCritical != null) {
+      this.batteryService.values.statusLowBattery = state.doorsensorBatteryCritical
+        ? this.Characteristics.hap.StatusLowBattery.BATTERY_LEVEL_LOW
+        : this.Characteristics.hap.StatusLowBattery.BATTERY_LEVEL_NORMAL
+    }
+  }
+
+  async identify () {
+    try {
+      const response = await this.client.lockState(
+        this.id, this.context.deviceType
+      )
+      this.update(response.body)
+    } catch (error) { this.error(error) }
+  }
+}
+
+module.exports = Keypad

package/lib/NbAccessory/Opener.js

@@ -0,0 +1,51 @@
+// homebridge-nb/lib/NbAccessory/Opener.js
+// Copyright © 2020-2023 Erik Baauw. All rights reserved.
+//
+// Homebridge plug-in for Nuki Bridge.
+
+'use strict'
+
+const { ServiceDelegate } = require('homebridge-lib')
+const NbAccessory = require('../NbAccessory')
+const NbService = require('../NbService')
+const { NbClient } = require('hb-nb-tools')
+
+class Opener extends NbAccessory {
+  constructor (bridge, params) {
+    super(bridge, {
+      id: params.id,
+      name: params.device.name,
+      device: params.device,
+      category: bridge.Accessory.Categories.DOOR_LOCK,
+      model: NbClient.modelName(params.device.deviceType, params.device.firmwareVersion)
+    })
+    this.openerService = new NbService.Opener(this)
+    this.doorBellService = new NbService.DoorBell(this)
+    this.batteryService = new ServiceDelegate.Battery(this, {
+      statusLowBattery: params.device.lastKnownState.doorsensorBatteryCritical
+        ? this.Characteristics.hap.StatusLowBattery.BATTERY_LEVEL_LOW
+        : this.Characteristics.hap.StatusLowBattery.BATTERY_LEVEL_NORMAL
+    })
+  }
+
+  update (state) {
+    this.openerService.update(state)
+    this.doorBellService.update(state)
+    if (state.batteryCritical != null) {
+      this.batteryService.values.statusLowBattery = state.batteryCritical
+        ? this.Characteristics.hap.StatusLowBattery.BATTERY_LEVEL_LOW
+        : this.Characteristics.hap.StatusLowBattery.BATTERY_LEVEL_NORMAL
+    }
+  }
+
+  async identify () {
+    try {
+      const response = await this.client.lockState(
+        this.id, NbClient.DeviceTypes.OPENER
+      )
+      this.update(response.body)
+    } catch (error) { this.error(error) }
+  }
+}
+
+module.exports = Opener

package/lib/NbAccessory/SmartLock.js

@@ -0,0 +1,67 @@
+// homebridge-nb/lib/NbAccessory/SmartLock.js
+// Copyright © 2020-2023 Erik Baauw. All rights reserved.
+//
+// Homebridge plug-in for Nuki Bridge.
+
+'use strict'
+
+const { ServiceDelegate } = require('homebridge-lib')
+const NbAccessory = require('../NbAccessory')
+const NbService = require('../NbService')
+const { NbClient } = require('hb-nb-tools')
+
+class SmartLock extends NbAccessory {
+  constructor (bridge, params) {
+    super(bridge, {
+      id: params.id,
+      name: params.device.name,
+      device: params.device,
+      category: bridge.Accessory.Categories.DOOR_LOCK,
+      model: NbClient.modelName(params.device.deviceType, params.device.firmwareVersion)
+    })
+    this.service = new NbService.SmartLock(this)
+    if (this.platform.config.latch) {
+      this.latchService = new NbService.Latch(this)
+    }
+    this.batteryService = new ServiceDelegate.Battery(this, {
+      batteryLevel: params.device.lastKnownState.batteryChargeState,
+      chargingState: params.device.lastKnownState.batteryCharging
+        ? this.Characteristics.hap.ChargingState.CHARGING
+        : this.Characteristics.hap.ChargingState.NOT_CHARGING,
+      statusLowBattery: params.device.lastKnownState.batteryCritical
+        ? this.Characteristics.hap.StatusLowBattery.BATTERY_LEVEL_LOW
+        : this.Characteristics.hap.StatusLowBattery.BATTERY_LEVEL_NORMAL
+    })
+  }
+
+  update (state) {
+    this.service.update(state)
+    if (this.platform.config.latch) {
+      this.latchService.update(state)
+    }
+    if (state.batteryChargeState) {
+      this.batteryService.values.batteryLevel = state.batteryChargeState
+    }
+    if (state.batteryCharging != null) {
+      this.batteryService.values.chargingState = state.batteryCharging
+        ? this.Characteristics.hap.ChargingState.CHARGING
+        : this.Characteristics.hap.ChargingState.NOT_CHARGING
+    }
+    if (state.batteryCritical != null) {
+      this.batteryService.values.statusLowBattery = state.batteryCritical
+        ? this.Characteristics.hap.StatusLowBattery.BATTERY_LEVEL_LOW
+        : this.Characteristics.hap.StatusLowBattery.BATTERY_LEVEL_NORMAL
+    }
+  }
+
+  async identify () {
+    try {
+      const response = await this.client.lockState(
+        this.id, this.context.deviceType
+      )
+      this.update(response.body)
+    } catch (error) { this.error(error) }
+  }
+}
+
+module.exports = SmartLock

package/lib/NbAccessory/index.js

@@ -0,0 +1,38 @@
+// homebridge-nb/lib/NbAccessory/index.js
+// Copyright © 2020-2023 Erik Baauw. All rights reserved.
+//
+// Homebridge plug-in for Nuki Bridge.
+
+'use strict'
+
+const { AccessoryDelegate } = require('homebridge-lib')
+
+class NbAccessory extends AccessoryDelegate {
+  static get Bridge () { return require('./Bridge') }
+  static get DoorSensor () { return require('./DoorSensor') }
+  static get Keypad () { return require('./Keypad') }
+  static get Opener () { return require('./Opener') }
+  static get SmartLock () { return require('./SmartLock') }
+
+  constructor (bridge, params) {
+    super(bridge.platform, {
+      id: params.id,
+      name: params.name,
+      category: params.category,
+      manufacturer: 'Nuki Home Solutions GmbH',
+      model: params.model,
+      firmware: params.device.firmwareVersion
+    })
+    this.inheritLogLevel(bridge)
+    this.id = params.id
+    this.bridge = bridge
+    this.client = this.bridge.client
+    this.context.bridgeId = this.bridge.id
+    this.deviceType = params.device
+    this.log('Nuki %s v%s %s', params.model, params.device.firmwareVersion, params.id)
+    this.on('identify', this.identify)
+    setImmediate(() => { this.emit('initialised') })
+  }
+}
+
+module.exports = NbAccessory