@desklink/host 0.5.9 → 0.5.11

package/engine/native/agent_overlay_x11.c

@@ -163,6 +163,50 @@ int desklink_agent_overlay_main(const char *display_name) {
     return 0;
 }
 
+// The ring is 72 logical px across, a 6px band with a pulse wave that grows
+// out from it every PULSE_SECONDS, so the cue reads at a glance. The label is
+// the core "fixed" font drawn at 2x, because a core X server offers nothing larger.
+#define POINT_RING 36
+#define POINT_PULSE_SECONDS 1.2
+#define POINT_BADGE_H 40
+#define POINT_FRAME_SECONDS 0.033
+
+static void point_shape(Display *d, Window window, Pixmap mask, GC shape, int x, int y,
+    int badge_x, int badge_y, int badge_w, double elapsed) {
+    double phase = fmod(elapsed, POINT_PULSE_SECONDS) / POINT_PULSE_SECONDS;
+    int wave = POINT_RING + (int)lround(18*phase), wave_width = 6 - (int)lround(4*phase);
+    XSetForeground(d, shape, 0); XFillRectangle(d, mask, shape, 0, 0, 0xffff, 0xffff);
+    XSetForeground(d, shape, 1);
+    XSetLineAttributes(d, shape, 6, LineSolid, CapRound, JoinRound);
+    XDrawArc(d, mask, shape, x-POINT_RING, y-POINT_RING, 2*POINT_RING, 2*POINT_RING, 0, 360*64);
+    XFillArc(d, mask, shape, x-6, y-6, 12, 12, 0, 360*64);
+    XSetLineAttributes(d, shape, wave_width, LineSolid, CapRound, JoinRound);
+    XDrawArc(d, mask, shape, x-wave, y-wave, 2*wave, 2*wave, 0, 360*64);
+    if (badge_w) XFillRectangle(d, mask, shape, badge_x, badge_y, badge_w, POINT_BADGE_H);
+    XShapeCombineMask(d, window, ShapeBounding, 0, 0, mask, ShapeSet);
+}
+
+// Text is rasterised once at 1x and drawn as 2x2 blocks.
+static void point_text(Display *d, Window window, GC ink, XFontStruct *font, const char *label,
+    int len, int x, int y) {
+    int w = XTextWidth(font, label, len), h = font->ascent + font->descent;
+    Pixmap bits = XCreatePixmap(d, window, w, h, 1);
+    GC gc = XCreateGC(d, bits, 0, NULL);
+    XSetFont(d, gc, font->fid);
+    XSetForeground(d, gc, 0); XFillRectangle(d, bits, gc, 0, 0, w, h);
+    XSetForeground(d, gc, 1); XDrawString(d, bits, gc, 0, font->ascent, label, len);
+    XImage *image = XGetImage(d, bits, 0, 0, w, h, 1, ZPixmap);
+    XRectangle *blocks = malloc(sizeof(XRectangle) * (size_t)w * h);
+    int count = 0;
+    if (image && blocks)
+        for (int row = 0; row < h; row++) for (int col = 0; col < w; col++)
+            if (XGetPixel(image, col, row))
+                blocks[count++] = (XRectangle){(short)(x+2*col), (short)(y+2*row), 2, 2};
+    if (count) XFillRectangles(d, window, ink, blocks, count);
+    free(blocks); if (image) XDestroyImage(image);
+    XFreeGC(d, gc); XFreePixmap(d, bits);
+}
+
 // Point cues are independent of the real cursor. A shaped override-redirect
 // window works without a compositor; an empty input shape passes every event
 // through and mapping it never asks for keyboard focus. It intentionally appears
