feat(ForceFeedback): add dbus interface for rumble

Author: ShadowApex

src/dbus/interface/composite_device.rs

@@ -297,6 +297,21 @@ impl CompositeDeviceInterface {
         Ok(capability_strings)
     }
 
+    #[zbus(property)]
+    async fn output_capabilities(&self) -> fdo::Result<Vec<String>> {
+        let capabilities = self
+            .composite_device
+            .get_output_capabilities()
+            .await
+            .map_err(|e| fdo::Error::Failed(e.to_string()))?;
+        let capability_strings = capabilities
+            .into_iter()
+            .map(|cap| cap.to_string())
+            .collect();
+
+        Ok(capability_strings)
+    }
+
     /// List of capabilities that all target devices implement
     #[zbus(property)]
     async fn target_capabilities(&self) -> fdo::Result<Vec<String>> {

src/dbus/interface/force_feedback.rs

@@ -0,0 +1,83 @@
+use std::{error::Error, future::Future};
+
+use packed_struct::types::{Integer, SizedInteger};
+use zbus::fdo;
+use zbus_macros::interface;
+
+use crate::{
+    drivers::steam_deck::hid_report::PackedRumbleReport,
+    input::{composite_device::client::CompositeDeviceClient, output_event::OutputEvent},
+};
+
+/// [ForceFeedbacker] is any device that can implement force feedback
+pub trait ForceFeedbacker {
+    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;
+}
+
+impl ForceFeedbacker for CompositeDeviceClient {
+    async fn rumble(&mut self, value: f64) -> Result<(), Box<dyn Error>> {
+        let value = value.min(1.0);
+        let value = value.max(0.0);
+        log::debug!("Sending rumble event with value: {value}");
+        let report = PackedRumbleReport {
+            intensity: (value * u8::MAX as f64) as u8,
+            left_speed: Integer::from_primitive((value * u16::MAX as f64) as u16),
+            right_speed: Integer::from_primitive((value * u16::MAX as f64) as u16),
+            ..Default::default()
+        };
+        let event = OutputEvent::SteamDeckRumble(report);
+        self.process_output_event(event).await?;
+        Ok(())
+    }
+
+    async fn stop(&mut self) -> Result<(), Box<dyn Error>> {
+        self.rumble(0.0).await
+    }
+}
+
+/// The [ForceFeedbackInterface] provides a DBus interface that can be exposed for
+/// managing force feedback events over dbus.
+pub struct ForceFeedbackInterface<T>
+where
+    T: ForceFeedbacker + Send + Sync,
+{
+    device: T,
+}
+
+impl<T> ForceFeedbackInterface<T>
+where
+    T: ForceFeedbacker + Send + Sync + 'static,
+{
+    /// Create a new dbus interface for the given force feedback device
+    pub fn new(device: T) -> Self {
+        Self { device }
+    }
+}
+
+#[interface(
+    name = "org.shadowblip.Output.ForceFeedback",
+    proxy(default_service = "org.shadowblip.InputPlumber",)
+)]
+impl<T> ForceFeedbackInterface<T>
+where
+    T: ForceFeedbacker + Send + Sync + 'static,
+{
+    /// Send a simple rumble event
+    async fn rumble(&mut self, value: f64) -> fdo::Result<()> {
+        self.device
+            .rumble(value)
+            .await
+            .map_err(|err| fdo::Error::Failed(err.to_string()))?;
+        Ok(())
+    }
+
+    /// Stop all currently playing force feedback effects
+    async fn stop(&mut self) -> fdo::Result<()> {
+        self.device
+            .stop()
+            .await
+            .map_err(|err| fdo::Error::Failed(err.to_string()))?;
+        Ok(())
+    }
+}

src/dbus/interface/mod.rs

@@ -1,4 +1,5 @@
 pub mod composite_device;
+pub mod force_feedback;
 pub mod manager;
 pub mod performance;
 pub mod source;

src/input/composite_device/client.rs

@@ -8,6 +8,7 @@ use tokio::sync::mpsc::{channel, error::SendError, Sender};
 use crate::config::CompositeDeviceConfig;
 use crate::input::event::native::NativeEvent;
 use crate::input::info::DeviceInfo;
+use crate::input::output_capability::OutputCapability;
 use crate::input::target::client::TargetDeviceClient;
 use crate::input::target::TargetDeviceTypeId;
 use crate::input::{capability::Capability, event::Event, output_event::OutputEvent};
@@ -18,6 +19,7 @@ use super::{CompositeCommand, InterceptMode};
 /// Maximum duration to wait for a response from a command. If this timeout
 /// is reached, that typically indicates a deadlock somewhere in the code.
 const DEFAULT_TIMEOUT: Duration = Duration::from_secs(5);
