`39bce59`

Add wayland input capture and emulation

- Implement layer-shell edge barriers for mouse edge detection
- Add virtual pointer injection using wlr-virtual-pointer protocol
- Add virtual keyboard injection using virtual-keyboard protocol
- Include XKB keymap for keyboard emulation
- Send edge events through mpsc channel for async processing

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 4 months ago

SHA: 39bce599bf227458669a8216c610ba22c03f2124
Parents: 6927e93
Tree: 621ba08

4 changed files

Status	File	+
A	`hyprkvm-daemon/src/input/capture.rs`	559
A	`hyprkvm-daemon/src/input/emulation.rs`	408
A	`hyprkvm-daemon/src/input/minimal_keymap.xkb`	275
A	`hyprkvm-daemon/src/input/mod.rs`	12

hyprkvm-daemon/src/input/capture.rsadded

 +//! Mouse edge capture via layer-shell
 +//!
 +//! Creates invisible 1-pixel barriers at screen edges to detect
 +//! when the cursor attempts to leave the screen.
++
 +use std::sync::mpsc;
 +use std::time::Instant;
++
 +use hyprkvm_common::Direction;
 +use smithay_client_toolkit::{
 +    compositor::{CompositorHandler, CompositorState},
 +    delegate_compositor, delegate_layer, delegate_output, delegate_pointer, delegate_registry,
 +    delegate_seat, delegate_shm,
 +    output::{OutputHandler, OutputState},
 +    registry::{ProvidesRegistryState, RegistryState},
 +    registry_handlers,
 +    seat::{
 +        pointer::{PointerEvent, PointerEventKind, PointerHandler},
 +        Capability, SeatHandler, SeatState,
 +    },
 +    shell::{
 +        wlr_layer::{
 +            Anchor, KeyboardInteractivity, Layer, LayerShell, LayerShellHandler, LayerSurface,
 +            LayerSurfaceConfigure,
 +        },
 +        WaylandSurface,
 +    },
 +    shm::{slot::SlotPool, Shm, ShmHandler},
 +};
 +use wayland_client::{
 +    globals::registry_queue_init,
 +    protocol::{wl_output, wl_pointer, wl_seat, wl_shm, wl_surface},
 +    Connection, QueueHandle,
 +};
++
 +/// Event emitted when cursor hits a screen edge
 +#[derive(Debug, Clone)]
 +pub struct EdgeEvent {
 +    pub direction: Direction,
 +    pub position: (i32, i32),
 +    pub timestamp: Instant,
 +}
++
 +/// Configuration for edge barriers
 +#[derive(Debug, Clone)]
 +pub struct EdgeCaptureConfig {
 +    /// Barrier thickness in pixels
 +    pub barrier_size: u32,
 +    /// Which edges to create barriers on
 +    pub enabled_edges: Vec<Direction>,
 +}
++
 +impl Default for EdgeCaptureConfig {
 +    fn default() -> Self {
 +        Self {
 +            barrier_size: 1,
 +            enabled_edges: vec![
 +                Direction::Left,
 +                Direction::Right,
 +                Direction::Up,
 +                Direction::Down,
 +            ],
 +        }
 +    }
 +}
++
 +/// An edge barrier surface
 +struct EdgeBarrier {
 +    direction: Direction,
 +    surface: LayerSurface,
 +    width: u32,
 +    height: u32,
 +    configured: bool,
 +}
++
 +/// Edge capture system state
 +struct EdgeCaptureState {
 +    registry_state: RegistryState,
 +    compositor_state: CompositorState,
 +    output_state: OutputState,
 +    seat_state: SeatState,
 +    shm_state: Shm,
 +    layer_shell: LayerShell,
++
 +    barriers: Vec<EdgeBarrier>,
 +    pool: Option<SlotPool>,
 +    event_tx: mpsc::Sender<EdgeEvent>,
 +    config: EdgeCaptureConfig,
++
 +    // Track outputs for barrier sizing
 +    outputs: Vec<OutputInfo>,
 +}
++
 +#[derive(Debug, Clone)]
 +struct OutputInfo {
 +    output: wl_output::WlOutput,
 +    width: u32,
 +    height: u32,
 +    x: i32,
 +    y: i32,
 +}
