feat(Force Feedback): add interface to toggle force feedback on/off

Author: ShadowApex

rootfs/usr/share/polkit-1/actions/org.shadowblip.InputPlumber.policy

@@ -823,6 +823,16 @@
     </defaults>
   </action>
 
+  <action id="org.shadowblip.Output.ForceFeedback.Enable">
+    <description>Allow toggling support for rumble events</description>
+    <message>Authentication is required to toggle rumble support</message>
+    <defaults>
+      <allow_any>no</allow_any>
+      <allow_inactive>no</allow_inactive>
+      <allow_active>auth_admin</allow_active>
+    </defaults>
+  </action>
+
   <action id="org.shadowblip.Output.ForceFeedback.Rumble">
     <description>Allow sending force feedback rumble events</description>
     <message>Authentication is required to send rumble events</message>

src/dbus/interface/force_feedback.rs

@@ -14,11 +14,25 @@ use super::Unregisterable;
 
 /// [ForceFeedbacker] is any device that can implement force feedback
 pub trait ForceFeedbacker {
+    fn get_enabled(&self) -> impl Future<Output = Result<bool, 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;
 }
 
 impl ForceFeedbacker for CompositeDeviceClient {
+    async fn get_enabled(&self) -> Result<bool, Box<dyn Error>> {
+        Ok(self.get_ff_enabled().await?)
+    }
+
+    async fn set_enabled(&mut self, enabled: bool) -> Result<(), Box<dyn Error>> {
+        self.set_ff_enabled(enabled).await?;
+        Ok(())
+    }
+
     async fn rumble(&mut self, value: f64) -> Result<(), Box<dyn Error>> {
         let value = value.min(1.0);
         let value = value.max(0.0);
@@ -66,6 +80,28 @@ impl<T> ForceFeedbackInterface<T>
 where
     T: ForceFeedbacker + Send + Sync + 'static,
 {
+    /// Whether or not the device should send force feedback events
+    #[zbus(property)]
+    async fn enabled(&self) -> fdo::Result<bool> {
+        self.device
+            .get_enabled()
+            .await
+            .map_err(|err| fdo::Error::Failed(err.to_string()))
+    }
+    #[zbus(property)]
+    async fn set_enabled(
+        &mut self,
+        enabled: bool,
+        #[zbus(header)] hdr: Option<Header<'_>>,
+    ) -> fdo::Result<()> {
+        check_polkit(hdr, "org.shadowblip.Output.ForceFeedback.Enable").await?;
+        self.device
+            .set_enabled(enabled)
+            .await
+            .map_err(|err| fdo::Error::Failed(err.to_string()))?;
+        Ok(())
+    }
+
     /// Send a simple rumble event
     async fn rumble(&mut self, value: f64, #[zbus(header)] hdr: Header<'_>) -> fdo::Result<()> {
         check_polkit(Some(hdr), "org.shadowblip.Output.ForceFeedback.Rumble").await?;

src/input/composite_device/client.rs

@@ -523,4 +523,22 @@ impl CompositeDeviceClient {
         }
         Err(ClientError::ChannelClosed)
     }
+
+    /// Returns whether or not the device should emit force feedback events
+    pub async fn get_ff_enabled(&self) -> Result<bool, ClientError> {
+        let (tx, rx) = channel(1);
+        self.send(CompositeCommand::GetForceFeedbackEnabled(tx))
+            .await?;
+        if let Some(result) = Self::recv(rx).await {
+            return Ok(result);
+        }
+        Err(ClientError::ChannelClosed)
+    }
+
+    /// Enable or disable force feedback output events from being emitted
+    pub async fn set_ff_enabled(&self, enabled: bool) -> Result<(), ClientError> {
+        self.send(CompositeCommand::SetForceFeedbackEnabled(enabled))
+            .await?;
+        Ok(())
+    }
 }

src/input/composite_device/command.rs

@@ -42,6 +42,8 @@ pub enum CompositeCommand {
     SetInterceptActivation(Vec<Capability>, Capability),
     SetInterceptMode(InterceptMode),
     SetTargetDevices(Vec<TargetDeviceTypeId>),
+    GetForceFeedbackEnabled(mpsc::Sender<bool>),
+    SetForceFeedbackEnabled(bool),
     SourceDeviceAdded(DeviceInfo),
     SourceDeviceRemoved(DeviceInfo),
     SourceDeviceStopped(DeviceInfo),

src/input/composite_device/mod.rs

@@ -14,14 +14,17 @@ use std::{
 use evdev::InputEvent;
 use targets::CompositeDeviceTargets;
 use tokio::{sync::mpsc, task::JoinSet, time::Duration};
-use zbus::Connection;
+use zbus::{object_server::Interface, Connection};
 
 use crate::{
     config::{
         capability_map::CapabilityMapConfig, path::get_profiles_path, CompositeDeviceConfig,
         DeviceProfile, ProfileMapping,
     },
-    dbus::interface::{composite_device::CompositeDeviceInterface, DBusInterfaceManager},
+    dbus::interface::{
+        composite_device::CompositeDeviceInterface, force_feedback::ForceFeedbackInterface,
+        DBusInterfaceManager,
+    },
     input::{
         capability::{Capability, Gamepad, GamepadButton, Mouse},
         event::{
@@ -77,8 +80,12 @@ pub struct CompositeDevice {
     name: String,
     /// Capabilities describe all input capabilities from all source devices
     capabilities: HashSet<Capability>,
+    /// Capabilities sorted by source device id
+    capabilities_by_source: HashMap<String, HashSet<Capability>>,
     /// Output capabilities describe all output capabilities from all source devices
     output_capabilities: HashSet<OutputCapability>,
+    /// Output capabilities sorted by source device id.
+    output_capabilities_by_source: HashMap<String, HashSet<OutputCapability>>,
     /// Capability mapping for the CompositeDevice
     capability_map: Option<CapabilityMapConfig>,
     /// Currently loaded [DeviceProfile] for the [CompositeDevice]. The [DeviceProfile]
@@ -127,6 +134,9 @@ pub struct CompositeDevice {
     source_devices_used: Vec<String>,
     /// State of target devices attached to the composite device
     targets: CompositeDeviceTargets,
+    /// Whether or not force feedback output events should be routed to
+    /// supported source devices.
+    ff_enabled: bool,
     /// Set of available Force Feedback effect IDs that are not in use
     /// TODO: Just use the keys from ff_effect_id_source_map to determine next id
     ff_effect_ids: BTreeSet<i16>,
@@ -169,7 +179,9 @@ impl CompositeDevice {
             config,
             name,
             capabilities: HashSet::new(),
+            capabilities_by_source: HashMap::new(),
             output_capabilities: HashSet::new(),
+            output_capabilities_by_source: HashMap::new(),
             capability_map,
             device_profile: None,
             device_profile_path: None,
@@ -189,6 +201,7 @@ impl CompositeDevice {
             source_device_tasks: JoinSet::new(),
             source_devices_used: Vec::new(),
             targets: CompositeDeviceTargets::new(conn, dbus_path, tx.into(), manager),
+            ff_enabled: true,
             ff_effect_ids: (0..64).collect(),
             ff_effect_id_source_map: HashMap::new(),
             intercept_activation_caps: vec![Capability::Gamepad(Gamepad::Button(
@@ -484,6 +497,15 @@ impl CompositeDevice {
                     CompositeCommand::SetInterceptActivation(activation_caps, target_cap) => {
                         self.set_intercept_activation(activation_caps, target_cap)
                     }
+                    CompositeCommand::GetForceFeedbackEnabled(sender) => {
+                        if let Err(e) = sender.send(self.ff_enabled).await {
+                            log::error!("Failed to send force feedback status: {e}");
+                        }
+                    }
+                    CompositeCommand::SetForceFeedbackEnabled(enabled) => {
+                        log::info!("Setting force feedback enabled: {enabled:?}");
+                        self.ff_enabled = enabled;
+                    }
                     CompositeCommand::Stop => {
                         log::debug!(
                             "Got STOP signal. Stopping CompositeDevice: {}",
@@ -785,6 +807,12 @@ impl CompositeDevice {
             return Ok(());
         }
 
+        // If force feedback is disabled at the composite device level, don't
+        // forward any other FF events to source devices.
+        if !self.ff_enabled && event.is_force_feedback() {
+            return Ok(());
+        }
+
         // TODO: Only write the event to devices that are capabile of handling it
         for (source_id, source) in self.source_devices.iter() {
             // If this is a force feedback event, translate the effect id into
@@ -1513,6 +1541,51 @@ impl CompositeDevice {
             self.ff_effect_ids.insert(effect_id);
         }
 
+        // Remove tracked input capabilities
+        self.capabilities_by_source.remove(&id);
+        let mut capabilities_to_remove = vec![];
+        for capability in self.capabilities.iter() {
+            // Check if any surviving source devices use this capability
+            let capability_in_use = self
+                .capabilities_by_source
+                .iter()
+                .any(|(_, capabilities)| capabilities.contains(capability));
+            if capability_in_use {
+                continue;
+            }
+            capabilities_to_remove.push(capability.clone());
+        }
+        for capability in capabilities_to_remove {
+            self.capabilities.remove(&capability);
+        }
+
+        // Remove tracked output capabilities
+        self.output_capabilities_by_source.remove(&id);
+        let mut capabilities_to_remove = vec![];
+        for capability in self.output_capabilities.iter() {
+            // Check if any surviving source devices use this capability
+            let capability_in_use = self
+                .output_capabilities_by_source
+                .iter()
+                .any(|(_, capabilities)| capabilities.contains(capability));
+            if capability_in_use {
+                continue;
+            }
+            capabilities_to_remove.push(capability.clone());
+        }
+        for capability in capabilities_to_remove {
+            self.output_capabilities.remove(&capability);
+        }
+
+        // Remove any interfaces that are no longer required
+        let ff_iface_name = ForceFeedbackInterface::<CompositeDeviceClient>::name();
+        let supports_ff = self
+            .output_capabilities
+            .contains(&OutputCapability::ForceFeedback);
+        if !supports_ff && self.dbus.has_interface(&ff_iface_name) {
+            self.dbus.unregister(&ff_iface_name);
+        }
+
         if let Some(idx) = self.source_device_paths.iter().position(|str| str == &path) {
             self.source_device_paths.remove(idx);
         };
@@ -1610,25 +1683,44 @@ impl CompositeDevice {
         };
 
         // Get the capabilities of the source device.
-        // TODO: When we *remove* a source device, we also need to remove
-        // capabilities
+        let id = source_device.get_id();
         if !is_blocked {
-            let capabilities = source_device.get_capabilities()?;
-            for cap in capabilities {
-                if self.translatable_capabilities.contains(&cap) {
+            // Get the input capabilities of the source device and keep track
+            // of them.
+            let capabilities: HashSet<Capability> =
+                source_device.get_capabilities()?.into_iter().collect();
+            for cap in capabilities.iter() {
+                if self.translatable_capabilities.contains(cap) {
                     continue;
                 }
-                self.capabilities.insert(cap);
+                self.capabilities.insert(cap.clone());
             }
+            self.capabilities_by_source.insert(id.clone(), capabilities);
 
-            let output_capabilities = source_device.get_output_capabilities()?;
-            for cap in output_capabilities {
-                self.output_capabilities.insert(cap);
+            // Get the output capabilities of the source device and keep track
+            // of them.
+            let output_capabilities: HashSet<OutputCapability> = source_device
+                .get_output_capabilities()?
+                .into_iter()
+                .collect();
+            for cap in output_capabilities.iter() {
+                self.output_capabilities.insert(cap.clone());
+            }
+            self.output_capabilities_by_source
+                .insert(id.clone(), output_capabilities);
+
+            // Determine if the FF dbus interface should be created
+            let supports_ff = self
+                .output_capabilities
+                .contains(&OutputCapability::ForceFeedback);
+            let ff_iface_name = ForceFeedbackInterface::<CompositeDeviceClient>::name();
+            if supports_ff && !self.dbus.has_interface(&ff_iface_name) {
+                let iface = ForceFeedbackInterface::new(self.client());
+                self.dbus.register(iface);
             }
         }
 
         // Check if this device should be blocked from sending events to target devices.
-        let id = source_device.get_id();
         if let Some(device_config) = self
             .config
             .get_matching_device(&source_device.get_device_ref().to_owned())

src/input/output_event/mod.rs

@@ -74,6 +74,20 @@ impl OutputEvent {
             OutputEvent::SteamDeckRumble(_) => vec![OutputCapability::ForceFeedback],
         }
     }
+
+    /// Returns true if the output event is a force feedback/rumble event
+    pub fn is_force_feedback(&self) -> bool {
+        match self {
+            OutputEvent::Evdev(event) => matches!(
+                event.destructure(),
+                evdev::EventSummary::ForceFeedback(_, _, _)
+            ),
+            OutputEvent::Uinput(_) => true,
+            OutputEvent::DualSense(report) => report.use_rumble_not_haptics,
+            OutputEvent::SteamDeckHaptics(_) => true,
+            OutputEvent::SteamDeckRumble(_) => true,
+        }
+    }
 }
 
 #[derive(Debug, Clone)]