split into input-{event,capture,emulation}

input-emulation/Cargo.toml

@@ -0,0 +1,47 @@
+[package]
+name = "input-emulation"
+description = "cross-platform input emulation library used by lan-mouse"
+version = "0.1.0"
+edition = "2021"
+license = "GPL-3.0-or-later"
+repository = "https://github.com/ferdinandschober/lan-mouse"
+
+[dependencies]
+anyhow = "1.0.86"
+async-trait = "0.1.80"
+futures = "0.3.28"
+log = "0.4.22"
+input-event = { path = "../input-event" }
+thiserror = "1.0.61"
+tokio = { version = "1.32.0", features = ["io-util", "io-std", "macros", "net", "process", "rt", "sync", "signal"] }
+
+[target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
+wayland-client = { version="0.31.1", optional = true }
+wayland-protocols = { version="0.31.0", features=["client", "staging", "unstable"], optional = true }
+wayland-protocols-wlr = { version="0.2.0", features=["client"], optional = true }
+wayland-protocols-misc = { version="0.2.0", features=["client"], optional = true }
+x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
+ashpd = { version = "0.8", default-features = false, features = ["tokio"], optional = true }
+reis = { version = "0.2", features = [ "tokio" ], optional = true }
+
+[target.'cfg(target_os="macos")'.dependencies]
+core-graphics = { version = "0.23", features = ["highsierra"] }
+keycode = "0.4.0"
+
+[target.'cfg(windows)'.dependencies]
+windows = {  version = "0.54.0", features = [
+    "Win32_System_LibraryLoader",
+    "Win32_System_Threading",
+    "Win32_Foundation",
+    "Win32_Graphics",
+    "Win32_Graphics_Gdi",
+    "Win32_UI_Input_KeyboardAndMouse",
+    "Win32_UI_WindowsAndMessaging",
+] }
+
+[features]
+default = ["wayland", "x11", "xdg_desktop_portal", "libei"]
+wayland = ["dep:wayland-client", "dep:wayland-protocols", "dep:wayland-protocols-wlr", "dep:wayland-protocols-misc" ]
+x11 = ["dep:x11"]
+xdg_desktop_portal = ["dep:ashpd"]
+libei = ["dep:reis", "dep:ashpd"]

input-emulation/src/dummy.rs

@@ -0,0 +1,22 @@
+use async_trait::async_trait;
+use input_event::Event;
+
+use super::{EmulationHandle, InputEmulation};
+
+#[derive(Default)]
+pub struct DummyEmulation;
+
+impl DummyEmulation {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+#[async_trait]
+impl InputEmulation for DummyEmulation {
+    async fn consume(&mut self, event: Event, client_handle: EmulationHandle) {
+        log::info!("received event: ({client_handle}) {event}");
+    }
+    async fn create(&mut self, _: EmulationHandle) {}
+    async fn destroy(&mut self, _: EmulationHandle) {}
+}

input-emulation/src/error.rs

@@ -0,0 +1,168 @@
+use std::fmt::Display;
+
+use thiserror::Error;
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+use wayland_client::{
+    backend::WaylandError,
+    globals::{BindError, GlobalError},
+    ConnectError, DispatchError,
+};
+
+#[derive(Debug, Error)]
+pub enum EmulationCreationError {
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    Wlroots(#[from] WlrootsEmulationCreationError),
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    Libei(#[from] LibeiEmulationCreationError),
+    #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+    Xdp(#[from] XdpEmulationCreationError),
+    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+    X11(#[from] X11EmulationCreationError),
+    #[cfg(target_os = "macos")]
+    MacOs(#[from] MacOSEmulationCreationError),
+    #[cfg(windows)]
+    Windows(#[from] WindowsEmulationCreationError),
+    NoAvailableBackend,
+}
+
+impl Display for EmulationCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let reason = match self {
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            EmulationCreationError::Wlroots(e) => format!("wlroots backend: {e}"),
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            EmulationCreationError::Libei(e) => format!("libei backend: {e}"),
+            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+            EmulationCreationError::Xdp(e) => format!("desktop portal backend: {e}"),
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+            EmulationCreationError::X11(e) => format!("x11 backend: {e}"),
+            #[cfg(target_os = "macos")]
+            EmulationCreationError::MacOs(e) => format!("macos backend: {e}"),
+            #[cfg(windows)]
+            EmulationCreationError::Windows(e) => format!("windows backend: {e}"),
+            EmulationCreationError::NoAvailableBackend => "no backend available".to_string(),
+        };
+        write!(f, "could not create input emulation backend: {reason}")
+    }
+}
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub enum WlrootsEmulationCreationError {
+    Connect(#[from] ConnectError),
+    Global(#[from] GlobalError),
+    Wayland(#[from] WaylandError),
+    Bind(#[from] WaylandBindError),
+    Dispatch(#[from] DispatchError),
+    Io(#[from] std::io::Error),
+}
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub struct WaylandBindError {
+    inner: BindError,
+    protocol: &'static str,
+}
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+impl WaylandBindError {
+    pub(crate) fn new(inner: BindError, protocol: &'static str) -> Self {
+        Self { inner, protocol }
+    }
+}
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+impl Display for WaylandBindError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{} protocol not supported: {}",
+            self.protocol, self.inner
+        )
+    }
+}
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+impl Display for WlrootsEmulationCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            WlrootsEmulationCreationError::Bind(e) => write!(f, "{e}"),
+            WlrootsEmulationCreationError::Connect(e) => {
+                write!(f, "could not connect to wayland compositor: {e}")
+            }
+            WlrootsEmulationCreationError::Global(e) => write!(f, "wayland error: {e}"),
+            WlrootsEmulationCreationError::Wayland(e) => write!(f, "wayland error: {e}"),
+            WlrootsEmulationCreationError::Dispatch(e) => {
+                write!(f, "error dispatching wayland events: {e}")
+            }
+            WlrootsEmulationCreationError::Io(e) => write!(f, "io error: {e}"),
+        }
+    }
+}
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub enum LibeiEmulationCreationError {
+    Ashpd(#[from] ashpd::Error),
+    Io(#[from] std::io::Error),
+}
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+impl Display for LibeiEmulationCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            LibeiEmulationCreationError::Ashpd(e) => write!(f, "xdg-desktop-portal: {e}"),
+            LibeiEmulationCreationError::Io(e) => write!(f, "io error: {e}"),
+        }
+    }
+}
+
+#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub enum XdpEmulationCreationError {
+    Ashpd(#[from] ashpd::Error),
+}
+
+#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+impl Display for XdpEmulationCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            XdpEmulationCreationError::Ashpd(e) => write!(f, "portal error: {e}"),
+        }
+    }
+}
+
+#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+#[derive(Debug, Error)]
+pub enum X11EmulationCreationError {
+    OpenDisplay,
+}
+
+#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+impl Display for X11EmulationCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            X11EmulationCreationError::OpenDisplay => write!(f, "could not open display!"),
+        }
+    }
+}
+
+#[cfg(target_os = "macos")]
+#[derive(Debug, Error)]
+pub enum MacOSEmulationCreationError {
+    EventSourceCreation,
+}
+
+#[cfg(target_os = "macos")]
+impl Display for MacOSEmulationCreationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            MacOSEmulationCreationError::EventSourceCreation => {
+                write!(f, "could not create event source")
+            }
+        }
+    }
+}
+
+#[cfg(windows)]
+#[derive(Debug, Error)]
+pub enum WindowsEmulationCreationError {}

input-emulation/src/lib.rs

