homebridge-nest-accfactory 0.3.0 → 0.3.2

package/dist/plugins/lock.js

@@ -0,0 +1,309 @@
+// Nest x Yale Lock (initial class - protobuf support only)
+// Part of homebridge-nest-accfactory
+//
+// Mark Hulskamp
+'use strict';
+
+// Define our modules
+import HomeKitDevice from '../HomeKitDevice.js';
+import { processCommonData, scaleValue } from '../utils.js';
+
+// Define constants
+import { DATA_SOURCE, DEVICE_TYPE, PROTOBUF_RESOURCES, LOW_BATTERY_LEVEL } from '../consts.js';
+
+export default class NestLock extends HomeKitDevice {
+  static TYPE = 'Lock';
+  static VERSION = '2025.08.04'; // Code version
+
+  // Define lock bolt states
+  static STATE = {
+    JAMMED: 'jammed',
+    LOCKING: 'locking',
+    UNLOCKING: 'unlocking',
+    LOCKED: 'locked',
+    UNLOCKED: 'unlocked',
+    UNKNOWN: 'unknown',
+  };
+
+  static LAST_ACTION = {
+    PHYSICAL: 'physical',
+    KEYPAD: 'keypad',
+    REMOTE: 'remote',
+    IMPLICIT: 'implicit',
+    VOICE: 'voice',
+  };
+
+  lockService = undefined;
+  batteryService = undefined;
+
+  onAdd() {
+    // Setup lock service if not already present on the accessory and link it to the Eve app if configured to do so
+    this.lockService = this.addHKService(this.hap.Service.LockMechanism, '', 1, {});
+    this.lockService.setPrimaryService();
+
+    // Setup set characteristics
+    this.addHKCharacteristic(this.lockService, this.hap.Characteristic.LockCurrentState, {
+      onGet: () => {
+        return this.#currentState(this.deviceData);
+      },
+    });
+
+    this.addHKCharacteristic(this.lockService, this.hap.Characteristic.LockTargetState, {
+      onSet: (value) => {
+        let locked = value === this.hap.Characteristic.LockTargetState.SECURED;
+
+        this.message(HomeKitDevice.SET, {
+          uuid: this.deviceData.nest_google_uuid,
+          bolt_lock: locked,
+        });
+
+        this.lockService.updateCharacteristic(this.hap.Characteristic.LockTargetState, value);
+
+        this?.log?.info?.('Setting lock on "%s" to "%s"', this.deviceData.description, locked ? 'Locked' : 'Unlocked');
+      },
+      onGet: () => {
+        return this.#targetState(this.deviceData);
+      },
+    });
+
+    this.addHKCharacteristic(this.lockService, this.hap.Characteristic.LockManagementAutoSecurityTimeout, {
+      props: {
+        minValue: 0,
+        maxValue: this.deviceData.max_auto_relock_duration,
+      },
+      onSet: (value) => {
+        value = Math.floor(value); // Make a round number
+
+        if (value !== this.deviceData.auto_relock_duration) {
+          this.message(HomeKitDevice.SET, {
+            uuid: this.deviceData.nest_google_uuid,
+            auto_relock_duration: value,
+          });
+
+          this?.log?.info?.(
+            'Setting lock auto-relocking duration on "%s" to "%s"',
+            this.deviceData.description,
+            value !== 0 ? value + ' seconds' : 'Disabled',
+          );
+        }
+      },
+      onGet: () => {
+        return this.deviceData.auto_relock_duration;
+      },
+    });
+
+    this.addHKCharacteristic(this.lockService, this.hap.Characteristic.LockLastKnownAction, {
+      onGet: () => {
+        return this.#lastAction(this.deviceData);
+      },
+    });
+
+    this.addHKCharacteristic(this.lockService, this.hap.Characteristic.StatusTampered, {
+      onGet: () => {
+        return this.deviceData.tampered === true
+          ? this.hap.Characteristic.StatusTampered.TAMPERED
+          : this.hap.Characteristic.StatusTampered.NOT_TAMPERED;
+      },
+    });
+
+    // Setup battery service if not already present on the accessory
+    this.batteryService = this.addHKService(this.hap.Service.Battery, '', 1);
+    this.batteryService.setHiddenService(true);
+  }
+
+  onRemove() {
+    this.accessory.removeService(this.lockService);
+    this.accessory.removeService(this.batteryService);
+    this.lockService = undefined;
+    this.batteryService = undefined;
+  }
+
+  onUpdate(deviceData) {
+    if (typeof deviceData !== 'object') {
+      return;
+    }
+
+    // Update lock state
+    this.lockService.updateCharacteristic(this.hap.Characteristic.LockCurrentState, this.#currentState(deviceData));
+    this.lockService.updateCharacteristic(this.hap.Characteristic.LockTargetState, this.#targetState(deviceData));
+    this.lockService.updateCharacteristic(this.hap.Characteristic.LockLastKnownAction, this.#lastAction(deviceData));
+    this.lockService.updateCharacteristic(this.hap.Characteristic.LockManagementAutoSecurityTimeout, deviceData.auto_relock_duration);
+
+    // If device isn't online report in HomeKit
+    this.lockService.updateCharacteristic(
+      this.hap.Characteristic.StatusFault,
+      deviceData.online === true ? this.hap.Characteristic.StatusFault.NO_FAULT : this.hap.Characteristic.StatusFault.GENERAL_FAULT,
+    );
+
+    // Update battery level and status
+    this.batteryService.updateCharacteristic(this.hap.Characteristic.BatteryLevel, deviceData.battery_level);
+    this.batteryService.updateCharacteristic(
+      this.hap.Characteristic.StatusLowBattery,
+      deviceData.battery_level > LOW_BATTERY_LEVEL
+        ? this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL
+        : this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW,
+    );
+    this.batteryService.updateCharacteristic(this.hap.Characteristic.ChargingState, this.hap.Characteristic.ChargingState.NOT_CHARGEABLE);
+
+    // Update tampered state
+    this.lockService.updateCharacteristic(
+      this.hap.Characteristic.StatusTampered,
+      deviceData.tampered !== true ? this.hap.Characteristic.StatusTampered.NOT_TAMPERED : this.hap.Characteristic.StatusTampered.TAMPERED,
+    );
+
+    // Log lock status to history only if changed to previous recording
+    this.history(this.lockService, {
+      status: deviceData.bolt_state === NestLock.STATE.LOCKED ? 0 : 1, // 0 = locked, 1 = unlocked
+    });
+  }
+
+  #currentState(deviceData) {
+    return deviceData.bolt_state === NestLock.STATE.JAMMED
+      ? this.hap.Characteristic.LockCurrentState.JAMMED
+      : deviceData.bolt_state === NestLock.STATE.LOCKED
+        ? this.hap.Characteristic.LockCurrentState.SECURED
+        : deviceData.bolt_state === NestLock.STATE.UNLOCKED
+          ? this.hap.Characteristic.LockCurrentState.UNSECURED
+          : this.hap.Characteristic.LockCurrentState.UNKNOWN;
+  }
+
+  #targetState(deviceData) {
+    return deviceData.bolt_state === NestLock.STATE.LOCKED || deviceData.bolt_state === NestLock.STATE.LOCKING
+      ? this.hap.Characteristic.LockTargetState.SECURED
+      : this.hap.Characteristic.LockTargetState.UNSECURED;
+  }
+
+  #lastAction(deviceData) {
+    return deviceData.bolt_actor === NestLock.LAST_ACTION.PHYSICAL
+      ? deviceData.bolt_state === NestLock.STATE.LOCKED || deviceData.bolt_state === NestLock.STATE.LOCKING
+        ? this.hap.Characteristic.LockLastKnownAction.SECURED_PHYSICALLY
+        : this.hap.Characteristic.LockLastKnownAction.UNSECURED_PHYSICALLY
+      : deviceData.bolt_actor === NestLock.LAST_ACTION.KEYPAD
+        ? deviceData.bolt_state === NestLock.STATE.LOCKED || deviceData.bolt_state === NestLock.STATE.LOCKING
+          ? this.hap.Characteristic.LockLastKnownAction.SECURED_BY_KEYPAD
+          : this.hap.Characteristic.LockLastKnownAction.UNSECURED_BY_KEYPAD
+        : deviceData.bolt_actor === NestLock.LAST_ACTION.REMOTE || deviceData.LAST_ACTION === NestLock.LAST_ACTION.VOICE
+          ? deviceData.bolt_state === NestLock.STATE.LOCKED || deviceData.bolt_state === NestLock.STATE.LOCKING
+            ? this.hap.Characteristic.LockLastKnownAction.SECURED_REMOTELY
+            : this.hap.Characteristic.LockLastKnownAction.UNSECURED_REMOTELY
+          : this.hap.Characteristic.LockLastKnownAction.UNSECURED; // Fallback
+  }
+}
+
+// Function to process our RAW Nest or Google for this device type
+export function processRawData(log, rawData, config, deviceType = undefined) {
+  if (
+    rawData === null ||
+    typeof rawData !== 'object' ||
+    rawData?.constructor !== Object ||
+    typeof config !== 'object' ||
+    config?.constructor !== Object
+  ) {
+    return;
+  }
+
+  // Process data for any lock(s) we have in the raw data
+  let devices = {};
+  Object.entries(rawData)
+    .filter(
+      ([key, value]) => key.startsWith('DEVICE_') === true && PROTOBUF_RESOURCES.LOCK.includes(value.value?.device_info?.typeName) === true,
+    )
+    .forEach(([object_key, value]) => {
+      let tempDevice = {};
+      try {
+        if (
+          value?.source === DATA_SOURCE.GOOGLE &&
+          value.value?.configuration_done?.deviceReady === true &&
+          rawData?.[value.value?.device_info?.pairerId?.resourceId] !== undefined
+        ) {
+          tempDevice = processCommonData(
+            object_key,
+            {
+              type: DEVICE_TYPE.LOCK,
+              model: 'x Yale Lock',
+              softwareVersion: value.value.device_identity.softwareVersion,
+              serialNumber: value.value.device_identity.serialNumber,
+              description: String(value.value?.label?.label ?? ''),
+              location: String(
+                [
+                  ...Object.values(
+                    rawData?.[value.value?.device_info?.pairerId?.resourceId]?.value?.located_annotations?.predefinedWheres || {},
+                  ),
+                  ...Object.values(
+                    rawData?.[value.value?.device_info?.pairerId?.resourceId]?.value?.located_annotations?.customWheres || {},
+                  ),
+                ].find((where) => where?.whereId?.resourceId === value.value?.device_located_settings?.whereAnnotationRid?.resourceId)
+                  ?.label?.literal ?? '',
+              ),
+              online: value.value?.liveness?.status === 'LIVENESS_DEVICE_STATUS_ONLINE',
+              tampered: value.value?.tamper?.tamperState === 'TAMPER_STATE_TAMPERED',
+              bolt_state:
+                value.value?.bolt_lock?.actuatorState.startsWith('BOLT_ACTUATOR_STATE_JAMMED') === true
+                  ? NestLock.STATE.JAMMED
+                  : value.value?.bolt_lock?.actuatorState === 'BOLT_ACTUATOR_STATE_LOCKING'
+                    ? NestLock.STATE.LOCKING
+                    : value.value?.bolt_lock?.actuatorState === 'BOLT_ACTUATOR_STATE_UNLOCKING'
+                      ? NestLock.STATE.UNLOCKING
+                      : value.value?.bolt_lock?.lockedState === 'BOLT_LOCKED_STATE_LOCKED'
+                        ? NestLock.STATE.LOCKED
+                        : value.value?.bolt_lock?.lockedState === 'BOLT_LOCKED_STATE_UNLOCKED'
+                          ? NestLock.STATE.UNLOCKED
+                          : NestLock.STATE.UNKNOWN,
+              bolt_actor:
+                value.value?.bolt_lock?.boltLockActor?.method === 'BOLT_LOCK_ACTOR_METHOD_PHYSICAL'
+                  ? NestLock.LAST_ACTION.PHYSICAL
+                  : value.value?.bolt_lock?.boltLockActor?.method === 'BOLT_LOCK_ACTOR_METHOD_KEYPAD_PIN'
+                    ? NestLock.LAST_ACTION.KEYPAD
+                    : [
+                        'BOLT_LOCK_ACTOR_METHOD_REMOTE_USER_EXPLICIT',
+                        'BOLT_LOCK_ACTOR_METHOD_REMOTE_USER_IMPLICIT',
+                        'BOLT_LOCK_ACTOR_METHOD_REMOTE_USER_OTHER',
+                        'BOLT_LOCK_ACTOR_METHOD_REMOTE_DELEGATE',
+                      ].includes(value.value?.bolt_lock?.boltLockActor?.method) === true
+                        ? NestLock.LAST_ACTION.REMOTE
+                        : value.value?.bolt_lock?.boltLockActor?.method === 'BOLT_LOCK_ACTOR_METHOD_VOICE_ASSISTANT'
+                          ? NestLock.LAST_ACTION.VOICE
+                          : ['BOLT_LOCK_ACTOR_METHOD_LOCAL_IMPLICIT', 'BOLT_LOCK_ACTOR_METHOD_LOW_POWER_SHUTDOWN'].includes(
+                              value.value?.bolt_lock?.boltLockActor?.method,
+                            ) === true
+                              ? NestLock.LAST_ACTION.IMPLICIT
+                              : NestLock.LAST_ACTION.PHYSICAL,
+              battery_level:
+                isNaN(value.value?.battery_power_source?.remaining?.remainingPercent) === false
+                  ? scaleValue(Number(value.value?.battery_power_source?.remaining?.remainingPercent), 0, 1, 0, 100)
+                  : 0,
+              auto_relock_duration:
+                isNaN(value.value?.bolt_lock_settings?.autoRelockDuration?.seconds) === false
+                  ? Number(value.value.bolt_lock_settings.autoRelockDuration.seconds)
+                  : 0,
+              max_auto_relock_duration:
+                isNaN(value.value?.bolt_lock_capabilities?.maxAutoRelockDuration?.seconds) === false
+                  ? Number(value.value.bolt_lock_capabilities.maxAutoRelockDuration.seconds)
+                  : 300,
+            },
+            config,
+          );
+        }
+        // eslint-disable-next-line no-unused-vars
+      } catch (error) {
+        log?.debug?.('Error processing lock data for "%s"', object_key);
+      }
+
+      if (
+        Object.entries(tempDevice).length !== 0 &&
+        typeof devices[tempDevice.serialNumber] === 'undefined' &&
+        (deviceType === undefined || (typeof deviceType === 'string' && deviceType !== '' && tempDevice.type === deviceType))
+      ) {
+        let deviceOptions = config?.devices?.find(
+          (device) => device?.serialNumber?.toUpperCase?.() === tempDevice?.serialNumber?.toUpperCase?.(),
+        );
+
+        // Insert any extra options we've read in from configuration file for this device
+        tempDevice.eveHistory = config.options.eveHistory === true || deviceOptions?.eveHistory === true;
+
+        devices[tempDevice.serialNumber] = tempDevice; // Store processed device
+      }
+    });
+
+  return devices;
+}