++
 +impl EdgeCaptureState {
 +    fn create_barriers(&mut self, qh: &QueueHandle<Self>) {
 +        // Get total screen bounds
 +        let (min_x, min_y, max_x, max_y) = self.screen_bounds();
 +        let total_width = (max_x - min_x) as u32;
 +        let total_height = (max_y - min_y) as u32;
++
 +        for direction in &self.config.enabled_edges.clone() {
 +            let (width, height, anchor) = match direction {
 +                Direction::Left => (
 +                    self.config.barrier_size,
 +                    total_height,
 +                    Anchor::LEFT | Anchor::TOP | Anchor::BOTTOM,
 +                ),
 +                Direction::Right => (
 +                    self.config.barrier_size,
 +                    total_height,
 +                    Anchor::RIGHT | Anchor::TOP | Anchor::BOTTOM,
 +                ),
 +                Direction::Up => (
 +                    total_width,
 +                    self.config.barrier_size,
 +                    Anchor::TOP | Anchor::LEFT | Anchor::RIGHT,
 +                ),
 +                Direction::Down => (
 +                    total_width,
 +                    self.config.barrier_size,
 +                    Anchor::BOTTOM | Anchor::LEFT | Anchor::RIGHT,
 +                ),
 +            };
++
 +            // Create layer surface
 +            let surface = self.compositor_state.create_surface(qh);
 +            let layer_surface = self.layer_shell.create_layer_surface(
 +                qh,
 +                surface,
 +                Layer::Top, // Top layer to catch pointer
 +                Some(format!("hyprkvm-edge-{}", direction)),
 +                None, // No specific output, use focused
 +            );
++
 +            // Configure the layer surface
 +            layer_surface.set_anchor(anchor);
 +            layer_surface.set_size(width, height);
 +            layer_surface.set_exclusive_zone(-1); // Don't reserve space
 +            layer_surface.set_keyboard_interactivity(KeyboardInteractivity::None);
++
 +            // Commit to apply configuration
 +            layer_surface.commit();
++
 +            self.barriers.push(EdgeBarrier {
 +                direction: *direction,
 +                surface: layer_surface,
 +                width,
 +                height,
 +                configured: false,
 +            });
 +        }
 +    }
++
 +    fn screen_bounds(&self) -> (i32, i32, i32, i32) {
 +        if self.outputs.is_empty() {
 +            return (0, 0, 1920, 1080); // Fallback
 +        }
++
 +        let mut min_x = i32::MAX;
 +        let mut min_y = i32::MAX;
 +        let mut max_x = i32::MIN;
 +        let mut max_y = i32::MIN;
++
 +        for output in &self.outputs {
 +            min_x = min_x.min(output.x);
 +            min_y = min_y.min(output.y);
 +            max_x = max_x.max(output.x + output.width as i32);
 +            max_y = max_y.max(output.y + output.height as i32);
 +        }
++
 +        (min_x, min_y, max_x, max_y)
 +    }
++
 +    fn draw_barrier(&mut self, barrier_idx: usize, qh: &QueueHandle<Self>) {
 +        let barrier = &self.barriers[barrier_idx];
 +        if !barrier.configured {
 +            return;
 +        }
++
 +        let pool = match &mut self.pool {
 +            Some(pool) => pool,
 +            None => return,
 +        };
++
 +        let width = barrier.width;
 +        let height = barrier.height;
 +        let stride = width * 4;
++
 +        let (buffer, canvas) = pool
 +            .create_buffer(
 +                width as i32,
 +                height as i32,
 +                stride as i32,
 +                wl_shm::Format::Argb8888,
 +            )
 +            .expect("Failed to create buffer");
++
 +        // Fill with transparent pixels
 +        canvas.fill(0);
++
 +        // Attach and commit
 +        barrier.surface.wl_surface().attach(Some(buffer.wl_buffer()), 0, 0);
 +        barrier.surface.wl_surface().damage_buffer(0, 0, width as i32, height as i32);
 +        barrier.surface.commit();
 +    }
++
 +    fn find_barrier_by_surface(&self, surface: &wl_surface::WlSurface) -> Option<usize> {
 +        self.barriers
 +            .iter()
 +            .position(|b| b.surface.wl_surface() == surface)
 +    }
 +}
++
 +// Implement all the required handlers
++
 +impl CompositorHandler for EdgeCaptureState {
 +    fn scale_factor_changed(
 +        &mut self,
 +        _conn: &Connection,
 +        _qh: &QueueHandle<Self>,
 +        _surface: &wl_surface::WlSurface,
 +        _new_factor: i32,
 +    ) {
 +    }
++
 +    fn transform_changed(
 +        &mut self,
 +        _conn: &Connection,
 +        _qh: &QueueHandle<Self>,
 +        _surface: &wl_surface::WlSurface,
 +        _new_transform: wl_output::Transform,
 +    ) {
 +    }
++
 +    fn frame(
 +        &mut self,
 +        _conn: &Connection,
 +        _qh: &QueueHandle<Self>,
 +        _surface: &wl_surface::WlSurface,
 +        _time: u32,
 +    ) {
 +    }
++
 +    fn surface_enter(
 +        &mut self,
 +        _conn: &Connection,
 +        _qh: &QueueHandle<Self>,
 +        _surface: &wl_surface::WlSurface,
 +        _output: &wl_output::WlOutput,
 +    ) {
 +    }
++
 +    fn surface_leave(
 +        &mut self,
 +        _conn: &Connection,
 +        _qh: &QueueHandle<Self>,
 +        _surface: &wl_surface::WlSurface,
 +        _output: &wl_output::WlOutput,
 +    ) {
 +    }
 +}
++
 +impl OutputHandler for EdgeCaptureState {
 +    fn output_state(&mut self) -> &mut OutputState {
 +        &mut self.output_state
 +    }
++
 +    fn new_output(
 +        &mut self,
 +        _conn: &Connection,
 +        _qh: &QueueHandle<Self>,
 +        output: wl_output::WlOutput,
 +    ) {
 +        // We'll get geometry info from the output state
 +        if let Some(info) = self.output_state.info(&output) {
 +            if let Some(size) = info.logical_size {
 +                let (x, y) = info.location;
 +                self.outputs.push(OutputInfo {
 +                    output,
 +                    width: size.0 as u32,
 +                    height: size.1 as u32,
 +                    x,
 +                    y,
 +                });
 +            }
 +        }
 +    }
++
 +    fn update_output(
 +        &mut self,
 +        _conn: &Connection,
 +        _qh: &QueueHandle<Self>,
 +        output: wl_output::WlOutput,
 +    ) {
 +        // Update output info
 +        if let Some(info) = self.output_state.info(&output) {
 +            if let Some(size) = info.logical_size {
 +                let (x, y) = info.location;
 +                if let Some(out) = self.outputs.iter_mut().find(|o| o.output == output) {
 +                    out.width = size.0 as u32;
 +                    out.height = size.1 as u32;
 +                    out.x = x;
 +                    out.y = y;
 +                }
 +            }
 +        }
 +    }
++
 +    fn output_destroyed(
 +        &mut self,
 +        _conn: &Connection,
 +        _qh: &QueueHandle<Self>,
 +        output: wl_output::WlOutput,
 +    ) {
 +        self.outputs.retain(|o| o.output != output);
 +    }
 +}