@@ -0,0 +1,139 @@
+use async_trait::async_trait;
+use std::{fmt::Display, future};
+
+use input_event::Event;
+
+use anyhow::Result;
+
+use self::error::EmulationCreationError;
+
+#[cfg(windows)]
+pub mod windows;
+
+#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+pub mod x11;
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+pub mod wlroots;
+
+#[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+pub mod xdg_desktop_portal;
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+pub mod libei;
+
+#[cfg(target_os = "macos")]
+pub mod macos;
+
+/// fallback input emulation (logs events)
+pub mod dummy;
+pub mod error;
+
+pub type EmulationHandle = u64;
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum Backend {
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    Wlroots,
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    Libei,
+    #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+    Xdp,
+    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+    X11,
+    #[cfg(windows)]
+    Windows,
+    #[cfg(target_os = "macos")]
+    MacOs,
+    Dummy,
+}
+
+impl Display for Backend {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            Backend::Wlroots => write!(f, "wlroots"),
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            Backend::Libei => write!(f, "libei"),
+            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+            Backend::Xdp => write!(f, "xdg-desktop-portal"),
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+            Backend::X11 => write!(f, "X11"),
+            #[cfg(windows)]
+            Backend::Windows => write!(f, "windows"),
+            #[cfg(target_os = "macos")]
+            Backend::MacOs => write!(f, "macos"),
+            Backend::Dummy => write!(f, "dummy"),
+        }
+    }
+}
+
+#[async_trait]
+pub trait InputEmulation: Send {
+    async fn consume(&mut self, event: Event, handle: EmulationHandle);
+    async fn create(&mut self, handle: EmulationHandle);
+    async fn destroy(&mut self, handle: EmulationHandle);
+    /// this function is waited on continuously and can be used to handle events
+    async fn dispatch(&mut self) -> Result<()> {
+        let _: () = future::pending().await;
+        Ok(())
+    }
+}
+
+pub async fn create_backend(
+    backend: Backend,
+) -> Result<Box<dyn InputEmulation>, EmulationCreationError> {
+    match backend {
+        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+        Backend::Wlroots => Ok(Box::new(wlroots::WlrootsEmulation::new()?)),
+        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+        Backend::Libei => Ok(Box::new(libei::LibeiEmulation::new().await?)),
+        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+        Backend::X11 => Ok(Box::new(x11::X11Emulation::new()?)),
+        #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+        Backend::Xdp => Ok(Box::new(
+            xdg_desktop_portal::DesktopPortalEmulation::new().await?,
+        )),
+        #[cfg(windows)]
+        Backend::Windows => Ok(Box::new(windows::WindowsEmulation::new()?)),
+        #[cfg(target_os = "macos")]
+        Backend::MacOs => Ok(Box::new(macos::MacOSEmulation::new()?)),
+        Backend::Dummy => Ok(Box::new(dummy::DummyEmulation::new())),
+    }
+}
+
+pub async fn create(
+    backend: Option<Backend>,
+) -> Result<Box<dyn InputEmulation>, EmulationCreationError> {
+    if let Some(backend) = backend {
+        let b = create_backend(backend).await;
+        if b.is_ok() {
+            log::info!("using emulation backend: {backend}");
+        }
+        return b;
+    }
+
+    for backend in [
+        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+        Backend::Wlroots,
+        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+        Backend::Libei,
+        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+        Backend::X11,
+        #[cfg(windows)]
+        Backend::Windows,
+        #[cfg(target_os = "macos")]
+        Backend::MacOs,
+        Backend::Dummy,
+    ] {
+        match create_backend(backend).await {
+            Ok(b) => {
+                log::info!("using emulation backend: {backend}");
+                return Ok(b);
+            }
+            Err(e) => log::warn!("{e}"),
+        }
+    }
+
+    Err(EmulationCreationError::NoAvailableBackend)
+}

input-emulation/src/libei.rs

