feat: add wayland implementation and basic dbus method to take screenshot

Cargo.toml

@@ -24,3 +24,5 @@ inotify = "0.11.0"
 gamescope-wayland-client = { git = "https://github.com/ShadowBlip/gamescope-wayland-client.git", version = "0.1.0" }
 gamescope-x11-client = { git = "https://github.com/ShadowBlip/gamescope-x11-client.git", rev = "9526a6e0d684d9530e8705f7f1a53efa401350f3" }
 serde = "1.0.214"
+nix = { version = "0.29.0", features = ["user"] }
+tokio-stream = "0.1.17"

src/gamescope/manager.rs

@@ -5,12 +5,13 @@ use zbus_macros::dbus_interface;
 
 use crate::watcher::{self, WatchEvent};
 
-use super::xwayland;
+use super::{wayland, xwayland};
 
 /// Manager commands define all the different ways to interact with [Manager]
 /// over a channel. These commands are processed in an asyncronous thread and
 /// dispatched as they come in.
 #[derive(Debug)]
+#[allow(dead_code)]
 pub enum Command {
     FilesystemEvent { event: WatchEvent },
     XWaylandAdded { name: String },
@@ -45,6 +46,18 @@ impl Manager {
         }
     }
 
+    /// Starts the wayland manager and adds its dbus interface
+    pub async fn start_wayland_manager(&self) -> Result<(), Box<dyn Error>> {
+        let path = "/org/shadowblip/Gamescope/Wayland".to_owned();
+        let interface = wayland::dbus::DBusInterface::new(path.clone(), self.dbus.clone()).await?;
+        self.dbus
+            .object_server()
+            .at(path.clone(), interface)
+            .await?;
+        log::info!("Initialized wayland manager at path:{path}");
+        Ok(())
+    }
+
     /// Starts listening for [Command] messages to be sent from clients and
     /// dispatch those events.
     pub async fn run(&mut self) -> Result<(), Box<dyn Error>> {

src/gamescope/wayland/dbus.rs

@@ -0,0 +1,85 @@
+use std::error::Error;
+
+use gamescope_wayland_client::control::gamescope_control::ScreenshotType;
+use zbus::{dbus_interface, fdo, Connection};
+
+use super::manager::{screenshot_type_from_u8, WaylandManager, WaylandMessage};
+
+/// DBus interface implementation for Gamescope Wayland instance.
+#[allow(dead_code)]
+pub struct DBusInterface {
+    path: String,
+    wayland: WaylandManager,
+    dbus: Connection,
+}
+
+#[allow(dead_code)]
+impl DBusInterface {
+    /// Returns a new instance of the Wayland DBus interface. Will error if
+    /// it cannot establish a connection.
+    pub async fn new(path: String, dbus: Connection) -> Result<DBusInterface, Box<dyn Error>> {
+        let wayland = WaylandManager::new().await?;
+
+        Ok(DBusInterface {
+            path,
+            wayland,
+            dbus,
+        })
+    }
+
+    /// Returns a reference to the dbus interface
+    async fn get_interface(&self) -> Result<zbus::InterfaceRef<DBusInterface>, zbus::Error> {
+        self.dbus
+            .clone()
+            .object_server()
+            .interface::<_, DBusInterface>(self.path.clone())
+            .await
+    }
+}
+
+#[dbus_interface(name = "org.shadowblip.Gamescope.Wayland")]
+impl DBusInterface {
+    /// Takes a screenshot using Wayland
+    /// the screenshot_type u8 converts to [ScreenshotType]
+    /// 0 => [ScreenshotType::AllRealLayers]
+    /// 1 => [ScreenshotType::BasePlaneOnly]
+    /// 2 => [ScreenshotType::FullComposition]
+    /// 3 => [ScreenshotType::ScreenBuffer]
+    pub async fn take_screenshot(&self, file_path: String, screenshot_type: u8) -> fdo::Result<()> {
+        let (tx, mut rx) = tokio::sync::mpsc::channel::<Result<(), String>>(16);
+        let Some(screenshot_type): Option<ScreenshotType> =
+            screenshot_type_from_u8(screenshot_type)
+        else {
+            return Err(fdo_error("Invalid screenshot type"));
+        };
+
+        self.wayland
+            .send(WaylandMessage::CommandTakeScreenshot(
+                tx,
+                file_path,
+                screenshot_type,
+            ))
+            .await
+            .map_err(|err| to_fdo_error("Error when sending screenshot command", err))?;
+
+        match rx.recv().await {
+            Some(Ok(_)) => {
+                log::info!("Screenshot taken");
+                Ok(())
+            }
+            Some(Err(err)) => Err(to_fdo_error("Error from screenshot command", err.into())),
+            None => Err(fdo_error("No response received for screenshot command")),
+        }
+    }
+}
+
+fn to_fdo_error(description: &str, err: Box<dyn Error>) -> fdo::Error {
+    let err = format!("{description}, err:{err:?}");
+    log::error!("{err}");
+    fdo::Error::Failed(err)
+}
+
+fn fdo_error(description: &str) -> fdo::Error {
+    log::error!("{description}");
+    fdo::Error::Failed(description.to_owned())
+}