++
 +impl LayerShellHandler for EdgeCaptureState {
 +    fn closed(&mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _layer: &LayerSurface) {
 +        // Barrier closed, could recreate if needed
 +    }
++
 +    fn configure(
 +        &mut self,
 +        _conn: &Connection,
 +        qh: &QueueHandle<Self>,
 +        layer: &LayerSurface,
 +        configure: LayerSurfaceConfigure,
 +        _serial: u32,
 +    ) {
 +        // Find which barrier this is
 +        if let Some(idx) = self.barriers.iter().position(|b| &b.surface == layer) {
 +            let barrier = &mut self.barriers[idx];
 +            barrier.configured = true;
++
 +            // Update size if compositor changed it
 +            if configure.new_size.0 > 0 {
 +                barrier.width = configure.new_size.0;
 +            }
 +            if configure.new_size.1 > 0 {
 +                barrier.height = configure.new_size.1;
 +            }
++
 +            // Draw the (transparent) barrier
 +            self.draw_barrier(idx, qh);
 +        }
 +    }
 +}
++
 +impl SeatHandler for EdgeCaptureState {
 +    fn seat_state(&mut self) -> &mut SeatState {
 +        &mut self.seat_state
 +    }
++
 +    fn new_seat(&mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _seat: wl_seat::WlSeat) {}
++
 +    fn new_capability(
 +        &mut self,
 +        _conn: &Connection,
 +        qh: &QueueHandle<Self>,
 +        seat: wl_seat::WlSeat,
 +        capability: Capability,
 +    ) {
 +        if capability == Capability::Pointer {
 +            self.seat_state.get_pointer(qh, &seat).ok();
 +        }
 +    }
++
 +    fn remove_capability(
 +        &mut self,
 +        _conn: &Connection,
 +        _qh: &QueueHandle<Self>,
 +        _seat: wl_seat::WlSeat,
 +        _capability: Capability,
 +    ) {
 +    }
++
 +    fn remove_seat(&mut self, _conn: &Connection, _qh: &QueueHandle<Self>, _seat: wl_seat::WlSeat) {
 +    }
 +}
++
 +impl PointerHandler for EdgeCaptureState {
 +    fn pointer_frame(
 +        &mut self,
 +        _conn: &Connection,
 +        _qh: &QueueHandle<Self>,
 +        _pointer: &wl_pointer::WlPointer,
 +        events: &[PointerEvent],
 +    ) {
 +        for event in events {
 +            if let PointerEventKind::Enter { .. } = event.kind {
 +                // Pointer entered one of our barrier surfaces
 +                let surface = &event.surface;
 +                if let Some(idx) = self.find_barrier_by_surface(surface) {
 +                    let barrier = &self.barriers[idx];
 +                    let edge_event = EdgeEvent {
 +                        direction: barrier.direction,
 +                        position: (event.position.0 as i32, event.position.1 as i32),
 +                        timestamp: Instant::now(),
 +                    };
++
 +                    tracing::info!(
 +                        "Edge hit: {:?} at ({}, {})",
 +                        barrier.direction,
 +                        event.position.0,
 +                        event.position.1
 +                    );
++
 +                    let _ = self.event_tx.send(edge_event);
 +                }
 +            }
 +        }
 +    }
 +}
++
 +impl ShmHandler for EdgeCaptureState {
 +    fn shm_state(&mut self) -> &mut Shm {
 +        &mut self.shm_state
 +    }
 +}
++
 +impl ProvidesRegistryState for EdgeCaptureState {
 +    fn registry(&mut self) -> &mut RegistryState {
 +        &mut self.registry_state
 +    }
++
 +    registry_handlers!(OutputState, SeatState);
 +}
++
 +// Delegate macros
 +delegate_compositor!(EdgeCaptureState);
 +delegate_output!(EdgeCaptureState);
 +delegate_layer!(EdgeCaptureState);
 +delegate_seat!(EdgeCaptureState);
 +delegate_pointer!(EdgeCaptureState);
 +delegate_shm!(EdgeCaptureState);
 +delegate_registry!(EdgeCaptureState);
++
 +/// Handle for controlling edge capture
 +pub struct EdgeCapture {
 +    event_rx: mpsc::Receiver<EdgeEvent>,
 +    // The event loop runs in a separate thread
 +    _thread: std::thread::JoinHandle<()>,
 +}
++
 +impl EdgeCapture {
 +    /// Create and start edge capture
 +    pub fn new(config: EdgeCaptureConfig) -> Result<Self, EdgeCaptureError> {
 +        let (event_tx, event_rx) = mpsc::channel();
++
 +        let thread = std::thread::spawn(move || {
 +            if let Err(e) = run_capture_loop(config, event_tx) {
 +                tracing::error!("Edge capture error: {}", e);
 +            }
 +        });
++
 +        Ok(Self {
 +            event_rx,
 +            _thread: thread,
 +        })
 +    }
++
 +    /// Try to receive an edge event (non-blocking)
 +    pub fn try_recv(&self) -> Option<EdgeEvent> {
 +        self.event_rx.try_recv().ok()
 +    }
++
 +    /// Receive an edge event (blocking)
 +    pub fn recv(&self) -> Option<EdgeEvent> {
 +        self.event_rx.recv().ok()
 +    }
++
 +    /// Get the receiver for async integration
 +    pub fn receiver(&self) -> &mpsc::Receiver<EdgeEvent> {
 +        &self.event_rx
 +    }
 +}