package/dist/plugins/protect.js

@@ -6,26 +6,33 @@
 
 // Define our modules
 import HomeKitDevice from '../HomeKitDevice.js';
+import { processCommonData, scaleValue } from '../utils.js';
 
-const LOWBATTERYLEVEL = 10; // Low battery level percentage
+// Define constants
+import { LOW_BATTERY_LEVEL, DATA_SOURCE, PROTOBUF_RESOURCES, DEVICE_TYPE } from '../consts.js';
 
 export default class NestProtect extends HomeKitDevice {
   static TYPE = 'Protect';
-  static VERSION = '2025.06.11';
+  static VERSION = '2025.08.04'; // Code version
 
   batteryService = undefined;
   smokeService = undefined;
   motionService = undefined;
   carbonMonoxideService = undefined;
 
-  constructor(accessory, api, log, eventEmitter, deviceData) {
-    super(accessory, api, log, eventEmitter, deviceData);
-  }
-
   // Class functions
-  setupDevice() {
+  onAdd() {
     // Setup the smoke sensor service if not already present on the accessory
-    this.smokeService = this.addHKService(this.hap.Service.SmokeSensor, '', 1);
+    this.smokeService = this.addHKService(this.hap.Service.SmokeSensor, '', 1, {
+      messages: this.message.bind(this),
+      EveSmoke_lastalarmtest: this.deviceData.latest_alarm_test,
+      EveSmoke_alarmtest: this.deviceData.self_test_in_progress,
+      EveSmoke_heatstatus: this.deviceData.heat_status,
+      EveSmoke_hushedstate: this.deviceData.hushed_state,
+      Evesmoke_statusled: this.deviceData.ntp_green_led_enable,
+      EveSmoke_smoketestpassed: this.deviceData.smoke_test_passed,
+      EveSmoke_heattestpassed: this.deviceData.heat_test_passed,
+    });
     this.smokeService.setPrimaryService();
 
     this.addHKCharacteristic(this.smokeService, this.hap.Characteristic.StatusActive);
@@ -43,29 +50,20 @@ export default class NestProtect extends HomeKitDevice {
       this.motionService = this.addHKService(this.hap.Service.MotionSensor, '', 1);
       this.postSetupDetail('With motion sensor');
     }
+  }
 
-    // Setup linkage to EveHome app if configured todo so
-    if (
-      this.deviceData?.eveHistory === true &&
-      this.smokeService !== undefined &&
-      typeof this.historyService?.linkToEveHome === 'function'
-    ) {
-      this.historyService.linkToEveHome(this.smokeService, {
-        description: this.deviceData.description,
-        getcommand: this.#EveHomeGetcommand.bind(this),
-        setcommand: this.#EveHomeSetcommand.bind(this),
-        EveSmoke_lastalarmtest: this.deviceData.latest_alarm_test,
-        EveSmoke_alarmtest: this.deviceData.self_test_in_progress,
-        EveSmoke_heatstatus: this.deviceData.heat_status,
-        EveSmoke_hushedstate: this.deviceData.hushed_state,
-        Evesmoke_statusled: this.deviceData.ntp_green_led_enable,
-        EveSmoke_smoketestpassed: this.deviceData.smoke_test_passed,
-        EveSmoke_heattestpassed: this.deviceData.heat_test_passed,
-      });
-    }
+  onRemove() {
+    this.accessory.removeService(this.smokeService);
+    this.accessory.removeService(this.carbonMonoxideService);
+    this.accessory.removeService(this.batteryService);
+    this.accessory.removeService(this.motionService);
+    this.smokeService = undefined;
+    this.carbonMonoxideService = undefined;
+    this.batteryService = undefined;
+    this.motionService = undefined;
   }
 
-  updateDevice(deviceData) {
+  onUpdate(deviceData) {
     if (
       typeof deviceData !== 'object' ||
       this.smokeService === undefined ||
@@ -79,7 +77,7 @@ export default class NestProtect extends HomeKitDevice {
     this.batteryService.updateCharacteristic(this.hap.Characteristic.BatteryLevel, deviceData.battery_level);
     this.batteryService.updateCharacteristic(
       this.hap.Characteristic.StatusLowBattery,
-      deviceData.battery_level > LOWBATTERYLEVEL && deviceData.battery_health_state === 0
+      deviceData.battery_level > LOW_BATTERY_LEVEL && deviceData.battery_health_state === 0
         ? this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_NORMAL
         : this.hap.Characteristic.StatusLowBattery.BATTERY_LEVEL_LOW,
     );
@@ -148,56 +146,227 @@ export default class NestProtect extends HomeKitDevice {
       }
 
       // Log motion to history only if changed to previous recording
-      if (deviceData.detected_motion !== this.deviceData.detected_motion && typeof this.historyService?.addHistory === 'function') {
-        this.historyService.addHistory(this.motionService, {
-          time: Math.floor(Date.now() / 1000),
-          status: deviceData.detected_motion === true ? 1 : 0,
-        });
-      }
+      this.history(this.motionService, {
+        status: deviceData.detected_motion === true ? 1 : 0,
+      });
     }
 
-    // Notify Eve App of device status changes if linked
-    if (
-      this.deviceData.eveHistory === true &&
-      this.smokeService !== undefined &&
-      typeof this.historyService?.updateEveHome === 'function'
-    ) {
-      // Update our internal data with properties Eve will need to process
-      this.deviceData.latest_alarm_test = deviceData.latest_alarm_test;
-      this.deviceData.self_test_in_progress = deviceData.self_test_in_progress;
-      this.deviceData.heat_status = deviceData.heat_status;
-      this.deviceData.ntp_green_led_enable = deviceData.ntp_green_led_enable;
-      this.deviceData.smoke_test_passed = deviceData.smoke_test_passed;
-      this.deviceData.heat_test_passed = deviceData.heat_test_passed;
-      this.historyService.updateEveHome(this.smokeService, this.#EveHomeGetcommand.bind(this));
-    }
+    // Update our internal data with properties Eve will need to process then Notify Eve App of device status changes if linked
+    this.deviceData.latest_alarm_test = deviceData.latest_alarm_test;
+    this.deviceData.self_test_in_progress = deviceData.self_test_in_progress;
+    this.deviceData.heat_status = deviceData.heat_status;
+    this.deviceData.ntp_green_led_enable = deviceData.ntp_green_led_enable;
+    this.deviceData.smoke_test_passed = deviceData.smoke_test_passed;
+    this.deviceData.heat_test_passed = deviceData.heat_test_passed;
+    this.historyService?.updateEveHome?.(this.smokeService);
   }
 
-  #EveHomeGetcommand(EveHomeGetData) {
-    // Pass back extra data for Eve Smoke onGet() to process command
-    // Data will already be an object, our only job is to add/modify to it
-    if (typeof EveHomeGetData === 'object') {
-      EveHomeGetData.lastalarmtest = this.deviceData.latest_alarm_test;
-      EveHomeGetData.alarmtest = this.deviceData.self_test_in_progress;
-      EveHomeGetData.heatstatus = this.deviceData.heat_status;
-      EveHomeGetData.statusled = this.deviceData.ntp_green_led_enable;
-      EveHomeGetData.smoketestpassed = this.deviceData.smoke_test_passed;
-      EveHomeGetData.heattestpassed = this.deviceData.heat_test_passed;
-      EveHomeGetData.hushedstate = this.deviceData.hushed_state;
-    }
-    return EveHomeGetData;
-  }
-
-  #EveHomeSetcommand(EveHomeSetData) {
-    if (typeof EveHomeSetData !== 'object') {
+  onMessage(type, message) {
+    if (typeof type !== 'string' || type === '' || typeof message !== 'object' || message === '') {
       return;
     }
 
-    if (typeof EveHomeSetData?.alarmtest === 'boolean') {
-      //this?.log?.info?.('Eve Smoke Alarm test', (EveHomeSetData.alarmtest === true ? 'start' : 'stop'));
+    if (type === HomeKitDevice?.HISTORY?.GET) {
+      // Pass back extra data for Eve Smoke onGet() to process command
+      // Data will already be an object, our only job is to add/modify to it
+      message.lastalarmtest = this.deviceData.latest_alarm_test;
+      message.alarmtest = this.deviceData.self_test_in_progress;
+      message.heatstatus = this.deviceData.heat_status;
+      message.statusled = this.deviceData.ntp_green_led_enable;
+      message.smoketestpassed = this.deviceData.smoke_test_passed;
+      message.heattestpassed = this.deviceData.heat_test_passed;
+      message.hushedstate = this.deviceData.hushed_state;
+      return message;
     }
-    if (typeof EveHomeSetData?.statusled === 'boolean') {
-      this.set({ uuid: this.deviceData.nest_google_uuid, ntp_green_led_enable: EveHomeSetData.statusled });
+
+    if (type === HomeKitDevice?.HISTORY?.SET) {
+      if (typeof message?.alarmtest === 'boolean') {
+        // TODO - How do we trigger an alarm test :-)
+        //this?.log?.info?.('Eve Smoke Alarm test', (message.alarmtest === true ? 'start' : 'stop'));
+      }
+      if (typeof message?.statusled === 'boolean') {
+        this.message(HomeKitDevice.SET, { uuid: this.deviceData.nest_google_uuid, ntp_green_led_enable: message.statusled });
+      }
     }
   }
 }
+
+// Function to process our RAW Nest or Google for this device type
+export function processRawData(log, rawData, config, deviceType = undefined) {
+  if (
+    rawData === null ||
+    typeof rawData !== 'object' ||
+    rawData?.constructor !== Object ||
+    typeof config !== 'object' ||
+    config?.constructor !== Object
+  ) {
+    return;
+  }
+
+  // Process data for any smoke detectors we have in the raw data
+  let devices = {};
+  Object.entries(rawData)
+    .filter(
+      ([key, value]) =>
+        key.startsWith('topaz.') === true ||
+        (key.startsWith('DEVICE_') === true && PROTOBUF_RESOURCES.PROTECT.includes(value.value?.device_info?.typeName) === true),
+    )
+    .forEach(([object_key, value]) => {
+      let tempDevice = {};
+      try {
+        if (
+          value?.source === DATA_SOURCE.GOOGLE &&
+          value.value?.configuration_done?.deviceReady === true &&
+          rawData?.[value.value?.device_info?.pairerId?.resourceId] !== undefined
+        ) {
+          tempDevice = processCommonData(
+            object_key,
+            {
+              type: DEVICE_TYPE.PROTECT,
+              model:
+                value.value.device_info.typeName === 'nest.resource.NestProtect1LinePoweredResource'
+                  ? 'Protect (1st gen, wired)'
+                  : value.value.device_info.typeName === 'nest.resource.NestProtect1BatteryPoweredResource'
+                    ? 'Protect (1st gen, battery)'
+                    : value.value.device_info.typeName === 'nest.resource.NestProtect2LinePoweredResource'
+                      ? 'Protect (2nd gen, wired)'
+                      : value.value.device_info.typeName === 'nest.resource.NestProtect2BatteryPoweredResource'
+                        ? 'Protect (2nd gen, battery)'
+                        : 'Protect (unknown)',
+              softwareVersion: value.value.device_identity.softwareVersion,
+              serialNumber: value.value.device_identity.serialNumber,
+              description: String(value.value?.label?.label ?? ''),
+              location: String(
+                [
+                  ...Object.values(
+                    rawData?.[value.value?.device_info?.pairerId?.resourceId]?.value?.located_annotations?.predefinedWheres || {},
+                  ),
+                  ...Object.values(
+                    rawData?.[value.value?.device_info?.pairerId?.resourceId]?.value?.located_annotations?.customWheres || {},
+                  ),
+                ].find((where) => where?.whereId?.resourceId === value.value?.device_located_settings?.whereAnnotationRid?.resourceId)
+                  ?.label?.literal ?? '',
+              ),
+              online: value.value?.liveness?.status === 'LIVENESS_DEVICE_STATUS_ONLINE',
+              line_power_present: value.value?.wall_power?.status === 'POWER_SOURCE_STATUS_ACTIVE',
+              wired_or_battery: typeof value.value?.wall_power?.status === 'string' ? 0 : 1,
+              battery_level:
+                isNaN(value.value?.battery_voltage_bank1?.batteryValue?.batteryVoltage?.value) === false
+                  ? scaleValue(Number(value.value.battery_voltage_bank1.batteryValue.batteryVoltage.value), 0, 5.4, 0, 100)
+                  : 0,
+              battery_health_state:
+                value.value?.battery_voltage_bank0?.faultInformation === undefined &&
+                value.value?.battery_voltage_bank1?.faultInformation === undefined
+                  ? 0
+                  : 1,
+              smoke_status: value.value?.safety_alarm_smoke?.alarmState === 'ALARM_STATE_ALARM',
+              co_status: value.value?.safety_alarm_co?.alarmState === 'ALARM_STATE_ALARM',
+              heat_status: false, // TODO <- need to find in protobuf
+              hushed_state:
+                value.value?.safety_alarm_smoke?.silenceState === 'SILENCE_STATE_SILENCED' ||
+                value.value?.safety_alarm_co?.silenceState === 'SILENCE_STATE_SILENCED',
+              ntp_green_led: value.value?.night_time_promise_settings?.greenLedEnabled === true,
+              smoke_test_passed:
+                typeof value.value.safety_summary?.warningDevices?.failures === 'object'
+                  ? value.value.safety_summary.warningDevices.failures.includes('FAILURE_TYPE_SMOKE') === false
+                  : true,
+              heat_test_passed:
+                typeof value.value.safety_summary?.warningDevices?.failures === 'object'
+                  ? value.value.safety_summary.warningDevices.failures.includes('FAILURE_TYPE_TEMP') === false
+                  : true,
+              latest_alarm_test:
+                isNaN(value.value?.self_test?.lastMstEnd?.seconds) === false ? Number(value.value.self_test.lastMstEnd.seconds) : 0,
+              self_test_in_progress:
+                value.value?.legacy_structure_self_test?.mstInProgress === true ||
+                value.value?.legacy_structure_self_test?.astInProgress === true,
+              replacement_date:
+                isNaN(value.value?.legacy_protect_device_settings?.replaceByDate?.seconds) === false
+                  ? Number(value.value.legacy_protect_device_settings.replaceByDate.seconds)
+                  : 0,
+              topaz_hush_key:
+                typeof value.value?.safety_structure_settings?.structureHushKey === 'string'
+                  ? value.value.safety_structure_settings.structureHushKey
+                  : '',
+              detected_motion:
+                value.value?.legacy_protect_device_info?.autoAway !== true || value.value?.structure_mode?.occupancy === 'ACTIVITY_ACTIVE',
+            },
+            config,
+          );
+        }
+
+        if (
+          value?.source === DATA_SOURCE.NEST &&
+          rawData?.['where.' + value.value?.structure_id] !== undefined &&
+          rawData?.['safety.' + value.value?.structure_id] !== undefined &&
+          rawData?.['widget_track.' + value.value?.thread_mac_address?.toUpperCase()] !== undefined &&
+          rawData?.['safety.' + value.value?.structure_id] !== undefined
+        ) {
+          tempDevice = processCommonData(
+            object_key,
+            {
+              type: DEVICE_TYPE.PROTECT,
+              model: (() => {
+                let model =
+                  value.value.serial_number.substring(0, 2) === '06'
+                    ? 'Protect (2nd gen)'
+                    : value.value.serial_number.substring(0, 2) === '05'
+                      ? 'Protect (1st gen)'
+                      : 'Protect (unknown)';
+                return value.value.wired_or_battery === 1
+                  ? model.replace(/\bgen\)/, 'gen, battery)')
+                  : value.value.wired_or_battery === 0
+                    ? model.replace(/\bgen\)/, 'gen, wired)')
+                    : model;
+              })(),
+              softwareVersion: value.value.software_version,
+              serialNumber: value.value.serial_number,
+              description: String(value.value?.description ?? ''),
+              location: String(
+                rawData?.['where.' + value.value.structure_id]?.value?.wheres?.find((where) => where?.where_id === value.value.where_id)
+                  ?.name ?? '',
+              ),
+              online: rawData?.['widget_track.' + value.value.thread_mac_address.toUpperCase()]?.value?.online === true,
+              line_power_present: value.value.line_power_present === true,
+              wired_or_battery: value.value.wired_or_battery,
+              battery_level: scaleValue(value.value.battery_level, 0, 5400, 0, 100),
+              battery_health_state: value.value.battery_health_state,
+              smoke_status: value.value.smoke_status !== 0,
+              co_status: value.value.co_status !== 0,
+              heat_status: value.value.heat_status !== 0,
+              hushed_state: value.value.hushed_state === true,
+              ntp_green_led_enable: value.value.ntp_green_led_enable === true,
+              smoke_test_passed: value.value.component_smoke_test_passed === true,
+              heat_test_passed: value.value.component_temp_test_passed === true,
+              latest_alarm_test: value.value.latest_manual_test_end_utc_secs,
+              self_test_in_progress: rawData?.['safety.' + value.value.structure_id]?.value?.manual_self_test_in_progress === true,
+              replacement_date: value.value.replace_by_date_utc_secs,
+              topaz_hush_key:
+                typeof rawData?.['structure.' + value.value.structure_id]?.value?.topaz_hush_key === 'string'
+                  ? rawData['structure.' + value.value.structure_id].value.topaz_hush_key
+                  : '',
+              detected_motion: value.value.auto_away === false,
+            },
+            config,
+          );
+        }
+        // eslint-disable-next-line no-unused-vars
+      } catch (error) {
+        log?.debug?.('Error processing protect data for "%s"', object_key);
+      }
+
+      if (
+        Object.entries(tempDevice).length !== 0 &&
+        typeof devices[tempDevice.serialNumber] === 'undefined' &&
+        (deviceType === undefined || (typeof deviceType === 'string' && deviceType !== '' && tempDevice.type === deviceType))
+      ) {
+        let deviceOptions = config?.devices?.find(
+          (device) => device?.serialNumber?.toUpperCase?.() === tempDevice?.serialNumber?.toUpperCase?.(),
+        );
+        // Insert any extra options we've read in from configuration file for this device
+        tempDevice.eveHistory = config.options.eveHistory === true || deviceOptions?.eveHistory === true;
+        devices[tempDevice.serialNumber] = tempDevice; // Store processed device
+      }
+    });
+
+  return devices;
+}