feat(motion): mark the current light level on the daylight slider

The reading is the one the automation compares: a sensor light_level, or a group grouped_light_level.

Author: eetu

backend/src/hue/data.rs

@@ -72,6 +72,8 @@ async fn fetch_from_bridge(state: &Arc<AppState>) -> Result<HueResponse, HueErro
     let grouped_motions: Vec<GroupedMotionResource> = resources.take("grouped_motion")?;
     let service_groups: Vec<ServiceGroupResource> = resources.take("service_group")?;
     let automations: Vec<BehaviorInstanceResource> = resources.take("behavior_instance")?;
+    let mut light_levels: Vec<LightLevelResource> = resources.take("light_level")?;
+    light_levels.extend(resources.take::<LightLevelResource>("grouped_light_level")?);
 
     // device ID → battery level
     let battery_by_device: HashMap<&str, u8> = device_powers
@@ -182,6 +184,7 @@ async fn fetch_from_bridge(state: &Arc<AppState>) -> Result<HueResponse, HueErro
         grouped: &grouped_motions,
         service_groups: &service_groups,
         automations: &automations,
+        light_levels: &light_levels,
         device_names: &device_name_by_id,
     });
 

backend/src/hue/events.rs

@@ -46,6 +46,11 @@ pub enum HueLiveEvent {
         id: String,
         sensitivity: u8,
     },
+    /// `id` is a `light_level` or `grouped_light_level` service.
+    LightLevel {
+        id: String,
+        level: u32,
+    },
     Daylight {
         #[serde(rename = "automationId")]
         automation_id: String,
@@ -237,6 +242,24 @@ fn parse_resource_update(resource: &serde_json::Value) -> Vec<HueLiveEvent> {
             }
             events
         }
+        "light_level" | "grouped_light_level" => resource
+            .get("light")
+            .and_then(|light| {
+                light
+                    .get("light_level_report")
+                    .and_then(|r| r.get("light_level"))
+                    .or_else(|| light.get("light_level"))
+            })
+            .and_then(|l| l.as_u64())
+            .and_then(|l| u32::try_from(l).ok())
+            .zip(resource.get("id").and_then(|v| v.as_str()))
+            .map(|(level, id)| {
+                vec![HueLiveEvent::LightLevel {
+                    id: id.to_string(),
+                    level,
+                }]
+            })
+            .unwrap_or_default(),
         "behavior_instance" => resource
             .get("configuration")
             .and_then(dark_threshold)
@@ -318,6 +341,19 @@ mod tests {
         );
     }
 