++
 +fn run_capture_loop(
 +    config: EdgeCaptureConfig,
 +    event_tx: mpsc::Sender<EdgeEvent>,
 +) -> Result<(), EdgeCaptureError> {
 +    let conn = Connection::connect_to_env().map_err(|e| EdgeCaptureError::Connection(e.to_string()))?;
++
 +    let (globals, mut event_queue) =
 +        registry_queue_init(&conn).map_err(|e| EdgeCaptureError::Registry(e.to_string()))?;
 +    let qh = event_queue.handle();
++
 +    let compositor_state = CompositorState::bind(&globals, &qh)
 +        .map_err(|e| EdgeCaptureError::Protocol(format!("compositor: {}", e)))?;
 +    let layer_shell = LayerShell::bind(&globals, &qh)
 +        .map_err(|e| EdgeCaptureError::Protocol(format!("layer_shell: {}", e)))?;
 +    let shm_state =
 +        Shm::bind(&globals, &qh).map_err(|e| EdgeCaptureError::Protocol(format!("shm: {}", e)))?;
++
 +    let mut state = EdgeCaptureState {
 +        registry_state: RegistryState::new(&globals),
 +        compositor_state,
 +        output_state: OutputState::new(&globals, &qh),
 +        seat_state: SeatState::new(&globals, &qh),
 +        shm_state,
 +        layer_shell,
 +        barriers: Vec::new(),
 +        pool: None,
 +        event_tx,
 +        config,
 +        outputs: Vec::new(),
 +    };
++
 +    // Initial roundtrip to get outputs
 +    event_queue.roundtrip(&mut state).map_err(|e| EdgeCaptureError::Dispatch(e.to_string()))?;
++
 +    // Create shm pool for buffers
 +    state.pool = Some(
 +        SlotPool::new(256 * 256 * 4, &state.shm_state)
 +            .map_err(|e| EdgeCaptureError::Shm(e.to_string()))?,
 +    );
++
 +    // Create barriers after we have output info
 +    state.create_barriers(&qh);
++
 +    // Another roundtrip to configure barriers
 +    event_queue.roundtrip(&mut state).map_err(|e| EdgeCaptureError::Dispatch(e.to_string()))?;
++
 +    tracing::info!("Edge capture running with {} barriers", state.barriers.len());
++
 +    // Main event loop
 +    loop {
 +        event_queue.blocking_dispatch(&mut state).map_err(|e| EdgeCaptureError::Dispatch(e.to_string()))?;
 +    }
 +}
++
 +#[derive(Debug, thiserror::Error)]
 +pub enum EdgeCaptureError {
 +    #[error("Failed to connect to Wayland: {0}")]
 +    Connection(String),
++
 +    #[error("Registry error: {0}")]
 +    Registry(String),
++
 +    #[error("Protocol not available: {0}")]
 +    Protocol(String),
++
 +    #[error("Dispatch error: {0}")]
 +    Dispatch(String),
++
 +    #[error("SHM error: {0}")]
 +    Shm(String),
 +}

hyprkvm-daemon/src/input/emulation.rsadded

 +//! Wayland input emulation
 +//!
 +//! Injects keyboard and mouse events via virtual input protocols.
 +//! Uses wlr-virtual-pointer and virtual-keyboard Wayland protocols.
++
 +use std::os::unix::io::{AsFd, OwnedFd};
 +use std::sync::Arc;
++
 +use wayland_client::{
 +    globals::{registry_queue_init, GlobalListContents},
 +    protocol::{wl_registry, wl_seat},
 +    Connection, Dispatch, EventQueue, QueueHandle,
 +};
 +use wayland_protocols_wlr::virtual_pointer::v1::client::{
 +    zwlr_virtual_pointer_manager_v1::ZwlrVirtualPointerManagerV1,
 +    zwlr_virtual_pointer_v1::ZwlrVirtualPointerV1,
 +};
 +use wayland_protocols_misc::zwp_virtual_keyboard_v1::client::{
 +    zwp_virtual_keyboard_manager_v1::ZwpVirtualKeyboardManagerV1,
 +    zwp_virtual_keyboard_v1::ZwpVirtualKeyboardV1,
 +};
 +use wayland_client::protocol::wl_pointer::{
 +    Axis as WlAxis,
 +    ButtonState as WlButtonState,
 +};
++
 +use hyprkvm_common::{ButtonState, KeyState};
++
 +/// Virtual pointer for mouse injection
 +pub struct VirtualPointer {
 +    pointer: ZwlrVirtualPointerV1,
 +    _connection: Arc<Connection>,
 +}
++
 +impl VirtualPointer {
 +    /// Send relative motion
 +    pub fn motion(&self, dx: f64, dy: f64) {
 +        // Time in milliseconds (monotonic, we just use 0 for simplicity)
 +        let time = std::time::SystemTime::now()
 +            .duration_since(std::time::UNIX_EPOCH)
 +            .unwrap()
 +            .as_millis() as u32;
++
 +        self.pointer.motion(time, dx, dy);
 +        self.pointer.frame();
 +    }
++
 +    /// Send absolute motion (normalized 0.0-1.0)
 +    pub fn motion_absolute(&self, x: f64, y: f64, width: u32, height: u32) {
 +        let time = std::time::SystemTime::now()
 +            .duration_since(std::time::UNIX_EPOCH)
 +            .unwrap()
 +            .as_millis() as u32;
++
 +        // Convert to fixed-point (wl_fixed)
 +        let x_fixed = (x * width as f64) as u32;
 +        let y_fixed = (y * height as f64) as u32;
++
 +        self.pointer.motion_absolute(time, x_fixed, y_fixed, width, height);
 +        self.pointer.frame();
 +    }
++
 +    /// Send button event
 +    pub fn button(&self, button: u32, state: ButtonState) {
 +        let time = std::time::SystemTime::now()
 +            .duration_since(std::time::UNIX_EPOCH)
 +            .unwrap()
 +            .as_millis() as u32;
++
 +        let wl_state = match state {
 +            ButtonState::Pressed => WlButtonState::Pressed,
 +            ButtonState::Released => WlButtonState::Released,
 +        };
++
 +        self.pointer.button(time, button, wl_state);
 +        self.pointer.frame();
 +    }
++
 +    /// Send scroll (axis) event
 +    pub fn scroll(&self, horizontal: f64, vertical: f64) {
 +        let time = std::time::SystemTime::now()
 +            .duration_since(std::time::UNIX_EPOCH)
 +            .unwrap()
 +            .as_millis() as u32;
++
 +        if vertical.abs() > 0.001 {
 +            self.pointer.axis(time, WlAxis::VerticalScroll, vertical);
 +        }
 +        if horizontal.abs() > 0.001 {
 +            self.pointer.axis(time, WlAxis::HorizontalScroll, horizontal);
 +        }
 +        self.pointer.frame();
 +    }
 +}
