@desklink/host 0.3.0 → 0.4.0

package/engine/src/portal_win.rs

@@ -0,0 +1,37 @@
+use anyhow::{bail, Result};
+use serde_json::Value;
+
+/// A selected display; Windows enumeration is deferred to the capture lane.
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct SelectedSource {
+    pub node_id: u32,
+    pub width: i32,
+    pub height: i32,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub position: Option<(i32, i32)>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub source_type: Option<String>,
+    pub origin_x: i32,
+    pub origin_y: i32,
+}
+
+pub struct PortalSession {
+    pub source: SelectedSource,
+    pub restore_token: Option<String>,
+}
+
+pub async fn open(_restore_token: Option<&str>) -> Result<PortalSession> {
+    open_display_inner(None)
+}
+
+pub async fn open_display(display_id: Option<u32>) -> Result<PortalSession> {
+    open_display_inner(display_id)
+}
+
+fn open_display_inner(_display_id: Option<u32>) -> Result<PortalSession> {
+    bail!("{}", crate::capture::unavailable_reason())
+}
+
+pub fn displays() -> Vec<Value> {
+    Vec::new()
+}

package/engine/src/protocol.rs

@@ -53,14 +53,6 @@ pub struct HelloParams {
     pub protocol: u32,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum Permission {
-    View,
-    Control,
-    Clipboard,
-}
-
 #[derive(Debug, Clone, Deserialize)]
 pub struct IceServerParam {
     #[serde(default)]
@@ -111,13 +103,21 @@ pub enum EncodedCodec {
     H264,
 }
 
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum CursorMode {
+    #[default]
+    Embedded,
+    Hidden,
+}
+
 #[derive(Debug, Deserialize)]
 pub struct OpenParams {
+    #[serde(default)]
+    pub cursor: CursorMode,
     /// Absent means "the portal, with the user's consent".
     #[serde(default)]
     pub source: Option<SourceRequest>,
-    #[serde(default)]
-    pub permissions: Vec<Permission>,
     #[serde(default = "default_max_width")]
     pub max_width: usize,
     #[serde(default = "default_max_height")]
@@ -168,6 +168,20 @@ fn default_fps() -> u32 {
     60
 }
 
+/// A host-only visual cue; never an input message.
+#[derive(Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct PointParams {
+    pub session_id: String,
+    pub x: Option<i64>,
+    pub y: Option<i64>,
+    #[serde(default)]
+    pub label: String,
+    pub timeout_ms: Option<u64>,
+    #[serde(default)]
+    pub clear: bool,
+}
+
 #[derive(Debug, Deserialize)]
 pub struct FrameParams {
     pub session_id: String,
@@ -385,6 +399,16 @@ pub enum ControlReply<'a> {
 mod tests {
     use super::*;
 
+    #[test]
+    fn cursor_option_defaults_and_refuses_unknown_modes() {
+        let default: OpenParams = serde_json::from_str("{}").unwrap();
+        assert_eq!(default.cursor, CursorMode::Embedded);
+        let hidden: OpenParams = serde_json::from_str(r#"{"cursor":"hidden"}"#).unwrap();
+        assert_eq!(hidden.cursor, CursorMode::Hidden);
+        assert!(serde_json::from_str::<OpenParams>(r#"{"cursor":"metadata"}"#).is_err());
+        assert!(serde_json::from_str::<OpenParams>(r#"{"cursor":false}"#).is_err());
+    }
+
     #[test]
     fn a_pointer_message_round_trips_with_its_sequence() {
         let parsed: ControlMessage =
@@ -505,6 +529,13 @@ mod tests {
 
     #[test]
     fn open_defaults_keep_the_desktops_own_pixels_up_to_4k() {
+        for payload in [
+            r#"{}"#,
+            r#"{"permissions":["view"]}"#,
+            r#"{"permissions":["view","unknown-legacy-scope"]}"#,
+        ] {
+            let _: OpenParams = serde_json::from_str(payload).unwrap();
+        }
         let params: OpenParams =
             serde_json::from_str(r#"{"permissions":["view","control"]}"#).unwrap();
         assert_eq!(params.max_width, 3840);
@@ -525,3 +556,18 @@ mod tests {
         assert!(agent.agent_indicator);
     }
 }
+
+/// Monotonic engine-process clock shared by local frame and cursor notices.
+pub fn timestamp_us(at: std::time::Instant) -> u64 {
+    static EPOCH: std::sync::OnceLock<std::time::Instant> = std::sync::OnceLock::new();
+    at.saturating_duration_since(*EPOCH.get_or_init(|| at))
+        .as_micros() as u64
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct CursorPosition {
+    pub x: i32,
+    pub y: i32,
+    pub visible: bool,
+    pub timestamp_us: u64,
+}