+    #[test]
+    fn light_level_update_carries_the_reading() {
+        let events = events(json!({
+            "id": "gl-1", "type": "grouped_light_level",
+            "light": {"light_level_report": {"changed": "2026-10-04T09:00:00Z", "light_level": 17723}},
+        }));
+
+        assert_eq!(
+            events,
+            [json!({"type": "light_level", "id": "gl-1", "level": 17723})]
+        );
+    }
+
     #[test]
     fn automation_update_carries_daylight_null_when_ignored() {
         let configuration = |t: u32| {

backend/src/hue/models.rs

@@ -116,6 +116,13 @@ pub struct Daylight {
     /// Hue light level (10000·log10(lux) + 1) below which motion counts as
     /// dark. `null` when the automation ignores daylight.
     pub dark_threshold: Option<u32>,
+    /// The `light_level` or `grouped_light_level` the automation compares
+    /// against. Live `light_level` events carry this ID.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub light_level_service_id: Option<String>,
+    /// That service's current reading, on the same scale as the threshold.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub light_level: Option<u32>,
 }
 
 // ---- CLIP v2 resource shapes (for deserialization from bridge) ----
@@ -257,6 +264,35 @@ pub struct BehaviorInstanceResource {
     pub configuration: serde_json::Value,
 }
 
+/// `light_level` and `grouped_light_level` share this shape.
+#[derive(Debug, Deserialize)]
+pub struct LightLevelResource {
+    pub id: String,
+    #[serde(default)]
+    pub light: LightData,
+}
+
+#[derive(Debug, Default, Deserialize)]
+pub struct LightData {
+    /// Absent on a `grouped_light_level`; only the report is emitted there.
+    pub light_level: Option<u32>,
+    pub light_level_report: Option<LightLevelReport>,
+}
+
+impl LightData {
+    pub fn current(&self) -> Option<u32> {
+        self.light_level_report
+            .as_ref()
+            .map(|r| r.light_level)
+            .or(self.light_level)
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct LightLevelReport {
+    pub light_level: u32,
+}
+
 #[derive(Debug, Deserialize)]
 pub struct SensitivityData {
     pub sensitivity: Option<u8>,

backend/src/hue/motion.rs

@@ -19,6 +19,10 @@ const MOTION_SERVICE_RID_POINTER: &str = "/motion/motion_service/rid";
 pub const DARK_THRESHOLD_POINTER: &str =
     "/light_level/daylight/daylight_sensitivity/settings/dark_threshold";
 
+/// Where a motion automation names the light reading it compares against.
+const LIGHT_LEVEL_SERVICE_RID_POINTER: &str =
+    "/light_level/daylight/daylight_sensitivity/light_level_service/rid";
+
 /// The `dark_threshold` of an automation that ignores daylight: the top of the
 /// light level scale, so it is always dark.
 pub const DAYLIGHT_OFF: u32 = 65534;
@@ -30,6 +34,8 @@ pub struct MotionInputs<'a> {
     pub grouped: &'a [GroupedMotionResource],
     pub service_groups: &'a [ServiceGroupResource],
     pub automations: &'a [BehaviorInstanceResource],
+    /// Both `light_level` and `grouped_light_level` resources.
+    pub light_levels: &'a [LightLevelResource],
     /// device ID → name
     pub device_names: &'a HashMap<&'a str, &'a str>,
 }
@@ -79,7 +85,7 @@ pub fn build_motion_units(inputs: &MotionInputs) -> Vec<MotionUnit> {
         }
     }));
 
-    let daylight_by_service = daylight_by_service(inputs.automations);
+    let daylight_by_service = daylight_by_service(inputs.automations, inputs.light_levels);
     let grouped_by_id: HashMap<&str, &GroupedMotionResource> =
         inputs.grouped.iter().map(|g| (g.id.as_str(), g)).collect();
 
@@ -160,7 +166,14 @@ pub fn set_dark_threshold(configuration: &mut Value, threshold: Option<u32>) ->
 }
 
 /// motion service ID → the daylight setting of the first automation on it.
-fn daylight_by_service(automations: &[BehaviorInstanceResource]) -> HashMap<&str, Daylight> {
+fn daylight_by_service<'a>(
+    automations: &'a [BehaviorInstanceResource],
+    light_levels: &[LightLevelResource],
+) -> HashMap<&'a str, Daylight> {
+    let level_by_service: HashMap<&str, Option<u32>> = light_levels
+        .iter()
+        .map(|l| (l.id.as_str(), l.light.current()))
+        .collect();
     let mut map = HashMap::new();
     for automation in automations {
         let Some(rid) = automation
@@ -173,9 +186,17 @@ fn daylight_by_service(automations: &[BehaviorInstanceResource]) -> HashMap<&str
         let Some(threshold) = dark_threshold(&automation.configuration) else {
             continue;
         };
+        let light_level_service = automation
+            .configuration
+            .pointer(LIGHT_LEVEL_SERVICE_RID_POINTER)
+            .and_then(Value::as_str);
         map.entry(rid).or_insert_with(|| Daylight {
             automation_id: automation.id.clone(),
             dark_threshold: threshold,
+            light_level_service_id: light_level_service.map(str::to_owned),
+            light_level: light_level_service
+                .and_then(|id| level_by_service.get(id).copied())
+                .flatten(),
         });
     }
     map
@@ -208,14 +229,14 @@ mod tests {
         json!({"motion_report": {"changed": "2026-10-04T09:00:00Z", "motion": motion}})
     }
 