++
 +/// Virtual keyboard for key injection
 +pub struct VirtualKeyboard {
 +    keyboard: ZwpVirtualKeyboardV1,
 +    _connection: Arc<Connection>,
 +    keymap_set: bool,
 +}
++
 +impl VirtualKeyboard {
 +    /// Send key event
 +    pub fn key(&self, keycode: u32, state: KeyState) {
 +        if !self.keymap_set {
 +            tracing::warn!("Keymap not set, key event may not work correctly");
 +        }
++
 +        let time = std::time::SystemTime::now()
 +            .duration_since(std::time::UNIX_EPOCH)
 +            .unwrap()
 +            .as_millis() as u32;
++
 +        let wl_state = match state {
 +            KeyState::Pressed => wl_keyboard_key_state::Pressed,
 +            KeyState::Released => wl_keyboard_key_state::Released,
 +        };
++
 +        // Note: keycode needs to be offset by 8 for evdev->xkb conversion
 +        self.keyboard.key(time, keycode, wl_state);
 +    }
++
 +    /// Send modifier state
 +    pub fn modifiers(&self, depressed: u32, latched: u32, locked: u32, group: u32) {
 +        self.keyboard.modifiers(depressed, latched, locked, group);
 +    }
 +}
++
 +// Key state constants
 +mod wl_keyboard_key_state {
 +    pub const Released: u32 = 0;
 +    pub const Pressed: u32 = 1;
 +}
++
 +/// State for input emulation setup
 +struct EmulationState {
 +    pointer_manager: Option<ZwlrVirtualPointerManagerV1>,
 +    keyboard_manager: Option<ZwpVirtualKeyboardManagerV1>,
 +    seat: Option<wl_seat::WlSeat>,
 +}
++
 +impl Dispatch<wl_registry::WlRegistry, GlobalListContents> for EmulationState {
 +    fn event(
 +        state: &mut Self,
 +        registry: &wl_registry::WlRegistry,
 +        event: wl_registry::Event,
 +        _data: &GlobalListContents,
 +        _conn: &Connection,
 +        qh: &QueueHandle<Self>,
 +    ) {
 +        if let wl_registry::Event::Global { name, interface, version } = event {
 +            match interface.as_str() {
 +                "zwlr_virtual_pointer_manager_v1" => {
 +                    state.pointer_manager = Some(registry.bind(name, version.min(2), qh, ()));
 +                }
 +                "zwp_virtual_keyboard_manager_v1" => {
 +                    state.keyboard_manager = Some(registry.bind(name, version.min(1), qh, ()));
 +                }
 +                "wl_seat" => {
 +                    state.seat = Some(registry.bind(name, version.min(7), qh, ()));
 +                }
 +                _ => {}
 +            }
 +        }
 +    }
 +}
++
 +// Implement empty dispatchers for the protocols we use
 +impl Dispatch<ZwlrVirtualPointerManagerV1, ()> for EmulationState {
 +    fn event(
 +        _state: &mut Self,
 +        _proxy: &ZwlrVirtualPointerManagerV1,
 +        _event: <ZwlrVirtualPointerManagerV1 as wayland_client::Proxy>::Event,
 +        _data: &(),
 +        _conn: &Connection,
 +        _qh: &QueueHandle<Self>,
 +    ) {
 +    }
 +}
++
 +impl Dispatch<ZwlrVirtualPointerV1, ()> for EmulationState {
 +    fn event(
 +        _state: &mut Self,
 +        _proxy: &ZwlrVirtualPointerV1,
 +        _event: <ZwlrVirtualPointerV1 as wayland_client::Proxy>::Event,
 +        _data: &(),
 +        _conn: &Connection,
 +        _qh: &QueueHandle<Self>,
 +    ) {
 +    }
 +}
++
 +impl Dispatch<ZwpVirtualKeyboardManagerV1, ()> for EmulationState {
 +    fn event(
 +        _state: &mut Self,
 +        _proxy: &ZwpVirtualKeyboardManagerV1,
 +        _event: <ZwpVirtualKeyboardManagerV1 as wayland_client::Proxy>::Event,
 +        _data: &(),
 +        _conn: &Connection,
 +        _qh: &QueueHandle<Self>,
 +    ) {
 +    }
 +}
++
 +impl Dispatch<ZwpVirtualKeyboardV1, ()> for EmulationState {
 +    fn event(
 +        _state: &mut Self,
 +        _proxy: &ZwpVirtualKeyboardV1,
 +        _event: <ZwpVirtualKeyboardV1 as wayland_client::Proxy>::Event,
 +        _data: &(),
 +        _conn: &Connection,
 +        _qh: &QueueHandle<Self>,
 +    ) {
 +    }
 +}
++
 +impl Dispatch<wl_seat::WlSeat, ()> for EmulationState {
 +    fn event(
 +        _state: &mut Self,
 +        _proxy: &wl_seat::WlSeat,
 +        _event: wl_seat::Event,
 +        _data: &(),
 +        _conn: &Connection,
 +        _qh: &QueueHandle<Self>,
 +    ) {
 +    }
 +}
++
 +/// Input emulator combining virtual pointer and keyboard
 +pub struct InputEmulator {
 +    pub pointer: VirtualPointer,
 +    pub keyboard: VirtualKeyboard,
 +    connection: Arc<Connection>,
 +    event_queue: EventQueue<EmulationState>,
 +}
