`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};