@@ -0,0 +1,397 @@
+use anyhow::{anyhow, Result};
+use std::{
+    collections::HashMap,
+    io,
+    os::{fd::OwnedFd, unix::net::UnixStream},
+    time::{SystemTime, UNIX_EPOCH},
+};
+
+use ashpd::{
+    desktop::{
+        remote_desktop::{DeviceType, RemoteDesktop},
+        ResponseError,
+    },
+    WindowIdentifier,
+};
+use async_trait::async_trait;
+use futures::StreamExt;
+
+use reis::{
+    ei::{self, button::ButtonState, handshake::ContextType, keyboard::KeyState},
+    tokio::EiEventStream,
+    PendingRequestResult,
+};
+
+use input_event::{Event, KeyboardEvent, PointerEvent};
+
+use super::{error::LibeiEmulationCreationError, EmulationHandle, InputEmulation};
+
+pub struct LibeiEmulation {
+    handshake: bool,
+    context: ei::Context,
+    events: EiEventStream,
+    pointer: Option<(ei::Device, ei::Pointer)>,
+    has_pointer: bool,
+    scroll: Option<(ei::Device, ei::Scroll)>,
+    has_scroll: bool,
+    button: Option<(ei::Device, ei::Button)>,
+    has_button: bool,
+    keyboard: Option<(ei::Device, ei::Keyboard)>,
+    has_keyboard: bool,
+    capabilities: HashMap<String, u64>,
+    capability_mask: u64,
+    sequence: u32,
+    serial: u32,
+}
+
+async fn get_ei_fd() -> Result<OwnedFd, ashpd::Error> {
+    let proxy = RemoteDesktop::new().await?;
+
+    // retry when user presses the cancel button
+    let (session, _) = loop {
+        log::debug!("creating session ...");
+        let session = proxy.create_session().await?;
+
+        log::debug!("selecting devices ...");
+        proxy
+            .select_devices(&session, DeviceType::Keyboard | DeviceType::Pointer)
+            .await?;
+
+        log::info!("requesting permission for input emulation");
+        match proxy
+            .start(&session, &WindowIdentifier::default())
+            .await?
+            .response()
+        {
+            Ok(d) => break (session, d),
+            Err(ashpd::Error::Response(ResponseError::Cancelled)) => {
+                log::warn!("request cancelled!");
+                continue;
+            }
+            e => e?,
+        };
+    };
+
+    proxy.connect_to_eis(&session).await
+}
+
+impl LibeiEmulation {
+    pub async fn new() -> Result<Self, LibeiEmulationCreationError> {
+        // fd is owned by the message, so we need to dup it
+        let eifd = get_ei_fd().await?;
+        let stream = UnixStream::from(eifd);
+        // let stream = UnixStream::connect("/run/user/1000/eis-0")?;
+        stream.set_nonblocking(true)?;
+        let context = ei::Context::new(stream)?;
+        context.flush().map_err(|e| io::Error::new(e.kind(), e))?;
+        let events = EiEventStream::new(context.clone())?;
+        Ok(Self {
+            handshake: false,
+            context,
+            events,
+            pointer: None,
+            button: None,
+            scroll: None,
+            keyboard: None,
+            has_pointer: false,
+            has_button: false,
+            has_scroll: false,
+            has_keyboard: false,
+            capabilities: HashMap::new(),
+            capability_mask: 0,
+            sequence: 0,
+            serial: 0,
+        })
+    }
+}
+
+#[async_trait]
+impl InputEmulation for LibeiEmulation {
+    async fn consume(&mut self, event: Event, _client_handle: EmulationHandle) {
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_micros() as u64;
+        match event {
+            Event::Pointer(p) => match p {
+                PointerEvent::Motion {
+                    time: _,
+                    relative_x,
+                    relative_y,
+                } => {
+                    if !self.has_pointer {
+                        return;
+                    }
+                    if let Some((d, p)) = self.pointer.as_mut() {
+                        p.motion_relative(relative_x as f32, relative_y as f32);
+                        d.frame(self.serial, now);
+                    }
+                }
+                PointerEvent::Button {
+                    time: _,
+                    button,
+                    state,
+                } => {
+                    if !self.has_button {
+                        return;
+                    }
+                    if let Some((d, b)) = self.button.as_mut() {
+                        b.button(
+                            button,
+                            match state {
+                                0 => ButtonState::Released,
+                                _ => ButtonState::Press,
+                            },
+                        );
+                        d.frame(self.serial, now);
+                    }
+                }
+                PointerEvent::Axis {
+                    time: _,
+                    axis,
+                    value,
+                } => {
+                    if !self.has_scroll {
+                        return;
+                    }
+                    if let Some((d, s)) = self.scroll.as_mut() {
+                        match axis {
+                            0 => s.scroll(0., value as f32),
+                            _ => s.scroll(value as f32, 0.),
+                        }
+                        d.frame(self.serial, now);
+                    }
+                }
+                PointerEvent::AxisDiscrete120 { axis, value } => {
+                    if !self.has_scroll {
+                        return;
+                    }
+                    if let Some((d, s)) = self.scroll.as_mut() {
+                        match axis {
+                            0 => s.scroll_discrete(0, value),
+                            _ => s.scroll_discrete(value, 0),
+                        }
+                        d.frame(self.serial, now);
+                    }
+                }
+                PointerEvent::Frame {} => {}
+            },
+            Event::Keyboard(k) => match k {
+                KeyboardEvent::Key {
+                    time: _,
+                    key,
+                    state,
+                } => {
+                    if !self.has_keyboard {
+                        return;
+                    }
+                    if let Some((d, k)) = &mut self.keyboard {
+                        k.key(
+                            key,
+                            match state {
+                                0 => KeyState::Released,
+                                _ => KeyState::Press,
+                            },
+                        );
+                        d.frame(self.serial, now);
+                    }
+                }
+                KeyboardEvent::Modifiers { .. } => {}
+            },
+            _ => {}
+        }
+        self.context.flush().unwrap();
+    }
+
+    async fn dispatch(&mut self) -> Result<()> {
+        let event = match self.events.next().await {
+            Some(e) => e?,
+            None => return Err(anyhow!("libei connection lost")),
+        };
+        let event = match event {
+            PendingRequestResult::Request(result) => result,
+            PendingRequestResult::ParseError(e) => {
+                return Err(anyhow!("libei protocol violation: {e}"))
+            }
+            PendingRequestResult::InvalidObject(e) => return Err(anyhow!("invalid object {e}")),
+        };
+        match event {
+            ei::Event::Handshake(handshake, request) => match request {
+                ei::handshake::Event::HandshakeVersion { version } => {
+                    if self.handshake {
+                        return Ok(());
+                    }
+                    log::info!("libei version {}", version);
+                    // sender means we are sending events _to_ the eis server
+                    handshake.handshake_version(version); // FIXME
+                    handshake.context_type(ContextType::Sender);
+                    handshake.name("ei-demo-client");
+                    handshake.interface_version("ei_connection", 1);
+                    handshake.interface_version("ei_callback", 1);
+                    handshake.interface_version("ei_pingpong", 1);
+                    handshake.interface_version("ei_seat", 1);
+                    handshake.interface_version("ei_device", 2);
+                    handshake.interface_version("ei_pointer", 1);
+                    handshake.interface_version("ei_pointer_absolute", 1);
+                    handshake.interface_version("ei_scroll", 1);
+                    handshake.interface_version("ei_button", 1);
+                    handshake.interface_version("ei_keyboard", 1);
+                    handshake.interface_version("ei_touchscreen", 1);
+                    handshake.finish();
+                    self.handshake = true;
+                }
+                ei::handshake::Event::InterfaceVersion { name, version } => {
+                    log::debug!("handshake: Interface {name} @ {version}");
+                }
+                ei::handshake::Event::Connection { serial, connection } => {
+                    connection.sync(1);
+                    self.serial = serial;
+                }
+                _ => unreachable!(),
+            },
+            ei::Event::Connection(_connection, request) => match request {
+                ei::connection::Event::Seat { seat } => {
+                    log::debug!("connected to seat: {seat:?}");
+                }
+                ei::connection::Event::Ping { ping } => {
+                    ping.done(0);
+                }
+                ei::connection::Event::Disconnected {
+                    last_serial: _,
+                    reason,
+                    explanation,
+                } => {
+                    log::debug!("ei - disconnected: reason: {reason:?}: {explanation}")
+                }
+                ei::connection::Event::InvalidObject {
+                    last_serial,
+                    invalid_id,
+                } => {
+                    return Err(anyhow!(
+                        "invalid object: id: {invalid_id}, serial: {last_serial}"
+                    ));
+                }
+                _ => unreachable!(),
+            },
+            ei::Event::Device(device, request) => match request {
+                ei::device::Event::Destroyed { serial } => {
+                    log::debug!("device destroyed: {device:?} - serial: {serial}")
+                }
+                ei::device::Event::Name { name } => {
+                    log::debug!("device name: {name}")
+                }
+                ei::device::Event::DeviceType { device_type } => {
+                    log::debug!("device type: {device_type:?}")
+                }
+                ei::device::Event::Dimensions { width, height } => {
+                    log::debug!("device dimensions: {width}x{height}")
+                }
+                ei::device::Event::Region {
+                    offset_x,
+                    offset_y,
+                    width,
+                    hight,
+                    scale,
+                } => log::debug!(
+                    "device region: {width}x{hight} @ ({offset_x},{offset_y}), scale: {scale}"
+                ),
+                ei::device::Event::Interface { object } => {
+                    log::debug!("device interface: {object:?}");
+                    if object.interface().eq("ei_pointer") {
+                        log::debug!("GOT POINTER DEVICE");
+                        self.pointer.replace((device, object.downcast().unwrap()));
+                    } else if object.interface().eq("ei_button") {
+                        log::debug!("GOT BUTTON DEVICE");
+                        self.button.replace((device, object.downcast().unwrap()));
+                    } else if object.interface().eq("ei_scroll") {
+                        log::debug!("GOT SCROLL DEVICE");
+                        self.scroll.replace((device, object.downcast().unwrap()));
+                    } else if object.interface().eq("ei_keyboard") {
+                        log::debug!("GOT KEYBOARD DEVICE");
+                        self.keyboard.replace((device, object.downcast().unwrap()));
+                    }
+                }
+                ei::device::Event::Done => {
+                    log::debug!("device: done {device:?}");
+                }
+                ei::device::Event::Resumed { serial } => {
+                    self.serial = serial;
+                    device.start_emulating(serial, self.sequence);
+                    self.sequence += 1;
+                    log::debug!("resumed: {device:?}");
+                    if let Some((d, _)) = &mut self.pointer {
+                        if d == &device {
+                            log::debug!("pointer resumed {serial}");
+                            self.has_pointer = true;
+                        }
+                    }
+                    if let Some((d, _)) = &mut self.button {
+                        if d == &device {
+                            log::debug!("button resumed {serial}");
+                            self.has_button = true;
+                        }
+                    }
+                    if let Some((d, _)) = &mut self.scroll {
+                        if d == &device {
+                            log::debug!("scroll resumed {serial}");
+                            self.has_scroll = true;
+                        }
+                    }
+                    if let Some((d, _)) = &mut self.keyboard {
+                        if d == &device {
+                            log::debug!("keyboard resumed {serial}");
+                            self.has_keyboard = true;
+                        }
+                    }
+                }
+                ei::device::Event::Paused { serial } => {
+                    self.has_pointer = false;
+                    self.has_button = false;
+                    self.serial = serial;
+                }
+                ei::device::Event::StartEmulating { serial, sequence } => {
+                    log::debug!("start emulating {serial}, {sequence}")
+                }
+                ei::device::Event::StopEmulating { serial } => {
+                    log::debug!("stop emulating {serial}")
+                }
+                ei::device::Event::Frame { serial, timestamp } => {
+                    log::debug!("frame: {serial}, {timestamp}");
+                }
+                ei::device::Event::RegionMappingId { mapping_id } => {
+                    log::debug!("RegionMappingId {mapping_id}")
+                }
+                e => log::debug!("invalid event: {e:?}"),
+            },
+            ei::Event::Seat(seat, request) => match request {
+                ei::seat::Event::Destroyed { serial } => {
+                    self.serial = serial;
+                    log::debug!("seat destroyed: {seat:?}");
+                }
+                ei::seat::Event::Name { name } => {
+                    log::debug!("seat name: {name}");
+                }
+                ei::seat::Event::Capability { mask, interface } => {
+                    log::debug!("seat capabilities: {mask}, interface: {interface:?}");
+                    self.capabilities.insert(interface, mask);
+                    self.capability_mask |= mask;
+                }
+                ei::seat::Event::Done => {
+                    log::debug!("seat done");
+                    log::debug!("binding capabilities: {}", self.capability_mask);
+                    seat.bind(self.capability_mask);
+                }
+                ei::seat::Event::Device { device } => {
+                    log::debug!("seat: new device - {device:?}");
+                }
+                _ => todo!(),
+            },
+            e => log::debug!("unhandled event: {e:?}"),
+        }
+        self.context.flush()?;
+        Ok(())
+    }
+
+    async fn create(&mut self, _: EmulationHandle) {}
+    async fn destroy(&mut self, _: EmulationHandle) {}
+}

