homebridge-lib 5.2.0 → 5.2.1

package/lib/ServiceDelegate/History/index.js

@@ -0,0 +1,318 @@
+// homebridge-lib/lib/ServiceDelegate/History/index.js
+//
+// Library for Homebridge plugins.
+// Copyright © 2017-2022 Erik Baauw. All rights reserved.
+//
+// The logic for handling Eve history was copied from Simone Tisa's
+// fakagato-history repository, copyright © 2017 simont77.
+// See https://github.com/simont77/fakegato-history.
+
+'use strict'
+
+const homebridgeLib = require('../../../index')
+
+const { ServiceDelegate } = homebridgeLib
+
+const util = require('util')
+
+/** Eve history keeps time as # seconds since epoch of 2001/01/01.
+  * @type {integer}
+  */
+const epoch = Math.round(new Date('2001-01-01T00:00:00Z').valueOf() / 1000)
+
+/** Convert Eve date (in # seconds since epoch) to string.
+  * @param {integer} d - Eve date as # seconds since epoch.
+  * @returns {string} Human readable date string.
+  */
+function dateToString (d) {
+  return new Date(1000 * (epoch + d)).toString().slice(0, 24)
+}
+
+function hexToBase64 (value) {
+  if (value == null || typeof value !== 'string') {
+    throw new TypeError('value: not a string')
+  }
+  return Buffer.from((value).replace(/[^0-9A-F]/ig, ''), 'hex')
+    .toString('base64')
+}
+
+function base64ToHex (value) {
+  if (value == null || typeof value !== 'string') {
+    throw new TypeError('value: not a string')
+  }
+  return Buffer.from(value, 'base64').toString('hex')
+}
+
+function swap16 (value) {
+  return ((value & 0xFF) << 8) | ((value >>> 8) & 0xFF)
+}
+
+function swap32 (value) {
+  return ((value & 0xFF) << 24) | ((value & 0xFF00) << 8) |
+    ((value >>> 8) & 0xFF00) | ((value >>> 24) & 0xFF)
+}
+
+function numToHex (value, length) {
+  let s = Number(value >>> 0).toString(16)
+  if (s.length % 2 !== 0) {
+    s = '0' + s
+  }
+  if (length) {
+    return ('0000000000000' + s).slice(-length)
+  }
+  return s
+}
+
+/** Abstract superclass for an Eve _History_ service delegate.
+  *
+  * This delegate sets up a `Services.eve.History` HomeKit service
+  * with keys for the following HomeKit characteristics:
+  *
+  * key              | Characteristic
+  * ---------------- | ----------------------------------
+  * `name`           | `Characteristics.hap.Name`
+  * `historyRequest` | `Characteristics.eve.HistoryRequest`
+  * `setTime`        | `Characteristics.eve.SetTime`
+  * `historyStatus`  | `Characteristics.eve.HistoryStatus`
+  * `historyEntries` | `Characteristics.eve.HistoryEntries`
+  * @abstract
+  * @extends ServiceDelegate
+  * @memberof ServiceDelegate
+  */
+class History extends ServiceDelegate {
+  static get Consumption () { return require('./Consumption') }
+  static get Contact () { return require('./Contact') }
+  static get Motion () { return require('./Motion') }
+  static get On () { return require('./On') }
+  static get Power () { return require('./Power') }
+  static get Room () { return require('./Room') }
+  static get Thermo () { return require('./Thermo') }
+  static get Weather () { return require('./Weather') }
+
+  static get hexToBase64 () { return hexToBase64 }
+  static get base64ToHex () { return base64ToHex }
+  static get swap16 () { return swap16 }
+  static get swap32 () { return swap32 }
+  static get numToHex () { return numToHex }
+
+  /** Create a new instance of an Eve _History_ service delegate.
+    * @param {!AccessoryDelegate} accessoryDelegate - The delegate of the
+    * corresponding HomeKit accessory.
+    * @param {!object} params - The parameters for the
+    * _History_ HomeKit service.
+    */
+  constructor (accessoryDelegate, params = {}) {
+    params.name = accessoryDelegate.name + ' History'
+    params.Service = accessoryDelegate.Services.eve.History
+    params.hidden = true
+    super(accessoryDelegate, params)
+    this._memorySize = 6 * 24 * 7 * 4 // Four weeks.
+    this._transfer = false
+    this._restarted = true
+
+    this.addCharacteristicDelegate({
+      key: 'history',
+      silent: true
+    })
+    if (this.context._history != null) {
+      this.values.history = this.context._history
+      delete this.context._history
+    }
+    this._h = this.values.history
+    if (this._h == null) {
+      this.values.history = {
+        firstEntry: 0,
+        lastEntry: 0,
+        history: ['noValue'],
+        usedMemory: 0,
+        currentEntry: 1,
+        initialTime: 0
+      }
+      this._h = this.values.history
+    } else {
+      this.debug('restored %d history entries', this._h.usedMemory)
+    }
+    if (this._h.refTime != null) {
+      this._h.initialTime = this._h.refTime + epoch
+      delete this._h.refTime
+    }
+
+    this.addCharacteristicDelegate({
+      key: 'historyRequest',
+      Characteristic: this.Characteristics.eve.HistoryRequest,
+      value: params.historyRequest,
+      setter: this._onSetHistoryRequest.bind(this),
+      silent: true
+    })
+    this.addCharacteristicDelegate({
+      key: 'setTime',
+      Characteristic: this.Characteristics.eve.SetTime,
+      value: params.setTime,
+      silent: true
+    }).on('didSet', (value) => {
+      const buffer = Buffer.from(value, 'base64')
+      this.debug('SetTime changed to %j', buffer.toString('hex'))
+      const date = dateToString(buffer.readUInt32LE())
+      this.debug('SetTime changed to %s', date)
+    })
+    this.addCharacteristicDelegate({
+      key: 'historyStatus',
+      Characteristic: this.Characteristics.eve.HistoryStatus,
+      value: params.historyStatus,
+      silent: true
+    })
+    this.addCharacteristicDelegate({
+      key: 'historyEntries',
+      Characteristic: this.Characteristics.eve.HistoryEntries,
+      value: params.historyEntries,
+      getter: this._onGetEntries.bind(this),
+      silent: true
+    })
+    this._accessoryDelegate.heartbeatEnabled = true
+    this._accessoryDelegate
+      .once('heartbeat', (beat) => {
+        this._historyBeat = (beat % 600) + 5
+      })
+      .on('heartbeat', this._heartbeat.bind(this))
+      .on('shutdown', () => {
+        this.debug('saved %d history entries', this._h.usedMemory)
+      })
+  }
+
+  _addEntry (now = Math.round(new Date().valueOf() / 1000)) {
+    this._entry.time = now
+    if (this._h.usedMemory < this._memorySize) {
+      this._h.usedMemory++
+      this._h.firstEntry = 0
+      this._h.lastEntry = this._h.usedMemory
+    } else {
+      this._h.firstEntry++
+      this._h.lastEntry = this._h.firstEntry + this._h.usedMemory
+      if (this._restarted === true) {
+        this._h.history[this._h.lastEntry % this._memorySize] = {
+          time: this._entry.time,
+          setRefTime: 1
+        }
+        this._h.firstEntry++
+        this._h.lastEntry = this._h.firstEntry + this._h.usedMemory
+        this._restarted = false
+      }
+    }
+
+    if (this._h.initialTime === 0) {
+      this._h.history[this._h.lastEntry] = {
+        time: this._entry.time,
+        setRefTime: 1
+      }
+      this._h.initialTime = this._entry.time
+      this._h.lastEntry++
+      this._h.usedMemory++
+    }
+
+    this._h.history[this._h.lastEntry % this._memorySize] =
+      Object.assign({}, this._entry)
+
+    const usedMemeoryOffset = this._h.usedMemory < this._memorySize ? 1 : 0
+    const firstEntryOffset = this._h.usedMemory < this._memorySize ? 0 : 1
+    const buffer = Buffer.alloc(1024)
+    let offset = 0
+    buffer.writeUInt32LE(this._entry.time - this._h.initialTime, offset)
+    offset += 4
+    buffer.writeUInt32LE(0, offset)
+    offset += 4
+    buffer.writeUInt32LE(this._h.initialTime - epoch, offset)
+    offset += 4
+    buffer.write(this._fingerPrint.replace(/[^0-9A-F]/ig, ''), offset, 'hex')
+    const length = 1 + 2 * parseInt(this._fingerPrint.slice(0, 2))
+    this.debug('fingerprint length: %d', length)
+    offset += length
+    buffer.writeUInt16LE(this._h.usedMemory + usedMemeoryOffset, offset)
+    offset += 2
+    buffer.writeUInt16LE(this._memorySize, offset)
+    offset += 2
+    buffer.writeUInt32LE(this._h.firstEntry + firstEntryOffset, offset)
+    offset += 4
+    buffer.writeUInt32LE(0, offset)
+    offset += 4
+    buffer.writeUint8(1, offset)
+    offset += 1
+    buffer.writeUint8(1, offset)
+    offset += 1
+
+    const value = util.format(
+      '%s 00000000 %s [%s] %s %s %s 000000000101',
+      numToHex(swap32(this._entry.time - this._h.initialTime), 8),
+      numToHex(swap32(this._h.initialTime - epoch), 8),
+      this._fingerPrint,
+      numToHex(swap16(this._h.usedMemory + usedMemeoryOffset), 4),
+      numToHex(swap16(this._memorySize), 4),
+      numToHex(swap32(this._h.firstEntry + firstEntryOffset), 8)
+    )
+
+    this.debug('add entry %d: %j', this._h.lastEntry, this._entry)
+    this.debug('set history status to: %j', value)
+    this.debug('set history status to: %j', buffer.slice(0, offset).toString('hex'))
+    this.values.historyStatus = hexToBase64(value)
+  }
+
+  _heartbeat (beat) {
+    if (beat % 600 === this._historyBeat) {
+      this._addEntry()
+    }
+  }
+
+  async _onSetHistoryRequest (value) {
+    const buffer = Buffer.from(value, 'base64')
+    this.debug('History Request changed to %j', base64ToHex(value))
+    const entry = buffer.readUInt32LE(2)
+    this.debug('request entry: %d', entry)
+    if (entry !== 0) {
+      this._h.currentEntry = entry
+    } else {
+      this._h.currentEntry = 1
+    }
+    this._transfer = true
+  }
+
+  async _onGetEntries () {
+    if (this._h.currentEntry > this._h.lastEntry || !this._transfer) {
+      this.debug('send data: 00')
+      this._transfer = false
+      return hexToBase64('00')
+    }
+
+    let dataStream = ''
+    for (let i = 0; i < 11; i++) {
+      const address = this._h.currentEntry % this._memorySize
+      if (
+        this._h.history[address].setRefTime === 1 ||
+        this._h.currentEntry === this._h.firstEntry + 1
+      ) {
+        this.debug(
+          'entry: %s, address %s, reftime: %s (%s)', this._h.currentEntry,
+          address, this._h.initialTime - epoch,
+          new Date(1000 * this._h.initialTime).toString().slice(0, 24)
+        )
+        dataStream += util.format(
+          '|15 %s 0100000081 %s 00000000000000',
+          numToHex(swap32(this._h.currentEntry), 8),
+          numToHex(swap32(this._h.initialTime - epoch), 8))
+      } else {
+        this.debug(
+          'entry: %s, address: %s, time: %s (%s)', this._h.currentEntry,
+          address, this._h.history[address].time - this._h.initialTime,
+          new Date(1000 * this._h.history[address].time).toString().slice(0, 24)
+        )
+        dataStream += this._entryStream(this._h.history[address])
+      }
+      this._h.currentEntry++
+      if (this._h.currentEntry > this._h.lastEntry) {
+        break
+      }
+    }
+    this.debug('send data: %s', dataStream)
+    return hexToBase64(dataStream)
+  }
+}
+
+module.exports = History

