@desklink/host 0.1.0 → 0.2.0

package/engine/src/main.rs

@@ -6,25 +6,77 @@
 //! process, owns its stdin/stdout, and carries the SDP/ICE the engine produces
 //! over whatever authenticated channel it already has.
 
+#[cfg(target_os = "linux")]
 mod capture;
+#[cfg(target_os = "macos")]
+#[path = "capture_mac.rs"]
+mod capture;
+#[cfg(target_os = "linux")]
+mod clipboard;
+#[cfg(target_os = "macos")]
+#[path = "clipboard_mac.rs"]
 mod clipboard;
+#[cfg(any(target_os = "linux", target_os = "macos"))]
 mod convert;
+#[cfg(target_os = "linux")]
+mod encoder;
+#[cfg(all(target_os = "macos", desklink_vpx))]
 mod encoder;
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
+mod indicator;
+#[cfg(target_os = "linux")]
 mod input;
+#[cfg(target_os = "macos")]
+#[path = "input_mac.rs"]
+mod input;
+#[cfg(target_os = "linux")]
+mod keeper;
+#[cfg(target_os = "linux")]
+mod keymap;
+#[cfg(target_os = "macos")]
+#[path = "keymap_mac.rs"]
 mod keymap;
+#[cfg(target_os = "macos")]
+mod mac;
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 mod peer;
+#[cfg(target_os = "linux")]
+mod portal;
+#[cfg(target_os = "macos")]
+#[path = "portal_mac.rs"]
 mod portal;
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 mod protocol;
+#[cfg(target_os = "linux")]
 mod session;
+#[cfg(all(target_os = "macos", desklink_vpx))]
+mod session;
+#[cfg(target_os = "linux")]
+mod x11;
+#[cfg(target_os = "macos")]
+#[path = "x11_mac.rs"]
 mod x11;
 
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 use anyhow::Result;
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 use protocol::{ErrorBody, Event, Request, Response};
+#[cfg(target_os = "linux")]
 use std::sync::mpsc as std_mpsc;
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 use std::time::Duration;
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 use tokio::sync::mpsc as tokio_mpsc;
 