input-emulation/src/macos.rs

@@ -0,0 +1,302 @@
+use super::{EmulationHandle, InputEmulation};
+use async_trait::async_trait;
+use core_graphics::display::{CGDisplayBounds, CGMainDisplayID, CGPoint};
+use core_graphics::event::{
+    CGEvent, CGEventTapLocation, CGEventType, CGKeyCode, CGMouseButton, EventField, ScrollEventUnit,
+};
+use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
+use input_event::{Event, KeyboardEvent, PointerEvent};
+use keycode::{KeyMap, KeyMapping};
+use std::ops::{Index, IndexMut};
+use std::time::Duration;
+use tokio::task::AbortHandle;
+
+use super::error::MacOSEmulationCreationError;
+
+const DEFAULT_REPEAT_DELAY: Duration = Duration::from_millis(500);
+const DEFAULT_REPEAT_INTERVAL: Duration = Duration::from_millis(32);
+
+pub struct MacOSEmulation {
+    pub event_source: CGEventSource,
+    repeat_task: Option<AbortHandle>,
+    button_state: ButtonState,
+}
+
+struct ButtonState {
+    left: bool,
+    right: bool,
+    center: bool,
+}
+
+impl Index<CGMouseButton> for ButtonState {
+    type Output = bool;
+
+    fn index(&self, index: CGMouseButton) -> &Self::Output {
+        match index {
+            CGMouseButton::Left => &self.left,
+            CGMouseButton::Right => &self.right,
+            CGMouseButton::Center => &self.center,
+        }
+    }
+}
+
+impl IndexMut<CGMouseButton> for ButtonState {
+    fn index_mut(&mut self, index: CGMouseButton) -> &mut Self::Output {
+        match index {
+            CGMouseButton::Left => &mut self.left,
+            CGMouseButton::Right => &mut self.right,
+            CGMouseButton::Center => &mut self.center,
+        }
+    }
+}
+
+unsafe impl Send for MacOSEmulation {}
+
+impl MacOSEmulation {
+    pub fn new() -> Result<Self, MacOSEmulationCreationError> {
+        let event_source = CGEventSource::new(CGEventSourceStateID::CombinedSessionState)
+            .map_err(|_| MacOSEmulationCreationError::EventSourceCreation)?;
+        let button_state = ButtonState {
+            left: false,
+            right: false,
+            center: false,
+        };
+        Ok(Self {
+            event_source,
+            button_state,
+            repeat_task: None,
+        })
+    }
+
+    fn get_mouse_location(&self) -> Option<CGPoint> {
+        let event: CGEvent = CGEvent::new(self.event_source.clone()).ok()?;
+        Some(event.location())
+    }
+
+    async fn spawn_repeat_task(&mut self, key: u16) {
+        // there can only be one repeating key and it's
+        // always the last to be pressed
+        self.kill_repeat_task();
+        let event_source = self.event_source.clone();
+        let repeat_task = tokio::task::spawn_local(async move {
+            tokio::time::sleep(DEFAULT_REPEAT_DELAY).await;
+            loop {
+                key_event(event_source.clone(), key, 1);
+                tokio::time::sleep(DEFAULT_REPEAT_INTERVAL).await;
+            }
+        });
+        self.repeat_task = Some(repeat_task.abort_handle());
+    }
+    fn kill_repeat_task(&mut self) {
+        if let Some(task) = self.repeat_task.take() {
+            task.abort();
+        }
+    }
+}
+
+fn key_event(event_source: CGEventSource, key: u16, state: u8) {
+    let event = match CGEvent::new_keyboard_event(event_source, key, state != 0) {
+        Ok(e) => e,
+        Err(_) => {
+            log::warn!("unable to create key event");
+            return;
+        }
+    };
+    event.post(CGEventTapLocation::HID);
+}
+
+#[async_trait]
+impl InputEmulation for MacOSEmulation {
+    async fn consume(&mut self, event: Event, _handle: EmulationHandle) {
+        match event {
+            Event::Pointer(pointer_event) => match pointer_event {
+                PointerEvent::Motion {
+                    time: _,
+                    relative_x,
+                    relative_y,
+                } => {
+                    // FIXME secondary displays?
+                    let (min_x, min_y, max_x, max_y) = unsafe {
+                        let display = CGMainDisplayID();
+                        let bounds = CGDisplayBounds(display);
+                        let min_x = bounds.origin.x;
+                        let max_x = bounds.origin.x + bounds.size.width;
+                        let min_y = bounds.origin.y;
+                        let max_y = bounds.origin.y + bounds.size.height;
+                        (min_x as f64, min_y as f64, max_x as f64, max_y as f64)
+                    };
+                    let mut mouse_location = match self.get_mouse_location() {
+                        Some(l) => l,
+                        None => {
+                            log::warn!("could not get mouse location!");
+                            return;
+                        }
+                    };
+
+                    mouse_location.x = (mouse_location.x + relative_x).clamp(min_x, max_x - 1.);
+                    mouse_location.y = (mouse_location.y + relative_y).clamp(min_y, max_y - 1.);
+
+                    let mut event_type = CGEventType::MouseMoved;
+                    if self.button_state.left {
+                        event_type = CGEventType::LeftMouseDragged
+                    } else if self.button_state.right {
+                        event_type = CGEventType::RightMouseDragged
+                    } else if self.button_state.center {
+                        event_type = CGEventType::OtherMouseDragged
+                    };
+                    let event = match CGEvent::new_mouse_event(
+                        self.event_source.clone(),
+                        event_type,
+                        mouse_location,
+                        CGMouseButton::Left,
+                    ) {
+                        Ok(e) => e,
+                        Err(_) => {
+                            log::warn!("mouse event creation failed!");
+                            return;
+                        }
+                    };
+                    event.set_integer_value_field(
+                        EventField::MOUSE_EVENT_DELTA_X,
+                        relative_x as i64,
+                    );
+                    event.set_integer_value_field(
+                        EventField::MOUSE_EVENT_DELTA_Y,
+                        relative_y as i64,
+                    );
+                    event.post(CGEventTapLocation::HID);
+                }
+                PointerEvent::Button {
+                    time: _,
+                    button,
+                    state,
+                } => {
+                    let (event_type, mouse_button) = match (button, state) {
+                        (b, 1) if b == input_event::BTN_LEFT => {
+                            (CGEventType::LeftMouseDown, CGMouseButton::Left)
+                        }
+                        (b, 0) if b == input_event::BTN_LEFT => {
+                            (CGEventType::LeftMouseUp, CGMouseButton::Left)
+                        }
+                        (b, 1) if b == input_event::BTN_RIGHT => {
+                            (CGEventType::RightMouseDown, CGMouseButton::Right)
+                        }
+                        (b, 0) if b == input_event::BTN_RIGHT => {
+                            (CGEventType::RightMouseUp, CGMouseButton::Right)
+                        }
+                        (b, 1) if b == input_event::BTN_MIDDLE => {
+                            (CGEventType::OtherMouseDown, CGMouseButton::Center)
+                        }
+                        (b, 0) if b == input_event::BTN_MIDDLE => {
+                            (CGEventType::OtherMouseUp, CGMouseButton::Center)
+                        }
+                        _ => {
+                            log::warn!("invalid button event: {button},{state}");
+                            return;
+                        }
+                    };
+                    // store button state
+                    self.button_state[mouse_button] = state == 1;
+
+                    let location = self.get_mouse_location().unwrap();
+                    let event = match CGEvent::new_mouse_event(
+                        self.event_source.clone(),
+                        event_type,
+                        location,
+                        mouse_button,
+                    ) {
+                        Ok(e) => e,
+                        Err(()) => {
+                            log::warn!("mouse event creation failed!");
+                            return;
+                        }
+                    };
+                    event.post(CGEventTapLocation::HID);
+                }
+                PointerEvent::Axis {
+                    time: _,
+                    axis,
+                    value,
+                } => {
+                    let value = value as i32;
+                    let (count, wheel1, wheel2, wheel3) = match axis {
+                        0 => (1, value, 0, 0), // 0 = vertical => 1 scroll wheel device (y axis)
+                        1 => (2, 0, value, 0), // 1 = horizontal => 2 scroll wheel devices (y, x) -> (0, x)
+                        _ => {
+                            log::warn!("invalid scroll event: {axis}, {value}");
+                            return;
+                        }
+                    };
+                    let event = match CGEvent::new_scroll_event(
+                        self.event_source.clone(),
+                        ScrollEventUnit::PIXEL,
+                        count,
+                        wheel1,
+                        wheel2,
+                        wheel3,
+                    ) {
+                        Ok(e) => e,
+                        Err(()) => {
+                            log::warn!("scroll event creation failed!");
+                            return;
+                        }
+                    };
+                    event.post(CGEventTapLocation::HID);
+                }
+                PointerEvent::AxisDiscrete120 { axis, value } => {
+                    let (count, wheel1, wheel2, wheel3) = match axis {
+                        0 => (1, value, 0, 0), // 0 = vertical => 1 scroll wheel device (y axis)
+                        1 => (2, 0, value, 0), // 1 = horizontal => 2 scroll wheel devices (y, x) -> (0, x)
+                        _ => {
+                            log::warn!("invalid scroll event: {axis}, {value}");
+                            return;
+                        }
+                    };
+                    let event = match CGEvent::new_scroll_event(
+                        self.event_source.clone(),
+                        ScrollEventUnit::PIXEL,
+                        count,
+                        wheel1,
+                        wheel2,
+                        wheel3,
+                    ) {
+                        Ok(e) => e,
+                        Err(()) => {
+                            log::warn!("scroll event creation failed!");
+                            return;
+                        }
+                    };
+                    event.post(CGEventTapLocation::HID);
+                }
+                PointerEvent::Frame { .. } => {}
+            },
+            Event::Keyboard(keyboard_event) => match keyboard_event {
+                KeyboardEvent::Key {
+                    time: _,
+                    key,
+                    state,
+                } => {
+                    let code = match KeyMap::from_key_mapping(KeyMapping::Evdev(key as u16)) {
+                        Ok(k) => k.mac as CGKeyCode,
+                        Err(_) => {
+                            log::warn!("unable to map key event");
+                            return;
+                        }
+                    };
+                    match state {
+                        // pressed
+                        1 => self.spawn_repeat_task(code).await,
+                        _ => self.kill_repeat_task(),
+                    }
+                    key_event(self.event_source.clone(), code, state)
+                }
+                KeyboardEvent::Modifiers { .. } => {}
+            },
+            _ => (),
+        }
+    }
+
+    async fn create(&mut self, _handle: EmulationHandle) {}
+
+    async fn destroy(&mut self, _handle: EmulationHandle) {}
+}

