WIP: LED interface

Author: ShadowApex

src/dbus/interface/led.rs

@@ -0,0 +1,195 @@
+use std::{error::Error, future::Future};
+
+use zbus::{fdo, message::Header, Connection};
+use zbus_macros::interface;
+
+use crate::dbus::polkit::check_polkit;
+
+use super::Unregisterable;
+
+/// [LedEmitter] is any device that can implement changing LED colors
+pub trait LedEmitter {
+    fn name(&self) -> impl Future<Output = Result<String, Box<dyn Error>>> + Send;
+    fn get_colors_available(
+        &self,
+    ) -> impl Future<Output = Result<Vec<String>, Box<dyn Error>>> + Send;
+    fn set_enabled(
+        &mut self,
+        enabled: bool,
+    ) -> impl Future<Output = Result<(), Box<dyn Error>>> + Send;
+    fn rumble(&mut self, value: f64) -> impl Future<Output = Result<(), Box<dyn Error>>> + Send;
+    fn stop(&mut self) -> impl Future<Output = Result<(), Box<dyn Error>>> + Send;
+}
+
+/// DBus interface for a particular LED zone
+pub struct LedInterface<T>
+where
+    T: LedEmitter + Send + Sync,
+{
+    device: T,
+    name: String,
+    colors: Vec<String>,
+}
+
+impl<T> LedInterface<T>
+where
+    T: LedEmitter + Send + Sync,
+{
+    /// Create a new dbus interface for the given LED zone
+    pub fn new(device: T, name: String, colors: Vec<String>) -> Self {
+        Self {
+            device,
+            name,
+            colors,
+        }
+    }
+}
+
+#[interface(
+    name = "org.shadowblip.Output.LED",
+    proxy(default_service = "org.shadowblip.InputPlumber")
+)]
+impl<T> LedInterface<T>
+where
+    T: LedEmitter + Send + Sync + 'static,
+{
+    /// Name of the LED zone
+    #[zbus(property)]
+    async fn name(&self) -> fdo::Result<String> {
+        Ok(self.name.clone())
+    }
+
+    /// Colors available for the LED zone
+    #[zbus(property)]
+    async fn colors(&self) -> fdo::Result<Vec<String>> {
+        Ok(self.colors.clone())
+    }
+}
+
+impl<T> Unregisterable for LedInterface<T> where T: LedEmitter + Send + Sync {}
+
+/// DBus interface for controlling a single LED color
+pub struct LedColorInterface {
+    color: String,
+    value: f64,
+    brightness: f64,
+}
+
+impl LedColorInterface {
+    /// Create a new dbus interface for the given color
+    pub fn new(color: &str) -> Self {
+        Self {
+            color: color.to_string(),
+            value: 0.0,
+            brightness: 0.0,
+        }
+    }
+
+    /// Update the color value
+    pub fn update_value(conn: &Connection, path: &str, value: f64) {
+        let conn = conn.clone();
+        let path = path.to_string();
+        tokio::task::spawn(async move {
+            // Get the object instance at the given path so we can send DBus signal
+            // updates
+            let iface_ref = match conn
+                .object_server()
+                .interface::<_, Self>(path.clone())
+                .await
+            {
+                Ok(iface) => iface,
+                Err(e) => {
+                    log::error!("Failed to get DBus interface {path}: {e}");
+                    return;
+                }
+            };
+
+            let mut iface = iface_ref.get_mut().await;
+            iface.value = value;
+            let result = iface.value_changed(iface_ref.signal_emitter()).await;
+            if let Err(e) = result {
+                log::error!("Failed to signal property changed: {e}");
+            }
+        });
+    }
+
+    /// Update the color brightness
+    pub fn update_brightness(conn: &Connection, path: &str, value: f64) {
+        let conn = conn.clone();
+        let path = path.to_string();
+        tokio::task::spawn(async move {
+            // Get the object instance at the given path so we can send DBus signal
+            // updates
+            let iface_ref = match conn
+                .object_server()
+                .interface::<_, Self>(path.clone())
+                .await
+            {
+                Ok(iface) => iface,
+                Err(e) => {
+                    log::error!("Failed to get DBus interface {path}: {e}");
+                    return;
+                }
+            };
+
+            let mut iface = iface_ref.get_mut().await;
+            iface.brightness = value;
+            let result = iface.brightness_changed(iface_ref.signal_emitter()).await;
+            if let Err(e) = result {
+                log::error!("Failed to signal property changed: {e}");
+            }
+        });
+    }
+}
+
+#[interface(
+    name = "org.shadowblip.Output.LED.Color",
+    proxy(default_service = "org.shadowblip.InputPlumber")
+)]
+impl LedColorInterface {
+    /// Name of the LED color
+    #[zbus(property)]
+    async fn color(&self) -> fdo::Result<String> {
+        Ok(self.color.clone())
+    }
+
+    /// Intensity value of the LED color. A value of 1.0 is maximum intensity, and 0.0 is minimum
+    /// intensity.
+    #[zbus(property)]
+    async fn value(&self) -> fdo::Result<f64> {
+        Ok(self.value)
+    }
+
+    #[zbus(property)]
+    async fn set_value(
+        &mut self,
+        value: f64,
+        #[zbus(connection)] conn: &Connection,
+        #[zbus(header)] hdr: Option<Header<'_>>,
+    ) -> fdo::Result<()> {
+        check_polkit(conn, hdr, "org.shadowblip.Output.LED.Color.Value").await?;
+        self.value = value.clamp(0.0, 1.0);
+        Ok(())
+    }
+
+    /// Brightness value of the LED color. A value of 1.0 is maximum brightness, and 0.0 is minimum
+    /// brightness.
+    #[zbus(property)]
+    async fn brightness(&self) -> fdo::Result<f64> {
+        Ok(0.0)
+    }
+
+    #[zbus(property)]
+    async fn set_brightness(
+        &mut self,
+        value: f64,
+        #[zbus(connection)] conn: &Connection,
+        #[zbus(header)] hdr: Option<Header<'_>>,
+    ) -> fdo::Result<()> {
+        check_polkit(conn, hdr, "org.shadowblip.Output.LED.Color.Brightness").await?;
+        self.brightness = value.clamp(0.0, 1.0);
+        Ok(())
+    }
+}
+
+impl Unregisterable for LedColorInterface {}

