fix drop impl for desktop-portal

Cargo.toml

@@ -1,3 +1,10 @@
+[workspace]
+members = [
+    "input-capture",
+    "input-emulation",
+    "input-event",
+]
+
 [package]
 name = "lan-mouse"
 description = "Software KVM Switch / mouse & keyboard sharing software for Local Area Networks"
@@ -6,16 +13,16 @@ edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/ferdinandschober/lan-mouse"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [profile.release]
 strip = true
 lto = "fat"
 
 [dependencies]
-tempfile = "3.8"
+input-event = { path = "input-event", version = "0.1.0" }
+input-emulation = { path = "input-emulation", version = "0.1.0", default-features = false }
+input-capture = { path = "input-capture", version = "0.1.0", default-features = false }
+
 hickory-resolver = "0.24.1"
-memmap = "0.7"
 toml = "0.8"
 serde = { version = "1.0", features = ["derive"] }
 anyhow = "1.0.71"
@@ -23,16 +30,11 @@ log = "0.4.20"
 env_logger = "0.11.3"
 serde_json = "1.0.107"
 tokio = {version = "1.32.0", features = ["io-util", "io-std", "macros", "net", "process", "rt", "sync", "signal"] }
-async-trait = "0.1.73"
-futures-core = "0.3.28"
 futures = "0.3.28"
 clap = { version="4.4.11", features = ["derive"] }
 gtk = { package = "gtk4", version = "0.8.1", features = ["v4_2"], optional = true }
 adw = { package = "libadwaita", version = "0.6.0", features = ["v1_1"], optional = true }
 async-channel = { version = "2.1.1", optional = true }
-keycode = "0.4.0"
-once_cell = "1.19.0"
-num_enum = "0.7.2"
 hostname = "0.4.0"
 slab = "0.4.9"
 endi = "1.1.0"
@@ -41,36 +43,13 @@ thiserror = "1.0.61"
 [target.'cfg(unix)'.dependencies]
 libc = "0.2.148"
 
-[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"] }
-
-[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",
-] }
-
 [build-dependencies]
 glib-build-tools = { version = "0.19.0", optional = true }
 
 [features]
-default = ["wayland", "x11", "xdg_desktop_portal", "libei", "gtk"]
+default = [ "wayland", "x11", "xdg_desktop_portal", "libei", "gtk" ]
-wayland = ["dep:wayland-client", "dep:wayland-protocols", "dep:wayland-protocols-wlr", "dep:wayland-protocols-misc" ]
+wayland = [ "input-capture/wayland", "input-emulation/wayland" ]
-x11 = ["dep:x11"]
+x11 = [ "input-capture/x11", "input-emulation/x11" ]
-xdg_desktop_portal = ["dep:ashpd"]
+xdg_desktop_portal = [ "input-emulation/xdg_desktop_portal" ]
-libei = ["dep:reis", "dep:ashpd"]
+libei = [ "input-capture/libei", "input-emulation/libei" ]
 gtk = ["dep:gtk", "dep:adw", "dep:async-channel", "dep:glib-build-tools"]

input-capture/Cargo.toml