input-emulation/src/windows.rs

@@ -0,0 +1,239 @@
+use super::error::WindowsEmulationCreationError;
+use input_event::{
+    scancode, Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE,
+    BTN_RIGHT,
+};
+
+use async_trait::async_trait;
+use std::ops::BitOrAssign;
+use std::time::Duration;
+use tokio::task::AbortHandle;
+use windows::Win32::UI::Input::KeyboardAndMouse::{
+    SendInput, INPUT_0, KEYEVENTF_EXTENDEDKEY, MOUSEEVENTF_XDOWN, MOUSEEVENTF_XUP,
+};
+use windows::Win32::UI::Input::KeyboardAndMouse::{
+    INPUT, INPUT_KEYBOARD, INPUT_MOUSE, KEYBDINPUT, KEYEVENTF_KEYUP, KEYEVENTF_SCANCODE,
+    MOUSEEVENTF_HWHEEL, MOUSEEVENTF_LEFTDOWN, MOUSEEVENTF_LEFTUP, MOUSEEVENTF_MIDDLEDOWN,
+    MOUSEEVENTF_MIDDLEUP, MOUSEEVENTF_MOVE, MOUSEEVENTF_RIGHTDOWN, MOUSEEVENTF_RIGHTUP,
+    MOUSEEVENTF_WHEEL, MOUSEINPUT,
+};
+use windows::Win32::UI::WindowsAndMessaging::{XBUTTON1, XBUTTON2};
+
+use super::{EmulationHandle, InputEmulation};
+
+const DEFAULT_REPEAT_DELAY: Duration = Duration::from_millis(500);
+const DEFAULT_REPEAT_INTERVAL: Duration = Duration::from_millis(32);
+
+pub struct WindowsEmulation {
+    repeat_task: Option<AbortHandle>,
+}
+
+impl WindowsEmulation {
+    pub fn new() -> Result<Self, WindowsEmulationCreationError> {
+        Ok(Self { repeat_task: None })
+    }
+}
+
+#[async_trait]
+impl InputEmulation for WindowsEmulation {
+    async fn consume(&mut self, event: Event, _: EmulationHandle) {
+        match event {
+            Event::Pointer(pointer_event) => match pointer_event {
+                PointerEvent::Motion {
+                    time: _,
+                    relative_x,
+                    relative_y,
+                } => {
+                    rel_mouse(relative_x as i32, relative_y as i32);
+                }
+                PointerEvent::Button {
+                    time: _,
+                    button,
+                    state,
+                } => mouse_button(button, state),
+                PointerEvent::Axis {
+                    time: _,
+                    axis,
+                    value,
+                } => scroll(axis, value as i32),
+                PointerEvent::AxisDiscrete120 { axis, value } => scroll(axis, value),
+                PointerEvent::Frame {} => {}
+            },
+            Event::Keyboard(keyboard_event) => match keyboard_event {
+                KeyboardEvent::Key {
+                    time: _,
+                    key,
+                    state,
+                } => {
+                    match state {
+                        // pressed
+                        0 => self.kill_repeat_task(),
+                        1 => self.spawn_repeat_task(key).await,
+                        _ => {}
+                    }
+                    key_event(key, state)
+                }
+                KeyboardEvent::Modifiers { .. } => {}
+            },
+            _ => {}
+        }
+    }
+
+    async fn create(&mut self, _handle: EmulationHandle) {}
+
+    async fn destroy(&mut self, _handle: EmulationHandle) {}
+}
+
+impl WindowsEmulation {
+    async fn spawn_repeat_task(&mut self, key: u32) {
+        // there can only be one repeating key and it's
+        // always the last to be pressed
+        self.kill_repeat_task();
+        let repeat_task = tokio::task::spawn_local(async move {
+            tokio::time::sleep(DEFAULT_REPEAT_DELAY).await;
+            loop {
+                key_event(key, 1);
+                tokio::time::sleep(DEFAULT_REPEAT_INTERVAL).await;
+            }
+        });
+        self.repeat_task = Some(repeat_task.abort_handle());
+    }
+    fn kill_repeat_task(&mut self) {
+        if let Some(task) = self.repeat_task.take() {
+            task.abort();
+        }
+    }
+}
+
+fn send_input_safe(input: INPUT) {
+    unsafe {
+        loop {
+            /* retval = number of successfully submitted events */
+            if SendInput(&[input], std::mem::size_of::<INPUT>() as i32) > 0 {
+                break;
+            }
+        }
+    }
+}
+
+fn send_mouse_input(mi: MOUSEINPUT) {
+    send_input_safe(INPUT {
+        r#type: INPUT_MOUSE,
+        Anonymous: INPUT_0 { mi },
+    });
+}
+
+fn send_keyboard_input(ki: KEYBDINPUT) {
+    send_input_safe(INPUT {
+        r#type: INPUT_KEYBOARD,
+        Anonymous: INPUT_0 { ki },
+    });
+}
+fn rel_mouse(dx: i32, dy: i32) {
+    let mi = MOUSEINPUT {
+        dx,
+        dy,
+        mouseData: 0,
+        dwFlags: MOUSEEVENTF_MOVE,
+        time: 0,
+        dwExtraInfo: 0,
+    };
+    send_mouse_input(mi);
+}
+
+fn mouse_button(button: u32, state: u32) {
+    let dw_flags = match state {
+        0 => match button {
+            BTN_LEFT => MOUSEEVENTF_LEFTUP,
+            BTN_RIGHT => MOUSEEVENTF_RIGHTUP,
+            BTN_MIDDLE => MOUSEEVENTF_MIDDLEUP,
+            BTN_BACK => MOUSEEVENTF_XUP,
+            BTN_FORWARD => MOUSEEVENTF_XUP,
+            _ => return,
+        },
+        1 => match button {
+            BTN_LEFT => MOUSEEVENTF_LEFTDOWN,
+            BTN_RIGHT => MOUSEEVENTF_RIGHTDOWN,
+            BTN_MIDDLE => MOUSEEVENTF_MIDDLEDOWN,
+            BTN_BACK => MOUSEEVENTF_XDOWN,
+            BTN_FORWARD => MOUSEEVENTF_XDOWN,
+            _ => return,
+        },
+        _ => return,
+    };
+    let mouse_data = match button {
+        BTN_BACK => XBUTTON1 as u32,
+        BTN_FORWARD => XBUTTON2 as u32,
+        _ => 0,
+    };
+    let mi = MOUSEINPUT {
+        dx: 0,
+        dy: 0, // no movement
+        mouseData: mouse_data,
+        dwFlags: dw_flags,
+        time: 0,
+        dwExtraInfo: 0,
+    };
+    send_mouse_input(mi);
+}
+
+fn scroll(axis: u8, value: i32) {
+    let event_type = match axis {
+        0 => MOUSEEVENTF_WHEEL,
+        1 => MOUSEEVENTF_HWHEEL,
+        _ => return,
+    };
+    let mi = MOUSEINPUT {
+        dx: 0,
+        dy: 0,
+        mouseData: -value as u32,
+        dwFlags: event_type,
+        time: 0,
+        dwExtraInfo: 0,
+    };
+    send_mouse_input(mi);
+}
+
+fn key_event(key: u32, state: u8) {
+    let scancode = match linux_keycode_to_windows_scancode(key) {
+        Some(code) => code,
+        None => return,
+    };
+    let extended = scancode > 0xff;
+    let scancode = scancode & 0xff;
+    let mut flags = KEYEVENTF_SCANCODE;
+    if extended {
+        flags.bitor_assign(KEYEVENTF_EXTENDEDKEY);
+    }
+    if state == 0 {
+        flags.bitor_assign(KEYEVENTF_KEYUP);
+    }
+    let ki = KEYBDINPUT {
+        wVk: Default::default(),
+        wScan: scancode,
+        dwFlags: flags,
+        time: 0,
+        dwExtraInfo: 0,
+    };
+    send_keyboard_input(ki);
+}
+
+fn linux_keycode_to_windows_scancode(linux_keycode: u32) -> Option<u16> {
+    let linux_scancode = match scancode::Linux::try_from(linux_keycode) {
+        Ok(s) => s,
+        Err(_) => {
+            log::warn!("unknown keycode: {linux_keycode}");
+            return None;
+        }
+    };
+    log::trace!("linux code: {linux_scancode:?}");
+    let windows_scancode = match scancode::Windows::try_from(linux_scancode) {
+        Ok(s) => s,
+        Err(_) => {
+            log::warn!("failed to translate linux code into windows scancode: {linux_scancode:?}");
+            return None;
+        }
+    };
+    log::trace!("windows code: {windows_scancode:?}");
+    Some(windows_scancode as u16)
+}

