homebridge-nest-accfactory 0.3.0 → 0.3.2

package/dist/HomeKitHistory.js

@@ -10,7 +10,7 @@
 //
 // Credit to https://github.com/simont77/fakegato-history for the work on starting the EveHome comms protocol decoding
 //
-// Version 2025/01/18
+// Version 2025.08.06
 // Mark Hulskamp
 
 // Define nodejs module requirements
@@ -23,281 +23,265 @@ import fs from 'fs';
 const MAX_HISTORY_SIZE = 16384; // 16k entries
 const EPOCH_OFFSET = 978307200; // Seconds since 1/1/1970 to 1/1/2001
 const EVEHOME_MAX_STREAM = 11; // Maximum number of history events we can stream to EveHome
-const DAYSOFWEEK = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'];
+const DAYS_OF_WEEK = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'];
+const EMPTY_SCHEDULE = 'ffffffffffffffff';
+const LOG_LEVELS = {
+  INFO: 'info',
+  SUCCESS: 'success',
+  WARN: 'warn',
+  ERROR: 'error',
+  DEBUG: 'debug',
+};
 
 // Create the history object
 export default class HomeKitHistory {
+  static GET = 'HomeKitHistory.onEveGet'; // for EveHome read requests
+  static SET = 'HomeKitHistory.onEveSet'; // for EveHome write requests
+
+  // Symbol used to temporarily store EveHome options on a service
+  static EVE_OPTIONS = Symbol('eveOptions');
+
+  historyData = {}; // Tracked history data via persistant storage
+  restart = Math.floor(Date.now() / 1000); // time we restarted object or created
+  EveHome = undefined;
+
   accessory = undefined; // Accessory service for this history
   hap = undefined; // HomeKit Accessory Protocol API stub
   log = undefined; // Logging function object
-  maxEntries = MAX_HISTORY_SIZE; // used for rolling history. if 0, means no rollover
-  EveHome = undefined;
 
-  constructor(accessory, log, api, options) {
+  // Internal data only for this class
+  #persistStorage = undefined;
+  #persistKey = undefined;
+  #maxEntries = MAX_HISTORY_SIZE; // used for rolling history. if 0, means no rollover
+
+  constructor(accessory = undefined, api = undefined, log = undefined, options = {}) {
     // Validate the passed in logging object. We are expecting certain functions to be present
-    if (
-      typeof log?.info === 'function' &&
-      typeof log?.success === 'function' &&
-      typeof log?.warn === 'function' &&
-      typeof log?.error === 'function' &&
-      typeof log?.debug === 'function'
-    ) {
+    if (Object.values(LOG_LEVELS).every((fn) => typeof log?.[fn] === 'function')) {
       this.log = log;
     }
 
-    if (typeof accessory !== 'undefined' && typeof accessory === 'object') {
-      this.accessory = accessory;
-    }
+    // Get the actual HAP entry point from passed in api object, either Homebridge or HAP-NodeJS
+    this.hap =
+      isNaN(api?.version) === false && typeof api?.hap === 'object' && api?.HAPLibraryVersion === undefined
+        ? api.hap
+        : typeof api?.HAPLibraryVersion === 'function' && api?.version === undefined && api?.hap === undefined
+          ? api
+          : undefined;
 
-    if (typeof options === 'object') {
-      if (typeof options?.maxEntries === 'number') {
-        this.maxEntries = options.maxEntries;
-      }
+    if (this.hap === undefined) {
+      this?.log?.error?.('Missing HAP library API, cannot use class');
+      return;
     }
 
-    // Workout if we're running under HomeBridge or HAP-NodeJS library
-    if (typeof api?.version === 'number' && typeof api?.hap === 'object' && typeof api?.HAPLibraryVersion === 'undefined') {
-      // We have the HomeBridge version number and hap API object
-      this.hap = api.hap;
+    if (typeof accessory !== 'undefined' && typeof accessory === 'object') {
+      this.accessory = accessory;
     }
 
-    if (typeof api?.HAPLibraryVersion === 'function' && typeof api?.version === 'undefined' && typeof api?.hap === 'undefined') {
-      // As we're missing the HomeBridge entry points but have the HAP library version
-      this.hap = api;
+    if (isNaN(options?.maxEntries) === false) {
+      this.#maxEntries = options.maxEntries;
     }
 
-    // Dynamically create the additional services and characteristics
-    this.#createHomeKitServicesAndCharacteristics();
-
-    // Setup HomeKitHistory using HAP-NodeJS library
+    // Determine the peristant storage file name
     if (typeof accessory?.username !== 'undefined') {
       // Since we have a username for the accessory, we'll assume this is not running under Homebridge
       // We'll use it's persist folder for storing history files
-      this.storageKey = util.format('History.%s.json', accessory.username.replace(/:/g, '').toUpperCase());
+      this.#persistKey = util.format('History.%s.json', accessory.username.replace(/:/g, '').toUpperCase());
     }
 
     // Setup HomeKitHistory under Homebridge
     if (typeof accessory?.username === 'undefined') {
-      this.storageKey = util.format('History.%s.json', accessory.UUID);
+      this.#persistKey = util.format('History.%s.json', accessory.UUID);
     }
 
-    this.storage = this.hap.HAPStorage.storage();
-
-    this.historyData = this.storage.getItem(this.storageKey);
+    // Setup persistant storage and load any data we have already
+    this.#persistStorage = this.hap.HAPStorage.storage();
+    this.historyData = this.#persistStorage.getItem(this.#persistKey);
     if (typeof this.historyData !== 'object') {
       // Getting storage key didnt return an object, we'll assume no history present, so start new history for this accessory
       this.resetHistory(); // Start with blank history
     }
 
-    this.restart = Math.floor(Date.now() / 1000); // time we restarted
-
     // perform rollover if needed when starting service
-    if (this.maxEntries !== 0 && this.historyData.next >= this.maxEntries) {
+    if (this.#maxEntries !== 0 && this.historyData.next >= this.#maxEntries) {
       this.rolloverHistory();
     }
+
+    // Dynamically create the additional services and characteristics
+    this.#createHomeKitServicesAndCharacteristics();
   }
 
   // Class functions
-  addHistory(service, entry, timegap) {
-    // we'll use the service or characteristic UUID to determine the history entry time and data we'll add
-    // reformat the entry object to order the fields consistantly in the output
-    // Add new history types in the switch statement
-    let historyEntry = {};
-    if (this.restart !== null && typeof entry.restart === 'undefined') {
-      // Object recently created, so log the time restarted our history service
-      entry.restart = this.restart;
-      this.restart = null;
-    }
-    if (typeof entry.time === 'undefined') {
-      // No logging time was passed in, so set
-      entry.time = Math.floor(Date.now() / 1000);
+  addHistory(target, entry, timegap) {
+    // Validate that target is a Service or Characteristic with a UUID string,
+    // entry is an object, and hap.Service exists (class/function)
+    if (
+      typeof target !== 'object' ||
+      typeof target.UUID !== 'string' ||
+      typeof entry !== 'object' ||
+      typeof this.hap?.Service !== 'function' ||
+      typeof this.hap?.Characteristic !== 'function'
+    ) {
+      return;
     }
-    if (typeof service.subtype === 'undefined') {
-      service.subtype = 0;
+
+    // Metadata map keyed by Service or Characteristic UUID
+    let SERVICE_HISTORY_META = {
+      [this.hap.Service.GarageDoorOpener.UUID]: {
+        required: ['status'],
+        comment: 'status => 0 = closed, 1 = open',
+      },
+      [this.hap.Service.LockMechanism.UUID]: {
+        required: ['status'],
+        comment: 'status => 0 = locked, 1 = unlocked',
+      },
+      [this.hap.Service.Fan.UUID]: {
+        required: ['status'],
+        comment: 'status => 0 = off, 1 = on; optional: temperature, humidity',
+      },
+      [this.hap.Service.Fan.Fanv2.UUID]: {
+        required: ['status'],
+        comment: 'status => 0 = off, 1 = on; optional: temperature, humidity',
+      },
+      [this.hap.Service.HumidifierDehumidifier.UUID]: {
+        required: ['status'],
+        comment: 'status => 0 = off, 1 = on; optional: temperature, humidity',
+      },
+      [this.hap.Service.MotionSensor.UUID]: {
+        required: ['status'],
+        comment: 'status => 0 = motion cleared, 1 = motion detected',
+      },
+      [this.hap.Service.Window.UUID]: {
+        required: ['status', 'position'],
+        comment: 'status => 0 = closed, 1 = open; position => % open (0–100)',
+      },
+      [this.hap.Service.WindowCovering.UUID]: {
+        required: ['status', 'position'],
+        comment: 'status => 0 = closed, 1 = open; position => % open (0–100)',
+      },
+      [this.hap.Service.HeaterCooler.UUID]: {
+        required: ['status', 'temperature', 'target', 'humidity'],
+        comment: 'status => 0 = off, 1 = cooling, 2 = heating; includes temperature, target {low/high}, humidity',
+      },
+      [this.hap.Service.Thermostat.UUID]: {
+        required: ['status', 'temperature', 'target', 'humidity'],
+        comment: 'status => 0 = off, 1 = cooling, 2 = heating; includes temperature, target {low/high}, humidity',
+      },
+      [this.hap.Service.TemperatureSensor.UUID]: {
+        required: ['temperature'],
+        defaults: { humidity: 0, ppm: 0, voc: 0, pressure: 0 },
+        comment: 'temperature required; humidity, ppm, voc, pressure default to 0',
+      },
+      [this.hap.Service.AirQualitySensor.UUID]: {
+        required: ['temperature'],
+        defaults: { humidity: 0, ppm: 0, voc: 0, pressure: 0 },
+        comment: 'temperature required; humidity, ppm, voc, pressure default to 0',
+      },
+      [this.hap.Service.EveAirPressureSensor.UUID]: {
+        required: ['temperature'],
+        defaults: { humidity: 0, ppm: 0, voc: 0, pressure: 0 },
+        comment: 'temperature required; humidity, ppm, voc, pressure default to 0',
+      },
+      [this.hap.Service.Valve.UUID]: {
+        required: ['status', 'water', 'duration'],
+        comment: 'status => 0 = valve closed, 1 = open; includes water (L) and duration (s)',
+      },
+      [this.hap.Characteristic.WaterLevel.UUID]: {
+        required: ['level'],
+        comment: 'level => water level percentage (0–100)',
+      },
+      [this.hap.Service.LeakSensor.UUID]: {
+        required: ['status'],
+        comment: 'status => 0 = no leak, 1 = leak detected',
+      },
+      [this.hap.Service.Outlet.UUID]: {
+        required: ['status', 'volts', 'watts', 'amps'],
+        comment: 'status => 0 = off, 1 = on; includes volts, watts, amps',
+      },
+      [this.hap.Service.Doorbell.UUID]: {
+        required: ['status'],
+        comment: 'status => 0 = not pressed, 1 = pressed',
+      },
+      [this.hap.Service.SmokeSensor.UUID]: {
+        required: ['status'],
+        comment: 'status => 0 = smoke cleared, 1 = smoke detected',
+      },
+    };
+
+    // Lookup metadata for this target UUID (service or characteristic)
+    let meta = SERVICE_HISTORY_META[target.UUID];
+    if (typeof meta !== 'object') {
+      return;
     }
-    if (typeof timegap === 'undefined') {
-      timegap = 0; // Zero minimum time gap between entries
+
+    // Set restart flag if applicable
+    if (isNaN(this.restart) === false && typeof entry?.restart === 'undefined') {
+      entry.restart = this.restart;
+      this.restart = undefined;
     }
-    switch (service.UUID) {
-      case this.hap.Service.GarageDoorOpener.UUID: {
-        // Garage door history
-        // entry.time => unix time in seconds
-        // entry.status => 0 = closed, 1 = open
-        historyEntry.status = entry.status;
-        if (typeof entry.restart !== 'undefined') {
-          historyEntry.restart = entry.restart;
-        }
-        this.#addEntry(service.UUID, service.subtype, entry.time, timegap, historyEntry);
-        break;
-      }
 
-      case this.hap.Service.MotionSensor.UUID: {
-        // Motion sensor history
-        // entry.time => unix time in seconds
-        // entry.status => 0 = motion cleared, 1 = motion detected
-        historyEntry.status = entry.status;
-        if (typeof entry.restart !== 'undefined') {
-          historyEntry.restart = entry.restart;
-        }
-        this.#addEntry(service.UUID, service.subtype, entry.time, timegap, historyEntry);
-        break;
-      }
+    // Ensure time is set
+    if (isNaN(entry?.time) === true) {
+      entry.time = Math.floor(Date.now() / 1000);
+    }
 
-      case this.hap.Service.Window.UUID:
-      case this.hap.Service.WindowCovering.UUID: {
-        // Window and Window Covering history
-        // entry.time => unix time in seconds
-        // entry.status => 0 = closed, 1 = open
-        // entry.position => position in % 0% = closed 100% fully open
-        historyEntry.status = entry.status;
-        historyEntry.position = entry.position;
-        if (typeof entry.restart !== 'undefined') {
-          historyEntry.restart = entry.restart;
-        }
-        this.#addEntry(service.UUID, service.subtype, entry.time, timegap, historyEntry);
-        break;
-      }
+    // Provide default subtype if missing
+    if (typeof target.subtype === 'undefined') {
+      target.subtype = 0;
+    }
 
-      case this.hap.Service.HeaterCooler.UUID:
-      case this.hap.Service.Thermostat.UUID: {
-        // Thermostat and Heater/Cooler history
-        // entry.time => unix time in seconds
-        // entry.status => 0 = off, 1 = fan, 2 = heating, 3 = cooling, 4 = dehumidifying
-        // entry.temperature  => current temperature in degress C
-        // entry.target => {low, high} = cooling limit, heating limit
-        // entry.humidity => current humidity
-        historyEntry.status = entry.status;
-        historyEntry.temperature = entry.temperature;
-        historyEntry.target = entry.target;
-        historyEntry.humidity = entry.humidity;
-        if (typeof entry.restart !== 'undefined') {
-          historyEntry.restart = entry.restart;
-        }
-        this.#addEntry(service.UUID, service.subtype, entry.time, timegap, historyEntry);
-        break;
-      }
+    // Default timegap if invalid
+    if (isNaN(timegap) === true) {
+      timegap = 0;
+    }
 
-      case this.hap.Service.EveAirPressureSensor.UUID:
-      case this.hap.Service.AirQualitySensor.UUID:
-      case this.hap.Service.TemperatureSensor.UUID: {
-        // Temperature sensor history
-        // entry.time => unix time in seconds
-        // entry.temperature => current temperature in degress C
-        // entry.humidity => current humidity
-        // optional (entry.ppm)
-        // optional (entry.voc => current VOC measurement in ppb)\
-        // optional (entry.pressure -> in hpa)
-        historyEntry.temperature = entry.temperature;
-        if (typeof entry.humidity === 'undefined') {
-          // fill out humidity if missing
-          entry.humidity = 0;
-        }
-        if (typeof entry.ppm === 'undefined') {
-          // fill out ppm if missing
-          entry.ppm = 0;
-        }
-        if (typeof entry.voc === 'undefined') {
-          // fill out voc if missing
-          entry.voc = 0;
-        }
-        if (typeof entry.pressure === 'undefined') {
-          // fill out pressure if missing
-          entry.pressure = 0;
-        }
-        historyEntry.temperature = entry.temperature;
-        historyEntry.humidity = entry.humidity;
-        historyEntry.ppm = entry.ppm;
-        historyEntry.voc = entry.voc;
-        historyEntry.pressure = entry.pressure;
-        if (typeof entry.restart !== 'undefined') {
-          historyEntry.restart = entry.restart;
-        }
-        this.#addEntry(service.UUID, service.subtype, entry.time, timegap, historyEntry);
-        break;
+    // Validate required keys exist on entry
+    let required = [].concat(meta.required || []);
+    for (let i = 0; i < required.length; i++) {
+      if (typeof entry[required[i]] === 'undefined') {
+        return;
       }
+    }
 
-      case this.hap.Service.Valve.UUID: {
-        // Water valve history
-        // entry.time => unix time in seconds
-        // entry.status => 0 = valve closed, 1 = valve opened
-        // entry.water => amount of water in L's
-        // entry.duration => time for water amount
-        historyEntry.status = entry.status;
-        historyEntry.water = entry.water;
-        historyEntry.duration = entry.duration;
-        if (typeof entry.restart !== 'undefined') {
-          historyEntry.restart = entry.restart;
+    // Fill in default values if specified
+    if (typeof meta.defaults === 'object') {
+      let defaults = meta.defaults;
+      for (let key in defaults) {
+        if (typeof entry[key] === 'undefined') {
+          entry[key] = defaults[key];
         }
-        this.#addEntry(service.UUID, service.subtype, entry.time, timegap, historyEntry);
-        break;
       }
+    }
 
-      case this.hap.Characteristic.WaterLevel.UUID: {
-        // Water level history
-        // entry.time => unix time in seconds
-        // entry.level => water level as percentage
-        historyEntry.level = entry.level;
-        if (typeof entry.restart !== 'undefined') {
-          historyEntry.restart = entry.restart;
+    // Compose list of keys to include in history entry (required + defaults)
+    let keys = [].concat(required);
+    if (typeof meta.defaults === 'object') {
+      for (let key in meta.defaults) {
+        if (keys.indexOf(key) === -1) {
+          keys.push(key);
         }
-        this.#addEntry(service.UUID, 0, entry.time, timegap, historyEntry); // Characteristics don't have sub type, so we'll use 0 for it
-        break;
       }
+    }
 
-      case this.hap.Service.LeakSensor.UUID: {
-        // Leak sensor history
-        // entry.time => unix time in seconds
-        // entry.status => 0 = no leak, 1 = leak
-        historyEntry.status = entry.status;
-        if (typeof entry.restart !== 'undefined') {
-          historyEntry.restart = entry.restart;
-        }
-        this.#addEntry(service.UUID, 0, entry.time, timegap, historyEntry); // Characteristics don't have sub type, so we'll use 0 for it
-        break;
+    // Build the filtered history entry
+    let historyEntry = {};
+    for (let i = 0; i < keys.length; i++) {
+      let key = keys[i];
+      if (typeof entry[key] !== 'undefined') {
+        historyEntry[key] = entry[key];
       }
+    }
 
-      case this.hap.Service.Outlet.UUID: {
-        // Power outlet history
-        // entry.time => unix time in seconds
-        // entry.status => 0 = off, 1 = on
-        // entry.volts  => voltage in Vs
-        // entry.watts  => watts in W's
-        // entry.amps  => current in A's
-        historyEntry.status = entry.status;
-        historyEntry.volts = entry.volts;
-        historyEntry.watts = entry.watts;
-        historyEntry.amps = entry.amps;
-        if (typeof entry.restart !== 'undefined') {
-          historyEntry.restart = entry.restart;
-        }
-        this.#addEntry(service.UUID, service.subtype, entry.time, timegap, historyEntry);
-        break;
-      }
+    // Include restart if set
+    if (isNaN(entry?.restart) === false) {
+      historyEntry.restart = entry.restart;
+    }
 
-      case this.hap.Service.Doorbell.UUID: {
-        // Doorbell press history
-        // entry.time => unix time in seconds
-        // entry.status => 0 = not pressed, 1 = doorbell pressed
-        historyEntry.status = entry.status;
-        if (typeof entry.restart !== 'undefined') {
-          historyEntry.restart = entry.restart;
-        }
-        this.#addEntry(service.UUID, service.subtype, entry.time, timegap, historyEntry);
-        break;
-      }
+    // Use subtype 0 for characteristics like WaterLevel or LeakSensor, else service subtype
+    let subtype =
+      target.UUID === this.hap.Characteristic.WaterLevel.UUID || target.UUID === this.hap.Service.LeakSensor.UUID ? 0 : target.subtype;
 
-      case this.hap.Service.SmokeSensor.UUID: {
-        // Smoke sensor history
-        // entry.time => unix time in seconds
-        // entry.status => 0 = smoke cleared, 1 = smoke detected
-        historyEntry.status = entry.status;
-        if (typeof historyEntry.restart !== 'undefined') {
-          historyEntry.restart = entry.restart;
-        }
-        this.#addEntry(service.UUID, service.subtype, entry.time, timegap, historyEntry);
-        break;
-      }
-    }
+    // Call internal add entry handler
+    this.#addEntry(target.UUID, subtype, entry.time, timegap, historyEntry);
   }
 
   resetHistory() {
@@ -308,42 +292,41 @@ export default class HomeKitHistory {
     this.historyData.next = 0; // next entry for history is at start
     this.historyData.types = []; // no service types in history
     this.historyData.data = []; // no history data
-    this.storage.setItem(this.storageKey, this.historyData);
+    this.#persistStorage.setItem(this.#persistKey, this.historyData);
   }
 
   rolloverHistory() {
     // Roll history over and start from zero.
     // We'll include an entry as to when the rollover took place
     // remove all history data after the rollover entry
-    this.historyData.data.splice(this.maxEntries, this.historyData.data.length);
+    this.historyData.data.splice(this.#maxEntries, this.historyData.data.length);
     this.historyData.rollover = Math.floor(Date.now() / 1000);
     this.historyData.next = 0;
     this.#updateHistoryTypes();
-    this.storage.setItem(this.storageKey, this.historyData);
+    this.#persistStorage.setItem(this.#persistKey, this.historyData);
   }
 
   #addEntry(type, sub, time, timegap, entry) {
     let historyEntry = {};
     let recordEntry = true; // always record entry unless we don't need to
+
     historyEntry.time = time;
     historyEntry.type = type;
     historyEntry.sub = sub;
+
+    // Filter out reserved keys
     Object.entries(entry).forEach(([key, value]) => {
-      if (key !== 'time' || key !== 'type' || key !== 'sub') {
-        // Filer out events we want to control
+      if (key !== 'time' && key !== 'type' && key !== 'sub') {
         historyEntry[key] = value;
       }
     });
 
     // If we have a minimum time gap specified, find the last time entry for this type and if less than min gap, ignore
     if (timegap !== 0) {
-      let typeIndex = this.historyData.types.findIndex((type) => type.type === historyEntry.type && type.sub === historyEntry.sub);
-      if (
-        typeIndex >= 0 &&
-        time - this.historyData.data[this.historyData.types[typeIndex].lastEntry].time < timegap &&
-        typeof historyEntry.restart === 'undefined'
-      ) {
-        // time between last recorded entry and new entry is less than minimum gap and its not a 'restart' entry
+      let typeIndex = this.historyData.types.findIndex((t) => t.type === type && t.sub === sub);
+      let entryTime = this.historyData.data?.[this.historyData.types?.[typeIndex]?.lastEntry]?.time;
+      if (typeIndex >= 0 && typeof entryTime === 'number' && time - entryTime < timegap && typeof historyEntry.restart === 'undefined') {
+        // time between last recorded entry and new entry is less than minimum gap and it's not a 'restart' entry
         // so don't log it
         recordEntry = false;
       }
@@ -351,34 +334,30 @@ export default class HomeKitHistory {
 
     if (recordEntry === true) {
       // Work out where this goes in the history data array
-      if (this.maxEntries !== 0 && this.historyData.next >= this.maxEntries) {
+      if (this.#maxEntries !== 0 && this.historyData.next >= this.#maxEntries) {
         // roll over history data as we've reached the defined max entry size
         this.rolloverHistory();
       }
-      this.historyData.data[this.historyData.next] = historyEntry;
+
+      let entryIndex = this.historyData.next;
+      this.historyData.data[entryIndex] = historyEntry;
       this.historyData.next++;
 
       // Update types we have in history. This will just be the main type and its latest location in history
-      let typeIndex = this.historyData.types.findIndex((type) => type.type === historyEntry.type && type.sub === historyEntry.sub);
+      let typeIndex = this.historyData.types.findIndex((t) => t.type === type && t.sub === sub);
       if (typeIndex === -1) {
-        this.historyData.types.push({
-          type: historyEntry.type,
-          sub: historyEntry.sub,
-          lastEntry: this.historyData.next - 1,
-        });
+        this.historyData.types.push({ type: type, sub: sub, lastEntry: entryIndex });
       } else {
-        this.historyData.types[typeIndex].lastEntry = this.historyData.next - 1;
+        this.historyData.types[typeIndex].lastEntry = entryIndex;
       }
 
       // Validate types last entries. Helps with rolled over data etc. If we cannot find the type anymore, remove from known types
-      this.historyData.types.forEach((typeEntry, index) => {
-        if (this.historyData.data[typeEntry.lastEntry].type !== typeEntry.type) {
-          // not found, so remove from known types
-          this.historyData.types.splice(index, 1);
-        }
+      this.historyData.types = this.historyData.types.filter((typeEntry) => {
+        return this.historyData.data[typeEntry?.lastEntry]?.type === typeEntry.type;
       });
 
-      this.storage.setItem(this.storageKey, this.historyData); // Save to persistent storage
+      // Save to persistent storage
+      this.#persistStorage.setItem(this.#persistKey, this.historyData);
     }
   }
 
@@ -497,7 +476,7 @@ export default class HomeKitHistory {
 
   // Overlay our history into EveHome. Can only have one service history exposed to EveHome (ATM... see if can work around)
   // Returns object created for our EveHome accessory if successfull
-  linkToEveHome(service, options) {
+  async linkToEveHome(service, options) {
     if (typeof service !== 'object' || typeof this?.EveHome?.service !== 'undefined') {
       return;
     }
@@ -510,7 +489,8 @@ export default class HomeKitHistory {
       case this.hap.Service.ContactSensor.UUID:
       case this.hap.Service.Door.UUID:
       case this.hap.Service.Window.UUID:
-      case this.hap.Service.GarageDoorOpener.UUID: {
+      case this.hap.Service.GarageDoorOpener.UUID:
+      case this.hap.Service.LockMechanism.UUID: {
         // treat these as EveHome Door
         // Inverse status used for all UUID types except this.hap.Service.ContactSensor.UUID
 
@@ -539,6 +519,7 @@ export default class HomeKitHistory {
           count: tempHistory.length,
           reftime: historyreftime,
           send: 0,
+          messages: typeof options?.messages === 'function' ? options.messages : undefined,
         };
 
         // Setup initial values and callbacks for charateristics we are using
@@ -587,6 +568,7 @@ export default class HomeKitHistory {
           count: tempHistory.length,
           reftime: historyreftime,
           send: 0,
+          messages: typeof options?.messages === 'function' ? options.messages : undefined,
         };
 
         //17      CurrentPosition
@@ -658,7 +640,7 @@ export default class HomeKitHistory {
               }
 
               default: {
-                this?.log?.debug && this.log.debug('Unknown Eve MotionBlinds command "%s" with data "%s"', command, data);
+                this?.log?.debug?.('Unknown Eve MotionBlinds command "%s" with data "%s"', command, data);
                 break;
               }
             }
@@ -702,6 +684,7 @@ export default class HomeKitHistory {
           count: tempHistory.length,
           reftime: historyreftime,
           send: 0,
+          messages: typeof options?.messages === 'function' ? options.messages : undefined,
         };
 
         // Need some internal storage to track Eve Thermo configuration from EveHome app
@@ -722,12 +705,12 @@ export default class HomeKitHistory {
           encodeEveData(util.format('2c %s be', numberToEveHexString(this.EveThermoPersist.firmware, 4))),
         ); // firmware version (build xxxx)));
 
-        service.updateCharacteristic(this.hap.Characteristic.EveProgramData, this.#EveThermoGetDetails(options.getcommand));
-        service.getCharacteristic(this.hap.Characteristic.EveProgramData).onGet(() => {
-          return this.#EveThermoGetDetails(options.getcommand);
+        service.updateCharacteristic(this.hap.Characteristic.EveProgramData, await this.#EveThermoGetDetails());
+        service.getCharacteristic(this.hap.Characteristic.EveProgramData).onGet(async () => {
+          return await this.#EveThermoGetDetails();
         });
 
-        service.getCharacteristic(this.hap.Characteristic.EveProgramCommand).onSet((value) => {
+        service.getCharacteristic(this.hap.Characteristic.EveProgramCommand).onSet(async (value) => {
           let programs = [];
           let processedData = {};
           let valHex = decodeEveData(value);
@@ -873,7 +856,7 @@ export default class HomeKitHistory {
                   }
                   programs.push({
                     id: programs.length + 1,
-                    days: DAYSOFWEEK[index2],
+                    days: DAYS_OF_WEEK[index2],
                     schedule: times,
                   });
                 }
@@ -908,15 +891,15 @@ export default class HomeKitHistory {
               }
 
               default: {
-                this?.log?.debug && this.log.debug('Unknown Eve Thermo command "%s"', command);
+                this?.log?.debug?.('Unknown Eve Thermo command "%s"', command);
                 break;
               }
             }
           }
 
-          // Send complete processed command data if configured to our callback
-          if (typeof options?.setcommand === 'function' && Object.keys(processedData).length !== 0) {
-            options.setcommand(processedData);
+          // Send complete processed command data via message router if defined
+          if (typeof this.EveHome?.messages === 'function' && Object.keys(processedData).length !== 0) {
+            await this.EveHome.messages(HomeKitHistory.SET, processedData);
           }
         });
         break;
@@ -942,6 +925,7 @@ export default class HomeKitHistory {
           count: tempHistory.length,
           reftime: historyreftime,
           send: 0,
+          messages: typeof options?.messages === 'function' ? options.messages : undefined,
         };
 
         service.updateCharacteristic(
@@ -983,6 +967,7 @@ export default class HomeKitHistory {
             count: tempHistory.length,
             reftime: historyreftime,
             send: 0,
+            messages: typeof options?.messages === 'function' ? options.messages : undefined,
           };
 
           service.updateCharacteristic(
@@ -1007,6 +992,7 @@ export default class HomeKitHistory {
             count: tempHistory.length,
             reftime: historyreftime,
             send: 0,
+            messages: typeof options?.messages === 'function' ? options.messages : undefined,
           };
 
           service.updateCharacteristic(
@@ -1053,6 +1039,7 @@ export default class HomeKitHistory {
           count: tempHistory.length,
           reftime: historyreftime,
           send: 0,
+          messages: typeof options?.messages === 'function' ? options.messages : undefined,
         };
 
         // Need some internal storage to track Eve Motion configuration from EveHome app
@@ -1121,7 +1108,7 @@ export default class HomeKitHistory {
                             }
 
                             default : {
-                                this?.log?.debug && this.log.debug('Unknown Eve Motion command "%s" with data "%s"', command, data);
+                                this?.log?.debug?.('Unknown Eve Motion command "%s" with data "%s"', command, data);
                                 break;
                             }
                         }
@@ -1159,6 +1146,7 @@ export default class HomeKitHistory {
           count: tempHistory.length,
           reftime: historyreftime,
           send: 0,
+          messages: typeof options?.messages === 'function' ? options.messages : undefined,
         };
 
         // TODO = work out what the 'signatures' need to be for an Eve Smoke
@@ -1179,21 +1167,21 @@ export default class HomeKitHistory {
         // Setup initial values and callbacks for charateristics we are using
         service.updateCharacteristic(
           this.hap.Characteristic.EveDeviceStatus,
-          this.#EveSmokeGetDetails(options.getcommand, this.hap.Characteristic.EveDeviceStatus),
+          await this.#EveSmokeGetDetails(this.hap.Characteristic.EveDeviceStatus),
         );
-        service.getCharacteristic(this.hap.Characteristic.EveDeviceStatus).onGet(() => {
-          return this.#EveSmokeGetDetails(options.getcommand, this.hap.Characteristic.EveDeviceStatus);
+        service.getCharacteristic(this.hap.Characteristic.EveDeviceStatus).onGet(async () => {
+          return await this.#EveSmokeGetDetails(this.hap.Characteristic.EveDeviceStatus);
         });
 
         service.updateCharacteristic(
           this.hap.Characteristic.EveGetConfiguration,
-          this.#EveSmokeGetDetails(options.getcommand, this.hap.Characteristic.EveGetConfiguration),
+          await this.#EveSmokeGetDetails(this.hap.Characteristic.EveGetConfiguration),
         );
-        service.getCharacteristic(this.hap.Characteristic.EveGetConfiguration).onGet(() => {
-          return this.#EveSmokeGetDetails(options.getcommand, this.hap.Characteristic.EveGetConfiguration);
+        service.getCharacteristic(this.hap.Characteristic.EveGetConfiguration).onGet(async () => {
+          return await this.#EveSmokeGetDetails(this.hap.Characteristic.EveGetConfiguration);
         });
 
-        service.getCharacteristic(this.hap.Characteristic.EveSetConfiguration).onSet((value) => {
+        service.getCharacteristic(this.hap.Characteristic.EveSetConfiguration).onSet(async (value) => {
           // Loop through set commands passed to us
           let processedData = {};
           let valHex = decodeEveData(value);
@@ -1218,22 +1206,22 @@ export default class HomeKitHistory {
                   processedData.statusled = this.EveSmokePersist.statusled;
                 }
                 if (subCommand !== 0x02 && subCommand !== 0x05) {
-                  this?.log?.debug && this.log.debug('Unknown Eve Smoke command "%s" with data "%s"', command, data);
+                  this?.log?.debug?.('Unknown Eve Smoke command "%s" with data "%s"', command, data);
                 }
                 break;
               }
 
               default: {
-                this?.log?.debug && this.log.debug('Unknown Eve Smoke command "%s" with data "%s"', command, data);
+                this?.log?.debug?.('Unknown Eve Smoke command "%s" with data "%s"', command, data);
                 break;
               }
             }
             index += 4 + size; // Move to next command accounting for header size of 4 bytes
           }
 
-          // Send complete processed command data if configured to our callback
-          if (typeof options?.setcommand === 'function' && Object.keys(processedData).length !== 0) {
-            options.setcommand(processedData);
+          // Send complete processed command data via message router if defined
+          if (typeof this.EveHome?.messages === 'function' && Object.keys(processedData).length !== 0) {
+            await this.EveHome.messages(HomeKitHistory.SET, processedData);
           }
         });
         break;
@@ -1274,6 +1262,7 @@ export default class HomeKitHistory {
           count: tempHistory.length,
           reftime: historyreftime,
           send: 0,
+          messages: typeof options?.messages === 'function' ? options.messages : undefined,
         };
 
         // Need some internal storage to track Eve Aqua configuration from EveHome app
@@ -1289,12 +1278,12 @@ export default class HomeKitHistory {
         };
 
         // Setup initial values and callbacks for charateristics we are using
-        service.updateCharacteristic(this.hap.Characteristic.EveGetConfiguration, this.#EveAquaGetDetails(options.getcommand));
-        service.getCharacteristic(this.hap.Characteristic.EveGetConfiguration).onGet(() => {
-          return this.#EveAquaGetDetails(options.getcommand);
+        service.updateCharacteristic(this.hap.Characteristic.EveGetConfiguration, await this.#EveAquaGetDetails());
+        service.getCharacteristic(this.hap.Characteristic.EveGetConfiguration).onGet(async () => {
+          return this.#EveAquaGetDetails();
         });
 
-        service.getCharacteristic(this.hap.Characteristic.EveSetConfiguration).onSet((value) => {
+        service.getCharacteristic(this.hap.Characteristic.EveSetConfiguration).onSet(async (value) => {
           // Loop through set commands passed to us
           let programs = [];
           let processedData = {};
@@ -1460,9 +1449,9 @@ export default class HomeKitHistory {
                 //let unknown = EveHexStringToNumber(data.substr(0, 6));   // Unknown data for first 6 bytes
                 let daysbitmask = EveHexStringToNumber(data.substr(8, 6)) >>> 4;
                 programs.forEach((program) => {
-                  for (let index2 = 0; index2 < DAYSOFWEEK.length; index2++) {
+                  for (let index2 = 0; index2 < DAYS_OF_WEEK.length; index2++) {
                     if (((daysbitmask >>> (index2 * 3)) & 0x7) === program.id) {
-                      program.days.push(DAYSOFWEEK[index2]);
+                      program.days.push(DAYS_OF_WEEK[index2]);
                     }
                   }
                 });
@@ -1498,16 +1487,16 @@ export default class HomeKitHistory {
               }
 
               default: {
-                this?.log?.debug && this.log.debug('Unknown Eve Aqua command "%s" with data "%s"', command, data);
+                this?.log?.debug?.('Unknown Eve Aqua command "%s" with data "%s"', command, data);
                 break;
               }
             }
             index += 4 + size; // Move to next command accounting for header size of 4 bytes
           }
 
-          // Send complete processed command data if configured to our callback
-          if (typeof options?.setcommand === 'function' && Object.keys(processedData).length !== 0) {
-            options.setcommand(processedData);
+          // Send complete processed command data via message router if defined
+          if (typeof this.EveHome?.messages === 'function' && Object.keys(processedData).length !== 0) {
+            await this.EveHome.messages(HomeKitHistory.SET, processedData);
           }
         });
         break;
@@ -1544,6 +1533,7 @@ export default class HomeKitHistory {
           count: tempHistory.length,
           reftime: historyreftime,
           send: 0,
+          messages: typeof options?.messages === 'function' ? options.messages : undefined,
         };
 
         // Setup initial values and callbacks for charateristics we are using
@@ -1554,26 +1544,26 @@ export default class HomeKitHistory {
 
         service.updateCharacteristic(
           this.hap.Characteristic.EveElectricalCurrent,
-          this.#EveEnergyGetDetails(options.getcommand, this.hap.Characteristic.EveElectricalCurrent),
+          await this.#EveEnergyGetDetails(this.hap.Characteristic.EveElectricalCurrent),
         );
-        service.getCharacteristic(this.hap.Characteristic.EveElectricalCurrent).onGet(() => {
-          return this.#EveEnergyGetDetails(options.getcommand, this.hap.Characteristic.EveElectricalCurrent);
+        service.getCharacteristic(this.hap.Characteristic.EveElectricalCurrent).onGet(async () => {
+          return await this.#EveEnergyGetDetails(this.hap.Characteristic.EveElectricalCurrent);
         });
 
         service.updateCharacteristic(
           this.hap.Characteristic.EveElectricalVoltage,
-          this.#EveEnergyGetDetails(options.getcommand, this.hap.Characteristic.EveElectricalVoltage),
+          await this.#EveEnergyGetDetails(this.hap.Characteristic.EveElectricalVoltage),
         );
-        service.getCharacteristic(this.hap.Characteristic.EveElectricalVoltage).onGet(() => {
-          return this.#EveEnergyGetDetails(options.getcommand, this.hap.Characteristic.EveElectricalVoltage);
+        service.getCharacteristic(this.hap.Characteristic.EveElectricalVoltage).onGet(async () => {
+          return await this.#EveEnergyGetDetails(this.hap.Characteristic.EveElectricalVoltage);
         });
 
         service.updateCharacteristic(
           this.hap.Characteristic.EveElectricalWattage,
-          this.#EveEnergyGetDetails(options.getcommand, this.hap.Characteristic.EveElectricalWattage),
+          await this.#EveEnergyGetDetails(this.hap.Characteristic.EveElectricalWattage),
         );
-        service.getCharacteristic(this.hap.Characteristic.EveElectricalWattage).onGet(() => {
-          return this.#EveEnergyGetDetails(options.getcommand, this.hap.Characteristic.EveElectricalWattage);
+        service.getCharacteristic(this.hap.Characteristic.EveElectricalWattage).onGet(async () => {
+          return await this.#EveEnergyGetDetails(this.hap.Characteristic.EveElectricalWattage);
         });
         break;
       }
@@ -1607,6 +1597,7 @@ export default class HomeKitHistory {
           count: tempHistory.length,
           reftime: historyreftime,
           send: 0,
+          messages: typeof options?.messages === 'function' ? options.messages : undefined,
         };
 
         // Need some internal storage to track Eve Water Guard configuration from EveHome app
@@ -1617,9 +1608,9 @@ export default class HomeKitHistory {
         };
 
         // Setup initial values and callbacks for charateristics we are using
-        service.updateCharacteristic(this.hap.Characteristic.EveGetConfiguration, this.#EveWaterGuardGetDetails(options.getcommand));
-        service.getCharacteristic(this.hap.Characteristic.EveGetConfiguration).onGet(() => {
-          return this.#EveWaterGuardGetDetails(options.getcommand);
+        service.updateCharacteristic(this.hap.Characteristic.EveGetConfiguration, await this.#EveWaterGuardGetDetails());
+        service.getCharacteristic(this.hap.Characteristic.EveGetConfiguration).onGet(async () => {
+          return await this.#EveWaterGuardGetDetails();
         });
 
         service.getCharacteristic(this.hap.Characteristic.EveSetConfiguration).onSet((value) => {
@@ -1666,7 +1657,7 @@ export default class HomeKitHistory {
               }
 
               default: {
-                this?.log?.debug && this.log.debug('Unknown Eve Water Guard command "%s" with data "%s"', command, data);
+                this?.log?.debug?.('Unknown Eve Water Guard command "%s" with data "%s"', command, data);
                 break;
               }
             }
@@ -1700,8 +1691,8 @@ export default class HomeKitHistory {
     }
   }
 
-  updateEveHome(service, getcommand) {
-    if (typeof this?.EveHome?.service !== 'object' || typeof getcommand !== 'function') {
+  async updateEveHome(service) {
+    if (typeof this?.EveHome?.service !== 'object') {
       return;
     }
 
@@ -1709,39 +1700,39 @@ export default class HomeKitHistory {
       case this.hap.Service.SmokeSensor.UUID: {
         service.updateCharacteristic(
           this.hap.Characteristic.EveDeviceStatus,
-          this.#EveSmokeGetDetails(getcommand, this.hap.Characteristic.EveDeviceStatus),
+          await this.#EveSmokeGetDetails(this.hap.Characteristic.EveDeviceStatus),
         );
         service.updateCharacteristic(
           this.hap.Characteristic.EveGetConfiguration,
-          this.#EveSmokeGetDetails(getcommand, this.hap.Characteristic.EveGetConfiguration),
+          await this.#EveSmokeGetDetails(this.hap.Characteristic.EveGetConfiguration),
         );
         break;
       }
 
       case this.hap.Service.HeaterCooler.UUID:
       case this.hap.Service.Thermostat.UUID: {
-        service.updateCharacteristic(this.hap.Characteristic.EveProgramCommand, this.#EveThermoGetDetails(getcommand));
+        service.updateCharacteristic(this.hap.Characteristic.EveProgramData, await this.#EveThermoGetDetails());
         break;
       }
 
       case this.hap.Service.Valve.UUID:
       case this.hap.Service.IrrigationSystem.UUID: {
-        service.updateCharacteristic(this.hap.Characteristic.EveGetConfiguration, this.#EveAquaGetDetails(getcommand));
+        service.updateCharacteristic(this.hap.Characteristic.EveGetConfiguration, await this.#EveAquaGetDetails());
         break;
       }
 
       case this.hap.Service.Outlet.UUID: {
         service.updateCharacteristic(
           this.hap.Characteristic.EveElectricalWattage,
-          this.#EveEnergyGetDetails(getcommand, this.hap.Characteristic.EveElectricalWattage),
+          await this.#EveEnergyGetDetails(this.hap.Characteristic.EveElectricalWattage),
         );
         service.updateCharacteristic(
           this.hap.Characteristic.EveElectricalVoltage,
-          this.#EveEnergyGetDetails(getcommand, this.hap.Characteristic.EveElectricalVoltage),
+          await this.#EveEnergyGetDetails(this.hap.Characteristic.EveElectricalVoltage),
         );
         service.updateCharacteristic(
           this.hap.Characteristic.EveElectricalCurrent,
-          this.#EveEnergyGetDetails(getcommand, this.hap.Characteristic.EveElectricalCurrent),
+          await this.#EveEnergyGetDetails(this.hap.Characteristic.EveElectricalCurrent),
         );
         break;
       }
@@ -1758,7 +1749,7 @@ export default class HomeKitHistory {
     return lastTime;
   }
 
-  #EveThermoGetDetails(getOptions) {
+  async #EveThermoGetDetails() {
     // returns an encoded value formatted for an Eve Thermo device
     //
     // TODO - before enabling below need to workout:
@@ -1786,9 +1777,12 @@ export default class HomeKitHistory {
     // fc - date/time (mmhhDDMMYY)
     // 1a - default day program??
 
-    if (typeof getOptions === 'function') {
-      // Fill in details we might want to be dynamic
-      this.EveThermoPersist = getOptions(this.EveThermoPersist);
+    // If a message router exists, call it to potentially update our persisted state
+    if (typeof this.EveHome?.messages === 'function') {
+      let updated = await this.EveHome.messages(HomeKitHistory.GET, this.EveThermoPersist);
+      if (typeof updated === 'object') {
+        this.EveThermoPersist = updated;
+      }
     }
 
     // Encode current date/time
@@ -1801,8 +1795,7 @@ export default class HomeKitHistory {
     // Encode program schedule and temperatures
     // f4 = temps
     // fa = schedule
-    const EMPTYSCHEDULE = 'ffffffffffffffff';
-    let encodedSchedule = [EMPTYSCHEDULE, EMPTYSCHEDULE, EMPTYSCHEDULE, EMPTYSCHEDULE, EMPTYSCHEDULE, EMPTYSCHEDULE, EMPTYSCHEDULE];
+    let encodedSchedule = [EMPTY_SCHEDULE, EMPTY_SCHEDULE, EMPTY_SCHEDULE, EMPTY_SCHEDULE, EMPTY_SCHEDULE, EMPTY_SCHEDULE, EMPTY_SCHEDULE];
     let encodedTemperatures = '0000';
     if (typeof this.EveThermoPersist.programs === 'object') {
       let tempTemperatures = [];
@@ -1815,8 +1808,8 @@ export default class HomeKitHistory {
             numberToEveHexString(Math.round((time.start + time.duration) / 600), 2);
           tempTemperatures.push(time.ecotemp, time.comforttemp);
         });
-        encodedSchedule[DAYSOFWEEK.indexOf(days.days.toLowerCase())] =
-          temp.substring(0, EMPTYSCHEDULE.length) + EMPTYSCHEDULE.substring(temp.length, EMPTYSCHEDULE.length);
+        encodedSchedule[DAYS_OF_WEEK.indexOf(days.days.toLowerCase())] =
+          temp.substring(0, EMPTY_SCHEDULE.length) + EMPTY_SCHEDULE.substring(temp.length, EMPTY_SCHEDULE.length);
       });
       let ecoTemp = tempTemperatures.length === 0 ? 0 : Math.min(...tempTemperatures);
       let comfortTemp = tempTemperatures.length === 0 ? 0 : Math.max(...tempTemperatures);
@@ -1842,11 +1835,15 @@ export default class HomeKitHistory {
     return encodeEveData(value);
   }
 
-  #EveAquaGetDetails(getOptions) {
+  async #EveAquaGetDetails() {
     // returns an encoded value formatted for an Eve Aqua device for water usage and last water time
-    if (typeof getOptions === 'function') {
-      // Fill in details we might want to be dynamic
-      this.EveAquaPersist = getOptions(this.EveAquaPersist);
+
+    // If a message router exists, call it to potentially update our persisted state
+    if (typeof this.EveHome?.messages === 'function') {
+      let updated = await this.EveHome.messages(HomeKitHistory.GET, this.EveAquaPersist);
+      if (typeof updated === 'object') {
+        this.EveAquaPersist = updated;
+      }
     }
 
     if (Array.isArray(this.EveAquaPersist.programs) === false) {
@@ -1868,7 +1865,7 @@ export default class HomeKitHistory {
     // Encode program schedule
     // 45 = schedules
     // 46 = days of weeks for schedule;
-    const EMPTYSCHEDULE = '0800';
+    const EMPTY_SCHEDULE = '0800';
     let encodedSchedule = '';
     let daysbitmask = 0;
     let temp45Command = '';
@@ -1915,12 +1912,12 @@ export default class HomeKitHistory {
       // Program ID is set in 3bit repeating sections
       // sunsatfrithuwedtuemon
       program.days.forEach((day) => {
-        daysbitmask = daysbitmask + (program.id << (DAYSOFWEEK.indexOf(day) * 3));
+        daysbitmask = daysbitmask + (program.id << (DAYS_OF_WEEK.indexOf(day) * 3));
       });
     });
 
     // Build the encoded schedules command to send back to Eve
-    temp45Command = '05' + numberToEveHexString(this.EveAquaPersist.programs.length + 1, 2) + '000000' + EMPTYSCHEDULE + encodedSchedule;
+    temp45Command = '05' + numberToEveHexString(this.EveAquaPersist.programs.length + 1, 2) + '000000' + EMPTY_SCHEDULE + encodedSchedule;
     temp45Command = '45' + numberToEveHexString(temp45Command.length / 2, 2) + temp45Command;
 
     // Build the encoded days command to send back to Eve
@@ -1948,13 +1945,16 @@ export default class HomeKitHistory {
     return encodeEveData(value);
   }
 
-  #EveEnergyGetDetails(getOptions, returnForCharacteristic) {
+  async #EveEnergyGetDetails(returnForCharacteristic) {
     let energyDetails = {};
     let returnValue = null;
 
-    if (typeof getOptions === 'function') {
-      // Fill in details we might want to be dynamic
-      energyDetails = getOptions(energyDetails);
+    // If a message router exists, call it to potentially update our persisted state
+    if (typeof this.EveHome?.messages === 'function') {
+      let updated = await this.EveHome.messages(HomeKitHistory.GET, energyDetails);
+      if (typeof updated === 'object') {
+        energyDetails = updated;
+      }
     }
 
     if (returnForCharacteristic.UUID === this.hap.Characteristic.EveElectricalWattage.UUID && typeof energyDetails?.watts === 'number') {
@@ -1970,13 +1970,16 @@ export default class HomeKitHistory {
     return returnValue;
   }
 
-  #EveSmokeGetDetails(getOptions, returnForCharacteristic) {
+  async #EveSmokeGetDetails(returnForCharacteristic) {
     // returns an encoded value formatted for an Eve Smoke device
     let returnValue = null;
 
-    if (typeof getOptions === 'function') {
-      // Fill in details we might want to be dynamic
-      this.EveSmokePersist = getOptions(this.EveSmokePersist);
+    // If a message router exists, call it to potentially update our persisted state
+    if (typeof this.EveHome?.messages === 'function') {
+      let updated = await this.EveHome.messages(HomeKitHistory.GET, this.EveSmokePersist);
+      if (typeof updated === 'object') {
+        this.EveSmokePersist = updated;
+      }
     }
 
     if (returnForCharacteristic.UUID === this.hap.Characteristic.EveGetConfiguration.UUID) {
@@ -2036,11 +2039,15 @@ export default class HomeKitHistory {
     return returnValue;
   }
 
-  #EveWaterGuardGetDetails(getOptions) {
+  async #EveWaterGuardGetDetails() {
     // returns an encoded value formatted for an Eve Water Guard
-    if (typeof getOptions === 'function') {
-      // Fill in details we might want to be dynamic
-      this.EveWaterGuardPersist = getOptions(this.EveWaterGuardPersist);
+
+    // If a message router exists, call it to potentially update our persisted state
+    if (typeof this.EveHome?.messages === 'function') {
+      let updated = await this.EveHome.messages(HomeKitHistory.GET, this.EveWaterGuardPersist);
+      if (typeof updated === 'object') {
+        this.EveWaterGuardPersist = updated;
+      }
     }
 
     let value = util.format(
@@ -2067,7 +2074,7 @@ export default class HomeKitHistory {
       numberToEveHexString(this.EveHome.fields.trim().match(/\S*[0-9]\S*/g).length, 2), // Calclate number of fields we have
       this.EveHome.fields.trim(), // Fields listed in string. Each field is seperated by spaces
       numberToEveHexString(this.EveHome.count, 4), // count of entries
-      numberToEveHexString(this.maxEntries === 0 ? MAX_HISTORY_SIZE : this.maxEntries, 4), // history max size
+      numberToEveHexString(this.#maxEntries === 0 ? MAX_HISTORY_SIZE : this.#maxEntries, 4), // history max size
       numberToEveHexString(1, 8),
     ); // first entry
 
@@ -2240,7 +2247,7 @@ export default class HomeKitHistory {
                 numberToEveHexString(historyEntry.temperature * 100, 4), // temperature
                 numberToEveHexString(historyEntry.humidity * 100, 4), // Humidity
                 numberToEveHexString(tempTarget * 100, 4), // target temperature for heating
-                numberToEveHexString(historyEntry.status === 2 ? 100 : historyEntry.status === 3 ? 50 : 0, 2), // 0% = off, 50% = cooling, 100% = heating
+                numberToEveHexString(historyEntry.status === 2 ? 100 : 0, 2), // 0% = off, 100% = heating
                 numberToEveHexString(0, 2), // Thermo target
                 numberToEveHexString(0, 2), // Window open status 0 = closed, 1 = open
               );
@@ -2306,29 +2313,38 @@ export default class HomeKitHistory {
       this.EveHome.entry = 1; // requested to restart from beginning of history for sending to EveHome
     }
     this.EveHome.send = this.EveHome.count - this.EveHome.entry + 1; // Number of entries we're expected to send
-    this?.log?.debug && this.log.debug('#EveHistoryRequest: requested address', this.EveHome.entry);
+    this?.log?.debug?.('#EveHistoryRequest: requested address', this.EveHome.entry);
   }
 
   #EveSetTime(value) {
     // Time stamp from EveHome
     let timestamp = EPOCH_OFFSET + EveHexStringToNumber(decodeEveData(value));
 
-    this?.log?.debug && this.log.debug('#EveSetTime: timestamp offset', new Date(timestamp * 1000));
+    this?.log?.debug?.('#EveSetTime: timestamp offset', new Date(timestamp * 1000));
   }
 
   #createHistoryService(service, characteristics) {
-    // Setup the history service
+    if (
+      typeof this?.accessory?.getService !== 'function' ||
+      typeof this?.accessory?.addService !== 'function' ||
+      typeof service?.testCharacteristic !== 'function' ||
+      typeof service?.addCharacteristic !== 'function'
+    ) {
+      return;
+    }
+
     let historyService = this.accessory.getService(this.hap.Service.EveHomeHistory);
     if (historyService === undefined) {
       historyService = this.accessory.addService(this.hap.Service.EveHomeHistory, '', 1);
     }
 
-    // Add in any specified characteristics
-    characteristics.forEach((characteristic) => {
-      if (service.testCharacteristic(characteristic) === false) {
-        service.addCharacteristic(characteristic);
-      }
-    });
+    if (Array.isArray(characteristics) === true) {
+      characteristics.forEach((char) => {
+        if (service.testCharacteristic(char) === false) {
+          service.addCharacteristic(char);
+        }
+      });
+    }
 
     return historyService;
   }