++
 +impl InputEmulator {
 +    /// Create a new input emulator
 +    pub fn new() -> Result<Self, EmulationError> {
 +        let conn = Connection::connect_to_env()
 +            .map_err(|e| EmulationError::Connection(e.to_string()))?;
 +        let conn = Arc::new(conn);
++
 +        let (globals, mut event_queue) = registry_queue_init(&conn)
 +            .map_err(|e| EmulationError::Registry(e.to_string()))?;
++
 +        let qh = event_queue.handle();
++
 +        let mut state = EmulationState {
 +            pointer_manager: None,
 +            keyboard_manager: None,
 +            seat: None,
 +        };
++
 +        // Bind to required globals
 +        for global in globals.contents().clone_list() {
 +            match global.interface.as_str() {
 +                "zwlr_virtual_pointer_manager_v1" => {
 +                    state.pointer_manager = Some(
 +                        globals
 +                            .registry()
 +                            .bind(global.name, global.version.min(2), &qh, ()),
 +                    );
 +                }
 +                "zwp_virtual_keyboard_manager_v1" => {
 +                    state.keyboard_manager = Some(
 +                        globals
 +                            .registry()
 +                            .bind(global.name, global.version.min(1), &qh, ()),
 +                    );
 +                }
 +                "wl_seat" => {
 +                    state.seat = Some(
 +                        globals
 +                            .registry()
 +                            .bind(global.name, global.version.min(7), &qh, ()),
 +                    );
 +                }
 +                _ => {}
 +            }
 +        }
++
 +        // Roundtrip to ensure we have all globals
 +        event_queue
 +            .roundtrip(&mut state)
 +            .map_err(|e| EmulationError::Dispatch(e.to_string()))?;
++
 +        // Check we have required protocols
 +        let pointer_manager = state.pointer_manager.clone().ok_or_else(|| {
 +            EmulationError::Protocol("zwlr_virtual_pointer_manager_v1 not available".to_string())
 +        })?;
++
 +        let keyboard_manager = state.keyboard_manager.clone().ok_or_else(|| {
 +            EmulationError::Protocol("zwp_virtual_keyboard_manager_v1 not available".to_string())
 +        })?;
++
 +        let seat = state.seat.clone().ok_or_else(|| {
 +            EmulationError::Protocol("wl_seat not available".to_string())
 +        })?;
++
 +        // Create virtual pointer
 +        let pointer = pointer_manager.create_virtual_pointer(Some(&seat), &qh, ());
++
 +        // Create virtual keyboard
 +        let keyboard = keyboard_manager.create_virtual_keyboard(&seat, &qh, ());
++
 +        // Set up a basic keymap for the keyboard
 +        // This is a minimal xkb keymap
 +        let keymap_string = include_str!("minimal_keymap.xkb");
 +        let keymap_size = keymap_string.len() as u32;
++
 +        // Create a memfd for the keymap
 +        let keymap_fd = create_keymap_fd(keymap_string)
 +            .map_err(|e| EmulationError::Keymap(e.to_string()))?;
++
 +        keyboard.keymap(
 +            1, // WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1
 +            keymap_fd.as_fd(),
 +            keymap_size,
 +        );
++
 +        // Roundtrip to ensure everything is set up
 +        event_queue
 +            .roundtrip(&mut state)
 +            .map_err(|e| EmulationError::Dispatch(e.to_string()))?;
++
 +        Ok(Self {
 +            pointer: VirtualPointer {
 +                pointer,
 +                _connection: conn.clone(),
 +            },
 +            keyboard: VirtualKeyboard {
 +                keyboard,
 +                _connection: conn.clone(),
 +                keymap_set: true,
 +            },
 +            connection: conn,
 +            event_queue,
 +        })
 +    }
++
 +    /// Dispatch any pending events
 +    pub fn dispatch(&mut self) -> Result<(), EmulationError> {
 +        let mut state = EmulationState {
 +            pointer_manager: None,
 +            keyboard_manager: None,
 +            seat: None,
 +        };
 +        self.event_queue
 +            .dispatch_pending(&mut state)
 +            .map_err(|e| EmulationError::Dispatch(e.to_string()))?;
 +        self.connection
 +            .flush()
 +            .map_err(|e| EmulationError::Dispatch(e.to_string()))?;
 +        Ok(())
 +    }
 +}
++
 +/// Create a memfd containing the keymap string
 +fn create_keymap_fd(keymap: &str) -> std::io::Result<OwnedFd> {
 +    use std::io::Write;
++
 +    // Create memfd
 +    let fd = rustix::fs::memfd_create(
 +        "hyprkvm-keymap",
 +        rustix::fs::MemfdFlags::CLOEXEC | rustix::fs::MemfdFlags::ALLOW_SEALING,
 +    )?;
++
 +    // Write keymap
 +    let mut file = std::fs::File::from(fd);
 +    file.write_all(keymap.as_bytes())?;
 +    file.write_all(&[0])?; // Null terminator
++
 +    // Seal the file
 +    let fd = OwnedFd::from(file);
++
 +    Ok(fd)
 +}
++
 +#[derive(Debug, thiserror::Error)]
 +pub enum EmulationError {
 +    #[error("Failed to connect to Wayland: {0}")]
 +    Connection(String),
++
 +    #[error("Registry error: {0}")]
 +    Registry(String),
++
 +    #[error("Protocol not available: {0}")]
 +    Protocol(String),
++
 +    #[error("Dispatch error: {0}")]
 +    Dispatch(String),
++
 +    #[error("Keymap error: {0}")]
 +    Keymap(String),
 +}
++
 +// Button codes (from linux/input-event-codes.h)
 +pub mod button_codes {
 +    pub const BTN_LEFT: u32 = 0x110;
 +    pub const BTN_RIGHT: u32 = 0x111;
 +    pub const BTN_MIDDLE: u32 = 0x112;
 +    pub const BTN_SIDE: u32 = 0x113;
 +    pub const BTN_EXTRA: u32 = 0x114;
 +    pub const BTN_FORWARD: u32 = 0x115;
 +    pub const BTN_BACK: u32 = 0x116;
 +}