input-emulation/src/wlroots.rs

@@ -0,0 +1,274 @@
+use super::{error::WlrootsEmulationCreationError, InputEmulation};
+use async_trait::async_trait;
+use std::collections::HashMap;
+use std::io;
+use std::os::fd::{AsFd, OwnedFd};
+use wayland_client::backend::WaylandError;
+use wayland_client::WEnum;
+
+use wayland_client::protocol::wl_keyboard::{self, WlKeyboard};
+use wayland_client::protocol::wl_pointer::{Axis, ButtonState};
+use wayland_client::protocol::wl_seat::WlSeat;
+use wayland_protocols_wlr::virtual_pointer::v1::client::{
+    zwlr_virtual_pointer_manager_v1::ZwlrVirtualPointerManagerV1 as VpManager,
+    zwlr_virtual_pointer_v1::ZwlrVirtualPointerV1 as Vp,
+};
+
+use wayland_protocols_misc::zwp_virtual_keyboard_v1::client::{
+    zwp_virtual_keyboard_manager_v1::ZwpVirtualKeyboardManagerV1 as VkManager,
+    zwp_virtual_keyboard_v1::ZwpVirtualKeyboardV1 as Vk,
+};
+
+use wayland_client::{
+    delegate_noop,
+    globals::{registry_queue_init, GlobalListContents},
+    protocol::{wl_registry, wl_seat},
+    Connection, Dispatch, EventQueue, QueueHandle,
+};
+
+use input_event::{Event, KeyboardEvent, PointerEvent};
+
+use super::error::WaylandBindError;
+use super::EmulationHandle;
+
+struct State {
+    keymap: Option<(u32, OwnedFd, u32)>,
+    input_for_client: HashMap<EmulationHandle, VirtualInput>,
+    seat: wl_seat::WlSeat,
+    qh: QueueHandle<Self>,
+    vpm: VpManager,
+    vkm: VkManager,
+}
+
+// App State, implements Dispatch event handlers
+pub(crate) struct WlrootsEmulation {
+    last_flush_failed: bool,
+    state: State,
+    queue: EventQueue<State>,
+}
+
+impl WlrootsEmulation {
+    pub fn new() -> Result<Self, WlrootsEmulationCreationError> {
+        let conn = Connection::connect_to_env()?;
+        let (globals, queue) = registry_queue_init::<State>(&conn)?;
+        let qh = queue.handle();
+
+        let seat: wl_seat::WlSeat = globals
+            .bind(&qh, 7..=8, ())
+            .map_err(|e| WaylandBindError::new(e, "wl_seat 7..=8"))?;
+
+        let vpm: VpManager = globals
+            .bind(&qh, 1..=1, ())
+            .map_err(|e| WaylandBindError::new(e, "wlr-virtual-pointer-unstable-v1"))?;
+        let vkm: VkManager = globals
+            .bind(&qh, 1..=1, ())
+            .map_err(|e| WaylandBindError::new(e, "virtual-keyboard-unstable-v1"))?;
+
+        let input_for_client: HashMap<EmulationHandle, VirtualInput> = HashMap::new();
+
+        let mut emulate = WlrootsEmulation {
+            last_flush_failed: false,
+            state: State {
+                keymap: None,
+                input_for_client,
+                seat,
+                vpm,
+                vkm,
+                qh,
+            },
+            queue,
+        };
+        while emulate.state.keymap.is_none() {
+            emulate.queue.blocking_dispatch(&mut emulate.state)?;
+        }
+        // let fd = unsafe { &File::from_raw_fd(emulate.state.keymap.unwrap().1.as_raw_fd()) };
+        // let mmap = unsafe { MmapOptions::new().map_copy(fd).unwrap() };
+        // log::debug!("{:?}", &mmap[..100]);
+        Ok(emulate)
+    }
+}
+
+impl State {
+    fn add_client(&mut self, client: EmulationHandle) {
+        let pointer: Vp = self.vpm.create_virtual_pointer(None, &self.qh, ());
+        let keyboard: Vk = self.vkm.create_virtual_keyboard(&self.seat, &self.qh, ());
+
+        // TODO: use server side keymap
+        if let Some((format, fd, size)) = self.keymap.as_ref() {
+            keyboard.keymap(*format, fd.as_fd(), *size);
+        } else {
+            panic!("no keymap");
+        }
+
+        let vinput = VirtualInput { pointer, keyboard };
+
+        self.input_for_client.insert(client, vinput);
+    }
+
+    fn destroy_client(&mut self, handle: EmulationHandle) {
+        if let Some(input) = self.input_for_client.remove(&handle) {
+            input.pointer.destroy();
+            input.keyboard.destroy();
+        }
+    }
+}
+
+#[async_trait]
+impl InputEmulation for WlrootsEmulation {
+    async fn consume(&mut self, event: Event, handle: EmulationHandle) {
+        if let Some(virtual_input) = self.state.input_for_client.get(&handle) {
+            if self.last_flush_failed {
+                if let Err(WaylandError::Io(e)) = self.queue.flush() {
+                    if e.kind() == io::ErrorKind::WouldBlock {
+                        /*
+                         * outgoing buffer is full - sending more events
+                         * will overwhelm the output buffer and leave the
+                         * wayland connection in a broken state
+                         */
+                        log::warn!("can't keep up, discarding event: ({handle}) - {event:?}");
+                        return;
+                    }
+                }
+            }
+            virtual_input.consume_event(event).unwrap();
+            match self.queue.flush() {
+                Err(WaylandError::Io(e)) if e.kind() == io::ErrorKind::WouldBlock => {
+                    self.last_flush_failed = true;
+                    log::warn!("can't keep up, retrying ...");
+                }
+                Err(WaylandError::Io(e)) => {
+                    log::error!("{e}")
+                }
+                Err(WaylandError::Protocol(e)) => {
+                    panic!("wayland protocol violation: {e}")
+                }
+                Ok(()) => {
+                    self.last_flush_failed = false;
+                }
+            }
+        }
+    }
+
+    async fn create(&mut self, handle: EmulationHandle) {
+        self.state.add_client(handle);
+        if let Err(e) = self.queue.flush() {
+            log::error!("{}", e);
+        }
+    }
+    async fn destroy(&mut self, handle: EmulationHandle) {
+        self.state.destroy_client(handle);
+        if let Err(e) = self.queue.flush() {
+            log::error!("{}", e);
+        }
+    }
+}
+
+struct VirtualInput {
+    pointer: Vp,
+    keyboard: Vk,
+}
+
+impl VirtualInput {
+    fn consume_event(&self, event: Event) -> Result<(), ()> {
+        match event {
+            Event::Pointer(e) => {
+                match e {
+                    PointerEvent::Motion {
+                        time,
+                        relative_x,
+                        relative_y,
+                    } => self.pointer.motion(time, relative_x, relative_y),
+                    PointerEvent::Button {
+                        time,
+                        button,
+                        state,
+                    } => {
+                        let state: ButtonState = state.try_into()?;
+                        self.pointer.button(time, button, state);
+                    }
+                    PointerEvent::Axis { time, axis, value } => {
+                        let axis: Axis = (axis as u32).try_into()?;
+                        self.pointer.axis(time, axis, value);
+                        self.pointer.frame();
+                    }
+                    PointerEvent::AxisDiscrete120 { axis, value } => {
+                        let axis: Axis = (axis as u32).try_into()?;
+                        self.pointer
+                            .axis_discrete(0, axis, value as f64 / 6., value / 120);
+                        self.pointer.frame();
+                    }
+                    PointerEvent::Frame {} => self.pointer.frame(),
+                }
+                self.pointer.frame();
+            }
+            Event::Keyboard(e) => match e {
+                KeyboardEvent::Key { time, key, state } => {
+                    self.keyboard.key(time, key, state as u32);
+                }
+                KeyboardEvent::Modifiers {
+                    mods_depressed,
+                    mods_latched,
+                    mods_locked,
+                    group,
+                } => {
+                    self.keyboard
+                        .modifiers(mods_depressed, mods_latched, mods_locked, group);
+                }
+            },
+            _ => {}
+        }
+        Ok(())
+    }
+}
+
+delegate_noop!(State: Vp);
+delegate_noop!(State: Vk);
+delegate_noop!(State: VpManager);
+delegate_noop!(State: VkManager);
+
+impl Dispatch<wl_registry::WlRegistry, GlobalListContents> for State {
+    fn event(
+        _: &mut State,
+        _: &wl_registry::WlRegistry,
+        _: wl_registry::Event,
+        _: &GlobalListContents,
+        _: &Connection,
+        _: &QueueHandle<State>,
+    ) {
+    }
+}
+
+impl Dispatch<WlKeyboard, ()> for State {
+    fn event(
+        state: &mut Self,
+        _: &WlKeyboard,
+        event: <WlKeyboard as wayland_client::Proxy>::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<Self>,
+    ) {
+        if let wl_keyboard::Event::Keymap { format, fd, size } = event {
+            state.keymap = Some((u32::from(format), fd, size));
+        }
+    }
+}
+
+impl Dispatch<WlSeat, ()> for State {
+    fn event(
+        _: &mut Self,
+        seat: &WlSeat,
+        event: <WlSeat as wayland_client::Proxy>::Event,
+        _: &(),
+        _: &Connection,
+        qhandle: &QueueHandle<Self>,
+    ) {
+        if let wl_seat::Event::Capabilities {
+            capabilities: WEnum::Value(capabilities),
+        } = event
+        {
+            if capabilities.contains(wl_seat::Capability::Keyboard) {
+                seat.get_keyboard(qhandle, ());
+            }
+        }
+    }
+}

