@desklink/host 0.1.0 → 0.1.1

package/engine/src/indicator.rs

@@ -0,0 +1,162 @@
+//! Local feedback for agent sessions. The helper is a separate nonactivating
+//! window-owning process so its windows can be excluded from desktop capture.
+use anyhow::{Context, Result};
+use std::io::{BufRead, BufReader, Write};
+use std::process::{Child, ChildStdin, Command, Stdio};
+
+pub struct Indicator {
+    child: Option<Child>,
+    input: Option<ChildStdin>,
+    scale_x: f64,
+    scale_y: f64,
+    #[cfg(target_os = "linux")]
+    position: std::sync::Arc<std::sync::Mutex<Option<(i64, i64)>>>,
+}
+
+impl Indicator {
+    #[cfg(target_os = "macos")]
+    pub fn start(display_id: u32, width: usize, height: usize) -> Result<Self> {
+        let executable = std::env::current_exe()?;
+        let (_, _, points_w, points_h) = crate::mac::display_geometry(display_id)
+            .context("the selected display is unavailable")?;
+        Self::spawn(
+            Command::new(executable)
+                .arg("agent-overlay")
+                .arg(display_id.to_string()),
+            points_w / width as f64,
+            points_h / height as f64,
+        )
+    }
+
+    #[cfg(target_os = "linux")]
+    pub fn start(display: &str, width: usize, height: usize) -> Result<Self> {
+        let executable = std::env::current_exe()?;
+        let _ = (width, height);
+        Self::spawn(
+            Command::new(executable).arg("agent-overlay").arg(display),
+            1.0,
+            1.0,
+        )
+    }
+
+    #[cfg(target_os = "linux")]
+    pub fn start_wayland(width: usize, height: usize) -> Result<Self> {
+        let executable = std::env::current_exe()?;
+        Self::spawn(
+            Command::new(executable)
+                .arg("agent-overlay-wayland")
+                .arg(width.to_string())
+                .arg(height.to_string()),
+            1.0,
+            1.0,
+        )
+    }
+
+    #[cfg(target_os = "linux")]
+    pub fn position(&self) -> std::sync::Arc<std::sync::Mutex<Option<(i64, i64)>>> {
+        self.position.clone()
+    }
+
+    fn spawn(command: &mut Command, scale_x: f64, scale_y: f64) -> Result<Self> {
+        let mut child = command
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::inherit())
+            .spawn()
+            .context("could not start agent indicator")?;
+        let stdout = child.stdout.take().unwrap();
+        let (ready_tx, ready_rx) = std::sync::mpsc::channel();
+        let reader = std::thread::spawn(move || {
+            let mut ready = String::new();
+            let result = BufReader::new(stdout).read_line(&mut ready);
+            let _ = ready_tx.send(result.is_ok() && ready.trim() == "READY");
+        });
+        if ready_rx.recv_timeout(std::time::Duration::from_secs(5)) != Ok(true) {
+            let _ = child.kill();
+            let _ = child.wait();
+            let _ = reader.join();
+            anyhow::bail!("agent indicator did not open its overlay within 5s");
+        }
+        let _ = reader.join();
+        Ok(Self {
+            input: child.stdin.take(),
+            child: Some(child),
+            scale_x,
+            scale_y,
+            #[cfg(target_os = "linux")]
+            position: Default::default(),
+        })
+    }
+
+    #[cfg(target_os = "macos")]
+    pub fn pid(&self) -> u32 {
+        self.child.as_ref().unwrap().id()
+    }
+
+    pub fn event(&mut self, kind: char, x: i64, y: i64) {
+        if let Some(input) = &mut self.input {
+            let (x, y) = (x as f64 * self.scale_x, y as f64 * self.scale_y);
+            if writeln!(input, "{kind} {x:.2} {y:.2}").is_err() {
+                self.input = None;
+            }
+            #[cfg(target_os = "linux")]
+            if x >= 0.0 && y >= 0.0 {
+                if let Ok(mut position) = self.position.lock() {
+                    *position = Some((x as i64, y as i64));
+                }
+            }
+        }
+    }
+}
+
+impl Drop for Indicator {
+    fn drop(&mut self) {
+        // Closing stdin fades the edge and exits; do not wait for the animation.
+        self.input.take();
+        if let Some(mut child) = self.child.take() {
+            std::thread::spawn(move || {
+                let _ = child.wait();
+            });
+        }
+    }
+}
+
+#[cfg(all(test, target_os = "linux"))]
+mod tests {
+    unsafe extern "C" {
+        fn desklink_wayland_geometry(
+            source_w: i32,
+            source_h: i32,
+            surface_w: i32,
+            surface_h: i32,
+            px: f64,
+            py: f64,
+            x: *mut f64,
+            y: *mut f64,
+        ) -> i32;
+        fn desklink_wayland_policy(
+            anchor: *mut u32,
+            keyboard_focus: *mut u32,
+            empty_input: *mut u32,
+        );
+    }
+
+    #[test]
+    fn layer_shell_maps_source_pixels_and_never_takes_input_or_focus() {
+        let (mut x, mut y) = (0.0, 0.0);
+        unsafe {
+            assert_eq!(
+                desklink_wayland_geometry(3840, 2160, 1920, 1080, 1000.0, 600.0, &mut x, &mut y),
+                1
+            );
+            assert_eq!((x, y), (500.0, 300.0));
+            assert_eq!(
+                desklink_wayland_geometry(0, 2160, 1920, 1080, 10.0, 10.0, &mut x, &mut y),
+                0
+            );
+            let (mut anchor, mut keyboard, mut empty) = (0, 1, 0);
+            desklink_wayland_policy(&mut anchor, &mut keyboard, &mut empty);
+            assert_eq!((anchor, keyboard, empty), (15, 0, 1));
+        }
+    }
+}