package/lib/ServiceDelegate/ServiceLabel.js

@@ -0,0 +1,47 @@
+// homebridge-lib/lib/ServiceDelegate/ServiceLabel.js
+//
+// Library for Homebridge plugins.
+// Copyright © 2017-2022 Erik Baauw. All rights reserved.
+
+'use strict'
+
+const homebridgeLib = require('../../index')
+
+const { ServiceDelegate } = homebridgeLib
+
+/** Class for a _ServiceLabel_ service delegate.
+  *
+  * This delegate sets up a `Services.hap.ServiceLabel` HomeKit service
+  * with the following HomeKit characteristics:
+  *
+  * key            | Characteristic                              | isOptional
+  * -------------- | ------------------------------------------- | ----------
+  * `name`         | `Characteristics.hap.Name`                  |
+  * `namespace`    | `Characteristics.hap.ServiceLabelNamespace` |
+  * @extends ServiceDelegate
+  * @memberof ServiceDelegate
+  */
+class ServiceLabel extends ServiceDelegate {
+  /** Create a new instance of an _ServiceLabel_ service delegate.
+    * @param {!AccessoryDelegate} accessoryDelegate - The delegate of the
+    * corresponding HomeKit accessory.
+    * @param {!object} params - The parameters for the
+    * _AccessoryInformation_ HomeKit service.
+    * @param {!string} params.name - Initial value for
+    * `Characteristics.hap.Name`. Also used to prefix log and error messages.
+    * @param {!string} params.namespace - Initial value for
+    * `Characteristics.hap.ServiceLabelNamespace`.
+    */
+  constructor (accessoryDelegate, params = {}) {
+    params.name = accessoryDelegate.name
+    params.Service = accessoryDelegate.Services.hap.ServiceLabel
+    super(accessoryDelegate, params)
+    this.addCharacteristicDelegate({
+      key: 'namespace',
+      Characteristic: this.Characteristics.hap.ServiceLabelNamespace,
+      value: params.namespace
+    })
+  }
+}
+
+module.exports = ServiceLabel

