@desklink/host 0.5.8 → 0.5.10

package/engine/src/portal.rs

@@ -47,13 +47,20 @@ pub async fn open_display(_: Option<u32>) -> Result<PortalSession> {
     anyhow::bail!("display selection is only supported on macOS")
 }
 
+/// The portal service answered without a ScreenCast interface. That happens
+/// when xdg-desktop-portal started before the compositor's portal and cached an
+/// interface list without it; only a restart makes it look again.
+const NO_SCREENCAST: &str = "compositor has no ScreenCast portal: xdg-desktop-portal does not export \
+org.freedesktop.portal.ScreenCast. If it started before the compositor's portal, run \
+`systemctl --user restart xdg-desktop-portal` once the compositor portal is running";
+
 pub async fn open(
     restore_token: Option<&str>,
     cursor: crate::protocol::CursorMode,
 ) -> Result<PortalSession> {
     let proxy = Screencast::new()
         .await
-        .context("compositor has no ScreenCast portal")?;
+        .context(NO_SCREENCAST)?;
 
     if proxy
         .available_source_types()
@@ -142,3 +149,78 @@ fn choose_cursor_mode(available: BitFlags<CursorMode>) -> Result<CursorMode> {
         .find(|mode| available.contains(*mode))
         .context("cursor-unavailable: portal cannot leave the cursor out of capture")
 }
+
+#[cfg(all(test, target_os = "linux"))]
+mod tests {
+    use super::*;
+    use std::process::{Child, Command, Stdio};
+    use zbus::{connection::Builder, message::Type, MessageStream};
+
+    struct Bus(Child);
+
+    impl Drop for Bus {
+        fn drop(&mut self) {
+            let _ = self.0.kill();
+            let _ = self.0.wait();
+        }
+    }
+
+    /// A private session bus whose `org.freedesktop.portal.Desktop` owner
+    /// answers every property read the way a stale xdg-desktop-portal answers
+    /// for ScreenCast: no such interface.
+    #[tokio::test]
+    async fn open_names_the_fix_when_the_portal_exports_no_screencast() {
+        use zbus::export::futures_core::Stream;
+
+        let mut daemon = Command::new("dbus-daemon")
+            .args(["--session", "--nofork", "--print-address=1"])
+            .stdout(Stdio::piped())
+            .spawn()
+            .expect("dbus-daemon");
+        let mut address = String::new();
+        std::io::BufRead::read_line(
+            &mut std::io::BufReader::new(daemon.stdout.take().unwrap()),
+            &mut address,
+        )
+        .unwrap();
+        let _bus = Bus(daemon);
+        let address = address.trim().to_owned();
+
+        let fake = Builder::address(address.as_str())
+            .unwrap()
+            .name("org.freedesktop.portal.Desktop")
+            .unwrap()
+            .build()
+            .await
+            .unwrap();
+        let service = fake.clone();
+        let answering = tokio::spawn(async move {
+            let mut messages = MessageStream::from(&service);
+            while let Some(Ok(message)) =
+                std::future::poll_fn(|cx| std::pin::Pin::new(&mut messages).poll_next(cx)).await
+            {
+                if message.message_type() != Type::MethodCall {
+                    continue;
+                }
+                let _ = service
+                    .reply_dbus_error(
+                        &message.header(),
+                        zbus::fdo::Error::InvalidArgs(
+                            "No such interface \u{201c}org.freedesktop.portal.ScreenCast\u{201d}".into(),
+                        ),
+                    )
+                    .await;
+            }
+        });
+        // Screencast::new reads the session bus from the environment.
+        std::env::set_var("DBUS_SESSION_BUS_ADDRESS", &address);
+
+        let error = match open(None, crate::protocol::CursorMode::Embedded).await {
+            Ok(_) => panic!("a portal without ScreenCast must not open a session"),
+            Err(error) => format!("{error:#}"),
+        };
+        answering.abort();
+        assert!(error.starts_with("compositor has no ScreenCast portal"), "{error}");
+        assert!(error.contains("systemctl --user restart xdg-desktop-portal"), "{error}");
+    }
+}

package/engine/src/protocol.rs

@@ -149,6 +149,11 @@ pub struct OpenParams {
     /// cannot be answered is refused.
     #[serde(default)]
     pub audio: bool,
+    /// Observe this computer's own pointer buttons, cursor and keys and raise
+    /// them as `session.input.observed` and `session.cursor`. Off unless asked:
+    /// it reports every key typed on the desktop, in every application.
+    #[serde(default)]
+    pub observe_input: bool,
 }
 
 fn default_local_frames() -> bool {
@@ -379,7 +384,7 @@ impl ControlMessage {
     }
 }
 
-#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum PointerPhase {
     Move,
@@ -388,6 +393,30 @@ pub enum PointerPhase {
     Cancel,
 }
 
+/// A pointer button or key the person pressed on the observed desktop. The
+/// vocabulary is the control channel's own (`pointer` and `key`), so a consumer
+/// reads what it sent and what it saw the same way. `x`/`y` are in the source's
+/// own pixels (`geometry.source`); `modifiers` is the modifier state after the
+/// event.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+#[serde(tag = "kind", rename_all = "snake_case")]
+pub enum ObservedInput {
+    Pointer {
+        phase: PointerPhase,
+        x: i64,
+        y: i64,
+        button: i64,
+    },
+    Key {
+        #[serde(skip_serializing_if = "Option::is_none")]
+        name: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        character: Option<String>,
+        down: bool,
+        modifiers: Vec<String>,
+    },
+}
+
 /// Messages the engine sends back on the control channel.
 #[derive(Debug, Serialize)]
 #[serde(tag = "kind", rename_all = "snake_case")]