homebridge-nest-accfactory 0.3.0 → 0.3.2

package/dist/plugins/tempsensor.js

@@ -6,43 +6,38 @@
 
 // Define our modules
 import HomeKitDevice from '../HomeKitDevice.js';
+import { processCommonData, adjustTemperature, 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 NestTemperatureSensor extends HomeKitDevice {
   static TYPE = 'TemperatureSensor';
-  static VERSION = '2025.06.11';
+  static VERSION = '2025.08.04'; // Code version
 
   batteryService = undefined;
   temperatureService = undefined;
 
-  constructor(accessory, api, log, eventEmitter, deviceData) {
-    super(accessory, api, log, eventEmitter, deviceData);
-  }
-
   // Class functions
-  setupDevice() {
-    // Setup temperature service if not already present on the accessory
-    this.temperatureService = this.addHKService(this.hap.Service.TemperatureSensor, '', 1);
+  onAdd() {
+    // Setup temperature service if not already present on the accessory and link it to the Eve app if configured to do so
+    this.temperatureService = this.addHKService(this.hap.Service.TemperatureSensor, '', 1, {});
     this.temperatureService.setPrimaryService();
 
     // Setup battery service if not already present on the accessory
     this.batteryService = this.addHKService(this.hap.Service.Battery, '', 1);
     this.batteryService.setHiddenService(true);
+    this.temperatureService.addLinkedService(this.batteryService);
+  }
 
-    // Setup linkage to EveHome app if configured todo so
-    if (
-      this.deviceData?.eveHistory === true &&
-      this.temperatureService !== undefined &&
-      typeof this.historyService?.linkToEveHome === 'function'
-    ) {
-      this.historyService.linkToEveHome(this.temperatureService, {
-        description: this.deviceData.description,
-      });
-    }
+  onRemove() {
+    this.accessory.removeService(this.temperatureService);
+    this.accessory.removeService(this.batteryService);
+    this.temperatureService = undefined;
+    this.batteryService = undefined;
   }
 
-  updateDevice(deviceData) {
+  onUpdate(deviceData) {
     if (typeof deviceData !== 'object' || this.temperatureService === undefined || this.batteryService === undefined) {
       return;
     }
@@ -70,26 +65,155 @@ export default class NestTemperatureSensor 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_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);
 
     // If we have the history service running and temperature has changed to previous in past 5mins
-    if (
-      deviceData.current_temperature !== this.deviceData.current_temperature &&
-      this.temperatureService !== undefined &&
-      typeof this.historyService?.addHistory === 'function'
-    ) {
-      this.historyService.addHistory(
-        this.temperatureService,
-        {
-          time: Math.floor(Date.now() / 1000),
-          temperature: deviceData.current_temperature,
-        },
-        300,
-      );
-    }
+    this.history(
+      this.temperatureService,
+      {
+        temperature: deviceData.current_temperature,
+      },
+      { timegap: 300, force: true },
+    );
   }
 }
+
+// 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 temperature sensors we have in the raw data
+  // We do this using any thermostat data
+  let devices = {};
+  Object.entries(rawData)
+    .filter(
+      ([key, value]) =>
+        key.startsWith('device.') === true ||
+        (key.startsWith('DEVICE_') === true && PROTOBUF_RESOURCES.THERMOSTAT.includes(value.value?.device_info?.typeName) === true),
+    )
+    .forEach(([object_key, value]) => {
+      try {
+        if (
+          value?.source === DATA_SOURCE.GOOGLE &&
+          value.value?.configuration_done?.deviceReady === true &&
+          Array.isArray(value.value?.remote_comfort_sensing_settings?.associatedRcsSensors) === true
+        ) {
+          value.value.remote_comfort_sensing_settings.associatedRcsSensors.forEach((sensor) => {
+            if (typeof rawData?.[sensor?.deviceId?.resourceId]?.value === 'object') {
+              let sensorData = rawData[sensor.deviceId.resourceId].value;
+              let tempDevice = processCommonData(
+                sensor.deviceId.resourceId,
+                {
+                  type: DEVICE_TYPE.TEMPSENSOR,
+                  model: 'Temperature Sensor',
+                  softwareVersion: NestTemperatureSensor.VERSION, // We'll use our class version here now
+                  serialNumber: sensorData.device_identity.serialNumber,
+                  description: String(sensorData?.label?.label ?? ''),
+                  location: String(
+                    [
+                      ...Object.values(
+                        rawData?.[sensorData?.device_info?.pairerId?.resourceId]?.value?.located_annotations?.predefinedWheres || {},
+                      ),
+                      ...Object.values(
+                        rawData?.[sensorData?.device_info?.pairerId?.resourceId]?.value?.located_annotations?.customWheres || {},
+                      ),
+                    ].find((where) => where?.whereId?.resourceId === sensorData?.device_located_settings?.whereAnnotationRid?.resourceId)
+                      ?.label?.literal ?? '',
+                  ),
+                  // Guessing battery minimum voltage is 2v??
+                  battery_level: scaleValue(Number(sensorData.battery.assessedVoltage.value), 2.0, 3.0, 0, 100),
+                  current_temperature: adjustTemperature(sensorData.current_temperature.temperatureValue.temperature.value, 'C', 'C', true),
+                  online:
+                    isNaN(sensorData?.last_updated_beacon?.lastBeaconTime?.seconds) === false &&
+                    Math.floor(Date.now() / 1000) - Number(sensorData.last_updated_beacon.lastBeaconTime.seconds) < 3600 * 4,
+                  associated_thermostat: object_key,
+                  active_sensor:
+                    value.value?.remote_comfort_sensing_settings?.activeRcsSelection?.activeRcsSensor?.resourceId ===
+                    sensor.deviceId.resourceId,
+                },
+                config,
+              );
+
+              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
+              }
+            }
+          });
+        }
+
+        if (
+          value?.source === DATA_SOURCE.NEST &&
+          Array.isArray(rawData?.['rcs_settings.' + value.value?.serial_number]?.value?.associated_rcs_sensors) === true
+        ) {
+          rawData['rcs_settings.' + value.value.serial_number].value.associated_rcs_sensors.forEach((sensor) => {
+            if (
+              typeof rawData[sensor]?.value === 'object' &&
+              typeof rawData?.['where.' + rawData?.[sensor]?.value?.structure_id] === 'object'
+            ) {
+              let sensorData = rawData[sensor].value;
+              let tempDevice = processCommonData(
+                sensor,
+                {
+                  type: DEVICE_TYPE.TEMPSENSOR,
+                  model: 'Temperature Sensor',
+                  softwareVersion: NestTemperatureSensor.VERSION, // We'll use our class version here now
+                  serialNumber: sensorData.serial_number,
+                  battery_level: scaleValue(Number(sensorData.battery_level), 0, 100, 0, 100),
+                  current_temperature: adjustTemperature(sensorData.current_temperature, 'C', 'C', true),
+                  online: Math.floor(Date.now() / 1000) - sensorData.last_updated_at < 3600 * 4,
+                  associated_thermostat: object_key,
+                  description: String(sensorData.description?.trim() ?? ''),
+                  location: String(
+                    rawData?.['where.' + sensorData.structure_id]?.value?.wheres?.find((where) => where?.where_id === sensorData.where_id)
+                      ?.name ?? '',
+                  ),
+                  active_sensor:
+                    rawData?.['rcs_settings.' + value.value.serial_number]?.value?.active_rcs_sensors?.includes?.(object_key) === true,
+                },
+                config,
+              );
+
+              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
+              }
+            }
+          });
+        }
+        // eslint-disable-next-line no-unused-vars
+      } catch (error) {
+        log?.debug?.('Error processing temperature sensor data for "%s"', object_key);
+      }
+    });
+
+  return devices;
+}