-    fn automation(id: &str, service: &str, threshold: Option<u32>) -> Value {
+    fn automation(id: &str, service: &str, light: &str, threshold: Option<u32>) -> Value {
         let mut configuration = json!({
             "motion": {"motion_service": {"rid": service, "rtype": "motion"}},
             "source": {"rid": "device-x", "rtype": "device"},
         });
         if let Some(t) = threshold {
             configuration["light_level"] = json!({"daylight": {"daylight_sensitivity": {
-                "light_level_service": {"rid": "ll", "rtype": "light_level"},
+                "light_level_service": {"rid": light, "rtype": "light_level"},
                 "settings": {"dark_threshold": t, "offset": 7000},
             }}});
         }
@@ -255,11 +276,17 @@ mod tests {
              ]},
         ]));
         let automations = parse::<BehaviorInstanceResource>(json!([
-            automation("b-kitchen", "g-kitchen", Some(14477)),
-            automation("b-hall", "m-hall", Some(DAYLIGHT_OFF)),
-            automation("b-hall-2", "m-hall", Some(100)),
+            automation("b-kitchen", "g-kitchen", "gl-kitchen", Some(14477)),
+            automation("b-hall", "m-hall", "ll-hall", Some(DAYLIGHT_OFF)),
+            automation("b-hall-2", "m-hall", "ll-hall", Some(100)),
             {"id": "b-other", "configuration": {"when": {}}},
         ]));
+        // The hall sensor has not reported yet.
+        let light_levels = parse::<LightLevelResource>(json!([
+            {"id": "gl-kitchen", "light": {"light_level_report":
+                {"changed": "2026-10-04T09:00:00Z", "light_level": 17723}}},
+            {"id": "ll-kitchen", "light": {"light_level": 17000}},
+        ]));
         let device_names = HashMap::from([("d-kitchen", "Keittiön anturi"), ("d-hall", "Käytävä")]);
 
         build_motion_units(&MotionInputs {
@@ -269,6 +296,7 @@ mod tests {
             grouped: &grouped,
             service_groups: &service_groups,
             automations: &automations,
+            light_levels: &light_levels,
             device_names: &device_names,
         })
     }
@@ -349,9 +377,31 @@ mod tests {
         assert_eq!(hall_daylight.dark_threshold, None, "65534 ignores daylight");
     }
 
+    #[test]
+    fn daylight_carries_the_reading_the_automation_compares() {
+        let units = units();
+        let kitchen = units.iter().find(|u| u.id == "sg-kitchen").unwrap();
+        let hall = units.iter().find(|u| u.id == "m-hall").unwrap();
+
+        let kitchen_daylight = kitchen.daylight.as_ref().unwrap();
+        assert_eq!(
+            kitchen_daylight.light_level_service_id.as_deref(),
+            Some("gl-kitchen"),
+            "the group's reading, not its sensor's"
+        );
+        assert_eq!(kitchen_daylight.light_level, Some(17723));
+
+        let hall_daylight = hall.daylight.as_ref().unwrap();
+        assert_eq!(
+            hall_daylight.light_level_service_id.as_deref(),
+            Some("ll-hall")
+        );
+        assert_eq!(hall_daylight.light_level, None);
+    }
+
     #[test]
     fn set_dark_threshold_rewrites_only_the_threshold() {
-        let mut configuration = automation("b", "m", Some(14477))["configuration"].clone();
+        let mut configuration = automation("b", "m", "ll", Some(14477))["configuration"].clone();
         let expected = {
             let mut c = configuration.clone();
             c["light_level"]["daylight"]["daylight_sensitivity"]["settings"]["dark_threshold"] =
@@ -368,7 +418,7 @@ mod tests {
 
     #[test]
     fn set_dark_threshold_refuses_automation_without_daylight() {
-        let mut configuration = automation("b", "m", None)["configuration"].clone();
+        let mut configuration = automation("b", "m", "ll", None)["configuration"].clone();
         let before = configuration.clone();
 
         assert!(!set_dark_threshold(&mut configuration, Some(20000)));

frontend/src/App.tsx

@@ -95,6 +95,15 @@ const applyEvent = (data: Response, event: HueLiveEvent): Response => {
           m.sensitivity ? { ...m, sensitivity: { ...m.sensitivity, value: event.sensitivity } } : m,
         ),
       };
+    case "light_level":
+      return {
+        ...data,
+        motionUnits: data.motionUnits.map((u) =>
+          u.daylight?.lightLevelServiceId === event.id
+            ? { ...u, daylight: { ...u.daylight, lightLevel: event.level } }
+            : u,
+        ),
+      };
     case "daylight":
       return {
         ...data,