+
 /// Possible errors for a composite device client
 #[derive(Error, Debug)]
 pub enum ClientError {
@@ -152,6 +154,31 @@ impl CompositeDeviceClient {
         Err(ClientError::ChannelClosed)
     }
 
+    /// Get the output capabilities from all source devices
+    pub async fn get_output_capabilities(&self) -> Result<HashSet<OutputCapability>, ClientError> {
+        let (tx, rx) = channel(1);
+        self.tx
+            .send(CompositeCommand::GetOutputCapabilities(tx))
+            .await?;
+        if let Some(capabilities) = Self::recv(rx).await {
+            return Ok(capabilities);
+        }
+        Err(ClientError::ChannelClosed)
+    }
+
+    /// Get the output capabilities from all source devices (blocking)
+    #[allow(dead_code)]
+    pub fn blocking_get_output_capabilities(
+        &self,
+    ) -> Result<HashSet<OutputCapability>, ClientError> {
+        let (tx, mut rx) = channel(1);
+        self.tx
+            .blocking_send(CompositeCommand::GetOutputCapabilities(tx))?;
+        if let Some(capabilities) = rx.blocking_recv() {
+            return Ok(capabilities);
+        }
+        Err(ClientError::ChannelClosed)
+    }
 
     /// Get the [CompositeDeviceConfig] from the [CompositeDevice]
     pub async fn get_config(&self) -> Result<CompositeDeviceConfig, ClientError> {

src/input/composite_device/command.rs

@@ -8,6 +8,7 @@ use crate::{
         capability::Capability,
         event::{native::NativeEvent, Event},
         info::DeviceInfo,
+        output_capability::OutputCapability,
         output_event::OutputEvent,
         target::{client::TargetDeviceClient, TargetDeviceTypeId},
     },
@@ -23,6 +24,7 @@ pub enum CompositeCommand {
     AttachTargetDevices(HashMap<String, TargetDeviceClient>),
     GetConfig(mpsc::Sender<CompositeDeviceConfig>),
     GetCapabilities(mpsc::Sender<HashSet<Capability>>),
+    GetOutputCapabilities(mpsc::Sender<HashSet<OutputCapability>>),
     GetDBusDevicePaths(mpsc::Sender<Vec<String>>),
     GetInterceptMode(mpsc::Sender<InterceptMode>),
     GetName(mpsc::Sender<String>),

src/input/composite_device/mod.rs

@@ -35,6 +35,7 @@ use crate::{
             value::{InputValue, TranslationError},
             Event,
         },
+        output_capability::OutputCapability,
         output_event::UinputOutputEvent,
         source::{
             evdev::EventDevice, hidraw::HidRawDevice, iio::IioDevice, led::LedDevice, SourceDevice,
@@ -82,6 +83,8 @@ pub struct CompositeDevice {
     name: String,
     /// Capabilities describe all input capabilities from all source devices
     capabilities: HashSet<Capability>,
+    /// Output capabilities describe all output capabilities from all source devices
+    output_capabilities: HashSet<OutputCapability>,
     /// Capability mapping for the CompositeDevice
     capability_map: Option<CapabilityMapConfig>,
     /// Currently loaded [DeviceProfile] for the [CompositeDevice]. The [DeviceProfile]
@@ -173,6 +176,7 @@ impl CompositeDevice {
             config,
             name,
             capabilities: HashSet::new(),
+            output_capabilities: HashSet::new(),
             capability_map,
             device_profile: None,
             device_profile_path: None,
@@ -254,7 +258,7 @@ impl CompositeDevice {
     }
 
     /// Creates a new instance of the composite device interface on DBus.
-    pub async fn listen_on_dbus(&self) -> Result<JoinHandle<()>, Box<dyn Error>> {
+    pub async fn listen_on_dbus(&mut self) -> Result<JoinHandle<()>, Box<dyn Error>> {
         let conn = self.conn.clone();
         let client = self.client();
         let path = String::from(self.dbus_path());
@@ -323,6 +327,11 @@ impl CompositeDevice {
                             log::error!("Failed to send capabilities: {:?}", e);
                         }
                     }
+                    CompositeCommand::GetOutputCapabilities(sender) => {
+                        if let Err(e) = sender.send(self.output_capabilities.clone()).await {
+                            log::debug!("Failed to send output capabilities: {:?}", e);
+                        }
+                    }
                     CompositeCommand::GetTargetCapabilities(sender) => {
                         let target_caps = match self.targets.get_capabilities().await {
                             Ok(caps) => caps,
@@ -1619,6 +1628,11 @@ impl CompositeDevice {
                 }
                 self.capabilities.insert(cap);
             }
+
+            let output_capabilities = source_device.get_output_capabilities()?;
+            for cap in output_capabilities {
+                self.output_capabilities.insert(cap);
+            }
         }
 
         // Check if this device should be blocked from sending events to target devices.

src/input/composite_device/targets.rs

@@ -91,6 +91,28 @@ impl CompositeDeviceTargets {
 
     /// Sets the DBus target devices attached to a [CompositeDevice]
     pub fn set_dbus_devices(&mut self, devices: HashMap<String, TargetDeviceClient>) {
+        // Notify the dbus device of the source device(s) capabilities
+        for dbus_device in devices.values() {
+            let device = self.device.clone();
+            let target = dbus_device.clone();
+            tokio::task::spawn(async move {
+                let source_capabilities = device.get_capabilities().await.unwrap_or_default();
+                let source_output_capabilities =
+                    device.get_output_capabilities().await.unwrap_or_default();
+                target
+                    .set_composite_device(device)
+                    .await
+                    .unwrap_or_default();
+                target
+                    .notify_capabilities_changed(source_capabilities)
+                    .await
+                    .unwrap_or_default();
+                target
+                    .notify_output_capabilities_changed(source_output_capabilities)
+                    .await
+                    .unwrap_or_default();
+            });
+        }
         self.target_dbus_devices = devices;
     }
 
@@ -437,6 +459,23 @@ impl CompositeDeviceTargets {
             }
             log::debug!("[{dbus_path}] Attached device {path}");
 
+            // Notify the target device of the supported source capabilities
+            let device = self.device.clone();
+            let target_clone = target.clone();
+            tokio::task::spawn(async move {
+                let source_capabilities = device.get_capabilities().await.unwrap_or_default();
+                let source_output_capabilities =
+                    device.get_output_capabilities().await.unwrap_or_default();
+                target_clone
+                    .notify_capabilities_changed(source_capabilities)
+                    .await
+                    .unwrap_or_default();
+                target_clone
+                    .notify_output_capabilities_changed(source_output_capabilities)
+                    .await
+                    .unwrap_or_default();
+            });
+
             // Track the target device by capabilities it has
             for cap in caps {
                 self.target_devices_by_capability

src/input/output_capability.rs

@@ -1,3 +1,5 @@
+use std::fmt::Display;
+
 /// Output capabilities describe what kind of output events a source input device
 /// is capable of handling. E.g. Force Feedback, LED control, etc.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
@@ -11,6 +13,21 @@ pub enum OutputCapability {
     LED(LED),
 }
 
+impl Display for OutputCapability {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let str = match self {
+            OutputCapability::NotImplemented => "NotImplemented".to_string(),
+            OutputCapability::ForceFeedback => "ForceFeedback".to_string(),
+            OutputCapability::ForceFeedbackUpload => "ForceFeedbackUpload".to_string(),
+            OutputCapability::ForceFeedbackErase => "ForceFeedbackErase".to_string(),
+            OutputCapability::Haptics(haptic) => format!("Haptics:{haptic}"),
+            OutputCapability::LED(led) => format!("LED:{led}"),
+        };
+
+        write!(f, "{}", str)
+    }
+}
+
 /// LED capability
 #[allow(clippy::upper_case_acronyms)]
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
@@ -19,10 +36,32 @@ pub enum LED {
     Color,
 }
 
+impl Display for LED {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let str = match self {
+            LED::Brightness => "Brightness",
+            LED::Color => "Color",
+        };
+
+        write!(f, "{}", str)
+    }
+}
+
 /// Haptic capabilities
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum Haptic {
     TrackpadLeft,
     TrackpadRight,
     //TrackpadCenter,
 }
+
+impl Display for Haptic {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let str = match self {
+            Haptic::TrackpadLeft => "TrackpadLeft",
+            Haptic::TrackpadRight => "TrackpadRight",
+        };
+
+        write!(f, "{}", str)
+    }
+}

src/input/source/evdev.rs

@@ -15,13 +15,16 @@ use crate::{
         capability_map::{load_capability_mappings, CapabilityMapConfig},
     },
     constants::BUS_SOURCES_PREFIX,
-    input::{composite_device::client::CompositeDeviceClient, info::DeviceInfoRef},
+    input::{
+        capability::Capability, composite_device::client::CompositeDeviceClient,
+        info::DeviceInfoRef, output_capability::OutputCapability,
+    },
     udev::device::UdevDevice,
 };
 
 use self::{blocked::BlockedEventDevice, gamepad::GamepadEventDevice};
 
-use super::{SourceDeviceCompatible, SourceDriver, SourceDriverOptions};
+use super::{OutputError, SourceDeviceCompatible, SourceDriver, SourceDriverOptions};
 
 /// List of available drivers
 enum DriverType {
@@ -77,9 +80,7 @@ impl SourceDeviceCompatible for EventDevice {
         }
     }
 
-    fn get_capabilities(
-        &self,
-    ) -> Result<Vec<crate::input::capability::Capability>, super::InputError> {
+    fn get_capabilities(&self) -> Result<Vec<Capability>, super::InputError> {
         match self {
             EventDevice::Blocked(source_driver) => source_driver.get_capabilities(),
             EventDevice::Gamepad(source_driver) => source_driver.get_capabilities(),
@@ -88,6 +89,15 @@ impl SourceDeviceCompatible for EventDevice {
         }
     }
 
+    fn get_output_capabilities(&self) -> Result<Vec<OutputCapability>, OutputError> {
+        match self {
+            EventDevice::Blocked(source_driver) => source_driver.get_output_capabilities(),
+            EventDevice::Gamepad(source_driver) => source_driver.get_output_capabilities(),
+            EventDevice::Touchscreen(source_driver) => source_driver.get_output_capabilities(),
+            EventDevice::Keyboard(source_driver) => source_driver.get_output_capabilities(),
+        }
+    }
+
     fn get_device_path(&self) -> String {
         match self {
             EventDevice::Blocked(source_driver) => source_driver.get_device_path(),