input-emulation/src/x11.rs

@@ -0,0 +1,151 @@
+use async_trait::async_trait;
+use std::ptr;
+use x11::{
+    xlib::{self, XCloseDisplay},
+    xtest,
+};
+
+use input_event::{
+    Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT,
+};
+
+use super::{error::X11EmulationCreationError, EmulationHandle, InputEmulation};
+
+pub struct X11Emulation {
+    display: *mut xlib::Display,
+}
+
+unsafe impl Send for X11Emulation {}
+
+impl X11Emulation {
+    pub fn new() -> Result<Self, X11EmulationCreationError> {
+        let display = unsafe {
+            match xlib::XOpenDisplay(ptr::null()) {
+                d if d == ptr::null::<xlib::Display>() as *mut xlib::Display => {
+                    Err(X11EmulationCreationError::OpenDisplay)
+                }
+                display => Ok(display),
+            }
+        }?;
+        Ok(Self { display })
+    }
+
+    fn relative_motion(&self, dx: i32, dy: i32) {
+        unsafe {
+            xtest::XTestFakeRelativeMotionEvent(self.display, dx, dy, 0, 0);
+        }
+    }
+
+    fn emulate_mouse_button(&self, button: u32, state: u32) {
+        unsafe {
+            let x11_button = match button {
+                BTN_RIGHT => 3,
+                BTN_MIDDLE => 2,
+                BTN_BACK => 8,
+                BTN_FORWARD => 9,
+                BTN_LEFT => 1,
+                _ => 1,
+            };
+            xtest::XTestFakeButtonEvent(self.display, x11_button, state as i32, 0);
+        };
+    }
+
+    const SCROLL_UP: u32 = 4;
+    const SCROLL_DOWN: u32 = 5;
+    const SCROLL_LEFT: u32 = 6;
+    const SCROLL_RIGHT: u32 = 7;
+
+    fn emulate_scroll(&self, axis: u8, value: f64) {
+        let direction = match axis {
+            1 => {
+                if value < 0.0 {
+                    Self::SCROLL_LEFT
+                } else {
+                    Self::SCROLL_RIGHT
+                }
+            }
+            _ => {
+                if value < 0.0 {
+                    Self::SCROLL_UP
+                } else {
+                    Self::SCROLL_DOWN
+                }
+            }
+        };
+
+        unsafe {
+            xtest::XTestFakeButtonEvent(self.display, direction, 1, 0);
+            xtest::XTestFakeButtonEvent(self.display, direction, 0, 0);
+        }
+    }
+
+    #[allow(dead_code)]
+    fn emulate_key(&self, key: u32, state: u8) {
+        let key = key + 8; // xorg keycodes are shifted by 8
+        unsafe {
+            xtest::XTestFakeKeyEvent(self.display, key, state as i32, 0);
+        }
+    }
+}
+
+impl Drop for X11Emulation {
+    fn drop(&mut self) {
+        unsafe {
+            XCloseDisplay(self.display);
+        }
+    }
+}
+
+#[async_trait]
+impl InputEmulation for X11Emulation {
+    async fn consume(&mut self, event: Event, _: EmulationHandle) {
+        match event {
+            Event::Pointer(pointer_event) => match pointer_event {
+                PointerEvent::Motion {
+                    time: _,
+                    relative_x,
+                    relative_y,
+                } => {
+                    self.relative_motion(relative_x as i32, relative_y as i32);
+                }
+                PointerEvent::Button {
+                    time: _,
+                    button,
+                    state,
+                } => {
+                    self.emulate_mouse_button(button, state);
+                }
+                PointerEvent::Axis {
+                    time: _,
+                    axis,
+                    value,
+                } => {
+                    self.emulate_scroll(axis, value);
+                }
+                PointerEvent::AxisDiscrete120 { axis, value } => {
+                    self.emulate_scroll(axis, value as f64);
+                }
+                PointerEvent::Frame {} => {}
+            },
+            Event::Keyboard(KeyboardEvent::Key {
+                time: _,
+                key,
+                state,
+            }) => {
+                self.emulate_key(key, state);
+            }
+            _ => {}
+        }
+        unsafe {
+            xlib::XFlush(self.display);
+        }
+    }
+
+    async fn create(&mut self, _: EmulationHandle) {
+        // for our purposes it does not matter what client sent the event
+    }
+
+    async fn destroy(&mut self, _: EmulationHandle) {
+        // for our purposes it does not matter what client sent the event
+    }
+}