@@ -185,12 +229,11 @@ int desklink_point_overlay_main(const char *display_name) {
     Pixmap mask = XCreatePixmap(d, root, width, height, 1);
     GC shape = XCreateGC(d, mask, 0, NULL), ink = XCreateGC(d, window, 0, NULL);
     XFontStruct *font = XLoadQueryFont(d, "fixed");
-    if (font) XSetFont(d, ink, font->fid);
-    XSetLineAttributes(d, shape, 4, LineSolid, CapRound, JoinRound);
     fcntl(STDIN_FILENO, F_SETFL, fcntl(STDIN_FILENO, F_GETFL) | O_NONBLOCK);
     puts("READY"); fflush(stdout);
     char pending[512]; size_t used = 0;
-    double deadline = 0;
+    double deadline = 0, started = 0, drawn = 0;
+    int x = 0, y = 0, badge_x = 0, badge_y = 0, badge_w = 0;
     for (;;) {
         char bytes[512]; ssize_t n = read(STDIN_FILENO, bytes, sizeof(bytes));
         if (n == 0) break;
@@ -200,35 +243,41 @@ int desklink_point_overlay_main(const char *display_name) {
             double px, py; unsigned timeout; int offset = 0;
             if (sscanf(pending, "P %lf %lf %u %n", &px, &py, &timeout, &offset) != 3 || !offset) continue;
             const char *label = pending + offset;
-            int x = (int)px, y = (int)py, len = (int)strlen(label);
-            int badge_w = font ? XTextWidth(font, label, len) + 16 : len * 6 + 16;
+            int len = (int)strlen(label);
+            x = (int)px; y = (int)py;
+            int text_w = font ? 2*XTextWidth(font, label, len) : 12*len;
+            badge_w = len ? text_w + 24 : 0;
             if (badge_w > width) badge_w = width;
-            int badge_x = x + 30, badge_y = y - 14;
+            badge_x = x + POINT_RING + 30; badge_y = y - POINT_BADGE_H/2;
             if (badge_x + badge_w > width) badge_x = width - badge_w;
             if (badge_y < 0) badge_y = 0;
-            if (badge_y + 28 > height) badge_y = height - 28;
+            if (badge_y + POINT_BADGE_H > height) badge_y = height - POINT_BADGE_H;
             XUnmapWindow(d, window);
-            XSetForeground(d, shape, 0); XFillRectangle(d, mask, shape, 0, 0, width, height);
-            XSetForeground(d, shape, 1);
-            XDrawArc(d, mask, shape, x-18, y-18, 36, 36, 0, 360*64);
-            XFillArc(d, mask, shape, x-3, y-3, 6, 6, 0, 360*64);
-            if (len) XFillRectangle(d, mask, shape, badge_x, badge_y, badge_w, 28);
-            XShapeCombineMask(d, window, ShapeBounding, 0, 0, mask, ShapeSet);
+            started = now();
+            point_shape(d, window, mask, shape, x, y, badge_x, badge_y, badge_w, 0);
             XMapRaised(d, window);
             XClearWindow(d, window);
             if (len) {
                 XSetForeground(d, ink, 0x123047);
-                XFillRectangle(d, window, ink, badge_x, badge_y, badge_w, 28);
+                XFillRectangle(d, window, ink, badge_x, badge_y, badge_w, POINT_BADGE_H);
                 XSetForeground(d, ink, 0xffffff);
-                XDrawString(d, window, ink, badge_x+8, badge_y+18, label, len);
+                if (font) point_text(d, window, ink, font, label, len, badge_x+12,
+                    badge_y + (POINT_BADGE_H - 2*(font->ascent+font->descent))/2);
             }
             XSync(d, False);
-            deadline = now() + timeout/1000.0;
+            drawn = now();
+            deadline = drawn + timeout/1000.0;
+        }
+        double t = now();
+        if (deadline && t >= deadline) { XUnmapWindow(d, window); XFlush(d); deadline = 0; }
+        else if (deadline && t - drawn >= POINT_FRAME_SECONDS) {
+            point_shape(d, window, mask, shape, x, y, badge_x, badge_y, badge_w, t - started);
+            XFlush(d); drawn = t;
         }
-        if (deadline && now() >= deadline) { XUnmapWindow(d, window); XFlush(d); deadline = 0; }
         usleep(5000);
     }
     XDestroyWindow(d, window); XFreeGC(d, shape); XFreeGC(d, ink);
     XFreePixmap(d, mask); if (font) XFreeFont(d, font); XCloseDisplay(d);
     return 0;
 }
+

package/engine/src/input_mac.rs

@@ -299,3 +299,436 @@ impl InputDevices {
         }
     }
 }