@@ -0,0 +1,48 @@
+[package]
+name = "input-capture"
+description = "cross-platform input-capture 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"
+futures = "0.3.28"
+futures-core = "0.3.30"
+log = "0.4.22"
+input-event = { path = "../input-event", version = "0.1.0" }
+memmap = "0.7"
+tempfile = "3.8"
+thiserror = "1.0.61"
+tokio = { version = "1.32.0", features = ["io-util", "io-std", "macros", "net", "process", "rt", "sync", "signal"] }
+once_cell = "1.19.0"
+
+
+[target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
+wayland-client = { version="0.31.1", optional = true }
+wayland-protocols = { version="0.32.1", features=["client", "staging", "unstable"], optional = true }
+wayland-protocols-wlr = { version="0.3.1", 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"] }
+
+[target.'cfg(windows)'.dependencies]
+windows = {  version = "0.57.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", "libei"]
+wayland = ["dep:wayland-client", "dep:wayland-protocols", "dep:wayland-protocols-wlr" ]
+x11 = ["dep:x11"]
+libei = ["dep:reis", "dep:ashpd"]

input-capture/src/dummy.rs

@@ -4,7 +4,7 @@ use std::task::{Context, Poll};
 
 use futures_core::Stream;
 
-use crate::event::Event;
+use input_event::Event;
 
 use super::{CaptureHandle, InputCapture, Position};
 

input-capture/src/lib.rs

@@ -2,7 +2,7 @@ use std::{fmt::Display, io};
 
 use futures_core::Stream;
 
-use crate::{config::CaptureBackend, event::Event};
+use input_event::Event;
 
 use self::error::CaptureCreationError;
 
@@ -59,6 +59,7 @@ impl Display for Position {
     }
 }
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum Backend {
     #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
     InputCapturePortal,
@@ -73,6 +74,24 @@ pub enum Backend {
     Dummy,
 }
 
+impl Display for Backend {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            Backend::InputCapturePortal => write!(f, "input-capture-portal"),
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            Backend::LayerShell => write!(f, "layer-shell"),
+            #[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"),
+        }
+    }
+}
+
 pub trait InputCapture: Stream<Item = io::Result<(CaptureHandle, Event)>> + Unpin {
     /// create a new client with the given id
     fn create(&mut self, id: CaptureHandle, pos: Position) -> io::Result<()>;
@@ -85,26 +104,26 @@ pub trait InputCapture: Stream<Item = io::Result<(CaptureHandle, Event)>> + Unpi
 }
 
 pub async fn create_backend(
-    backend: CaptureBackend,
+    backend: Backend,
 ) -> Result<Box<dyn InputCapture<Item = io::Result<(CaptureHandle, Event)>>>, CaptureCreationError>
 {
     match backend {
         #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-        CaptureBackend::InputCapturePortal => Ok(Box::new(libei::LibeiInputCapture::new().await?)),
+        Backend::InputCapturePortal => Ok(Box::new(libei::LibeiInputCapture::new().await?)),
         #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-        CaptureBackend::LayerShell => Ok(Box::new(wayland::WaylandInputCapture::new()?)),
+        Backend::LayerShell => Ok(Box::new(wayland::WaylandInputCapture::new()?)),
         #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-        CaptureBackend::X11 => Ok(Box::new(x11::X11InputCapture::new()?)),
+        Backend::X11 => Ok(Box::new(x11::X11InputCapture::new()?)),
         #[cfg(windows)]
-        CaptureBackend::Windows => Ok(Box::new(windows::WindowsInputCapture::new())),
+        Backend::Windows => Ok(Box::new(windows::WindowsInputCapture::new())),
         #[cfg(target_os = "macos")]
-        CaptureBackend::MacOs => Ok(Box::new(macos::MacOSInputCapture::new()?)),
+        Backend::MacOs => Ok(Box::new(macos::MacOSInputCapture::new()?)),
-        CaptureBackend::Dummy => Ok(Box::new(dummy::DummyInputCapture::new())),
+        Backend::Dummy => Ok(Box::new(dummy::DummyInputCapture::new())),
     }
 }
 
 pub async fn create(
-    backend: Option<CaptureBackend>,
+    backend: Option<Backend>,
 ) -> Result<Box<dyn InputCapture<Item = io::Result<(CaptureHandle, Event)>>>, CaptureCreationError>
 {
     if let Some(backend) = backend {
@@ -117,16 +136,16 @@ pub async fn create(
 
     for backend in [
         #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-        CaptureBackend::InputCapturePortal,
+        Backend::InputCapturePortal,
         #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-        CaptureBackend::LayerShell,
+        Backend::LayerShell,
         #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-        CaptureBackend::X11,
+        Backend::X11,
         #[cfg(windows)]
-        CaptureBackend::Windows,
+        Backend::Windows,
         #[cfg(target_os = "macos")]
-        CaptureBackend::MacOs,
+        Backend::MacOs,
-        CaptureBackend::Dummy,
+        Backend::Dummy,
     ] {
         match create_backend(backend).await {
             Ok(b) => {

input-capture/src/libei.rs

@@ -30,7 +30,7 @@ use tokio::{
 use futures_core::Stream;
 use once_cell::sync::Lazy;
 
-use crate::event::{Event, KeyboardEvent, PointerEvent};
+use input_event::{Event, KeyboardEvent, PointerEvent};
 
 use super::{
     error::LibeiCaptureCreationError, CaptureHandle, InputCapture as LanMouseInputCapture, Position,

input-capture/src/macos.rs

@@ -1,7 +1,6 @@
-use crate::capture::error::MacOSInputCaptureCreationError;
+use crate::{error::MacOSInputCaptureCreationError, CaptureHandle, InputCapture, Position};
-use crate::capture::{CaptureHandle, InputCapture, Position};
-use crate::event::Event;
 use futures_core::Stream;
+use input_event::Event;
 use std::task::{Context, Poll};
 use std::{io, pin::Pin};
 

input-capture/src/wayland.rs

@@ -60,7 +60,7 @@ use wayland_client::{
 
 use tempfile;
 
-use crate::event::{Event, KeyboardEvent, PointerEvent};
+use input_event::{Event, KeyboardEvent, PointerEvent};
 
 use super::{
     error::{LayerShellCaptureCreationError, WaylandBindError},

input-capture/src/windows.rs

@@ -32,10 +32,10 @@ use windows::Win32::UI::WindowsAndMessaging::{
     WNDPROC,
 };
 
-use crate::event::{
+use input_event::{
-    KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT,
+    scancode::{self, Linux},
+    Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT,
 };
-use crate::{event::Event, scancode, scancode::Linux};
 
 use super::{CaptureHandle, InputCapture, Position};
 
@@ -565,7 +565,7 @@ fn message_thread(ready_tx: mpsc::Sender<()>) {
                 }
             } else {
                 /* other messages for window_procs */
-                TranslateMessage(&msg);
+                let _ = TranslateMessage(&msg);
                 DispatchMessageW(&msg);
             }
         }

input-capture/src/x11.rs

@@ -4,7 +4,7 @@ use std::task::Poll;
 use futures_core::Stream;
 
 use super::InputCapture;
-use crate::event::Event;
+use input_event::Event;
 
 use super::error::X11InputCaptureCreationError;
 use super::{CaptureHandle, Position};

input-emulation/Cargo.toml

@@ -0,0 +1,48 @@
+[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", version = "0.1.0" }
+thiserror = "1.0.61"
+tokio = { version = "1.32.0", features = ["io-util", "io-std", "macros", "net", "process", "rt", "sync", "signal"] }
+once_cell = "1.19.0"
+
+[target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
+wayland-client = { version="0.31.1", optional = true }
+wayland-protocols = { version="0.32.1", features=["client", "staging", "unstable"], optional = true }
+wayland-protocols-wlr = { version="0.3.1", features=["client"], optional = true }
+wayland-protocols-misc = { version="0.3.1", 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.57.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

@@ -1,5 +1,7 @@
-use crate::event::Event;
 use async_trait::async_trait;
+use input_event::Event;
+
+use crate::error::EmulationError;
 
 use super::{EmulationHandle, InputEmulation};
 
@@ -14,8 +16,13 @@ impl DummyEmulation {
 
 #[async_trait]
 impl InputEmulation for DummyEmulation {
-    async fn consume(&mut self, event: Event, client_handle: EmulationHandle) {
+    async fn consume(
+        &mut self,
+        event: Event,
+        client_handle: EmulationHandle,
+    ) -> Result<(), EmulationError> {
         log::info!("received event: ({client_handle}) {event}");
+        Ok(())
     }
     async fn create(&mut self, _: EmulationHandle) {}
     async fn destroy(&mut self, _: EmulationHandle) {}

input-emulation/src/error.rs

@@ -1,4 +1,4 @@
-use std::fmt::Display;
+use std::{fmt::Display, io};
 
 use thiserror::Error;
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
@@ -8,6 +8,28 @@ use wayland_client::{
     ConnectError, DispatchError,
 };
 
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+use reis::tokio::HandshakeError;
+
+#[derive(Debug, Error)]
+pub enum EmulationError {
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    #[error("libei error flushing events: `{0}`")]
+    Libei(#[from] reis::event::Error),
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    #[error("wayland error: `{0}`")]
+    Wayland(#[from] wayland_client::backend::WaylandError),
+    #[cfg(all(
+        unix,
+        any(feature = "xdg_desktop_portal", feature = "libei"),
+        not(target_os = "macos")
+    ))]
+    #[error("xdg-desktop-portal: `{0}`")]
+    Ashpd(#[from] ashpd::Error),
+    #[error("io error: `{0}`")]
+    Io(#[from] io::Error),
+}
+
 #[derive(Debug, Error)]
 pub enum EmulationCreationError {
     #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
@@ -104,6 +126,7 @@ impl Display for WlrootsEmulationCreationError {
 pub enum LibeiEmulationCreationError {
     Ashpd(#[from] ashpd::Error),
     Io(#[from] std::io::Error),
+    Handshake(#[from] HandshakeError),
 }
 
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
@@ -112,6 +135,7 @@ impl Display for LibeiEmulationCreationError {
         match self {
             LibeiEmulationCreationError::Ashpd(e) => write!(f, "xdg-desktop-portal: {e}"),
             LibeiEmulationCreationError::Io(e) => write!(f, "io error: {e}"),
+            LibeiEmulationCreationError::Handshake(e) => write!(f, "error in libei handshake: {e}"),
         }
     }
 }

input-emulation/src/lib.rs

@@ -0,0 +1,141 @@
+use async_trait::async_trait;
+use error::EmulationError;
+use std::fmt::Display;
+
+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,
+    ) -> Result<(), EmulationError>;
+    async fn create(&mut self, handle: EmulationHandle);
+    async fn destroy(&mut self, handle: EmulationHandle);
+}
+
+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 = "xdg_desktop_portal", not(target_os = "macos")))]
+        Backend::Xdp,
+        #[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,336 @@
+use anyhow::{anyhow, Result};
+use futures::StreamExt;
+use once_cell::sync::Lazy;
+use std::{
+    collections::HashMap,
+    io,
+    os::{fd::OwnedFd, unix::net::UnixStream},
+    sync::{
+        atomic::{AtomicU32, Ordering},
+        Arc, RwLock,
+    },
+    time::{SystemTime, UNIX_EPOCH},
+};
+use tokio::task::JoinHandle;
+
+use ashpd::{
+    desktop::{
+        remote_desktop::{DeviceType, RemoteDesktop},
+        ResponseError,
+    },
+    WindowIdentifier,
+};
+use async_trait::async_trait;
+
+use reis::{
+    ei::{
+        self, button::ButtonState, handshake::ContextType, keyboard::KeyState, Button, Keyboard,
+        Pointer, Scroll,
+    },
+    event::{DeviceCapability, DeviceEvent, EiEvent, SeatEvent},
+    tokio::{ei_handshake, EiConvertEventStream, EiEventStream},
+};
+
+use input_event::{Event, KeyboardEvent, PointerEvent};
+
+use crate::error::EmulationError;
+
+use super::{error::LibeiEmulationCreationError, EmulationHandle, InputEmulation};
+
+static INTERFACES: Lazy<HashMap<&'static str, u32>> = Lazy::new(|| {
+    let mut m = HashMap::new();
+    m.insert("ei_connection", 1);
+    m.insert("ei_callback", 1);
+    m.insert("ei_pingpong", 1);
+    m.insert("ei_seat", 1);
+    m.insert("ei_device", 2);
+    m.insert("ei_pointer", 1);
+    m.insert("ei_pointer_absolute", 1);
+    m.insert("ei_scroll", 1);
+    m.insert("ei_button", 1);
+    m.insert("ei_keyboard", 1);
+    m.insert("ei_touchscreen", 1);
+    m
+});
+
+#[derive(Clone, Default)]
+struct Devices {
+    pointer: Arc<RwLock<Option<(ei::Device, ei::Pointer)>>>,
+    scroll: Arc<RwLock<Option<(ei::Device, ei::Scroll)>>>,
+    button: Arc<RwLock<Option<(ei::Device, ei::Button)>>>,
+    keyboard: Arc<RwLock<Option<(ei::Device, ei::Keyboard)>>>,
+}
+
+pub struct LibeiEmulation {
+    context: ei::Context,
+    devices: Devices,
+    serial: AtomicU32,
+    ei_task: JoinHandle<Result<()>>,
+}
+
+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> {
+        let eifd = get_ei_fd().await?;
+        let stream = UnixStream::from(eifd);
+        stream.set_nonblocking(true)?;
+        let context = ei::Context::new(stream)?;
+        context.flush().map_err(|e| io::Error::new(e.kind(), e))?;
+        let mut events = EiEventStream::new(context.clone())?;
+        let handshake = ei_handshake(
+            &mut events,
+            "de.feschber.LanMouse",
+            ContextType::Sender,
+            &INTERFACES,
+        )
+        .await?;
+        let events = EiConvertEventStream::new(events, handshake.serial);
+        let devices = Devices::default();
+        let ei_task =
+            tokio::task::spawn_local(ei_event_handler(events, context.clone(), devices.clone()));
+
+        let serial = AtomicU32::new(handshake.serial);
+
+        Ok(Self {
+            serial,
+            context,
+            ei_task,
+            devices,
+        })
+    }
+}
+
+impl Drop for LibeiEmulation {
+    fn drop(&mut self) {
+        self.ei_task.abort();
+    }
+}
+
+#[async_trait]
+impl InputEmulation for LibeiEmulation {
+    async fn consume(
+        &mut self,
+        event: Event,
+        _handle: EmulationHandle,
+    ) -> Result<(), EmulationError> {
+        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,
+                } => {
+                    let pointer_device = self.devices.pointer.read().unwrap();
+                    if let Some((d, p)) = pointer_device.as_ref() {
+                        p.motion_relative(relative_x as f32, relative_y as f32);
+                        d.frame(self.serial.load(Ordering::SeqCst), now);
+                    }
+                }
+                PointerEvent::Button {
+                    time: _,
+                    button,
+                    state,
+                } => {
+                    let button_device = self.devices.button.read().unwrap();
+                    if let Some((d, b)) = button_device.as_ref() {
+                        b.button(
+                            button,
+                            match state {
+                                0 => ButtonState::Released,
+                                _ => ButtonState::Press,
+                            },
+                        );
+                        d.frame(self.serial.load(Ordering::SeqCst), now);
+                    }
+                }
+                PointerEvent::Axis {
+                    time: _,
+                    axis,
+                    value,
+                } => {
+                    let scroll_device = self.devices.scroll.read().unwrap();
+                    if let Some((d, s)) = scroll_device.as_ref() {
+                        match axis {
+                            0 => s.scroll(0., value as f32),
+                            _ => s.scroll(value as f32, 0.),
+                        }
+                        d.frame(self.serial.load(Ordering::SeqCst), now);
+                    }
+                }
+                PointerEvent::AxisDiscrete120 { axis, value } => {
+                    let scroll_device = self.devices.scroll.read().unwrap();
+                    if let Some((d, s)) = scroll_device.as_ref() {
+                        match axis {
+                            0 => s.scroll_discrete(0, value),
+                            _ => s.scroll_discrete(value, 0),
+                        }
+                        d.frame(self.serial.load(Ordering::SeqCst), now);
+                    }
+                }
+                PointerEvent::Frame {} => {}
+            },
+            Event::Keyboard(k) => match k {
+                KeyboardEvent::Key {
+                    time: _,
+                    key,
+                    state,
+                } => {
+                    let keyboard_device = self.devices.keyboard.read().unwrap();
+                    if let Some((d, k)) = keyboard_device.as_ref() {
+                        k.key(
+                            key,
+                            match state {
+                                0 => KeyState::Released,
+                                _ => KeyState::Press,
+                            },
+                        );
+                        d.frame(self.serial.load(Ordering::SeqCst), now);
+                    }
+                }
+                KeyboardEvent::Modifiers { .. } => {}
+            },
+            _ => {}
+        }
+        self.context
+            .flush()
+            .map_err(|e| io::Error::new(e.kind(), e))?;
+        Ok(())
+    }
+
+    async fn create(&mut self, _: EmulationHandle) {}
+    async fn destroy(&mut self, _: EmulationHandle) {}
+}
+
+async fn ei_event_handler(
+    mut events: EiConvertEventStream,
+    context: ei::Context,
+    devices: Devices,
+) -> Result<()> {
+    loop {
+        let event = events
+            .next()
+            .await
+            .ok_or(anyhow!("ei stream closed"))?
+            .map_err(|e| anyhow!("libei error: {e:?}"))?;
+        const CAPABILITIES: &[DeviceCapability] = &[
+            DeviceCapability::Pointer,
+            DeviceCapability::PointerAbsolute,
+            DeviceCapability::Keyboard,
+            DeviceCapability::Touch,
+            DeviceCapability::Scroll,
+            DeviceCapability::Button,
+        ];
+        log::debug!("{event:?}");
+        match event {
+            EiEvent::Disconnected(e) => {
+                log::debug!("ei disconnected: {e:?}");
+                break;
+            }
+            EiEvent::SeatAdded(e) => {
+                e.seat().bind_capabilities(CAPABILITIES);
+            }
+            EiEvent::SeatRemoved(e) => {
+                log::debug!("seat removed: {:?}", e.seat());
+            }
+            EiEvent::DeviceAdded(e) => {
+                let device_type = e.device().device_type();
+                log::debug!("device added: {device_type:?}");
+                e.device().device();
+                let device = e.device();
+                if let Some(pointer) = e.device().interface::<Pointer>() {
+                    devices
+                        .pointer
+                        .write()
+                        .unwrap()
+                        .replace((device.device().clone(), pointer));
+                }
+                if let Some(keyboard) = e.device().interface::<Keyboard>() {
+                    devices
+                        .keyboard
+                        .write()
+                        .unwrap()
+                        .replace((device.device().clone(), keyboard));
+                }
+                if let Some(scroll) = e.device().interface::<Scroll>() {
+                    devices
+                        .scroll
+                        .write()
+                        .unwrap()
+                        .replace((device.device().clone(), scroll));
+                }
+                if let Some(button) = e.device().interface::<Button>() {
+                    devices
+                        .button
+                        .write()
+                        .unwrap()
+                        .replace((device.device().clone(), button));
+                }
+            }
+            EiEvent::DeviceRemoved(e) => {
+                log::debug!("device removed: {:?}", e.device().device_type());
+            }
+            EiEvent::DevicePaused(e) => {
+                log::debug!("device paused: {:?}", e.device().device_type());
+            }
+            EiEvent::DeviceResumed(e) => {
+                log::debug!("device resumed: {:?}", e.device().device_type());
+                e.device().device().start_emulating(0, 0);
+            }
+            EiEvent::KeyboardModifiers(e) => {
+                log::debug!("modifiers: {e:?}");
+            }
+            // only for receiver context
+            // EiEvent::Frame(_) => { },
+            // EiEvent::DeviceStartEmulating(_) => { },
+            // EiEvent::DeviceStopEmulating(_) => { },
+            // EiEvent::PointerMotion(_) => { },
+            // EiEvent::PointerMotionAbsolute(_) => { },
+            // EiEvent::Button(_) => { },
+            // EiEvent::ScrollDelta(_) => { },
+            // EiEvent::ScrollStop(_) => { },
+            // EiEvent::ScrollCancel(_) => { },
+            // EiEvent::ScrollDiscrete(_) => { },
+            // EiEvent::KeyboardKey(_) => { },
+            // EiEvent::TouchDown(_) => { },
+            // EiEvent::TouchUp(_) => { },
+            // EiEvent::TouchMotion(_) => { },
+            _ => unreachable!("unexpected ei event"),
+        }
+        context.flush()?;
+    }
+    Ok(())
+}

input-emulation/src/macos.rs

@@ -1,11 +1,11 @@
-use super::{EmulationHandle, InputEmulation};
+use super::{error::EmulationError, EmulationHandle, InputEmulation};
-use crate::event::{Event, KeyboardEvent, PointerEvent};
 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;
@@ -107,7 +107,11 @@ fn key_event(event_source: CGEventSource, key: u16, state: u8) {
 
 #[async_trait]
 impl InputEmulation for MacOSEmulation {
-    async fn consume(&mut self, event: Event, _handle: EmulationHandle) {
+    async fn consume(
+        &mut self,
+        event: Event,
+        _handle: EmulationHandle,
+    ) -> Result<(), EmulationError> {
         match event {
             Event::Pointer(pointer_event) => match pointer_event {
                 PointerEvent::Motion {
@@ -129,7 +133,7 @@ impl InputEmulation for MacOSEmulation {
                         Some(l) => l,
                         None => {
                             log::warn!("could not get mouse location!");
-                            return;
+                            return Ok(());
                         }
                     };
 
@@ -153,7 +157,7 @@ impl InputEmulation for MacOSEmulation {
                         Ok(e) => e,
                         Err(_) => {
                             log::warn!("mouse event creation failed!");
-                            return;
+                            return Ok(());
                         }
                     };
                     event.set_integer_value_field(
@@ -172,27 +176,27 @@ impl InputEmulation for MacOSEmulation {
                     state,
                 } => {
                     let (event_type, mouse_button) = match (button, state) {
-                        (b, 1) if b == crate::event::BTN_LEFT => {
+                        (b, 1) if b == input_event::BTN_LEFT => {
                             (CGEventType::LeftMouseDown, CGMouseButton::Left)
                         }
-                        (b, 0) if b == crate::event::BTN_LEFT => {
+                        (b, 0) if b == input_event::BTN_LEFT => {
                             (CGEventType::LeftMouseUp, CGMouseButton::Left)
                         }
-                        (b, 1) if b == crate::event::BTN_RIGHT => {
+                        (b, 1) if b == input_event::BTN_RIGHT => {
                             (CGEventType::RightMouseDown, CGMouseButton::Right)
                         }
-                        (b, 0) if b == crate::event::BTN_RIGHT => {
+                        (b, 0) if b == input_event::BTN_RIGHT => {
                             (CGEventType::RightMouseUp, CGMouseButton::Right)
                         }
-                        (b, 1) if b == crate::event::BTN_MIDDLE => {
+                        (b, 1) if b == input_event::BTN_MIDDLE => {
                             (CGEventType::OtherMouseDown, CGMouseButton::Center)
                         }
-                        (b, 0) if b == crate::event::BTN_MIDDLE => {
+                        (b, 0) if b == input_event::BTN_MIDDLE => {
                             (CGEventType::OtherMouseUp, CGMouseButton::Center)
                         }
                         _ => {
                             log::warn!("invalid button event: {button},{state}");
-                            return;
+                            return Ok(());
                         }
                     };
                     // store button state
@@ -208,7 +212,7 @@ impl InputEmulation for MacOSEmulation {
                         Ok(e) => e,
                         Err(()) => {
                             log::warn!("mouse event creation failed!");
-                            return;
+                            return Ok(());
                         }
                     };
                     event.post(CGEventTapLocation::HID);
@@ -224,7 +228,7 @@ impl InputEmulation for MacOSEmulation {
                         1 => (2, 0, value, 0), // 1 = horizontal => 2 scroll wheel devices (y, x) -> (0, x)
                         _ => {
                             log::warn!("invalid scroll event: {axis}, {value}");
-                            return;
+                            return Ok(());
                         }
                     };
                     let event = match CGEvent::new_scroll_event(
@@ -238,7 +242,7 @@ impl InputEmulation for MacOSEmulation {
                         Ok(e) => e,
                         Err(()) => {
                             log::warn!("scroll event creation failed!");
-                            return;
+                            return Ok(());
                         }
                     };
                     event.post(CGEventTapLocation::HID);
@@ -249,7 +253,7 @@ impl InputEmulation for MacOSEmulation {
                         1 => (2, 0, value, 0), // 1 = horizontal => 2 scroll wheel devices (y, x) -> (0, x)
                         _ => {
                             log::warn!("invalid scroll event: {axis}, {value}");
-                            return;
+                            return Ok(());
                         }
                     };
                     let event = match CGEvent::new_scroll_event(
@@ -263,7 +267,7 @@ impl InputEmulation for MacOSEmulation {
                         Ok(e) => e,
                         Err(()) => {
                             log::warn!("scroll event creation failed!");
-                            return;
+                            return Ok(());
                         }
                     };
                     event.post(CGEventTapLocation::HID);
@@ -280,7 +284,7 @@ impl InputEmulation for MacOSEmulation {
                         Ok(k) => k.mac as CGKeyCode,
                         Err(_) => {
                             log::warn!("unable to map key event");
-                            return;
+                            return Ok(());
                         }
                     };
                     match state {
@@ -294,6 +298,8 @@ impl InputEmulation for MacOSEmulation {
             },
             _ => (),
         }
+        // FIXME
+        Ok(())
     }
 
     async fn create(&mut self, _handle: EmulationHandle) {}

input-emulation/src/windows.rs

@@ -1,9 +1,7 @@
-use super::error::WindowsEmulationCreationError;
+use super::error::{EmulationError, WindowsEmulationCreationError};
-use crate::{
+use input_event::{
-    event::{
+    scancode, Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE,
-        Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT,
+    BTN_RIGHT,
-    },
-    scancode,
 };
 
 use async_trait::async_trait;
@@ -38,7 +36,7 @@ impl WindowsEmulation {
 
 #[async_trait]
 impl InputEmulation for WindowsEmulation {
-    async fn consume(&mut self, event: Event, _: EmulationHandle) {
+    async fn consume(&mut self, event: Event, _: EmulationHandle) -> Result<(), EmulationError> {
         match event {
             Event::Pointer(pointer_event) => match pointer_event {
                 PointerEvent::Motion {
@@ -79,6 +77,8 @@ impl InputEmulation for WindowsEmulation {
             },
             _ => {}
         }
+        // FIXME
+        Ok(())
     }
 
     async fn create(&mut self, _handle: EmulationHandle) {}

input-emulation/src/wlroots.rs

@@ -1,4 +1,6 @@
-use crate::emulate::{error::WlrootsEmulationCreationError, InputEmulation};
+use crate::error::EmulationError;
+
+use super::{error::WlrootsEmulationCreationError, InputEmulation};
 use async_trait::async_trait;
 use std::collections::HashMap;
 use std::io;
@@ -26,7 +28,7 @@ use wayland_client::{
     Connection, Dispatch, EventQueue, QueueHandle,
 };
 
-use crate::event::{Event, KeyboardEvent, PointerEvent};
+use input_event::{Event, KeyboardEvent, PointerEvent};
 
 use super::error::WaylandBindError;
 use super::EmulationHandle;
@@ -115,38 +117,40 @@ impl State {
 
 #[async_trait]
 impl InputEmulation for WlrootsEmulation {
-    async fn consume(&mut self, event: Event, handle: EmulationHandle) {
+    async fn consume(
+        &mut self,
+        event: Event,
+        handle: EmulationHandle,
+    ) -> Result<(), EmulationError> {
         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() {
+                match self.queue.flush() {
-                    if e.kind() == io::ErrorKind::WouldBlock {
+                    Err(WaylandError::Io(e)) 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;
+                        return Ok(());
+                    }
+                    _ => {}
                 }
             }
-            }
+            virtual_input
-            virtual_input.consume_event(event).unwrap();
+                .consume_event(event)
+                .unwrap_or_else(|_| panic!("failed to convert event: {event:?}"));
             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 ...");
+                    log::warn!("can't keep up, discarding event: ({handle}) - {event:?}");
-                }
-                Err(WaylandError::Io(e)) => {
-                    log::error!("{e}")
-                }
-                Err(WaylandError::Protocol(e)) => {
-                    panic!("wayland protocol violation: {e}")
-                }
-                Ok(()) => {
-                    self.last_flush_failed = false;
                 }
+                Err(WaylandError::Protocol(e)) => panic!("wayland protocol violation: {e}"),
+                Ok(()) => self.last_flush_failed = false,
+                Err(e) => Err(e)?,
             }
         }
+        Ok(())
     }
 
     async fn create(&mut self, handle: EmulationHandle) {

input-emulation/src/x11.rs

@@ -5,10 +5,12 @@ use x11::{
     xtest,
 };
 
-use crate::event::{
+use input_event::{
     Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT,
 };
 
+use crate::error::EmulationError;
+
 use super::{error::X11EmulationCreationError, EmulationHandle, InputEmulation};
 
 pub struct X11Emulation {
@@ -98,7 +100,7 @@ impl Drop for X11Emulation {
 
 #[async_trait]
 impl InputEmulation for X11Emulation {
-    async fn consume(&mut self, event: Event, _: EmulationHandle) {
+    async fn consume(&mut self, event: Event, _: EmulationHandle) -> Result<(), EmulationError> {
         match event {
             Event::Pointer(pointer_event) => match pointer_event {
                 PointerEvent::Motion {
@@ -139,6 +141,8 @@ impl InputEmulation for X11Emulation {
         unsafe {
             xlib::XFlush(self.display);
         }
+        // FIXME
+        Ok(())
     }
 
     async fn create(&mut self, _: EmulationHandle) {

input-emulation/src/xdg_desktop_portal.rs

@@ -4,20 +4,24 @@ use ashpd::{
         remote_desktop::{Axis, DeviceType, KeyState, RemoteDesktop},
         ResponseError, Session,
     },
+    zbus::AsyncDrop,
     WindowIdentifier,
 };
 use async_trait::async_trait;
 
-use crate::event::{
+use futures::FutureExt;
+use input_event::{
     Event::{Keyboard, Pointer},
     KeyboardEvent, PointerEvent,
 };
 
+use crate::error::EmulationError;
+
 use super::{error::XdpEmulationCreationError, EmulationHandle, InputEmulation};
 
 pub struct DesktopPortalEmulation<'a> {
     proxy: RemoteDesktop<'a>,
-    session: Option<Session<'a>>,
+    session: Session<'a>,
 }
 
 impl<'a> DesktopPortalEmulation<'a> {
@@ -51,7 +55,7 @@ impl<'a> DesktopPortalEmulation<'a> {
         };
 
         log::debug!("started session");
-        let session = Some(session);
+        let session = session;
 
         Ok(Self { proxy, session })
     }
@@ -59,7 +63,11 @@ impl<'a> DesktopPortalEmulation<'a> {
 
 #[async_trait]
 impl<'a> InputEmulation for DesktopPortalEmulation<'a> {
-    async fn consume(&mut self, event: crate::event::Event, _client: crate::client::ClientHandle) {
+    async fn consume(
+        &mut self,
+        event: input_event::Event,
+        _client: EmulationHandle,
+    ) -> Result<(), EmulationError> {
         match event {
             Pointer(p) => match p {
                 PointerEvent::Motion {
@@ -67,17 +75,9 @@ impl<'a> InputEmulation for DesktopPortalEmulation<'a> {
                     relative_x,
                     relative_y,
                 } => {
-                    if let Err(e) = self
+                    self.proxy
-                        .proxy
+                        .notify_pointer_motion(&self.session, relative_x, relative_y)
-                        .notify_pointer_motion(
+                        .await?;
-                            self.session.as_ref().expect("no session"),
-                            relative_x,
-                            relative_y,
-                        )
-                        .await
-                    {
-                        log::warn!("{e}");
-                    }
                 }
                 PointerEvent::Button {
                     time: _,
@@ -88,34 +88,18 @@ impl<'a> InputEmulation for DesktopPortalEmulation<'a> {
                         0 => KeyState::Released,
                         _ => KeyState::Pressed,
                     };
-                    if let Err(e) = self
+                    self.proxy
-                        .proxy
+                        .notify_pointer_button(&self.session, button as i32, state)
-                        .notify_pointer_button(
+                        .await?;
-                            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
+                    self.proxy
-                        .proxy
+                        .notify_pointer_axis_discrete(&self.session, axis, value)
-                        .notify_pointer_axis_discrete(
+                        .await?;
-                            self.session.as_ref().expect("no session"),
-                            axis,
-                            value,
-                        )
-                        .await
-                    {
-                        log::warn!("{e}");
-                    }
                 }
                 PointerEvent::Axis {
                     time: _,
@@ -130,18 +114,9 @@ impl<'a> InputEmulation for DesktopPortalEmulation<'a> {
                         Axis::Vertical => (0., value),
                         Axis::Horizontal => (value, 0.),
                     };
-                    if let Err(e) = self
+                    self.proxy
-                        .proxy
+                        .notify_pointer_axis(&self.session, dx, dy, true)
-                        .notify_pointer_axis(
+                        .await?;
-                            self.session.as_ref().expect("no session"),
-                            dx,
-                            dy,
-                            true,
-                        )
-                        .await
-                    {
-                        log::warn!("{e}");
-                    }
                 }
                 PointerEvent::Frame {} => {}
             },
@@ -156,17 +131,9 @@ impl<'a> InputEmulation for DesktopPortalEmulation<'a> {
                             0 => KeyState::Released,
                             _ => KeyState::Pressed,
                         };
-                        if let Err(e) = self
+                        self.proxy
-                            .proxy
+                            .notify_keyboard_keycode(&self.session, key as i32, state)
-                            .notify_keyboard_keycode(
+                            .await?;
-                                self.session.as_ref().expect("no session"),
-                                key as i32,
-                                state,
-                            )
-                            .await
-                        {
-                            log::warn!("{e}");
-                        }
                     }
                     KeyboardEvent::Modifiers { .. } => {
                         // ignore
@@ -175,22 +142,28 @@ impl<'a> InputEmulation for DesktopPortalEmulation<'a> {
             }
             _ => {}
         }
+        Ok(())
     }
 
     async fn create(&mut self, _client: EmulationHandle) {}
     async fn destroy(&mut self, _client: EmulationHandle) {}
 }
 
-impl<'a> Drop for DesktopPortalEmulation<'a> {
+impl<'a> AsyncDrop for DesktopPortalEmulation<'a> {
-    fn drop(&mut self) {
+    #[doc = r" Perform the async cleanup."]
-        let session = self.session.take().expect("no session");
+    #[must_use]
-        tokio::runtime::Handle::try_current()
+    #[allow(clippy::type_complexity, clippy::type_repetition_in_bounds)]
-            .expect("no runtime")
+    fn async_drop<'async_trait>(
-            .block_on(async move {
+        self,
-                log::debug!("closing remote desktop session");
+    ) -> ::core::pin::Pin<
-                if let Err(e) = session.close().await {
+        Box<dyn ::core::future::Future<Output = ()> + ::core::marker::Send + 'async_trait>,
-                    log::error!("failed to close remote desktop session: {e}");
+    >
+    where
+        Self: 'async_trait,
+    {
+        async move {
+            let _ = self.session.close().await;
         }
-            });
+        .boxed()
     }
 }

input-event/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "input-event"
+description = "cross-platform input-event types for input-capture / input-emulation"
+version = "0.1.0"
+edition = "2021"
+license = "GPL-3.0-or-later"
+repository = "https://github.com/ferdinandschober/lan-mouse"
+
+[dependencies]
+anyhow = "1.0.86"
+futures-core = "0.3.30"
+log = "0.4.22"
+num_enum = "0.7.2"
+serde = { version = "1.0", features = ["derive"] }

input-event/src/lib.rs

@@ -1,10 +1,11 @@
-use crate::scancode;
 use anyhow::{anyhow, Result};
 use std::{
     error::Error,
     fmt::{self, Display},
 };
 
+pub mod scancode;
+
 // FIXME
 pub const BTN_LEFT: u32 = 0x110;
 pub const BTN_RIGHT: u32 = 0x111;

src/capture_test.rs

@@ -1,8 +1,8 @@
-use crate::capture::{self, Position};
 use crate::config::Config;
-use crate::event::{Event, KeyboardEvent};
 use anyhow::{anyhow, Result};
 use futures::StreamExt;
+use input_capture::{self, Position};
+use input_event::{Event, KeyboardEvent};
 use tokio::task::LocalSet;
 
 pub fn run() -> Result<()> {
@@ -19,7 +19,8 @@ pub fn run() -> Result<()> {
 
 async fn input_capture_test(config: Config) -> Result<()> {
     log::info!("creating input capture");
-    let mut input_capture = capture::create(config.capture_backend).await?;
+    let backend = config.capture_backend.map(|b| b.into());
+    let mut input_capture = input_capture::create(backend).await?;
     log::info!("creating clients");
     input_capture.create(0, Position::Left)?;
     input_capture.create(1, Position::Right)?;

src/client.rs

@@ -9,7 +9,8 @@ use std::{
 use serde::{Deserialize, Serialize};
 use slab::Slab;
 
-use crate::{capture, config::DEFAULT_PORT};
+use crate::config::DEFAULT_PORT;
+use input_capture;
 
 #[derive(Debug, Eq, Hash, PartialEq, Clone, Copy, Serialize, Deserialize)]
 pub enum Position {
@@ -25,13 +26,13 @@ impl Default for Position {
     }
 }
 
-impl From<Position> for capture::Position {
+impl From<Position> for input_capture::Position {
-    fn from(position: Position) -> capture::Position {
+    fn from(position: Position) -> input_capture::Position {
         match position {
-            Position::Left => capture::Position::Left,
+            Position::Left => input_capture::Position::Left,
-            Position::Right => capture::Position::Right,
+            Position::Right => input_capture::Position::Right,
-            Position::Top => capture::Position::Top,
+            Position::Top => input_capture::Position::Top,
-            Position::Bottom => capture::Position::Bottom,
+            Position::Bottom => input_capture::Position::Bottom,
         }
     }
 }

src/config.rs

@@ -9,8 +9,11 @@ use std::{error::Error, fs};
 use toml;
 
 use crate::client::Position;
-use crate::scancode;
+
-use crate::scancode::Linux::{KeyLeftAlt, KeyLeftCtrl, KeyLeftMeta, KeyLeftShift};
+use input_event::scancode::{
+    self,
+    Linux::{KeyLeftAlt, KeyLeftCtrl, KeyLeftMeta, KeyLeftShift},
+};
 
 pub const DEFAULT_PORT: u16 = 4242;
 
@@ -115,6 +118,24 @@ impl Display for CaptureBackend {
     }
 }
 
+impl From<CaptureBackend> for input_capture::Backend {
+    fn from(backend: CaptureBackend) -> Self {
+        match backend {
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            CaptureBackend::InputCapturePortal => Self::InputCapturePortal,
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            CaptureBackend::LayerShell => Self::LayerShell,
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+            CaptureBackend::X11 => Self::X11,
+            #[cfg(windows)]
+            CaptureBackend::Windows => Self::Windows,
+            #[cfg(target_os = "macos")]
+            CaptureBackend::MacOs => Self::MacOs,
+            CaptureBackend::Dummy => Self::Dummy,
+        }
+    }
+}
+
 #[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize, ValueEnum)]
 pub enum EmulationBackend {
     #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
@@ -132,6 +153,26 @@ pub enum EmulationBackend {
     Dummy,
 }
 
+impl From<EmulationBackend> for input_emulation::Backend {
+    fn from(backend: EmulationBackend) -> Self {
+        match backend {
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            EmulationBackend::Wlroots => Self::Wlroots,
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            EmulationBackend::Libei => Self::Libei,
+            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+            EmulationBackend::Xdp => Self::Xdp,
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+            EmulationBackend::X11 => Self::X11,
+            #[cfg(windows)]
+            EmulationBackend::Windows => Self::Windows,
+            #[cfg(target_os = "macos")]
+            EmulationBackend::MacOs => Self::MacOs,
+            EmulationBackend::Dummy => Self::Dummy,
+        }
+    }
+}
+
 impl Display for EmulationBackend {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {

src/emulate.rs

@@ -1,101 +0,0 @@
-use async_trait::async_trait;
-use std::future;
-
-use crate::{config::EmulationBackend, 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;
-
-#[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: EmulationBackend,
-) -> Result<Box<dyn InputEmulation>, EmulationCreationError> {
-    match backend {
-        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-        EmulationBackend::Wlroots => Ok(Box::new(wlroots::WlrootsEmulation::new()?)),
-        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-        EmulationBackend::Libei => Ok(Box::new(libei::LibeiEmulation::new().await?)),
-        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-        EmulationBackend::X11 => Ok(Box::new(x11::X11Emulation::new()?)),
-        #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
-        EmulationBackend::Xdp => Ok(Box::new(
-            xdg_desktop_portal::DesktopPortalEmulation::new().await?,
-        )),
-        #[cfg(windows)]
-        EmulationBackend::Windows => Ok(Box::new(windows::WindowsEmulation::new()?)),
-        #[cfg(target_os = "macos")]
-        EmulationBackend::MacOs => Ok(Box::new(macos::MacOSEmulation::new()?)),
-        EmulationBackend::Dummy => Ok(Box::new(dummy::DummyEmulation::new())),
-    }
-}
-
-pub async fn create(
-    backend: Option<EmulationBackend>,
-) -> 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")))]
-        EmulationBackend::Wlroots,
-        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-        EmulationBackend::Libei,
-        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-        EmulationBackend::X11,
-        #[cfg(windows)]
-        EmulationBackend::Windows,
-        #[cfg(target_os = "macos")]
-        EmulationBackend::MacOs,
-        EmulationBackend::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)
-}

src/emulate/libei.rs

@@ -1,397 +0,0 @@
-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 crate::event::Event;
-
-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 {
-                crate::event::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);
-                    }
-                }
-                crate::event::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);
-                    }
-                }
-                crate::event::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);
-                    }
-                }
-                crate::event::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);
-                    }
-                }
-                crate::event::PointerEvent::Frame {} => {}
-            },
-            Event::Keyboard(k) => match k {
-                crate::event::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);
-                    }
-                }
-                crate::event::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) {}
-}

src/emulation_test.rs

@@ -1,7 +1,6 @@
 use crate::config::Config;
-use crate::emulate;
-use crate::event::{Event, PointerEvent};
 use anyhow::Result;
+use input_event::{Event, PointerEvent};
 use std::f64::consts::PI;
 use std::time::{Duration, Instant};
 use tokio::task::LocalSet;
@@ -22,14 +21,13 @@ const FREQUENCY_HZ: f64 = 1.0;
 const RADIUS: f64 = 100.0;
 
 async fn input_emulation_test(config: Config) -> Result<()> {
-    let mut emulation = emulate::create(config.emulation_backend).await?;
+    let backend = config.emulation_backend.map(|b| b.into());
+    let mut emulation = input_emulation::create(backend).await?;
     emulation.create(0).await;
     let start = Instant::now();
     let mut offset = (0, 0);
     loop {
-        tokio::select! {
+        tokio::time::sleep(Duration::from_millis(1)).await;
-            _ = emulation.dispatch() => {}
-            _ = tokio::time::sleep(Duration::from_millis(1)) => {
         let elapsed = start.elapsed();
         let elapsed_sec_f64 = elapsed.as_secs_f64();
         let second_fraction = elapsed_sec_f64 - elapsed_sec_f64 as u64 as f64;
@@ -40,9 +38,12 @@ async fn input_emulation_test(config: Config) -> Result<()> {
             let relative_motion = (new_offset.0 - offset.0, new_offset.1 - offset.1);
             offset = new_offset;
             let (relative_x, relative_y) = (relative_motion.0 as f64, relative_motion.1 as f64);
-                    emulation.consume(Event::Pointer(PointerEvent::Motion {time: 0, relative_x, relative_y }), 0).await;
+            let event = Event::Pointer(PointerEvent::Motion {
-                }
+                time: 0,
-            }
+                relative_x,
+                relative_y,
+            });
+            emulation.consume(event, 0).await?;
         }
     }
 }

src/lib.rs

@@ -1,13 +1,8 @@
 pub mod client;
 pub mod config;
 pub mod dns;
-pub mod event;
 pub mod server;
 
-pub mod capture;
-pub mod emulate;
-
 pub mod capture_test;
 pub mod emulation_test;
 pub mod frontend;
-pub mod scancode;

src/server.rs

@@ -40,7 +40,7 @@ pub struct Server {
     client_manager: Rc<RefCell<ClientManager>>,
     port: Rc<Cell<u16>>,
     state: Rc<Cell<State>>,
-    release_bind: Vec<crate::scancode::Linux>,
+    release_bind: Vec<input_event::scancode::Linux>,
 }
 
 impl Server {

src/server/capture_task.rs

@@ -4,14 +4,11 @@ use std::{collections::HashSet, net::SocketAddr};
 
 use tokio::{process::Command, sync::mpsc::Sender, task::JoinHandle};
 
-use crate::{
+use input_capture::{self, error::CaptureCreationError, CaptureHandle, InputCapture, Position};
-    capture::{self, error::CaptureCreationError, CaptureHandle, InputCapture, Position},
+
-    client::ClientHandle,
+use input_event::{scancode, Event, KeyboardEvent};
-    config::CaptureBackend,
+
-    event::{Event, KeyboardEvent},
+use crate::{client::ClientHandle, config::CaptureBackend, server::State};
-    scancode,
-    server::State,
-};
 
 use super::Server;
 
@@ -35,8 +32,9 @@ pub fn new(
     release_bind: Vec<scancode::Linux>,
 ) -> Result<(JoinHandle<Result<()>>, Sender<CaptureEvent>), CaptureCreationError> {
     let (tx, mut rx) = tokio::sync::mpsc::channel(32);
+    let backend = backend.map(|b| b.into());
     let task = tokio::task::spawn_local(async move {
-        let mut capture = capture::create(backend).await?;
+        let mut capture = input_capture::create(backend).await?;
         let mut pressed_keys = HashSet::new();
         loop {
             tokio::select! {

src/server/emulation_task.rs

@@ -6,14 +6,13 @@ use tokio::{
     task::JoinHandle,
 };
 
-use crate::{
+use crate::{client::ClientHandle, config::EmulationBackend, server::State};
-    client::ClientHandle,
+use input_emulation::{
-    config::EmulationBackend,
+    self,
-    emulate::{self, error::EmulationCreationError, EmulationHandle, InputEmulation},
+    error::{EmulationCreationError, EmulationError},
-    event::{Event, KeyboardEvent},
+    EmulationHandle, InputEmulation,
-    scancode,
-    server::State,
 };
+use input_event::{Event, KeyboardEvent};
 
 use super::{CaptureEvent, Server};
 
@@ -39,29 +38,27 @@ pub fn new(
 ) -> Result<(JoinHandle<Result<()>>, Sender<EmulationEvent>), EmulationCreationError> {
     let (tx, mut rx) = tokio::sync::mpsc::channel(32);
     let emulate_task = tokio::task::spawn_local(async move {
-        let mut emulate = emulate::create(backend).await?;
+        let backend = backend.map(|b| b.into());
+        let mut emulate = input_emulation::create(backend).await?;
         let mut last_ignored = None;
 
         loop {
             tokio::select! {
                 udp_event = udp_rx.recv() => {
                     let udp_event = udp_event.ok_or(anyhow!("receiver closed"))??;
-                    handle_udp_rx(&server, &capture_tx, &mut emulate, &sender_tx, &mut last_ignored, udp_event, &timer_tx).await;
+                    handle_udp_rx(&server, &capture_tx, &mut emulate, &sender_tx, &mut last_ignored, udp_event, &timer_tx).await?;
                 }
                 emulate_event = rx.recv() => {
                     match emulate_event {
                         Some(e) => match e {
                             EmulationEvent::Create(h) => emulate.create(h).await,
                             EmulationEvent::Destroy(h) => emulate.destroy(h).await,
-                            EmulationEvent::ReleaseKeys(c) => release_keys(&server, &mut emulate, c).await,
+                            EmulationEvent::ReleaseKeys(c) => release_keys(&server, &mut emulate, c).await?,
                             EmulationEvent::Terminate => break,
                         },
                         None => break,
                     }
                 }
-                res = emulate.dispatch() => {
-                    res?;
-                }
             }
         }
 
@@ -73,7 +70,7 @@ pub fn new(
             .map(|(h, _)| h)
             .collect::<Vec<_>>();
         for client in clients {
-            release_keys(&server, &mut emulate, client).await;
+            release_keys(&server, &mut emulate, client).await?;
         }
 
         anyhow::Ok(())
@@ -89,7 +86,7 @@ async fn handle_udp_rx(
     last_ignored: &mut Option<SocketAddr>,
     event: (Event, SocketAddr),
     timer_tx: &Sender<()>,
-) {
+) -> Result<(), EmulationError> {
     let (event, addr) = event;
 
     // get handle for addr
@@ -100,7 +97,7 @@ async fn handle_udp_rx(
                 log::warn!("ignoring events from client {addr}");
                 last_ignored.replace(addr);
             }
-            return;
+            return Ok(());
         }
     };
 
@@ -114,7 +111,7 @@ async fn handle_udp_rx(
             Some((_, s)) => s,
             None => {
                 log::error!("unknown handle");
-                return;
+                return Ok(());
             }
         };
 
@@ -130,7 +127,7 @@ async fn handle_udp_rx(
             let _ = sender_tx.send((Event::Pong(), addr)).await;
         }
         (Event::Disconnect(), _) => {
-            release_keys(server, emulate, handle).await;
+            release_keys(server, emulate, handle).await?;
         }
         (event, addr) => {
             // tell clients that we are ready to receive events
@@ -163,7 +160,7 @@ async fn handle_udp_rx(
                             s
                         } else {
                             log::error!("unknown handle");
-                            return;
+                            return Ok(());
                         };
                         if state == 0 {
                             // ignore release event if key not pressed
@@ -178,7 +175,7 @@ async fn handle_udp_rx(
                     // workaround buggy rdp backend.
                     if !ignore_event {
                         // consume event
-                        emulate.consume(event, handle).await;
+                        emulate.consume(event, handle).await?;
                         log::trace!("{event} => emulate");
                     }
                 }
@@ -203,13 +200,14 @@ async fn handle_udp_rx(
             }
         }
     }
+    Ok(())
 }
 
 async fn release_keys(
     server: &Server,
     emulate: &mut Box<dyn InputEmulation>,
     client: ClientHandle,
-) {
+) -> Result<(), EmulationError> {
     let keys = server
         .client_manager
         .borrow_mut()
@@ -224,19 +222,18 @@ async fn release_keys(
             key,
             state: 0,
         });
-        emulate.consume(event, client).await;
+        emulate.consume(event, client).await?;
-        if let Ok(key) = scancode::Linux::try_from(key) {
+        if let Ok(key) = input_event::scancode::Linux::try_from(key) {
             log::warn!("releasing stuck key: {key:?}");
         }
     }
 
-    let modifiers_event = KeyboardEvent::Modifiers {
+    let event = Event::Keyboard(KeyboardEvent::Modifiers {
         mods_depressed: 0,
         mods_latched: 0,
         mods_locked: 0,
         group: 0,
-    };
+    });
-    emulate
+    emulate.consume(event, client).await?;
-        .consume(Event::Keyboard(modifiers_event), client)
+    Ok(())
-        .await;
 }

src/server/network_task.rs

@@ -7,7 +7,8 @@ use tokio::{
     task::JoinHandle,
 };
 
-use crate::{event::Event, frontend::FrontendEvent};
+use crate::frontend::FrontendEvent;
+use input_event::Event;
 
 use super::Server;
 

src/server/ping_task.rs

@@ -5,7 +5,9 @@ use tokio::{
     task::JoinHandle,
 };
 
-use crate::{client::ClientHandle, event::Event};
+use input_event::Event;
+
+use crate::client::ClientHandle;
 
 use super::{capture_task::CaptureEvent, emulation_task::EmulationEvent, Server, State};