input-emulation/src/xdg_desktop_portal.rs

@@ -0,0 +1,196 @@
+use anyhow::Result;
+use ashpd::{
+    desktop::{
+        remote_desktop::{Axis, DeviceType, KeyState, RemoteDesktop},
+        ResponseError, Session,
+    },
+    WindowIdentifier,
+};
+use async_trait::async_trait;
+
+use input_event::{
+    Event::{Keyboard, Pointer},
+    KeyboardEvent, PointerEvent,
+};
+
+use super::{error::XdpEmulationCreationError, EmulationHandle, InputEmulation};
+
+pub struct DesktopPortalEmulation<'a> {
+    proxy: RemoteDesktop<'a>,
+    session: Option<Session<'a>>,
+}
+
+impl<'a> DesktopPortalEmulation<'a> {
+    pub async fn new() -> Result<DesktopPortalEmulation<'a>, XdpEmulationCreationError> {
+        log::debug!("connecting to org.freedesktop.portal.RemoteDesktop portal ...");
+        let proxy = RemoteDesktop::new().await?;
+
+        // retry when user presses the cancel button
+        let (session, _) = loop {
+            log::debug!("creating session ...");
+            let session = proxy.create_session().await?;
+
+            log::debug!("selecting devices ...");
+            proxy
+                .select_devices(&session, DeviceType::Keyboard | DeviceType::Pointer)
+                .await?;
+
+            log::info!("requesting permission for input emulation");
+            match proxy
+                .start(&session, &WindowIdentifier::default())
+                .await?
+                .response()
+            {
+                Ok(d) => break (session, d),
+                Err(ashpd::Error::Response(ResponseError::Cancelled)) => {
+                    log::warn!("request cancelled!");
+                    continue;
+                }
+                e => e?,
+            };
+        };
+
+        log::debug!("started session");
+        let session = Some(session);
+
+        Ok(Self { proxy, session })
+    }
+}
+
+#[async_trait]
+impl<'a> InputEmulation for DesktopPortalEmulation<'a> {
+    async fn consume(&mut self, event: input_event::Event, _client: EmulationHandle) {
+        match event {
+            Pointer(p) => match p {
+                PointerEvent::Motion {
+                    time: _,
+                    relative_x,
+                    relative_y,
+                } => {
+                    if let Err(e) = self
+                        .proxy
+                        .notify_pointer_motion(
+                            self.session.as_ref().expect("no session"),
+                            relative_x,
+                            relative_y,
+                        )
+                        .await
+                    {
+                        log::warn!("{e}");
+                    }
+                }
+                PointerEvent::Button {
+                    time: _,
+                    button,
+                    state,
+                } => {
+                    let state = match state {
+                        0 => KeyState::Released,
+                        _ => KeyState::Pressed,
+                    };
+                    if let Err(e) = self
+                        .proxy
+                        .notify_pointer_button(
+                            self.session.as_ref().expect("no session"),
+                            button as i32,
+                            state,
+                        )
+                        .await
+                    {
+                        log::warn!("{e}");
+                    }
+                }
+                PointerEvent::AxisDiscrete120 { axis, value } => {
+                    let axis = match axis {
+                        0 => Axis::Vertical,
+                        _ => Axis::Horizontal,
+                    };
+                    if let Err(e) = self
+                        .proxy
+                        .notify_pointer_axis_discrete(
+                            self.session.as_ref().expect("no session"),
+                            axis,
+                            value,
+                        )
+                        .await
+                    {
+                        log::warn!("{e}");
+                    }
+                }
+                PointerEvent::Axis {
+                    time: _,
+                    axis,
+                    value,
+                } => {
+                    let axis = match axis {
+                        0 => Axis::Vertical,
+                        _ => Axis::Horizontal,
+                    };
+                    let (dx, dy) = match axis {
+                        Axis::Vertical => (0., value),
+                        Axis::Horizontal => (value, 0.),
+                    };
+                    if let Err(e) = self
+                        .proxy
+                        .notify_pointer_axis(
+                            self.session.as_ref().expect("no session"),
+                            dx,
+                            dy,
+                            true,
+                        )
+                        .await
+                    {
+                        log::warn!("{e}");
+                    }
+                }
+                PointerEvent::Frame {} => {}
+            },
+            Keyboard(k) => {
+                match k {
+                    KeyboardEvent::Key {
+                        time: _,
+                        key,
+                        state,
+                    } => {
+                        let state = match state {
+                            0 => KeyState::Released,
+                            _ => KeyState::Pressed,
+                        };
+                        if let Err(e) = self
+                            .proxy
+                            .notify_keyboard_keycode(
+                                self.session.as_ref().expect("no session"),
+                                key as i32,
+                                state,
+                            )
+                            .await
+                        {
+                            log::warn!("{e}");
+                        }
+                    }
+                    KeyboardEvent::Modifiers { .. } => {
+                        // ignore
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+
+    async fn create(&mut self, _client: EmulationHandle) {}
+    async fn destroy(&mut self, _client: EmulationHandle) {}
+}
+
+impl<'a> Drop for DesktopPortalEmulation<'a> {
+    fn drop(&mut self) {
+        let session = self.session.take().expect("no session");
+        tokio::runtime::Handle::try_current()
+            .expect("no runtime")
+            .block_on(async move {
+                log::debug!("closing remote desktop session");
+                if let Err(e) = session.close().await {
+                    log::error!("failed to close remote desktop session: {e}");
+                }
+            });
+    }
+}