+#[cfg(target_os = "linux")]
+unsafe extern "C" {
+    fn desklink_agent_overlay_main(display: *const std::ffi::c_char) -> i32;
+    fn desklink_agent_overlay_wayland(source_w: i32, source_h: i32) -> i32;
+}
+
+#[cfg(target_os = "linux")]
 fn main() {
     let args: Vec<String> = std::env::args().skip(1).collect();
     let command = args.first().map(String::as_str).unwrap_or("help");
@@ -43,6 +95,20 @@ fn main() {
             println!("{}", env!("CARGO_PKG_VERSION"));
             0
         }
+        "agent-overlay" => {
+            let display = args.get(1).map(String::as_str).unwrap_or("");
+            let display = std::ffi::CString::new(display).expect("valid X display");
+            unsafe { desklink_agent_overlay_main(display.as_ptr()) }
+        }
+        "agent-overlay-wayland" => {
+            let width = args.get(1).and_then(|v| v.parse().ok()).unwrap_or(0);
+            let height = args.get(2).and_then(|v| v.parse().ok()).unwrap_or(0);
+            if width <= 0 || height <= 0 {
+                2
+            } else {
+                unsafe { desklink_agent_overlay_wayland(width, height) }
+            }
+        }
         "capabilities" => {
             println!(
                 "{}",
@@ -51,6 +117,7 @@ fn main() {
             0
         }
         "serve" => report(runtime.block_on(serve())),
+        "keep" => keeper::command(&args[1..]),
         "capture-probe" => report(runtime.block_on(probe(
             args.get(1).and_then(|value| value.parse().ok()),
             args.get(2).map(String::as_str),
@@ -72,6 +139,7 @@ fn main() {
     std::process::exit(code);
 }
 
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 fn report(result: Result<()>) -> i32 {
     match result {
         Ok(()) => 0,
@@ -82,12 +150,16 @@ fn report(result: Result<()>) -> i32 {
     }
 }
 
+#[cfg(target_os = "linux")]
 fn print_help() {
     println!(
         "desklink-host {}
 
 USAGE:
   desklink-host serve            speak the local control protocol on stdin/stdout
+  desklink-host keep --display :N
+                                 keep one private X screen: kiosk geometry, focus,
+                                 and a JSON-lines window report on stdout
   desklink-host capabilities     print what this machine can do right now
   desklink-host capture-probe [seconds] [display]
                                  capture frames and report the stream; with a
@@ -105,6 +177,7 @@ anything. See docs/PROTOCOL.md for the protocol.",
 
 /// Deliberately does not perform the change. Kernel input access is a privileged
 /// decision, so the engine explains it and stops; the user runs the command.
+#[cfg(target_os = "linux")]
 fn print_input_setup() {
     match input::probe() {
         Ok(()) => {
@@ -154,6 +227,7 @@ fn print_input_setup() {
 
 /// Start the portal session, capture a few frames, and print what actually
 /// arrived. This is the diagnostic to run when the picture does not appear.
+#[cfg(target_os = "linux")]
 async fn probe(seconds: Option<u64>, display: Option<&str>) -> Result<()> {
     let seconds = seconds.unwrap_or(3);
     match display {
@@ -164,6 +238,7 @@ async fn probe(seconds: Option<u64>, display: Option<&str>) -> Result<()> {
 
 /// Read a named X display's root window for a few seconds. The frame shape is
 /// reported as a coarse checksum so a flat or unreadable screen is visible.
+#[cfg(target_os = "linux")]
 fn probe_x11(display: &str, seconds: u64) -> Result<()> {
     let mut desktop = crate::x11::X11Desktop::connect(Some(display))?;
     let (width, height) = desktop.screen_size();
@@ -195,6 +270,7 @@ fn probe_x11(display: &str, seconds: u64) -> Result<()> {
 
 /// A cheap fingerprint of a frame, enough to tell "the screen changed" from
 /// "the screen is one flat colour".
+#[cfg(target_os = "linux")]
 fn frame_shape(frame: &crate::convert::I420) -> u64 {
     frame
         .y_plane()
@@ -207,6 +283,7 @@ fn frame_shape(frame: &crate::convert::I420) -> u64 {
         })
 }
 
+#[cfg(target_os = "linux")]
 async fn probe_portal(seconds: u64) -> Result<()> {
     let portal = portal::open(None).await?;
     eprintln!("portal source: {:?}", portal.source);
@@ -217,9 +294,11 @@ async fn probe_portal(seconds: u64) -> Result<()> {
         0,
         0,
         30,
-        Box::new(move |frame, seq| {
+        Box::new(move |frame, seq, _raw| {
             let _ = tx.send((frame.width, frame.height, seq));
         }),
+        None,
+        Box::new(|reason| eprintln!("{reason}")),
     )?;
 
     let deadline = std::time::Instant::now() + Duration::from_secs(seconds);
@@ -253,6 +332,7 @@ async fn probe_portal(seconds: u64) -> Result<()> {
 }
 
 /// The local control protocol loop.
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 async fn serve() -> Result<()> {
     let (out_tx, mut out_rx) = tokio_mpsc::unbounded_channel::<String>();
     let writer = tokio::spawn(async move {
@@ -343,6 +423,7 @@ async fn serve() -> Result<()> {
     Ok(())
 }
 
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 fn render_event(notice: session::Notice) -> Option<String> {
     let session::Notice { session_id, event } = notice;
     let (name, params) = match event {
@@ -373,10 +454,26 @@ fn render_event(notice: session::Notice) -> Option<String> {
             "session.state",
             serde_json::json!({ "sessionId": session_id, "capture": capture, "transport": transport, "firstFrame": first_frame }),
         ),
+        session::SessionEvent::Frame { seq, damage } => (
+            "session.frame.changed",
+            serde_json::json!({ "sessionId": session_id, "seq": seq, "damage": damage }),
+        ),
+        session::SessionEvent::Input { input } => (
+            "session.input",
+            serde_json::json!({ "sessionId": session_id, "input": input }),
+        ),
+        session::SessionEvent::KeyframeRequest { generation } => (
+            "session.keyframeRequest",
+            serde_json::json!({ "sessionId": session_id, "generation": generation }),
+        ),
         session::SessionEvent::RestoreToken(token) => (
             "session.restoreToken",
             serde_json::json!({ "sessionId": session_id, "token": token }),
         ),
+        session::SessionEvent::CaptureStopped { reason } => (
+            "session.capture.stopped",
+            serde_json::json!({ "sessionId": session_id, "reason": reason }),
+        ),
         session::SessionEvent::Revoked { reason } => (
             "session.revoked",
             serde_json::json!({ "sessionId": session_id, "reason": reason }),
@@ -389,6 +486,7 @@ fn render_event(notice: session::Notice) -> Option<String> {
     .ok()
 }
 
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 async fn dispatch(
     request: &Request,
     hello_seen: &mut bool,
@@ -439,6 +537,7 @@ async fn dispatch(
                 restore_token: params.restore_token,
                 ttl: params.ttl_seconds.map(Duration::from_secs),
                 loopback_tcp: params.loopback_tcp,
+                agent_indicator: params.agent_indicator,
                 ice_servers: params
                     .ice_servers
                     .into_iter()
@@ -496,6 +595,21 @@ async fn dispatch(
                 .map_err(|error| ErrorBody::new("transport", format!("{error:#}")))?;
             Ok(serde_json::json!({ "accepted": true }))
         }
+        "session.restart_ice" => {
+            // The client asks; the engine offers. The fresh offer travels as a
+            // new `session.description` event and the client answers it as
+            // usual, so no new event shape is needed and the session,
+            // generation and control channel survive.
+            let session = require_session(current)?;
+            let params: protocol::SessionRef = serde_json::from_value(request.params.clone())
+                .map_err(|error| ErrorBody::new("malformed", error.to_string()))?;
+            check_session(session, &params.session_id, params.generation)?;
+            session
+                .restart_ice()
+                .await
+                .map_err(|error| ErrorBody::new("transport", format!("{error:#}")))?;
+            Ok(serde_json::json!({ "accepted": true }))
+        }
         "session.clipboard.read" => {
             let session = require_session(current)?;
             let params: protocol::ClipboardParams = serde_json::from_value(request.params.clone())
@@ -518,6 +632,41 @@ async fn dispatch(
                 .map_err(|reason| ErrorBody::new("clipboard", reason))?;
             Ok(serde_json::json!({ "written": true }))
         }
+        "session.frame" => {
+            let session = require_session(current)?;
+            let params: protocol::FrameParams = serde_json::from_value(request.params.clone())
+                .map_err(|error| ErrorBody::new("malformed", error.to_string()))?;
+            check_session(session, &params.session_id, None)?;
+            if params.after_seq.is_some()
+                || params.still_ms.is_some()
+                || params.timeout_ms.is_some()
+            {
+                session
+                    .wait_frame(
+                        params.after_seq,
+                        params.still_ms,
+                        params.timeout_ms.unwrap_or(5000),
+                    )
+                    .await
+                    .map_err(|error| ErrorBody::new(error.code, error.message))?;
+            }
+            session
+                .frame(params.since, &params.path, params.region)
+                .map_err(|error| ErrorBody::new(error.code, error.message))
+        }
+        "session.feed" => {
+            let session = require_session(current)?;
+            let params: protocol::FeedParams = serde_json::from_value(request.params.clone())
+                .map_err(|error| ErrorBody::new("malformed", error.to_string()))?;
+            check_session(session, &params.session_id, None)?;
+            let data = params
+                .access_unit()
+                .map_err(|message| ErrorBody::new("malformed", message))?;
+            session
+                .feed(params.keyframe, data)
+                .map_err(|error| ErrorBody::new(error.code, error.message))?;
+            Ok(serde_json::json!({ "accepted": true }))
+        }
         "session.metrics" => {
             let session = require_session(current)?;
             Ok(serde_json::to_value(session.metrics()).unwrap_or(serde_json::Value::Null))
@@ -538,6 +687,7 @@ async fn dispatch(
     }
 }
 
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 fn require_session(
     current: &mut Option<session::Session>,
 ) -> std::result::Result<&mut session::Session, ErrorBody> {
@@ -548,6 +698,7 @@ fn require_session(
 
 /// A late message for a session that has already ended must not revive it, and a
 /// message for a different session must not reach this one.
+#[cfg(any(target_os = "linux", all(target_os = "macos", desklink_vpx)))]
 fn check_session(
     session: &session::Session,
     id: &str,
@@ -567,7 +718,12 @@ fn check_session(
     Ok(())
 }
 
-#[cfg(test)]
+#[cfg(target_os = "macos")]
+fn main() {
+    std::process::exit(mac::run());
+}
+
+#[cfg(all(test, target_os = "linux"))]
 mod tests {
     use super::*;