+
+/// Whether the engine may listen to the desktop's input. Listening needs Input
+/// Monitoring, a separate grant from the Accessibility one that posting needs.
+pub fn observe_probe() -> Result<(), InputUnavailable> {
+    if unsafe { crate::mac::CGPreflightListenEventAccess() } {
+        Ok(())
+    } else {
+        let app = crate::mac::tcc_responsible_app_name();
+        Err(InputUnavailable {
+            reason: format!("Input Monitoring permission has not been granted to {app}."),
+            remedy: format!("Allow {app} in System Settings › Privacy & Security › Input Monitoring, then reconnect."),
+        })
+    }
+}
+
+/// Shows the system's Input Monitoring prompt, once, and lists the app there.
+pub fn request_observe_access() -> bool {
+    unsafe { crate::mac::CGRequestListenEventAccess() }
+}
+
+#[cfg(desklink_vpx)]
+pub use observer::observe;
+
+#[cfg(desklink_vpx)]
+mod observer {
+    use super::*;
+    use crate::observe::{Observation, Sink, Tap, Unavailable};
+    use crate::protocol::{timestamp_us, ObservedInput, PointerPhase};
+    use std::sync::atomic::{AtomicBool, Ordering};
+    use std::sync::Arc;
+    use std::time::Instant;
+
+    type TapCallback = extern "C" fn(EventRef, u32, EventRef, *mut c_void) -> EventRef;
+
+    #[link(name = "ApplicationServices", kind = "framework")]
+    unsafe extern "C" {
+        fn CGEventTapCreate(tap: u32, place: u32, options: u32, events_of_interest: u64, callback: TapCallback, user_info: *mut c_void) -> CfTypeRef;
+        fn CGEventTapEnable(tap: CfTypeRef, enable: bool);
+        fn CGEventCreate(source: SourceRef) -> EventRef;
+        fn CGEventGetLocation(event: EventRef) -> Point;
+        fn CGEventGetFlags(event: EventRef) -> u64;
+        fn CGEventGetIntegerValueField(event: EventRef, field: u32) -> i64;
+        fn CGEventKeyboardGetUnicodeString(event: EventRef, max_length: usize, actual_length: *mut usize, buffer: *mut u16);
+    }
+
+    #[link(name = "CoreFoundation", kind = "framework")]
+    unsafe extern "C" {
+        fn CFMachPortCreateRunLoopSource(allocator: CfTypeRef, port: CfTypeRef, order: isize) -> CfTypeRef;
+        fn CFMachPortInvalidate(port: CfTypeRef);
+        fn CFRunLoopGetCurrent() -> CfTypeRef;
+        fn CFRunLoopAddSource(run_loop: CfTypeRef, source: CfTypeRef, mode: CfTypeRef);
+        fn CFRunLoopRunInMode(mode: CfTypeRef, seconds: f64, return_after_source: u8) -> i32;
+        static kCFRunLoopCommonModes: CfTypeRef;
+        static kCFRunLoopDefaultMode: CfTypeRef;
+    }
+
+    // CGEventType values this tap listens for.
+    const LEFT_DOWN: u32 = 1; const LEFT_UP: u32 = 2; const RIGHT_DOWN: u32 = 3; const RIGHT_UP: u32 = 4;
+    const MOVED: u32 = 5; const LEFT_DRAGGED: u32 = 6; const RIGHT_DRAGGED: u32 = 7; const KEY_DOWN: u32 = 10;
+    const KEY_UP: u32 = 11; const FLAGS_CHANGED: u32 = 12; const OTHER_DOWN: u32 = 25; const OTHER_UP: u32 = 26;
+    const OTHER_DRAGGED: u32 = 27;
+    // The system switches a tap off when its callback is slow or on its own
+    // say-so; these arrive in its place.
+    const DISABLED_BY_TIMEOUT: u32 = 0xFFFF_FFFE;
+    const DISABLED_BY_USER_INPUT: u32 = 0xFFFF_FFFF;
+
+    const BUTTON_NUMBER: u32 = 3;
+    const KEYCODE: u32 = 9;
+    const AUTOREPEAT: u32 = 8;
+
+    /// Where the selected display is on the desktop, so a point the system
+    /// reports (global, in points) becomes the source's own pixel.
+    #[derive(Debug, Clone, Copy, PartialEq)]
+    pub struct Geometry {
+        origin: (f64, f64),
+        points_per_pixel: (f64, f64),
+        pixels: (i64, i64),
+    }
+
+    impl Geometry {
+        pub fn new(origin: (f64, f64), points: (f64, f64), pixels: (i64, i64)) -> Self {
+            Self {
+                origin,
+                points_per_pixel: (points.0 / pixels.0 as f64, points.1 / pixels.1 as f64),
+                pixels,
+            }
+        }
+
+        /// `None` when the point is on another display.
+        pub fn to_source(&self, x: f64, y: f64) -> Option<(i64, i64)> {
+            let px = ((x - self.origin.0) / self.points_per_pixel.0).floor() as i64;
+            let py = ((y - self.origin.1) / self.points_per_pixel.1).floor() as i64;
+            ((0..self.pixels.0).contains(&px) && (0..self.pixels.1).contains(&py))
+                .then_some((px, py))
+        }
+    }
+
+    /// The control channel's pointer button numbers: 1 left, 2 middle, 3 right,
+    /// and 4 and up for the extra buttons.
+    pub fn observed_button(event_type: u32, button_number: i64) -> Option<(PointerPhase, i64)> {
+        let extra = |down| match button_number {
+            2 => Some((down, 2)),
+            n if n > 2 => Some((down, n + 1)),
+            _ => None,
+        };
+        match event_type {
+            LEFT_DOWN => Some((PointerPhase::Down, 1)),
+            LEFT_UP => Some((PointerPhase::Up, 1)),
+            RIGHT_DOWN => Some((PointerPhase::Down, 3)),
+            RIGHT_UP => Some((PointerPhase::Up, 3)),
+            OTHER_DOWN => extra(PointerPhase::Down),
+            OTHER_UP => extra(PointerPhase::Up),
+            _ => None,
+        }
+    }
+
+    struct Observer {
+        geometry: Geometry,
+        sink: Sink,
+        cursor: crate::cursor::Reporter,
+        last_inside: (i64, i64),
+        port: CfTypeRef,
+    }
+
+    impl Observer {
+        fn handle(&mut self, event_type: u32, event: EventRef) {
+            match event_type {
+                DISABLED_BY_TIMEOUT | DISABLED_BY_USER_INPUT => {
+                    log::warn!("the input event tap was switched off by the system; re-enabling it");
+                    unsafe { CGEventTapEnable(self.port, true) };
+                }
+                MOVED | LEFT_DRAGGED | RIGHT_DRAGGED | OTHER_DRAGGED => {
+                    let at = unsafe { CGEventGetLocation(event) };
+                    self.report_pointer(at);
+                }
+                LEFT_DOWN | LEFT_UP | RIGHT_DOWN | RIGHT_UP | OTHER_DOWN | OTHER_UP => {
+                    let number = unsafe { CGEventGetIntegerValueField(event, BUTTON_NUMBER) };
+                    let Some((phase, button)) = observed_button(event_type, number) else {
+                        return;
+                    };
+                    let at = unsafe { CGEventGetLocation(event) };
+                    // A click on another display is not on this source.
+                    let Some((x, y)) = self.geometry.to_source(at.x, at.y) else {
+                        return;
+                    };
+                    self.last_inside = (x, y);
+                    self.send(ObservedInput::Pointer { phase, x, y, button });
+                }
+                KEY_DOWN | KEY_UP | FLAGS_CHANGED => {
+                    let code = unsafe { CGEventGetIntegerValueField(event, KEYCODE) } as i16;
+                    let flags = unsafe { CGEventGetFlags(event) };
+                    let repeat = unsafe { CGEventGetIntegerValueField(event, AUTOREPEAT) } != 0;
+                    let text = if event_type == FLAGS_CHANGED {
+                        String::new()
+                    } else {
+                        let mut buffer = [0u16; 8];
+                        let mut length = 0usize;
+                        unsafe {
+                            CGEventKeyboardGetUnicodeString(
+                                event,
+                                buffer.len(),
+                                &mut length,
+                                buffer.as_mut_ptr(),
+                            )
+                        };
+                        String::from_utf16_lossy(&buffer[..length.min(buffer.len())])
+                    };
+                    if let Some(input) =
+                        crate::keymap::observed_key(event_type, code, flags, repeat, &text)
+                    {
+                        self.send(input);
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        /// Reports where the pointer is now, whether or not it moves.
+        fn report_pointer(&mut self, at: Point) {
+            match self.geometry.to_source(at.x, at.y) {
+                Some(inside) => {
+                    self.last_inside = inside;
+                    self.cursor.update(inside.0 as i32, inside.1 as i32, true);
+                }
+                None => self.cursor.update(
+                    self.last_inside.0 as i32,
+                    self.last_inside.1 as i32,
+                    false,
+                ),
+            }
+        }
+
+        fn send(&self, input: ObservedInput) {
+            (self.sink)(Observation::Input {
+                timestamp_us: timestamp_us(Instant::now()),
+                input,
+            });
+        }
+    }
+
+    extern "C" fn tap_callback(
+        _proxy: EventRef,
+        event_type: u32,
+        event: EventRef,
+        user_info: *mut c_void,
+    ) -> EventRef {
+        // The run loop of the tap's own thread is the only caller.
+        let observer = unsafe { &mut *(user_info as *mut Observer) };
+        observer.handle(event_type, event);
+        event
+    }
+
+    /// The observer thread and the flag that ends it.
+    struct Running {
+        stop: Arc<AtomicBool>,
+        thread: Option<std::thread::JoinHandle<()>>,
+    }
+
+    impl Drop for Running {
+        fn drop(&mut self) {
+            self.stop.store(true, Ordering::Release);
+            if let Some(thread) = self.thread.take() {
+                let _ = thread.join();
+            }
+        }
+    }
+
+    fn unavailable(code: &'static str, reason: String, remedy: String) -> Unavailable {
+        Unavailable {
+            code,
+            reason,
+            remedy,
+        }
+    }
+
+    /// Listens to the pointer and keyboard of the display `display_id` with a
+    /// listen-only event tap: it sees events, it cannot change or block them.
+    pub fn observe(
+        display_id: u32,
+        pixels: (usize, usize),
+        sink: Sink,
+    ) -> Result<Tap, Unavailable> {
+        let app = crate::mac::tcc_responsible_app_name();
+        // Preflight never prompts; the owner grants with `setup-input` or by
+        // adding the app in System Settings.
+        if let Err(missing) = observe_probe() {
+            return Err(unavailable(
+                "missing-input-monitoring",
+                missing.reason,
+                missing.remedy,
+            ));
+        }
+        let (origin_x, origin_y, width, height) = crate::mac::display_geometry(display_id)
+            .ok_or_else(|| {
+                unavailable(
+                    "display-unavailable",
+                    String::from("the selected display is no longer active"),
+                    String::from("select an active display and reconnect"),
+                )
+            })?;
+        let geometry = Geometry::new(
+            (origin_x, origin_y),
+            (width, height),
+            (pixels.0 as i64, pixels.1 as i64),
+        );
+        let (started_tx, started_rx) = std::sync::mpsc::channel();
+        let stop = Arc::new(AtomicBool::new(false));
+        let stopped = stop.clone();
+        let thread = std::thread::Builder::new()
+            .name(String::from("input-observer"))
+            .spawn(move || {
+                let cursor_sink = sink.clone();
+                let observer = Box::into_raw(Box::new(Observer {
+                    geometry,
+                    sink,
+                    cursor: crate::cursor::Reporter::new(Box::new(move |position| {
+                        cursor_sink(Observation::Cursor(position))
+                    })),
+                    last_inside: (0, 0),
+                    port: std::ptr::null(),
+                }));
+                let mask: u64 = [
+                    LEFT_DOWN,
+                    LEFT_UP,
+                    RIGHT_DOWN,
+                    RIGHT_UP,
+                    MOVED,
+                    LEFT_DRAGGED,
+                    RIGHT_DRAGGED,
+                    KEY_DOWN,
+                    KEY_UP,
+                    FLAGS_CHANGED,
+                    OTHER_DOWN,
+                    OTHER_UP,
+                    OTHER_DRAGGED,
+                ]
+                .iter()
+                .fold(0u64, |mask, event| mask | (1u64 << *event));
+                // kCGSessionEventTap, kCGHeadInsertEventTap, kCGEventTapOptionListenOnly.
+                let port =
+                    unsafe { CGEventTapCreate(1, 0, 1, mask, tap_callback, observer.cast()) };
+                if port.is_null() {
+                    drop(unsafe { Box::from_raw(observer) });
+                    let _ = started_tx.send(Err(()));
+                    return;
+                }
+                unsafe { (*observer).port = port };
+                let source = unsafe { CFMachPortCreateRunLoopSource(std::ptr::null(), port, 0) };
+                let run_loop = unsafe { CFRunLoopGetCurrent() };
+                unsafe {
+                    CFRunLoopAddSource(run_loop, source, kCFRunLoopCommonModes);
+                    CGEventTapEnable(port, true);
+                    // Where the pointer already is, so a consumer does not wait for it to move.
+                    let here = CGEventCreate(std::ptr::null());
+                    if !here.is_null() {
+                        (*observer).report_pointer(CGEventGetLocation(here));
+                        CFRelease(here);
+                    }
+                }
+                let _ = started_tx.send(Ok(()));
+                // Polled rather than stopped from outside: stopping a run loop
+                // that has not started yet is lost, and Drop would wait forever.
+                while !stopped.load(Ordering::Acquire) {
+                    unsafe { CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, 0) };
+                }
+                unsafe {
+                    CGEventTapEnable(port, false);
+                    CFMachPortInvalidate(port);
+                    CFRelease(source);
+                    CFRelease(port);
+                    drop(Box::from_raw(observer));
+                }
+            })
+            .map_err(|error| {
+                unavailable(
+                    "event-tap-failed",
+                    format!("could not start the input observer thread: {error}"),
+                    String::from("retry; if it persists, restart the engine"),
+                )
+            })?;
+        match started_rx.recv() {
+            Ok(Ok(())) => Ok(Tap {
+                mechanism: "cgeventtap",
+                guard: Box::new(Running {
+                    stop,
+                    thread: Some(thread),
+                }),
+            }),
+            _ => {
+                let _ = thread.join();
+                Err(unavailable(
+                    "event-tap-failed",
+                    format!("macOS refused to create the input event tap for {app}."),
+                    format!("Remove {app} from System Settings › Privacy & Security › Input Monitoring, add it again, then reconnect."),
+                ))
+            }
+        }
+    }
+
+    #[cfg(test)]
+    mod tests {
+        use super::*;
+
+        // A 3420x2224 pixel panel shown as 1710x1112 points, with a second
+        // display to its right.
+        fn geometry() -> Geometry {
+            Geometry::new((0.0, 0.0), (1710.0, 1112.0), (3420, 2224))
+        }
+
+        #[test]
+        fn a_point_becomes_the_source_pixel_under_it() {
+            assert_eq!(geometry().to_source(100.5, 50.0), Some((201, 100)));
+            assert_eq!(geometry().to_source(0.0, 0.0), Some((0, 0)));
+            assert_eq!(geometry().to_source(1709.9, 1111.9), Some((3419, 2223)));
+        }
+
+        #[test]
+        fn a_point_on_another_display_is_not_on_this_source() {
+            assert_eq!(geometry().to_source(1710.0, 10.0), None);
+            assert_eq!(geometry().to_source(-1.0, 10.0), None);
+            assert_eq!(geometry().to_source(10.0, 1112.0), None);
+        }
+
+        #[test]
+        fn a_display_left_of_the_main_one_maps_from_its_own_origin() {
+            let left = Geometry::new((-1920.0, 0.0), (1920.0, 1080.0), (1920, 1080));
+            assert_eq!(left.to_source(-1920.0, 0.0), Some((0, 0)));
+            assert_eq!(left.to_source(-1.0, 1.0), Some((1919, 1)));
+            assert_eq!(left.to_source(0.0, 1.0), None);
+        }
+
+        #[test]
+        fn buttons_use_the_control_channels_numbers() {
+            assert_eq!(observed_button(LEFT_DOWN, 0), Some((PointerPhase::Down, 1)));
+            assert_eq!(observed_button(LEFT_UP, 0), Some((PointerPhase::Up, 1)));
+            assert_eq!(observed_button(RIGHT_DOWN, 1), Some((PointerPhase::Down, 3)));
+            assert_eq!(observed_button(RIGHT_UP, 1), Some((PointerPhase::Up, 3)));
+            assert_eq!(observed_button(OTHER_DOWN, 2), Some((PointerPhase::Down, 2)));
+            assert_eq!(observed_button(OTHER_UP, 3), Some((PointerPhase::Up, 4)));
+        }
+
+        #[test]
+        fn a_motion_or_a_key_is_not_a_button() {
+            assert_eq!(observed_button(MOVED, 0), None);
+            assert_eq!(observed_button(KEY_DOWN, 0), None);
+            assert_eq!(observed_button(OTHER_DOWN, 1), None);
+        }
+
+        #[test]
+        fn without_input_monitoring_the_tap_is_typed_unavailable_and_silent() {
+            // The CI and lab Macs this runs on have not granted Input Monitoring
+            // to the test binary; where one has, there is nothing to refuse.
+            if observe_probe().is_ok() {
+                return;
+            }
+            let delivered = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
+            let counted = delivered.clone();
+            let refused = observe(
+                1,
+                (1920, 1080),
+                std::sync::Arc::new(move |_| {
+                    counted.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+                }),
+            );
+            let Err(refused) = refused else {
+                panic!("a tap was created without the grant");
+            };
+            assert_eq!(refused.code, "missing-input-monitoring");
+            assert!(refused.remedy.contains("Input Monitoring"));
+            assert_eq!(delivered.load(std::sync::atomic::Ordering::SeqCst), 0);
+        }
+    }
+}