package/lib/ServiceDelegate/index.js

@@ -0,0 +1,332 @@
+// homebridge-lib/lib/ServiceDelegate/index.js
+//
+// Library for Homebridge plugins.
+// Copyright © 2017-2022 Erik Baauw. All rights reserved.
+
+'use strict'
+
+const homebridgeLib = require('../../index')
+
+/** Delegate of a HomeKit service.
+  *
+  * This delegate sets up a HomeKit service with the following HomeKit
+  * characteristic:
+  *
+  * key              | Characteristic
+  * ---------------- | -----------------------------------
+  * `name`           | `Characteristics.hap.Name`
+  * `configuredName` | `Characteristics.hap.ConfiguredName`
+  * @abstract
+  * @extends Delegate
+  */
+class ServiceDelegate extends homebridgeLib.Delegate {
+  static get AccessoryInformation () { return require('./AccessoryInformation') }
+  static get Battery () { return require('./Battery') }
+  static get Dummy () { return require('./Dummy') }
+  static get History () { return require('./History') }
+  static get ServiceLabel () { return require('./ServiceLabel') }
+
+  /** Create a new instance of a HomeKit service delegate.
+    *
+    * When the associated HomeKit service was restored from persistent
+    * storage, it is linked to the new delegate. Otherwise a new HomeKit
+    * service will be created, using the values from `params`.
+    * @param {!AccessoryDelegate} accessoryDelegate - Reference to the
+    * associated HomeKit accessory delegate.
+    * @param {!object} params - Properties of the HomeKit service.<br>
+    * Next to the fixed properties below, `params` also contains the value for
+    * each key specified in {@link ServiceDelegate#characteristics characteristics}.
+    * @param {!string} params.name - The (Siri) name of the service.
+    * Also used to prefix log and error messages.
+    * @param {!Service} params.Service - The type of the HomeKit service.
+    * @param {?string} params.subtype - The subtype of the HomeKit service.
+    * Needs to be specified when the accessory has multuple services of the
+    * same type.
+    * @params {?boolean} params.primaryService - This is the primary service
+    * for the accessory.
+    * @params {?ServiceDelegate} params.linkedServiceDelegate - The delegate
+    * of the service this service links to.
+    * @params {?boolean} params.hidden - Hidden service.
+    * @params {?boolean} params.exposeConfiguredName - Expose
+    * `Characteristics.hap.ConfiguredName`, so device name can be synced with
+    * HomeKit service name.
+    */
+  constructor (accessoryDelegate, params = {}) {
+    if (!(accessoryDelegate instanceof homebridgeLib.AccessoryDelegate)) {
+      throw new TypeError('parent: not a AccessoryDelegate')
+    }
+    if (params.name == null) {
+      throw new SyntaxError('params.name: missing')
+    }
+    super(accessoryDelegate.platform, params.name)
+    if (
+      typeof params.Service !== 'function' ||
+      typeof params.Service.UUID !== 'string'
+    ) {
+      throw new TypeError('params.Service: not a Service')
+    }
+    this._accessoryDelegate = accessoryDelegate
+    this._accessory = this._accessoryDelegate._accessory
+    this._key = params.Service.UUID
+    if (params.subtype != null) {
+      this._key += '.' + params.subtype
+    }
+
+    // Get or create associated Service.
+    this._service = params.subtype == null
+      ? this._accessory.getService(params.Service)
+      : this._accessory.getServiceByUUIDAndSubType(params.Service, params.subtype)
+    if (this._service == null) {
+      this._service = this._accessory.addService(
+        new params.Service(this.name, params.subtype)
+      )
+      this._service.displayName = this.name
+    }
+    this._accessoryDelegate._linkServiceDelegate(this)
+    this._service.setPrimaryService(!!params.primaryService)
+    if (params.linkedServiceDelegate != null) {
+      params.linkedServiceDelegate._service.addLinkedService(this._service)
+    }
+    this._service.setHiddenService(!!params.hidden)
+
+    // Fix bug in homebridge-lib@<4.3.0 that caused the service context in
+    // ~/.homebridge/accessories/cachedAccessories to be stored under the
+    // wrong key.
+    if (
+      params.subtype == null &&
+      this._accessory.context[this._key + '.'] != null
+    ) {
+      this._accessory.context[this._key] =
+        this._accessory.context[this._key + '.']
+      delete this._accessory.context[this._key + '.']
+    }
+
+    // Setup persisted storage in ~/.homebridge/accessories/cachedAccessories.
+    if (this._accessory.context[this._key] == null) {
+      this._accessory.context[this._key] = {}
+    }
+    this._context = this._accessory.context[this._key]
+
+    // Setup shortcut for characteristic values.
+    this._values = {} // by key
+
+    // Setup characteristics
+    this._characteristicDelegates = {} // by key
+    this._characteristics = {} // by uuid
+
+    if (!params.hidden) {
+      this.addCharacteristicDelegate({
+        key: 'name',
+        Characteristic: this.Characteristics.hap.Name,
+        silent: true,
+        value: params.name
+      })
+      if (params.exposeConfiguredName) {
+        this.addCharacteristicDelegate({
+          key: 'configuredName',
+          Characteristic: this.Characteristics.hap.ConfiguredName,
+          // silent: true,
+          props: {
+            perms: [
+              this.Characteristic.Perms.READ, this.Characteristic.Perms.WRITE
+            ]
+          },
+          value: params.name
+        }).on('didSet', (value) => {
+          if (value.trim() !== '') {
+            this.name = value
+            this._service.displayName = value
+            this.values.name = value
+            for (const key in this._characteristicDelegates) {
+              this._characteristicDelegates[key].name = value
+            }
+          }
+        })
+      }
+    }
+
+    this.once('initialised', () => {
+      const staleCharacteristics = []
+      for (const uuid in this._service.characteristics) {
+        const characteristic = this._service.characteristics[uuid]
+        if (this._characteristics[characteristic.UUID] == null) {
+          staleCharacteristics.push(characteristic)
+        }
+      }
+      for (const characteristic of staleCharacteristics) {
+        this.log('remove stale characteristic %s', characteristic.displayName)
+        this._service.removeCharacteristic(characteristic)
+      }
+      const staleKeys = []
+      for (const key in this._context) {
+        if (key !== 'context' && this._characteristicDelegates[key] == null) {
+          staleKeys.push(key)
+        }
+      }
+      for (const key of staleKeys) {
+        this.log('remove stale value %s', key)
+        delete this._context[key]
+      }
+    })
+  }
+
+  /** Destroy the HomeKit service delegate.
+    *
+    * Destroys the associated HomeKit characteristic delegates.
+    * Removes the associated HomeKit service.
+    */
+  destroy () {
+    this.debug('destroy %s (%s)', this._key, this._service.displayName)
+    this._accessoryDelegate._unlinkServiceDelegate(this)
+    this.removeAllListeners()
+    for (const key in this._characteristicDelegates) {
+      this._characteristicDelegates[key]._destroy()
+    }
+    this._accessory.removeService(this._service)
+    delete this._accessory.context[this._key]
+  }
+
+  /** Add a HomeKit characteristic delegate to the HomeKit service delegate.
+    *
+    * The characteristic delegate manages a value that:
+    * - Is persisted across homebridge restarts;
+    * - Can be monitored through homebridge's log output;
+    * - Can be monitored programmatially through `didSet` events; and
+    * - Mirrors the value of the optionally associated HomeKit characteristic.
+    *
+    * This value is accessed through {@link ServiceDelegate#values values}.
+    * The delegate is returned, but can also be accessed through
+    * {@link ServiceDelegate#characteristicDelegate characteristicDelegate()}.
+    *
+    * When the associated HomeKit characteristic was restored from persistent
+    * storage, it is linked to the new delegate. Otherwise a new HomeKit
+    * charactertistic will be created, using the values from `params`.
+    * @param {!object} params - Properties of the HomeKit characteristic.
+    * @param {!string} params.key - The key for the characteristic.
+    * @param {?*} params.value - The initial value when the characteristic
+    * is added.
+    * @param {?boolean} params.silent - Suppress set log messages.
+    * @param {?Characteristic} params.Characteristic - The type of the
+    * characteristic, from {@link Delegate#Characteristic Characteristic}.
+    * @param {?object} params.props - The properties of the HomeKit
+    * characteristic.<br>
+    * Overrides the properties from the characteristic type.
+    * @param {?string} params.unit - The unit of the value of the HomeKit
+    * characteristic.<br>
+    * Overrides the unit from the characteristic type.
+    * @param {?function} params.getter - Asynchronous function to be invoked
+    * when HomeKit reads the characteristic value.<br>
+    * This must be an `async` function returning a `Promise` to the new
+    * characteristic value.
+    * @param {?function} params.setter - Asynchronous function to be invoked
+    * when HomeKit writes the characteristic value.<br>
+    * This must be an `async` function returning a `Promise` that resolves
+    * when the corresonding device value has been updated.
+    * @returns {CharacteristicDelegate}
+    * @throws {TypeError} When a parameter has an invalid type.
+    * @throws {RangeError} When a parameter has an invalid value.
+    * @throws {SyntaxError} When a mandatory parameter is missing or an
+    * optional parameter is not applicable.
+    */
+  addCharacteristicDelegate (params = {}) {
+    if (typeof params.key !== 'string') {
+      throw new TypeError(`params.key: ${params.key}: invalid key`)
+    }
+    if (params.key === '') {
+      throw new RangeError(`params.key: ${params.key}: invalid key`)
+    }
+    const key = params.key
+    if (this.values[key] !== undefined) {
+      throw new SyntaxError(`${key}: duplicate key`)
+    }
+
+    const characteristicDelegate = new homebridgeLib.CharacteristicDelegate(
+      this, params
+    )
+    this._characteristicDelegates[key] = characteristicDelegate
+    if (params.Characteristic != null) {
+      this._characteristics[params.Characteristic.UUID] = true
+    }
+
+    // Create shortcut for characteristic value.
+    Object.defineProperty(this.values, key, {
+      configurable: true, // make sure we can delete it again
+      writeable: true,
+      get () { return characteristicDelegate.value },
+      set (value) { characteristicDelegate.value = value }
+    })
+
+    return characteristicDelegate
+  }
+
+  removeCharacteristicDelegate (key) {
+    delete this.values[key]
+    const characteristicDelegate = this._characteristicDelegates[key]
+    if (characteristicDelegate._characteristic != null) {
+      const characteristic = characteristicDelegate._characteristic
+      delete this._characteristics[characteristic.UUID]
+    }
+    characteristicDelegate._destroy()
+    delete this._characteristicDelegates[key]
+    delete this._context[key]
+  }
+
+  /** Values of the HomeKit characteristics for the HomeKit service.
+    *
+    * Contains the key of each characteristic added by
+    * {@link ServiceDelegate#addCharacteristic addCharacteristic}.
+    * When the value is written, the value of the corresponding HomeKit
+    * characteristic is updated; when the characteristic value is changed from
+    * HomeKit, this value is updated.
+    * @type {object}
+    */
+  get values () {
+    return this._values
+  }
+
+  /** Returns the HomeKit characteristic delegate correspondig to the key.
+    * @param {!string} key - The key for the characteristic.
+    * returns {CharacteristicDelegate}
+    */
+  characteristicDelegate (key) {
+    return this._characteristicDelegates[key]
+  }
+
+  /** The corrresponding HomeKit accessory delegate.
+    * @type {AccessoryDelegate}
+    */
+  get accessoryDelegate () {
+    return this._accessoryDelegate
+  }
+
+  /** Service context to be persisted across Homebridge restarts.
+    * @type {object}
+    */
+  get context () {
+    if (this._context.context == null) {
+      this._context.context = {}
+    }
+    return this._context.context
+  }
+
+  /** Current log level (of the associated accessory delegate).
+    *
+    * The log level determines what type of messages are printed:
+    *
+    * 0. Print error and warning messages.
+    * 1. Print error, warning, and log messages.
+    * 2. Print error, warning, log, and debug messages.
+    * 3. Print error, warning, log, debug, and verbose debug messages.
+    *
+    * Note that debug messages (level 2 and 3) are only printed when
+    * Homebridge was started with the `-D` or `--debug` command line option.
+    *
+    * @type {!integer}
+    * @readonly
+    */
+  get logLevel () {
+    return this._accessoryDelegate.logLevel
+  }
+}
+
+module.exports = ServiceDelegate