src/dbus/interface/mod.rs

@@ -5,6 +5,7 @@ use zbus::{names::InterfaceName, object_server::Interface, zvariant::ObjectPath,
 
 pub mod composite_device;
 pub mod force_feedback;
+pub mod led;
 pub mod manager;
 pub mod performance;
 pub mod source;
@@ -19,13 +20,14 @@ pub enum InterfaceError {
 /// Manages dbus interface registration and deregistration. When the interface
 /// manager goes out of scope, all registered interfaces are automatically
 /// unregistered.
-pub struct DBusInterfaceManager {
+pub struct DBusInterfaceManager<'path> {
     dbus: Connection,
     dbus_path: String,
     dbus_ifaces: HashMap<InterfaceName<'static>, Box<UnregisterFn>>,
+    children: HashMap<ObjectPath<'path>, DBusInterfaceManager<'path>>,
 }
 
-impl DBusInterfaceManager {
+impl<'path> DBusInterfaceManager<'path> {
     /// Creates a new dbus interface manager to manage one or more dbus interfaces
     /// for the given dbus path.
     ///
@@ -71,6 +73,7 @@ impl DBusInterfaceManager {
             dbus: conn,
             dbus_path: dbus_path.to_string(),
             dbus_ifaces: Default::default(),
+            children: Default::default(),
         })
     }
 
@@ -135,6 +138,35 @@ impl DBusInterfaceManager {
         });
     }
 
+    /// Register and start the given dbus interface as a child object. The given
+    /// path should be relative to the parent path.
+    pub fn register_child<P, I>(&mut self, path: P, iface: I) -> Result<(), InterfaceError>
+    where
+        P: TryInto<ObjectPath<'path>>,
+        I: Interface + Unregisterable,
+    {
+        let parent_path = self.path();
+        let child_path: ObjectPath<'path> = match path.try_into() {
+            Ok(path) => path,
+            Err(_) => {
+                return Err(InterfaceError::PathError);
+            }
+        };
+
+        let path = format!("{parent_path}{}", child_path.to_string());
+        let path: ObjectPath<'path> = match path.try_into() {
+            Ok(path) => path,
+            Err(_) => {
+                return Err(InterfaceError::PathError);
+            }
+        };
+        let mut child_manager = Self::new(self.connection().clone(), path.clone())?;
+        child_manager.register(iface);
+        self.children.insert(path, child_manager);
+
+        Ok(())
+    }
+
     /// Returns true if the interface with the given name has been registered.
     pub fn has_interface(&self, iface_name: &InterfaceName<'static>) -> bool {
         self.dbus_ifaces.contains_key(iface_name)
@@ -190,7 +222,7 @@ impl DBusInterfaceManager {
     }
 }
 
-impl Debug for DBusInterfaceManager {
+impl Debug for DBusInterfaceManager<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let mut dbus_ifaces: HashMap<String, &str> = HashMap::with_capacity(self.dbus_ifaces.len());
         for (key, _value) in self.dbus_ifaces.iter() {
@@ -204,7 +236,7 @@ impl Debug for DBusInterfaceManager {
     }
 }
 
-impl Drop for DBusInterfaceManager {
+impl Drop for DBusInterfaceManager<'_> {
     /// Unregister all dbus interfaces when this goes out of scope
     fn drop(&mut self) {
         self.unregister_all();

src/input/composite_device/mod.rs

@@ -32,7 +32,7 @@ use crate::{
             value::{InputValue, TranslationError},
             Event,
         },
-        output_capability::OutputCapability,
+        output_capability::{OutputCapability, LED},
         output_event::UinputOutputEvent,
         source::{
             evdev::EventDevice, hidraw::HidRawDevice, iio::IioDevice, led::LedDevice,
@@ -1800,6 +1800,11 @@ impl CompositeDevice {
                 let iface = ForceFeedbackInterface::new(self.client());
                 self.dbus.register(iface);
             }
+
+            // Determine if the LED dbus interface(s) should be created
+            let supports_leds = self
+                .output_capabilities
+                .contains(&OutputCapability::LED(LED::Color));
         }
 
         // Check if this device should be blocked from sending events to target devices.