package/engine/src/input.rs

@@ -108,6 +108,18 @@ pub mod keycode {
     pub const PAGE_UP: i16 = 104;
     pub const PAGE_DOWN: i16 = 109;
     pub const DELETE: i16 = 111;
+    pub const F1: i16 = 59;
+    pub const F2: i16 = 60;
+    pub const F3: i16 = 61;
+    pub const F4: i16 = 62;
+    pub const F5: i16 = 63;
+    pub const F6: i16 = 64;
+    pub const F7: i16 = 65;
+    pub const F8: i16 = 66;
+    pub const F9: i16 = 67;
+    pub const F10: i16 = 68;
+    pub const F11: i16 = 87;
+    pub const F12: i16 = 88;
 }
 
 /// Why the input backend is unavailable, so the consumer can say something true

package/engine/src/input_mac.rs

@@ -0,0 +1,312 @@
+use anyhow::{bail, Result};
+use std::os::raw::c_void;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Button {
+    Left,
+    Middle,
+    Right,
+}
+
+pub mod keycode {
+    pub const LEFT_CTRL: i16 = 59;
+    pub const LEFT_SHIFT: i16 = 56;
+    pub const LEFT_ALT: i16 = 58;
+    pub const LEFT_META: i16 = 55;
+}
+
+impl Button {
+    pub fn from_number(number: i64) -> Self {
+        match number {
+            2 => Self::Middle,
+            3 => Self::Right,
+            _ => Self::Left,
+        }
+    }
+}
+
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
+pub struct HeldState {
+    keys: Vec<i16>,
+    buttons: Vec<Button>,
+}
+
+impl HeldState {
+    pub fn key(&mut self, code: i16, down: bool) {
+        if down {
+            if !self.keys.contains(&code) {
+                self.keys.push(code);
+            }
+        } else {
+            self.keys.retain(|held| *held != code);
+        }
+    }
+
+    pub fn button(&mut self, button: Button, down: bool) {
+        if down {
+            if !self.buttons.contains(&button) {
+                self.buttons.push(button);
+            }
+        } else {
+            self.buttons.retain(|held| *held != button);
+        }
+    }
+
+    pub fn release_plan(&mut self) -> (Vec<Button>, Vec<i16>) {
+        (
+            std::mem::take(&mut self.buttons),
+            std::mem::take(&mut self.keys),
+        )
+    }
+}
+
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct InputUnavailable {
+    pub reason: String,
+    pub remedy: String,
+}
+
+pub fn probe() -> Result<(), InputUnavailable> {
+    if unsafe { crate::mac::CGPreflightPostEventAccess() } {
+        Ok(())
+    } else {
+        let app = crate::mac::tcc_responsible_app_name();
+        Err(InputUnavailable {
+            reason: format!("Accessibility permission has not been granted to {app}."),
+            remedy: format!("Allow {app} in System Settings › Privacy & Security › Accessibility, then reconnect."),
+        })
+    }
+}
+
+pub fn request_access() -> bool {
+    let key = unsafe { kAXTrustedCheckOptionPrompt };
+    let value = unsafe { kCFBooleanTrue };
+    let keys = [key];
+    let values = [value];
+    let options = unsafe {
+        CFDictionaryCreate(
+            kCFAllocatorDefault,
+            keys.as_ptr(),
+            values.as_ptr(),
+            1,
+            &kCFTypeDictionaryKeyCallBacks,
+            &kCFTypeDictionaryValueCallBacks,
+        )
+    };
+    if options.is_null() {
+        return false;
+    }
+    let trusted = unsafe { AXIsProcessTrustedWithOptions(options) };
+    unsafe { CFRelease(options) };
+    trusted
+}
+
+fn modifier_flag(code: i16) -> u64 {
+    match code {
+        keycode::LEFT_SHIFT => 0x20000,
+        keycode::LEFT_CTRL => 0x40000,
+        keycode::LEFT_ALT => 0x80000,
+        keycode::LEFT_META => 0x100000,
+        _ => 0,
+    }
+}
+
+pub fn native_keycode(code: i16) -> Result<i16> {
+    anyhow::ensure!(
+        (0..=127).contains(&code),
+        "invalid macOS virtual key code {code}"
+    );
+    Ok(code)
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+struct Point {
+    x: f64,
+    y: f64,
+}
+
+type EventRef = *const c_void;
+type SourceRef = *const c_void;
+type CfTypeRef = *const c_void;
+
+#[link(name = "ApplicationServices", kind = "framework")]
+unsafe extern "C" {
+    fn AXIsProcessTrustedWithOptions(options: CfTypeRef) -> bool;
+    static kAXTrustedCheckOptionPrompt: CfTypeRef;
+}
+
+#[link(name = "ApplicationServices", kind = "framework")]
+unsafe extern "C" {
+    fn CGEventCreateMouseEvent(
+        source: SourceRef,
+        event_type: u32,
+        point: Point,
+        button: u32,
+    ) -> EventRef;
+    fn CGEventCreateScrollWheelEvent(
+        source: SourceRef,
+        units: u32,
+        wheel_count: u32,
+        vertical: i32,
+        horizontal: i32,
+    ) -> EventRef;
+    fn CGEventCreateKeyboardEvent(source: SourceRef, keycode: u16, key_down: bool) -> EventRef;
+    fn CGEventKeyboardSetUnicodeString(event: EventRef, length: u32, text: *const u16);
+    fn CGEventSetFlags(event: EventRef, flags: u64);
+    fn CGEventSetLocation(event: EventRef, location: Point);
+    fn CGEventPost(tap: u32, event: EventRef);
+}
+
+#[link(name = "CoreFoundation", kind = "framework")]
+unsafe extern "C" {
+    fn CFDictionaryCreate(
+        allocator: CfTypeRef,
+        keys: *const CfTypeRef,
+        values: *const CfTypeRef,
+        count: isize,
+        key_callbacks: *const u8,
+        value_callbacks: *const u8,
+    ) -> CfTypeRef;
+    fn CFRelease(value: CfTypeRef);
+    static kCFAllocatorDefault: CfTypeRef;
+    static kCFBooleanTrue: CfTypeRef;
+    static kCFTypeDictionaryKeyCallBacks: u8;
+    static kCFTypeDictionaryValueCallBacks: u8;
+}
+
+pub struct InputDevices {
+    pixel_width: i32,
+    pixel_height: i32,
+    origin: (f64, f64),
+    points_per_pixel: (f64, f64),
+    last_position: Point,
+    wheel_rest: (f64, f64),
+    modifier_flags: u64,
+}
+
+unsafe impl Send for InputDevices {}
+
+impl InputDevices {
+    pub fn create_for_display(width: i32, height: i32, display_id: u32) -> Result<Self> {
+        if !request_access() && !unsafe { crate::mac::CGPreflightPostEventAccess() } {
+            let app = crate::mac::tcc_responsible_app_name();
+            bail!("Accessibility permission is required; allow {app} in System Settings › Privacy & Security › Accessibility");
+        }
+        let (origin_x, origin_y, point_width, point_height) =
+            crate::mac::display_geometry(display_id)
+                .ok_or_else(|| anyhow::anyhow!("the selected display is no longer active"))?;
+        anyhow::ensure!(
+            width > 0 && height > 0,
+            "display has invalid pixel dimensions"
+        );
+        let origin = (origin_x, origin_y);
+        Ok(Self {
+            pixel_width: width,
+            pixel_height: height,
+            origin,
+            points_per_pixel: (point_width / width as f64, point_height / height as f64),
+            last_position: Point {
+                x: origin_x,
+                y: origin_y,
+            },
+            wheel_rest: (0.0, 0.0),
+            modifier_flags: 0,
+        })
+    }
+
+    pub fn move_absolute(&mut self, x: i64, y: i64) {
+        let x = x.clamp(0, self.pixel_width as i64 - 1);
+        let y = y.clamp(0, self.pixel_height as i64 - 1);
+        let point = Point {
+            x: self.origin.0 + x as f64 * self.points_per_pixel.0,
+            y: self.origin.1 + y as f64 * self.points_per_pixel.1,
+        };
+        self.last_position = point;
+        self.post_mouse(5, point, 0);
+    }
+
+    pub fn button(&mut self, button: Button, down: bool) {
+        let (event_type, native_button) = match (button, down) {
+            (Button::Left, true) => (1, 0),
+            (Button::Left, false) => (2, 0),
+            (Button::Right, true) => (3, 1),
+            (Button::Right, false) => (4, 1),
+            (Button::Middle, true) => (25, 2),
+            (Button::Middle, false) => (26, 2),
+        };
+        self.post_mouse(event_type, self.last_position, native_button);
+    }
+
+    pub fn scroll(&mut self, dx: f64, dy: f64) {
+        let (x, y) = (self.wheel_rest.0 + dx, self.wheel_rest.1 + dy);
+        let whole_x = x.trunc();
+        let whole_y = y.trunc();
+        self.wheel_rest = (x - whole_x, y - whole_y);
+        if whole_x == 0.0 && whole_y == 0.0 {
+            return;
+        }
+        let event = unsafe {
+            CGEventCreateScrollWheelEvent(std::ptr::null(), 0, 2, -whole_y as i32, whole_x as i32)
+        };
+        if !event.is_null() {
+            unsafe { CGEventSetLocation(event, self.last_position) };
+        }
+        Self::post(event);
+    }
+
+    pub fn key(&mut self, code: i16, down: bool) -> Result<()> {
+        let code = native_keycode(code)? as u16;
+        let flag = modifier_flag(code as i16);
+        if down {
+            self.modifier_flags |= flag;
+        } else {
+            self.modifier_flags &= !flag;
+        }
+        let event = unsafe { CGEventCreateKeyboardEvent(std::ptr::null(), code, down) };
+        if !event.is_null() {
+            unsafe { CGEventSetFlags(event, self.modifier_flags) };
+        }
+        Self::post(event);
+        Ok(())
+    }
+
+    pub fn unicode_text(&mut self, text: &str) -> Result<()> {
+        let characters: Vec<u16> = text.encode_utf16().collect();
+        let event = unsafe { CGEventCreateKeyboardEvent(std::ptr::null(), 0, true) };
+        if event.is_null() {
+            bail!("CoreGraphics could not create a Unicode key event");
+        }
+        unsafe {
+            CGEventKeyboardSetUnicodeString(event, characters.len() as u32, characters.as_ptr());
+            CGEventSetFlags(event, self.modifier_flags);
+        }
+        Self::post(event);
+        Self::post(unsafe { CGEventCreateKeyboardEvent(std::ptr::null(), 0, false) });
+        Ok(())
+    }
+
+    fn post_mouse(&self, event_type: u32, point: Point, button: u32) {
+        Self::post(unsafe { CGEventCreateMouseEvent(std::ptr::null(), event_type, point, button) });
+    }
+
+    fn post(event: EventRef) {
+        if !event.is_null() {
+            unsafe {
+                CGEventPost(0, event);
+                CFRelease(event);
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn command_key_uses_quartz_command_flag() {
+        assert_eq!(modifier_flag(keycode::LEFT_META), 0x100000);
+        assert_eq!(modifier_flag(0), 0);
+    }
+}

package/engine/src/keymap.rs

@@ -72,6 +72,18 @@ pub fn named_key(name: &str) -> Option<Keystroke> {
         "End" => keycode::END,
         "PageUp" => keycode::PAGE_UP,
         "PageDown" => keycode::PAGE_DOWN,
+        "F1" => keycode::F1,
+        "F2" => keycode::F2,
+        "F3" => keycode::F3,
+        "F4" => keycode::F4,
+        "F5" => keycode::F5,
+        "F6" => keycode::F6,
+        "F7" => keycode::F7,
+        "F8" => keycode::F8,
+        "F9" => keycode::F9,
+        "F10" => keycode::F10,
+        "F11" => keycode::F11,
+        "F12" => keycode::F12,
         _ => return None,
     };
     Some(Keystroke::simple(code))
@@ -309,7 +321,20 @@ mod tests {
     fn named_keys_and_modifiers_resolve_to_linux_key_codes() {
         assert_eq!(named_key("Enter").unwrap().code, keycode::ENTER);
         assert_eq!(named_key("ArrowLeft").unwrap().code, keycode::LEFT);
+        for (name, code) in [
+            ("Delete", keycode::DELETE), ("Home", keycode::HOME), ("End", keycode::END),
+            ("PageUp", keycode::PAGE_UP), ("PageDown", keycode::PAGE_DOWN),
+            ("F1", keycode::F1), ("F2", keycode::F2), ("F3", keycode::F3),
+            ("F4", keycode::F4), ("F5", keycode::F5), ("F6", keycode::F6),
+            ("F7", keycode::F7), ("F8", keycode::F8), ("F9", keycode::F9),
+            ("F10", keycode::F10), ("F11", keycode::F11), ("F12", keycode::F12),
+        ] {
+            assert_eq!(named_key(name).unwrap().code, code);
+            assert!(crate::input::native_keycode(code).is_ok(), "{name} must reach inputtino");
+        }
         assert_eq!(modifier_key("Control"), Some(keycode::LEFT_CTRL));
+        assert_eq!(modifier_key("Alt"), Some(keycode::LEFT_ALT));
+        assert_eq!(modifier_key("Super"), Some(keycode::LEFT_META));
         assert!(named_key("Frobnicate").is_none());
         assert!(modifier_key("Hyper").is_none());
     }