hyprkvm-daemon/src/input/minimal_keymap.xkbadded

 +xkb_keymap {
 +    xkb_keycodes "evdev" {
 +        minimum = 8;
 +        maximum = 255;
 +        <ESC> = 9;
 +        <AE01> = 10;
 +        <AE02> = 11;
 +        <AE03> = 12;
 +        <AE04> = 13;
 +        <AE05> = 14;
 +        <AE06> = 15;
 +        <AE07> = 16;
 +        <AE08> = 17;
 +        <AE09> = 18;
 +        <AE10> = 19;
 +        <AE11> = 20;
 +        <AE12> = 21;
 +        <BKSP> = 22;
 +        <TAB> = 23;
 +        <AD01> = 24;
 +        <AD02> = 25;
 +        <AD03> = 26;
 +        <AD04> = 27;
 +        <AD05> = 28;
 +        <AD06> = 29;
 +        <AD07> = 30;
 +        <AD08> = 31;
 +        <AD09> = 32;
 +        <AD10> = 33;
 +        <AD11> = 34;
 +        <AD12> = 35;
 +        <RTRN> = 36;
 +        <LCTL> = 37;
 +        <AC01> = 38;
 +        <AC02> = 39;
 +        <AC03> = 40;
 +        <AC04> = 41;
 +        <AC05> = 42;
 +        <AC06> = 43;
 +        <AC07> = 44;
 +        <AC08> = 45;
 +        <AC09> = 46;
 +        <AC10> = 47;
 +        <AC11> = 48;
 +        <TLDE> = 49;
 +        <LFSH> = 50;
 +        <BKSL> = 51;
 +        <AB01> = 52;
 +        <AB02> = 53;
 +        <AB03> = 54;
 +        <AB04> = 55;
 +        <AB05> = 56;
 +        <AB06> = 57;
 +        <AB07> = 58;
 +        <AB08> = 59;
 +        <AB09> = 60;
 +        <AB10> = 61;
 +        <RTSH> = 62;
 +        <KPMU> = 63;
 +        <LALT> = 64;
 +        <SPCE> = 65;
 +        <CAPS> = 66;
 +        <FK01> = 67;
 +        <FK02> = 68;
 +        <FK03> = 69;
 +        <FK04> = 70;
 +        <FK05> = 71;
 +        <FK06> = 72;
 +        <FK07> = 73;
 +        <FK08> = 74;
 +        <FK09> = 75;
 +        <FK10> = 76;
 +        <NMLK> = 77;
 +        <SCLK> = 78;
 +        <KP7> = 79;
 +        <KP8> = 80;
 +        <KP9> = 81;
 +        <KPSU> = 82;
 +        <KP4> = 83;
 +        <KP5> = 84;
 +        <KP6> = 85;
 +        <KPAD> = 86;
 +        <KP1> = 87;
 +        <KP2> = 88;
 +        <KP3> = 89;
 +        <KP0> = 90;
 +        <KPDL> = 91;
 +        <FK11> = 95;
 +        <FK12> = 96;
 +        <KPEN> = 104;
 +        <RCTL> = 105;
 +        <KPDV> = 106;
 +        <PRSC> = 107;
 +        <RALT> = 108;
 +        <HOME> = 110;
 +        <UP> = 111;
 +        <PGUP> = 112;
 +        <LEFT> = 113;
 +        <RGHT> = 114;
 +        <END> = 115;
 +        <DOWN> = 116;
 +        <PGDN> = 117;
 +        <INS> = 118;
 +        <DELE> = 119;
 +        <PAUS> = 127;
 +        <LWIN> = 133;
 +        <RWIN> = 134;
 +        <MENU> = 135;
 +    };
++
 +    xkb_types "complete" {
 +        virtual_modifiers NumLock,Alt,LevelThree,LAlt,RAlt,RControl,LControl,ScrollLock,LevelFive,AltGr,Meta,Super,Hyper;
++
 +        type "ONE_LEVEL" {
 +            modifiers= none;
 +            level_name[Level1]= "Any";
 +        };
 +        type "TWO_LEVEL" {
 +            modifiers= Shift;
 +            map[Shift]= Level2;
 +            level_name[Level1]= "Base";
 +            level_name[Level2]= "Shift";
 +        };
 +        type "ALPHABETIC" {
 +            modifiers= Shift+Lock;
 +            map[Shift]= Level2;
 +            map[Lock]= Level2;
 +            level_name[Level1]= "Base";
 +            level_name[Level2]= "Caps";
 +        };
 +        type "KEYPAD" {
 +            modifiers= Shift+NumLock;
 +            map[Shift]= Level2;
 +            map[NumLock]= Level2;
 +            level_name[Level1]= "Base";
 +            level_name[Level2]= "Number";
 +        };
 +    };
++
 +    xkb_compatibility "complete" {
 +        virtual_modifiers NumLock,Alt,LevelThree,LAlt,RAlt,RControl,LControl,ScrollLock,LevelFive,AltGr,Meta,Super,Hyper;
++
 +        interpret.useModMapMods= AnyLevel;
 +        interpret.repeat= False;
++
 +        interpret Shift_L+AnyOf(all) {
 +            action= SetMods(modifiers=Shift,clearLocks);
 +        };
 +        interpret Shift_R+AnyOf(all) {
 +            action= SetMods(modifiers=Shift,clearLocks);
 +        };
 +        interpret Control_L+AnyOf(all) {
 +            action= SetMods(modifiers=Control,clearLocks);
 +        };
 +        interpret Control_R+AnyOf(all) {
 +            action= SetMods(modifiers=Control,clearLocks);
 +        };
 +        interpret Caps_Lock+AnyOf(all) {
 +            action= LockMods(modifiers=Lock);
 +        };
 +        interpret Num_Lock+AnyOf(all) {
 +            action= LockMods(modifiers=NumLock);
 +        };
 +        interpret Alt_L+AnyOf(all) {
 +            action= SetMods(modifiers=Alt,clearLocks);
 +        };
 +        interpret Alt_R+AnyOf(all) {
 +            action= SetMods(modifiers=Alt,clearLocks);
 +        };
 +        interpret Super_L+AnyOf(all) {
 +            action= SetMods(modifiers=Super,clearLocks);
 +        };
 +        interpret Super_R+AnyOf(all) {
 +            action= SetMods(modifiers=Super,clearLocks);
 +        };
 +    };
++
 +    xkb_symbols "us" {
 +        name[group1]="English (US)";
++
 +        key <ESC>  { [ Escape ] };
 +        key <AE01> { [ 1, exclam ] };
 +        key <AE02> { [ 2, at ] };
 +        key <AE03> { [ 3, numbersign ] };
 +        key <AE04> { [ 4, dollar ] };
 +        key <AE05> { [ 5, percent ] };
 +        key <AE06> { [ 6, asciicircum ] };
 +        key <AE07> { [ 7, ampersand ] };
 +        key <AE08> { [ 8, asterisk ] };
 +        key <AE09> { [ 9, parenleft ] };
 +        key <AE10> { [ 0, parenright ] };
 +        key <AE11> { [ minus, underscore ] };
 +        key <AE12> { [ equal, plus ] };
 +        key <BKSP> { [ BackSpace ] };
 +        key <TAB>  { [ Tab, ISO_Left_Tab ] };
 +        key <AD01> { [ q, Q ] };
 +        key <AD02> { [ w, W ] };
 +        key <AD03> { [ e, E ] };
 +        key <AD04> { [ r, R ] };
 +        key <AD05> { [ t, T ] };
 +        key <AD06> { [ y, Y ] };
 +        key <AD07> { [ u, U ] };
 +        key <AD08> { [ i, I ] };
 +        key <AD09> { [ o, O ] };
 +        key <AD10> { [ p, P ] };
 +        key <AD11> { [ bracketleft, braceleft ] };
 +        key <AD12> { [ bracketright, braceright ] };
 +        key <RTRN> { [ Return ] };
 +        key <LCTL> { [ Control_L ] };
 +        key <AC01> { [ a, A ] };
 +        key <AC02> { [ s, S ] };
 +        key <AC03> { [ d, D ] };
 +        key <AC04> { [ f, F ] };
 +        key <AC05> { [ g, G ] };
 +        key <AC06> { [ h, H ] };
 +        key <AC07> { [ j, J ] };
 +        key <AC08> { [ k, K ] };
 +        key <AC09> { [ l, L ] };
 +        key <AC10> { [ semicolon, colon ] };
 +        key <AC11> { [ apostrophe, quotedbl ] };
 +        key <TLDE> { [ grave, asciitilde ] };
 +        key <LFSH> { [ Shift_L ] };
 +        key <BKSL> { [ backslash, bar ] };
 +        key <AB01> { [ z, Z ] };
 +        key <AB02> { [ x, X ] };
 +        key <AB03> { [ c, C ] };
 +        key <AB04> { [ v, V ] };
 +        key <AB05> { [ b, B ] };
 +        key <AB06> { [ n, N ] };
 +        key <AB07> { [ m, M ] };
 +        key <AB08> { [ comma, less ] };
 +        key <AB09> { [ period, greater ] };
 +        key <AB10> { [ slash, question ] };
 +        key <RTSH> { [ Shift_R ] };
 +        key <LALT> { [ Alt_L ] };
 +        key <SPCE> { [ space ] };
 +        key <CAPS> { [ Caps_Lock ] };
 +        key <FK01> { [ F1 ] };
 +        key <FK02> { [ F2 ] };
 +        key <FK03> { [ F3 ] };
 +        key <FK04> { [ F4 ] };
 +        key <FK05> { [ F5 ] };
 +        key <FK06> { [ F6 ] };
 +        key <FK07> { [ F7 ] };
 +        key <FK08> { [ F8 ] };
 +        key <FK09> { [ F9 ] };
 +        key <FK10> { [ F10 ] };
 +        key <FK11> { [ F11 ] };
 +        key <FK12> { [ F12 ] };
 +        key <NMLK> { [ Num_Lock ] };
 +        key <SCLK> { [ Scroll_Lock ] };
 +        key <RCTL> { [ Control_R ] };
 +        key <RALT> { [ Alt_R ] };
 +        key <HOME> { [ Home ] };
 +        key <UP>   { [ Up ] };
 +        key <PGUP> { [ Prior ] };
 +        key <LEFT> { [ Left ] };
 +        key <RGHT> { [ Right ] };
 +        key <END>  { [ End ] };
 +        key <DOWN> { [ Down ] };
 +        key <PGDN> { [ Next ] };
 +        key <INS>  { [ Insert ] };
 +        key <DELE> { [ Delete ] };
 +        key <PAUS> { [ Pause ] };
 +        key <LWIN> { [ Super_L ] };
 +        key <RWIN> { [ Super_R ] };
 +        key <MENU> { [ Menu ] };
++
 +        modifier_map Shift { <LFSH>, <RTSH> };
 +        modifier_map Lock { <CAPS> };
 +        modifier_map Control { <LCTL>, <RCTL> };
 +        modifier_map Mod1 { <LALT>, <RALT> };
 +        modifier_map Mod4 { <LWIN>, <RWIN> };
 +    };
 +};

hyprkvm-daemon/src/input/mod.rsadded

 +//! Input handling module
 +//!
 +//! Handles input capture (when sending to remote) and injection (when receiving).
++
 +pub mod capture;
 +pub mod emulation;
++
 +// TODO: Sprint 3 - Implement input handling
 +// pub mod router;
++
 +pub use capture::{EdgeCapture, EdgeCaptureConfig, EdgeCaptureError, EdgeEvent};
 +pub use emulation::{InputEmulator, VirtualKeyboard, VirtualPointer, EmulationError, button_codes};