Merge pull request #136 from chrivers/chrivers/z2m-new-features

After the many fundamental and infrastructure changes in Bifrost, it's finally
time for a set of changes that add new features!

This one is particularly exciting, as it contains a number of exciting additions
that directly improve the end-user experience.

Bifrost is now able to:

 - Update existing scenes (closes #85)
 - Delete lights
 - Add new lights to the bridge
 - Add new lights to rooms
 - Remove lights from rooms
 - Make lights pulse when selected
 - Learn scenes with gradient colors

All these actions now work from the api, including directly from the Hue app!

No more jumping back and forth between the app and z2m to perform common
maintenance tasks!

Author: chrivers

crates/bifrost-api/src/backend.rs

@@ -1,7 +1,10 @@
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-use hue::api::{GroupedLightUpdate, LightUpdate, ResourceLink, RoomUpdate, Scene, SceneUpdate};
+use hue::api::{
+    GroupedLightUpdate, LightUpdate, ResourceLink, RoomUpdate, Scene, SceneUpdate,
+    ZigbeeDeviceDiscoveryUpdate,
+};
 use hue::stream::HueStreamLightsV2;
 
 use crate::Client;
@@ -25,6 +28,8 @@ pub enum BackendRequest {
     EntertainmentStart(Uuid),
     EntertainmentFrame(HueStreamLightsV2),
     EntertainmentStop(),
+
+    ZigbeeDeviceDiscovery(ResourceLink, ZigbeeDeviceDiscoveryUpdate),
 }
 
 impl Client {

crates/hue/src/api/device.rs

@@ -27,6 +27,8 @@ pub struct DeviceUpdate {
     pub services: Option<Vec<ResourceLink>>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub product_data: Option<Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub identify: Option<DeviceIdentifyUpdate>,
 }
 
 impl Device {
@@ -46,6 +48,17 @@ impl Device {
     }
 }
 
+#[derive(Debug, Serialize, Deserialize, Copy, Clone, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum DeviceIdentify {
+    Identify,
+}
+
+#[derive(Debug, Serialize, Deserialize, Copy, Clone, PartialEq, Eq)]
+pub struct DeviceIdentifyUpdate {
+    pub action: DeviceIdentify,
+}
+
 #[derive(Debug, Serialize, Deserialize, Clone, Default, PartialEq, Eq)]
 pub struct Identify {}
 
@@ -103,14 +116,14 @@ impl DeviceUpdate {
     }
 }
 
