Parse new z2m field philips_raw and use it update light state

This let's use both remove some old state hacks and ensure that Bifrost's state is up to date with Hue changes from z2m.
It also let's us parse the raw update directly instead of relying on z2m to do this correctly.

Author: duvholt

Cargo.lock

@@ -238,6 +238,12 @@ impl AddAssign<&LightUpdate> for Light {
                 effects.status = light_effect;
             }
         }
+
+        if let Some(upd) = &upd.timed_effects {
+            if let Some(timed_effects) = &mut self.timed_effects {
+                timed_effects.status = upd.effect.unwrap_or(LightTimedEffect::NoEffect);
+            }
+        }
     }
 }
 
@@ -589,6 +595,22 @@ pub struct LightEffectsV2Update {
     pub status: Option<Value>,
 }
 
+impl LightEffectsV2Update {
+    pub fn no_effect() -> Self {
+        Self {
+            action: Some(LightEffectActionUpdate {
+                effect: Some(LightEffect::NoEffect),
+                parameters: LightEffectParameters {
+                    color: None,
+                    color_temperature: None,
+                    speed: None,
+                },
+            }),
+            status: None,
+        }
+    }
+}
+
 impl AddAssign<&LightEffectsV2Update> for LightEffectsV2 {
     fn add_assign(&mut self, upd: &LightEffectsV2Update) {
         let light_effect = upd
@@ -661,6 +683,15 @@ pub struct LightTimedEffectsUpdate {
     pub duration: Option<u32>,
 }
 
+impl LightTimedEffectsUpdate {
+    pub fn no_effect() -> Self {
+        Self {
+            effect: Some(LightTimedEffect::NoEffect),
+            duration: None,
+        }
+    }
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone, Default)]
 pub struct LightUpdate {
     #[serde(skip_serializing_if = "Option::is_none")]

crates/hue/src/api/light.rs

@@ -2,6 +2,7 @@ pub trait Clamp {
     fn unit_to_u8_clamped(self) -> u8;
     fn unit_to_u8_clamped_light(self) -> u8;
     fn unit_from_u8(value: u8) -> Self;
+    fn unit_from_u8_light(value: u8) -> Self;
 }
 
 impl Clamp for f32 {
@@ -18,6 +19,10 @@ impl Clamp for f32 {
     fn unit_from_u8(value: u8) -> Self {
         Self::from(value) / 255.0
     }
+
+    fn unit_from_u8_light(value: u8) -> Self {
+        Self::from(value) / 254.0
+    }
 }
 
 impl Clamp for f64 {
@@ -34,6 +39,10 @@ impl Clamp for f64 {
     fn unit_from_u8(value: u8) -> Self {
         Self::from(value) / 255.0
     }
+
+    fn unit_from_u8_light(value: u8) -> Self {
+        Self::from(value) / 254.0
+    }
 }
 
 #[cfg(test)]

crates/hue/src/clamp.rs

@@ -5,13 +5,18 @@ use byteorder::{LittleEndian as LE, ReadBytesExt, WriteBytesExt};
 use packed_struct::derive::{PackedStruct, PrimitiveEnum_u8};
 use packed_struct::{PackedStruct, PackedStructSlice, PrimitiveEnum};
 
-use crate::api::{LightEffect, LightGradientMode, LightTimedEffect};
+use crate::api::{
+    ColorUpdate, LightEffect, LightEffectActionUpdate, LightEffectParameters, LightEffectsV2Update,
+    LightGradientMode, LightGradientPoint, LightGradientUpdate, LightTimedEffect,
+    LightTimedEffectsUpdate, LightUpdate, On,
+};
+use crate::clamp::Clamp;
 use crate::effect_duration::EffectDuration;
 use crate::error::{HueError, HueResult};
 use crate::flags::TakeFlag;
 use crate::xy::XY;
 
-#[derive(PrimitiveEnum_u8, Debug, Copy, Clone)]
+#[derive(PrimitiveEnum_u8, Debug, Copy, Clone, PartialEq, Eq)]
 pub enum EffectType {
     NoEffect = 0x00,
     Candle = 0x01,
@@ -396,6 +401,69 @@ impl HueZigbeeUpdate {
     }
 }
 
+impl From<HueZigbeeUpdate> for LightUpdate {
+    fn from(hz: HueZigbeeUpdate) -> Self {
+        let mut upd = Self::new()
+            .with_on(hz.onoff.map(|o| On::new(o > 0)))
+            .with_brightness(hz.brightness.map(|b| (b as f64) / 254.0 * 100.0))
+            .with_color_temperature(hz.color_mirek)
+            .with_color_xy(hz.color_xy);
+
+        if let Some(effect_type) = hz.effect_type {
+            if let Some(light_effect) = LightEffect::ALL.iter().copied().find(|&e| {
+                let e: EffectType = e.into();
+                e == effect_type
+            }) {
+                let action = Some(LightEffectActionUpdate {
+                    effect: Some(light_effect),
+                    parameters: LightEffectParameters {
+                        color: upd.color,
+                        color_temperature: upd.color_temperature,
+                        speed: hz.effect_speed.map(Clamp::unit_from_u8_light),
+                    },
+                });
+                upd.effects_v2 = Some(LightEffectsV2Update {
+                    action: action,
+                    status: None,
+                });
+                upd.timed_effects = Some(LightTimedEffectsUpdate::no_effect());
+            } else if let Some(light_timed_effect) = LightTimedEffect::ALL.into_iter().find(|&e| {
+                let e: EffectType = e.into();
+                e == effect_type
+            }) {
+                upd.effects_v2 = Some(LightEffectsV2Update::no_effect());
+                upd.timed_effects = Some(LightTimedEffectsUpdate {
+                    effect: Some(light_timed_effect),
+                    duration: None,
+                });
+            }
+        } else {
+            upd.effects_v2 = Some(LightEffectsV2Update::no_effect());
+            upd.timed_effects = Some(LightTimedEffectsUpdate::no_effect());
+        }
+
+        if let Some(gradient_colors) = &hz.gradient_colors {
+            upd.gradient = Some(LightGradientUpdate {
+                mode: Some(match gradient_colors.header.style {
+                    GradientStyle::Linear => LightGradientMode::InterpolatedPalette,
+                    GradientStyle::Mirrored => LightGradientMode::InterpolatedPaletteMirrored,
+                    GradientStyle::Scattered => LightGradientMode::RandomPixelated,
+                }),
+                points: gradient_colors
+                    .points
+                    .iter()
+                    .copied()
+                    .map(|point| LightGradientPoint {
+                        color: ColorUpdate::new(point),
+                    })
+                    .collect(),
+            })
+        }
+
+        upd
+    }
+}
+
 #[cfg_attr(coverage_nightly, coverage(off))]
 #[cfg(test)]
 mod tests {

crates/hue/src/zigbee/composite.rs

@@ -16,7 +16,9 @@ keywords.workspace = true
 workspace = true
 
 [dependencies]
+hex = "0.4.3"
 hue = { version = "0.1.0", path = "../hue", default-features = false }
+log = "0.4.29"
 serde = "1.0.219"
 serde_json = "1.0.140"
 thiserror = "2.0.12"

crates/z2m/Cargo.toml

@@ -1,12 +1,15 @@
 use std::collections::BTreeSet;
+use std::io::Cursor;
 
 use hue::api::{
     ColorGamut, ColorTemperature, DeviceProductData, Dimming, DimmingDeltaAction, GamutType,
     GroupedLightUpdate, LightColor, LightGradient, LightGradientMode, LightGradientPoint,
     LightGradientUpdate, LightUpdate, MirekSchema,
 };
 use hue::devicedb::{hardware_platform_type, product_archetype};
+use hue::error::HueError;
 use hue::xy::XY;
+use hue::zigbee::HueZigbeeUpdate;
 
 use crate::api::{Device, Expose, ExposeList, ExposeNumeric};
 use crate::update::{DeviceColorMode, DeviceUpdate};
@@ -156,6 +159,24 @@ impl ExtractDeviceProductData for DeviceProductData {
 
 impl From<&DeviceUpdate> for LightUpdate {
     fn from(value: &DeviceUpdate) -> Self {
+        if let Some(philips_raw) = &value.philips_raw {
+            match hex::decode(&philips_raw)
+                .map_err(HueError::from)
+                .and_then(|data| {
+                    let mut cur = Cursor::new(data);
+                    HueZigbeeUpdate::from_reader(&mut cur)
+                }) {
+                Ok(hz) => {
+                    let upd = hz.into();
+                    log::trace!("Converted Philips raw update to light update {philips_raw} {upd:#?}");
+                    return upd;
+                }
+                Err(err) => {
+                    log::error!("Failed to parse Philips Hue raw update {philips_raw}: {err}. Falling back to using z2m data");
+                }
+            }
+        }
+
         let mut upd = Self::new()
             .with_on(value.state.map(Into::into))
             .with_brightness(value.brightness.map(|b| b / 254.0 * 100.0))

crates/z2m/src/convert.rs

@@ -50,6 +50,8 @@ pub struct DeviceUpdate {
     pub transition: Option<f64>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub effect: Option<DeviceEffect>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub philips_raw: Option<String>,
 
     /* all other fields */
     #[serde(skip_serializing_if = "HashMap::is_empty")]

crates/z2m/src/update.rs

@@ -10,10 +10,9 @@ use uuid::Uuid;
 use bifrost_api::backend::BackendRequest;
 use hue::api::{
     BridgeHome, ColorTemperatureUpdate, DimmingDeltaAction, Entertainment,
-    EntertainmentConfiguration, GroupedLight, GroupedLightUpdate, Light, LightEffect,
-    LightEffectsV2Update, LightGradientMode, LightUpdate, RType, Resource, ResourceLink, Room,
-    RoomUpdate, Scene, SceneActive, SceneStatus, SceneStatusEnum, SceneUpdate,
-    ZigbeeDeviceDiscoveryUpdate,
+    EntertainmentConfiguration, GroupedLight, GroupedLightUpdate, Light, LightEffectsV2Update,
+    LightGradientMode, LightUpdate, RType, Resource, ResourceLink, Room, RoomUpdate, Scene,
+    SceneActive, SceneStatus, SceneStatusEnum, SceneUpdate, ZigbeeDeviceDiscoveryUpdate,
 };
 use hue::error::HueError;
 use hue::stream::HueStreamLightsV2;
@@ -72,7 +71,7 @@ impl Z2mBackend {
                 hz = hz.with_effect_type(fx.into());
             }
             if let Some(speed) = &act.parameters.speed {
-                hz = hz.with_effect_speed(speed.unit_to_u8_clamped());
+                hz = hz.with_effect_speed(speed.unit_to_u8_clamped_light());
             }
             if let Some(mirek) = &act.parameters.color_temperature.and_then(|ct| ct.mirek) {
                 hz = hz.with_color_mirek(*mirek);
@@ -105,43 +104,18 @@ impl Z2mBackend {
             return Ok(());
         };
 
-        let mut lock = self.state.lock().await;
-
-        // We cannot recover .mode from backend updates, since these only contain
-        // the gradient colors. So we have no choice, but to update the mode
-        // here. Otherwise, the information would be lost.
-        if let Some(mode) = upd.gradient.as_ref().and_then(|gr| gr.mode) {
-            lock.update::<Light>(&link.rid, |light| {
-                if let Some(gr) = &mut light.gradient {
-                    gr.mode = mode;
-                }
-            })?;
-        }
-        // Effect state is currently not retrieved from backend updates either
-        if let Some(upd) = upd.effects_v2.as_ref() {
-            lock.update::<Light>(&link.rid, |light| {
-                if let Some(effects_v2) = &mut light.effects_v2 {
-                    *effects_v2 += upd;
-                }
-                if let Some(effects) = &mut light.effects {
-                    let light_effect = upd
-                        .action
-                        .as_ref()
-                        .and_then(|a| a.effect)
-                        .unwrap_or(LightEffect::NoEffect);
-                    effects.status = light_effect;
-                }
-            })?;
-        }
-        let hue_effects = lock.get::<Light>(link)?.effects.is_some();
-        drop(lock);
+        let hue_effects = self
+            .state
+            .lock()
+            .await
+            .get::<Light>(link)?
+            .effects
+            .is_some();
 
         let mut payload: Option<DeviceUpdate> = None;
 
         // handle "identify" request (light breathing)
         if upd.identify.is_some() {
-            // handle "identify" request (light breathing)
-
             payload = Some(
                 payload
                     .unwrap_or_default()
@@ -209,17 +183,7 @@ impl Z2mBackend {
             if !hz.is_empty() {
                 hz = hz.with_fade_speed(0x0001);
 
-                let read_payload = DeviceRead::default()
-                    .with_state(
-                        hz.onoff.is_some() || hz.brightness.is_some() || hz.effect_type.is_some(),
-                    )
-                    .with_color(
-                        hz.color_mirek.is_some()
-                            || hz.color_xy.is_some()
-                            || hz.effect_type.is_some(),
-                    )
-                    .with_brightness(hz.brightness.is_some() || hz.effect_type.is_some());
-
+                let read_payload = DeviceRead::default().with_state(true);
                 z2mws.send_hue_effects(topic, hz).await?;
 
                 // Do an explicit attribute read since Hue specific updates do not automatically update z2m state

src/backend/z2m/backend_event.rs

@@ -50,6 +50,7 @@ impl Z2mBackend {
         }
 
         let upd = DeviceUpdate::deserialize(payload)?;
+        log::trace!("Device update {upd:#?}");
 
         let obj = self.state.lock().await.get_resource_by_id(rid)?.obj;
         match obj {