-impl AddAssign<DeviceUpdate> for Device {
-    fn add_assign(&mut self, upd: DeviceUpdate) {
-        if let Some(md) = upd.metadata {
-            if let Some(name) = md.name {
-                self.metadata.name = name;
+impl AddAssign<&DeviceUpdate> for Device {
+    fn add_assign(&mut self, upd: &DeviceUpdate) {
+        if let Some(md) = &upd.metadata {
+            if let Some(name) = &md.name {
+                self.metadata.name.clone_from(name);
             }
-            if let Some(archetype) = md.archetype {
-                self.metadata.archetype = archetype;
+            if let Some(archetype) = &md.archetype {
+                self.metadata.archetype.clone_from(archetype);
             }
         }
     }

crates/hue/src/api/light.rs

@@ -4,6 +4,7 @@ use std::ops::{AddAssign, Sub};
 use serde::{Deserialize, Serialize};
 use serde_json::{Value, json};
 
+use crate::api::device::DeviceIdentifyUpdate;
 use crate::api::{DeviceArchetype, Identify, Metadata, MetadataUpdate, ResourceLink, Stub};
 use crate::hs::HS;
 use crate::legacy_api::ApiLightStateUpdate;
@@ -32,7 +33,8 @@ pub struct Light {
     pub effects: Option<LightEffects>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub effects_v2: Option<LightEffectsV2>,
-    pub service_id: u32,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub service_id: Option<u32>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub gradient: Option<LightGradient>,
     #[serde(default)]
@@ -107,7 +109,7 @@ impl Light {
             dynamics: Some(LightDynamics::default()),
             effects: None,
             effects_v2: None,
-            service_id: 0,
+            service_id: Some(0),
             gradient: None,
             identify: Identify {},
             timed_effects: Some(LightTimedEffects {
@@ -182,14 +184,14 @@ impl Light {
     }
 }
 
-impl AddAssign<LightUpdate> for Light {
-    fn add_assign(&mut self, upd: LightUpdate) {
-        if let Some(md) = upd.metadata {
-            if let Some(name) = md.name {
-                self.metadata.name = name;
+impl AddAssign<&LightUpdate> for Light {
+    fn add_assign(&mut self, upd: &LightUpdate) {
+        if let Some(md) = &upd.metadata {
+            if let Some(name) = &md.name {
+                self.metadata.name.clone_from(name);
             }
-            if let Some(archetype) = md.archetype {
-                self.metadata.archetype = archetype;
+            if let Some(archetype) = &md.archetype {
+                self.metadata.archetype = archetype.clone();
             }
         }
 
@@ -217,9 +219,9 @@ impl AddAssign<LightUpdate> for Light {
         }
 
         if let Some(grad) = &mut self.gradient {
-            if let Some(grupd) = upd.gradient {
+            if let Some(grupd) = &upd.gradient {
                 grad.mode = grupd.mode.unwrap_or(grad.mode);
-                grad.points = grupd.points;
+                grad.points.clone_from(&grupd.points);
             }
         }
     }
@@ -626,6 +628,8 @@ pub struct LightUpdate {
     pub powerup: Option<Value>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub dynamics: Option<LightDynamicsUpdate>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub identify: Option<DeviceIdentifyUpdate>,
 }
 
 impl LightUpdate {
@@ -674,6 +678,11 @@ impl LightUpdate {
         }
     }
 
+    #[must_use]
+    pub fn with_identify(self, identify: Option<DeviceIdentifyUpdate>) -> Self {
+        Self { identify, ..self }
+    }
+
     #[must_use]
     pub fn with_gradient(self, gradient: Option<LightGradientUpdate>) -> Self {
         Self { gradient, ..self }

crates/hue/src/api/mod.rs

@@ -9,6 +9,7 @@ mod scene;
 mod stream;
 mod stubs;
 mod update;
+mod zigbee_device_discovery;
 
 pub use device::{Device, DeviceArchetype, DeviceProductData, DeviceUpdate, Identify};
 pub use entertainment::{Entertainment, EntertainmentSegment, EntertainmentSegments};
@@ -47,10 +48,14 @@ pub use stubs::{
     ButtonData, ButtonMetadata, ButtonReport, DevicePower, DeviceSoftwareUpdate, DollarRef,
     GeofenceClient, Geolocation, GroupedLightLevel, GroupedMotion, Homekit, LightLevel, Matter,
     Metadata, MetadataUpdate, Motion, PrivateGroup, PublicImage, RelativeRotary, SmartScene,
-    Taurus, Temperature, TimeZone, ZigbeeConnectivity, ZigbeeConnectivityStatus,
-    ZigbeeDeviceDiscovery, Zone,
+    Taurus, Temperature, TimeZone, ZigbeeConnectivity, ZigbeeConnectivityStatus, Zone,
 };
 pub use update::Update;
+pub use zigbee_device_discovery::{
+    ZigbeeDeviceDiscovery, ZigbeeDeviceDiscoveryAction, ZigbeeDeviceDiscoveryInstallCode,
+    ZigbeeDeviceDiscoveryStatus, ZigbeeDeviceDiscoveryUpdate, ZigbeeDeviceDiscoveryUpdateAction,
+    ZigbeeDeviceDiscoveryUpdateActionType,
+};
 
 use std::fmt::Debug;
 

crates/hue/src/api/resource.rs

@@ -170,9 +170,10 @@ impl ResourceLink {
 
 impl Debug for ResourceLink {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let rtype = format!("{:?}", self.rtype).to_lowercase();
+        // we need serde(rename_all = "snake_case") translation
+        let rtype = serde_json::to_string(&self.rtype).unwrap();
         let rid = self.rid;
-        write!(f, "{rtype}/{rid}")
+        write!(f, "{}/{rid}", rtype.trim_matches('"'))
     }
 }
 

crates/hue/src/api/room.rs

@@ -133,24 +133,24 @@ impl RoomMetadata {
     }
 }
 
-impl AddAssign<RoomUpdate> for Room {
-    fn add_assign(&mut self, rhs: RoomUpdate) {
-        if let Some(md) = rhs.metadata {
+impl AddAssign<&RoomUpdate> for Room {
+    fn add_assign(&mut self, rhs: &RoomUpdate) {
+        if let Some(md) = &rhs.metadata {
             self.metadata += md;
         }
-        if let Some(children) = rhs.children {
-            self.children = children;
+        if let Some(children) = &rhs.children {
+            self.children.clone_from(children);
         }
     }
 }
 
-impl AddAssign<RoomMetadataUpdate> for RoomMetadata {
-    fn add_assign(&mut self, upd: RoomMetadataUpdate) {
-        if let Some(name) = upd.name {
-            self.name = name;
+impl AddAssign<&RoomMetadataUpdate> for RoomMetadata {
+    fn add_assign(&mut self, upd: &RoomMetadataUpdate) {
+        if let Some(name) = &upd.name {
+            self.name.clone_from(name);
         }
-        if let Some(archetype) = upd.archetype {
-            self.archetype = archetype;
+        if let Some(archetype) = &upd.archetype {
+            self.archetype = *archetype;
         }
     }
 }

crates/hue/src/api/scene.rs

@@ -4,7 +4,9 @@ use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
-use crate::api::{ColorTemperatureUpdate, ColorUpdate, DimmingUpdate, On, ResourceLink};
+use crate::api::{
+    ColorTemperatureUpdate, ColorUpdate, DimmingUpdate, LightGradientUpdate, On, ResourceLink,
+};
 use crate::date_format;
 
 #[derive(Copy, Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
@@ -26,18 +28,6 @@ pub struct SceneStatus {
     pub last_recall: Option<DateTime<Utc>>,
 }
 
-#[derive(Copy, Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
-pub struct SceneStatusUpdate {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub active: Option<SceneActive>,
-    #[serde(
-        with = "date_format::utc_ms_opt",
-        default,
-        skip_serializing_if = "Option::is_none"
-    )]
-    pub last_recall: Option<DateTime<Utc>>,
-}
-
 #[derive(Copy, Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
 #[serde(rename_all = "snake_case")]
 pub enum SceneStatusEnum {
@@ -88,7 +78,7 @@ pub struct SceneAction {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub on: Option<On>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub gradient: Option<Value>,
+    pub gradient: Option<LightGradientUpdate>,
     #[serde(default, skip_serializing_if = "Value::is_null")]
     pub effects: Value,
 }
@@ -131,8 +121,6 @@ pub struct SceneUpdate {
     pub speed: Option<f64>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub auto_dynamic: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub status: Option<SceneStatusUpdate>,
 }
 
 impl SceneUpdate {
@@ -163,16 +151,36 @@ impl SceneUpdate {
     }
 }
 
-impl AddAssign<SceneMetadataUpdate> for SceneMetadata {
-    fn add_assign(&mut self, upd: SceneMetadataUpdate) {
-        if let Some(appdata) = upd.appdata {
-            self.appdata = Some(appdata);
+impl AddAssign<&SceneUpdate> for Scene {
+    fn add_assign(&mut self, upd: &SceneUpdate) {
+        if let Some(actions) = &upd.actions {
+            self.actions.clone_from(actions);
+        }
+        if let Some(md) = &upd.metadata {
+            self.metadata += md;
+        }
+        if let Some(palette) = &upd.palette {
+            self.palette.clone_from(palette);
+        }
+        if let Some(speed) = upd.speed {
+            self.speed = speed;
+        }
+        if let Some(auto_dynamic) = upd.auto_dynamic {
+            self.auto_dynamic = auto_dynamic;
+        }
+    }
+}
+
+impl AddAssign<&SceneMetadataUpdate> for SceneMetadata {
+    fn add_assign(&mut self, upd: &SceneMetadataUpdate) {
+        if let Some(appdata) = &upd.appdata {
+            self.appdata = Some(appdata.to_string());
         }
-        if let Some(image) = upd.image {
-            self.image = Some(image);
+        if let Some(image) = &upd.image {
+            self.image = Some(*image);
         }
-        if let Some(name) = upd.name {
-            self.name = name;
+        if let Some(name) = &upd.name {
+            self.name.clone_from(name);
         }
     }
 }

crates/hue/src/api/stubs.rs

@@ -239,15 +239,6 @@ pub struct ZigbeeConnectivity {
     pub status: ZigbeeConnectivityStatus,
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
-pub struct ZigbeeDeviceDiscovery {
-    pub owner: ResourceLink,
-    pub status: String,
-    #[serde(default)]
-    #[serde(skip_serializing_if = "Value::is_null")]
-    pub action: Value,
-}
-
 #[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct Zone {
     pub metadata: Metadata,

crates/hue/src/api/zigbee_device_discovery.rs

@@ -0,0 +1,60 @@
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use uuid::Uuid;
+
+use crate::api::ResourceLink;
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "snake_case")]
+pub enum ZigbeeDeviceDiscoveryStatus {
+    Active,
+    Ready,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone, Default)]
+pub struct ZigbeeDeviceDiscoveryAction {
+    pub action_type_values: Vec<Value>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub search_codes: Vec<String>,
+}
+
+impl ZigbeeDeviceDiscoveryAction {
+    #[must_use]
+    pub fn is_empty(&self) -> bool {
+        self.action_type_values.is_empty()
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct ZigbeeDeviceDiscovery {
+    pub owner: ResourceLink,
+    pub status: ZigbeeDeviceDiscoveryStatus,
+
+    #[serde(default, skip_serializing_if = "ZigbeeDeviceDiscoveryAction::is_empty")]
+    pub action: ZigbeeDeviceDiscoveryAction,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct ZigbeeDeviceDiscoveryInstallCode {
+    pub mac_address: String,
+    pub ic: Uuid,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "snake_case")]
+pub enum ZigbeeDeviceDiscoveryUpdateActionType {
+    Search,
+    SearchAllowDefaultLinkKey,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct ZigbeeDeviceDiscoveryUpdateAction {
+    pub action_type: ZigbeeDeviceDiscoveryUpdateActionType,
+    pub search_codes: Option<Vec<String>>,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct ZigbeeDeviceDiscoveryUpdate {
+    pub action: ZigbeeDeviceDiscoveryUpdateAction,
+    pub add_install_code: Option<ZigbeeDeviceDiscoveryInstallCode>,
+}