fix transmuting to pointer types UB

Cargo.toml

@@ -1,10 +1,3 @@
-[workspace]
-members = [
-    "input-capture",
-    "input-emulation",
-    "input-event",
-]
-
 [package]
 name = "lan-mouse"
 description = "Software KVM Switch / mouse & keyboard sharing software for Local Area Networks"
@@ -13,16 +6,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]
-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 }
-
+tempfile = "3.8"
 hickory-resolver = "0.24.1"
+memmap = "0.7"
 toml = "0.8"
 serde = { version = "1.0", features = ["derive"] }
 anyhow = "1.0.71"
@@ -30,26 +23,53 @@ 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"
-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" ]
-wayland = [ "input-capture/wayland", "input-emulation/wayland" ]
-x11 = [ "input-capture/x11", "input-emulation/x11" ]
-xdg_desktop_portal = [ "input-emulation/xdg_desktop_portal" ]
-libei = [ "input-capture/libei", "input-emulation/libei" ]
+default = ["wayland", "x11", "xdg_desktop_portal", "libei", "gtk"]
+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"]
 gtk = ["dep:gtk", "dep:adw", "dep:async-channel", "dep:glib-build-tools"]

config.toml

@@ -1,7 +1,5 @@
 # example configuration
 
-# capture_backend = "LayerShell"
-
 # release bind
 release_bind = [ "KeyA", "KeyS", "KeyD", "KeyF" ]
 

input-capture/Cargo.toml

@@ -1,48 +0,0 @@
-[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" }
-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.31.0", features=["client", "staging", "unstable"], optional = true }
-wayland-protocols-wlr = { 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",
-] }
-
-[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/error.rs

@@ -1,142 +0,0 @@
-use std::fmt::Display;
-use thiserror::Error;
-
-#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-use std::io;
-#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-use wayland_client::{
-    backend::WaylandError,
-    globals::{BindError, GlobalError},
-    ConnectError, DispatchError,
-};
-
-#[derive(Debug, Error)]
-pub enum CaptureCreationError {
-    NoAvailableBackend,
-    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-    Libei(#[from] LibeiCaptureCreationError),
-    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-    LayerShell(#[from] LayerShellCaptureCreationError),
-    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-    X11(#[from] X11InputCaptureCreationError),
-    #[cfg(target_os = "macos")]
-    Macos(#[from] MacOSInputCaptureCreationError),
-    #[cfg(windows)]
-    Windows,
-}
-
-impl Display for CaptureCreationError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let reason = match self {
-            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-            CaptureCreationError::Libei(reason) => {
-                format!("error creating portal backend: {reason}")
-            }
-            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-            CaptureCreationError::LayerShell(reason) => {
-                format!("error creating layer-shell backend: {reason}")
-            }
-            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-            CaptureCreationError::X11(e) => format!("{e}"),
-            #[cfg(target_os = "macos")]
-            CaptureCreationError::Macos(e) => format!("{e}"),
-            #[cfg(windows)]
-            CaptureCreationError::Windows => String::new(),
-            CaptureCreationError::NoAvailableBackend => "no available backend".to_string(),
-        };
-        write!(f, "could not create input capture: {reason}")
-    }
-}
-
-#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-#[derive(Debug, Error)]
-pub enum LibeiCaptureCreationError {
-    Ashpd(#[from] ashpd::Error),
-}
-
-#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-impl Display for LibeiCaptureCreationError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            LibeiCaptureCreationError::Ashpd(portal_error) => write!(f, "{portal_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")))]
-#[derive(Debug, Error)]
-pub enum LayerShellCaptureCreationError {
-    Connect(#[from] ConnectError),
-    Global(#[from] GlobalError),
-    Wayland(#[from] WaylandError),
-    Bind(#[from] WaylandBindError),
-    Dispatch(#[from] DispatchError),
-    Io(#[from] io::Error),
-}
-
-#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-impl Display for LayerShellCaptureCreationError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            LayerShellCaptureCreationError::Bind(e) => write!(f, "{e}"),
-            LayerShellCaptureCreationError::Connect(e) => {
-                write!(f, "could not connect to wayland compositor: {e}")
-            }
-            LayerShellCaptureCreationError::Global(e) => write!(f, "wayland error: {e}"),
-            LayerShellCaptureCreationError::Wayland(e) => write!(f, "wayland error: {e}"),
-            LayerShellCaptureCreationError::Dispatch(e) => {
-                write!(f, "error dispatching wayland events: {e}")
-            }
-            LayerShellCaptureCreationError::Io(e) => write!(f, "io error: {e}"),
-        }
-    }
-}
-
-#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-#[derive(Debug, Error)]
-pub enum X11InputCaptureCreationError {
-    NotImplemented,
-}
-
-#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-impl Display for X11InputCaptureCreationError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "X11 input capture is not yet implemented :(")
-    }
-}
-#[cfg(target_os = "macos")]
-#[derive(Debug, Error)]
-pub enum MacOSInputCaptureCreationError {
-    NotImplemented,
-}
-
-#[cfg(target_os = "macos")]
-impl Display for MacOSInputCaptureCreationError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "macos input capture is not yet implemented :(")
-    }
-}

input-capture/src/lib.rs

@@ -1,159 +0,0 @@
-use std::{fmt::Display, io};
-
-use futures_core::Stream;
-
-use input_event::Event;
-
-use self::error::CaptureCreationError;
-
-pub mod error;
-
-#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-pub mod libei;
-
-#[cfg(target_os = "macos")]
-pub mod macos;
-
-#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-pub mod wayland;
-
-#[cfg(windows)]
-pub mod windows;
-
-#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-pub mod x11;
-
-/// fallback input capture (does not produce events)
-pub mod dummy;
-
-pub type CaptureHandle = u64;
-
-#[derive(Debug, Clone, Copy, Eq, Hash, PartialEq)]
-pub enum Position {
-    Left,
-    Right,
-    Top,
-    Bottom,
-}
-
-impl Position {
-    pub fn opposite(&self) -> Self {
-        match self {
-            Position::Left => Self::Right,
-            Position::Right => Self::Left,
-            Position::Top => Self::Bottom,
-            Position::Bottom => Self::Top,
-        }
-    }
-}
-
-impl Display for Position {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let pos = match self {
-            Position::Left => "left",
-            Position::Right => "right",
-            Position::Top => "top",
-            Position::Bottom => "bottom",
-        };
-        write!(f, "{}", pos)
-    }
-}
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum Backend {
-    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-    InputCapturePortal,
-    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-    LayerShell,
-    #[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 = "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<()>;
-
-    /// destroy the client with the given id, if it exists
-    fn destroy(&mut self, id: CaptureHandle) -> io::Result<()>;
-
-    /// release mouse
-    fn release(&mut self) -> io::Result<()>;
-}
-
-pub async fn create_backend(
-    backend: Backend,
-) -> Result<Box<dyn InputCapture<Item = io::Result<(CaptureHandle, Event)>>>, CaptureCreationError>
-{
-    match backend {
-        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-        Backend::InputCapturePortal => Ok(Box::new(libei::LibeiInputCapture::new().await?)),
-        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-        Backend::LayerShell => Ok(Box::new(wayland::WaylandInputCapture::new()?)),
-        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-        Backend::X11 => Ok(Box::new(x11::X11InputCapture::new()?)),
-        #[cfg(windows)]
-        Backend::Windows => Ok(Box::new(windows::WindowsInputCapture::new())),
-        #[cfg(target_os = "macos")]
-        Backend::MacOs => Ok(Box::new(macos::MacOSInputCapture::new()?)),
-        Backend::Dummy => Ok(Box::new(dummy::DummyInputCapture::new())),
-    }
-}
-
-pub async fn create(
-    backend: Option<Backend>,
-) -> Result<Box<dyn InputCapture<Item = io::Result<(CaptureHandle, Event)>>>, CaptureCreationError>
-{
-    if let Some(backend) = backend {
-        let b = create_backend(backend).await;
-        if b.is_ok() {
-            log::info!("using capture backend: {backend}");
-        }
-        return b;
-    }
-
-    for backend in [
-        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-        Backend::InputCapturePortal,
-        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-        Backend::LayerShell,
-        #[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 capture backend: {backend}");
-                return Ok(b);
-            }
-            Err(e) => log::warn!("{backend} input capture backend unavailable: {e}"),
-        }
-    }
-    Err(CaptureCreationError::NoAvailableBackend)
-}

input-capture/src/macos.rs

@@ -1,35 +0,0 @@
-use crate::{error::MacOSInputCaptureCreationError, CaptureHandle, InputCapture, Position};
-use futures_core::Stream;
-use input_event::Event;
-use std::task::{Context, Poll};
-use std::{io, pin::Pin};
-
-pub struct MacOSInputCapture;
-
-impl MacOSInputCapture {
-    pub fn new() -> std::result::Result<Self, MacOSInputCaptureCreationError> {
-        Err(MacOSInputCaptureCreationError::NotImplemented)
-    }
-}
-
-impl Stream for MacOSInputCapture {
-    type Item = io::Result<(CaptureHandle, Event)>;
-
-    fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        Poll::Pending
-    }
-}
-
-impl InputCapture for MacOSInputCapture {
-    fn create(&mut self, _id: CaptureHandle, _pos: Position) -> io::Result<()> {
-        Ok(())
-    }
-
-    fn destroy(&mut self, _id: CaptureHandle) -> io::Result<()> {
-        Ok(())
-    }
-
-    fn release(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}

input-capture/src/x11.rs

@@ -1,43 +0,0 @@
-use std::io;
-use std::task::Poll;
-
-use futures_core::Stream;
-
-use super::InputCapture;
-use input_event::Event;
-
-use super::error::X11InputCaptureCreationError;
-use super::{CaptureHandle, Position};
-
-pub struct X11InputCapture {}
-
-impl X11InputCapture {
-    pub fn new() -> std::result::Result<Self, X11InputCaptureCreationError> {
-        Err(X11InputCaptureCreationError::NotImplemented)
-    }
-}
-
-impl InputCapture for X11InputCapture {
-    fn create(&mut self, _id: CaptureHandle, _pos: Position) -> io::Result<()> {
-        Ok(())
-    }
-
-    fn destroy(&mut self, _id: CaptureHandle) -> io::Result<()> {
-        Ok(())
-    }
-
-    fn release(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-impl Stream for X11InputCapture {
-    type Item = io::Result<(CaptureHandle, Event)>;
-
-    fn poll_next(
-        self: std::pin::Pin<&mut Self>,
-        _cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Option<Self::Item>> {
-        Poll::Pending
-    }
-}

input-emulation/Cargo.toml

@@ -1,47 +0,0 @@
-[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

@@ -1,22 +0,0 @@
-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

@@ -1,168 +0,0 @@
-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

@@ -1,141 +0,0 @@
-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 = "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-event/Cargo.toml

@@ -1,14 +0,0 @@
-[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"] }

src/capture.rs

@@ -0,0 +1,78 @@
+use std::io;
+
+use futures_core::Stream;
+
+use crate::{
+    client::{ClientEvent, ClientHandle},
+    event::Event,
+};
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+pub mod libei;
+
+#[cfg(target_os = "macos")]
+pub mod macos;
+
+#[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+pub mod wayland;
+
+#[cfg(windows)]
+pub mod windows;
+
+#[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+pub mod x11;
+
+/// fallback input capture (does not produce events)
+pub mod dummy;
+
+pub async fn create() -> Box<dyn InputCapture<Item = io::Result<(ClientHandle, Event)>>> {
+    #[cfg(target_os = "macos")]
+    match macos::MacOSInputCapture::new() {
+        Ok(p) => return Box::new(p),
+        Err(e) => log::info!("macos input capture not available: {e}"),
+    }
+
+    #[cfg(windows)]
+    match windows::WindowsInputCapture::new() {
+        Ok(p) => return Box::new(p),
+        Err(e) => log::info!("windows input capture not available: {e}"),
+    }
+
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    match libei::LibeiInputCapture::new().await {
+        Ok(p) => {
+            log::info!("using libei input capture");
+            return Box::new(p);
+        }
+        Err(e) => log::info!("libei input capture not available: {e}"),
+    }
+
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    match wayland::WaylandInputCapture::new() {
+        Ok(p) => {
+            log::info!("using layer-shell input capture");
+            return Box::new(p);
+        }
+        Err(e) => log::info!("layer_shell input capture not available: {e}"),
+    }
+
+    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+    match x11::X11InputCapture::new() {
+        Ok(p) => {
+            log::info!("using x11 input capture");
+            return Box::new(p);
+        }
+        Err(e) => log::info!("x11 input capture not available: {e}"),
+    }
+
+    log::error!("falling back to dummy input capture");
+    Box::new(dummy::DummyInputCapture::new())
+}
+
+pub trait InputCapture: Stream<Item = io::Result<(ClientHandle, Event)>> + Unpin {
+    /// notify input capture of configuration changes
+    fn notify(&mut self, event: ClientEvent) -> io::Result<()>;
+
+    /// release mouse
+    fn release(&mut self) -> io::Result<()>;
+}

src/capture/dummy.rs

@@ -4,9 +4,10 @@ use std::task::{Context, Poll};
 
 use futures_core::Stream;
 
-use input_event::Event;
+use crate::capture::InputCapture;
+use crate::event::Event;
 
-use super::{CaptureHandle, InputCapture, Position};
+use crate::client::{ClientEvent, ClientHandle};
 
 pub struct DummyInputCapture {}
 
@@ -23,11 +24,7 @@ impl Default for DummyInputCapture {
 }
 
 impl InputCapture for DummyInputCapture {
-    fn create(&mut self, _handle: CaptureHandle, _pos: Position) -> io::Result<()> {
-        Ok(())
-    }
-
-    fn destroy(&mut self, _handle: CaptureHandle) -> io::Result<()> {
+    fn notify(&mut self, _event: ClientEvent) -> io::Result<()> {
         Ok(())
     }
 
@@ -37,7 +34,7 @@ impl InputCapture for DummyInputCapture {
 }
 
 impl Stream for DummyInputCapture {
-    type Item = io::Result<(CaptureHandle, Event)>;
+    type Item = io::Result<(ClientHandle, Event)>;
 
     fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         Poll::Pending

src/capture/libei.rs

@@ -30,24 +30,23 @@ use tokio::{
 use futures_core::Stream;
 use once_cell::sync::Lazy;
 
-use input_event::{Event, KeyboardEvent, PointerEvent};
-
-use super::{
-    error::LibeiCaptureCreationError, CaptureHandle, InputCapture as LanMouseInputCapture, Position,
+use crate::{
+    capture::InputCapture as LanMouseInputCapture,
+    client::{ClientEvent, ClientHandle, Position},
+    event::{Event, KeyboardEvent, PointerEvent},
 };
 
 #[derive(Debug)]
 enum ProducerEvent {
     Release,
-    Create(CaptureHandle, Position),
-    Destroy(CaptureHandle),
+    ClientEvent(ClientEvent),
 }
 
 #[allow(dead_code)]
 pub struct LibeiInputCapture<'a> {
     input_capture: Pin<Box<InputCapture<'a>>>,
     libei_task: JoinHandle<Result<()>>,
-    event_rx: tokio::sync::mpsc::Receiver<(CaptureHandle, Event)>,
+    event_rx: tokio::sync::mpsc::Receiver<(ClientHandle, Event)>,
     notify_tx: tokio::sync::mpsc::Sender<ProducerEvent>,
 }
 
@@ -80,9 +79,9 @@ fn pos_to_barrier(r: &Region, pos: Position) -> (i32, i32, i32, i32) {
 
 fn select_barriers(
     zones: &Zones,
-    clients: &Vec<(CaptureHandle, Position)>,
+    clients: &Vec<(ClientHandle, Position)>,
     next_barrier_id: &mut u32,
-) -> (Vec<Barrier>, HashMap<BarrierID, CaptureHandle>) {
+) -> (Vec<Barrier>, HashMap<BarrierID, ClientHandle>) {
     let mut client_for_barrier = HashMap::new();
     let mut barriers: Vec<Barrier> = vec![];
 
@@ -106,9 +105,9 @@ fn select_barriers(
 async fn update_barriers(
     input_capture: &InputCapture<'_>,
     session: &Session<'_>,
-    active_clients: &Vec<(CaptureHandle, Position)>,
+    active_clients: &Vec<(ClientHandle, Position)>,
     next_barrier_id: &mut u32,
-) -> Result<HashMap<BarrierID, CaptureHandle>> {
+) -> Result<HashMap<BarrierID, ClientHandle>> {
     let zones = input_capture.zones(session).await?.response()?;
     log::debug!("zones: {zones:?}");
 
@@ -132,7 +131,7 @@ impl<'a> Drop for LibeiInputCapture<'a> {
 
 async fn create_session<'a>(
     input_capture: &'a InputCapture<'a>,
-) -> std::result::Result<(Session<'a>, BitFlags<Capabilities>), ashpd::Error> {
+) -> Result<(Session<'a>, BitFlags<Capabilities>)> {
     log::debug!("creating input capture session");
     let (session, capabilities) = loop {
         match input_capture
@@ -184,8 +183,8 @@ async fn connect_to_eis(
 async fn libei_event_handler(
     mut ei_event_stream: EiConvertEventStream,
     context: ei::Context,
-    event_tx: Sender<(CaptureHandle, Event)>,
-    current_client: Rc<Cell<Option<CaptureHandle>>>,
+    event_tx: Sender<(ClientHandle, Event)>,
+    current_client: Rc<Cell<Option<ClientHandle>>>,
 ) -> Result<()> {
     loop {
         let ei_event = match ei_event_stream.next().await {
@@ -201,12 +200,12 @@ async fn libei_event_handler(
 
 async fn wait_for_active_client(
     notify_rx: &mut Receiver<ProducerEvent>,
-    active_clients: &mut Vec<(CaptureHandle, Position)>,
+    active_clients: &mut Vec<(ClientHandle, Position)>,
 ) -> Result<()> {
     // wait for a client update
     while let Some(producer_event) = notify_rx.recv().await {
-        if let ProducerEvent::Create(c, p) = producer_event {
-            handle_producer_event(ProducerEvent::Create(c, p), active_clients)?;
+        if let ProducerEvent::ClientEvent(c) = producer_event {
+            handle_producer_event(ProducerEvent::ClientEvent(c), active_clients)?;
             break;
         }
     }
@@ -214,7 +213,7 @@ async fn wait_for_active_client(
 }
 
 impl<'a> LibeiInputCapture<'a> {
-    pub async fn new() -> std::result::Result<Self, LibeiCaptureCreationError> {
+    pub async fn new() -> Result<Self> {
         let input_capture = Box::pin(InputCapture::new().await?);
         let input_capture_ptr = input_capture.as_ref().get_ref() as *const InputCapture<'static>;
         let mut first_session = Some(create_session(unsafe { &*input_capture_ptr }).await?);
@@ -225,7 +224,7 @@ impl<'a> LibeiInputCapture<'a> {
             /* safety: libei_task does not outlive Self */
             let input_capture = unsafe { &*input_capture_ptr };
 
-            let mut active_clients: Vec<(CaptureHandle, Position)> = vec![];
+            let mut active_clients: Vec<(ClientHandle, Position)> = vec![];
             let mut next_barrier_id = 1u32;
 
             /* there is a bug in xdg-remote-desktop-portal-gnome / mutter that
@@ -348,8 +347,8 @@ async fn release_capture(
     input_capture: &InputCapture<'_>,
     session: &Session<'_>,
     activated: Activated,
-    current_client: CaptureHandle,
-    active_clients: &[(CaptureHandle, Position)],
+    current_client: ClientHandle,
+    active_clients: &[(ClientHandle, Position)],
 ) -> Result<()> {
     log::debug!("releasing input capture {}", activated.activation_id());
     let (x, y) = activated.cursor_position();
@@ -376,16 +375,16 @@ async fn release_capture(
 
 fn handle_producer_event(
     producer_event: ProducerEvent,
-    active_clients: &mut Vec<(CaptureHandle, Position)>,
+    active_clients: &mut Vec<(ClientHandle, Position)>,
 ) -> Result<bool> {
     log::debug!("handling event: {producer_event:?}");
     let updated = match producer_event {
         ProducerEvent::Release => false,
-        ProducerEvent::Create(c, p) => {
+        ProducerEvent::ClientEvent(ClientEvent::Create(c, p)) => {
             active_clients.push((c, p));
             true
         }
-        ProducerEvent::Destroy(c) => {
+        ProducerEvent::ClientEvent(ClientEvent::Destroy(c)) => {
             active_clients.retain(|(h, _)| *h != c);
             true
         }
@@ -395,9 +394,9 @@ fn handle_producer_event(
 
 async fn handle_ei_event(
     ei_event: EiEvent,
-    current_client: Option<CaptureHandle>,
+    current_client: Option<ClientHandle>,
     context: &ei::Context,
-    event_tx: &Sender<(CaptureHandle, Event)>,
+    event_tx: &Sender<(ClientHandle, Event)>,
 ) {
     match ei_event {
         EiEvent::SeatAdded(s) => {
@@ -546,18 +545,12 @@ async fn handle_ei_event(
 }
 
 impl<'a> LanMouseInputCapture for LibeiInputCapture<'a> {
-    fn create(&mut self, handle: super::CaptureHandle, pos: super::Position) -> io::Result<()> {
+    fn notify(&mut self, event: ClientEvent) -> io::Result<()> {
         let notify_tx = self.notify_tx.clone();
         tokio::task::spawn_local(async move {
-            let _ = notify_tx.send(ProducerEvent::Create(handle, pos)).await;
-        });
-        Ok(())
-    }
-
-    fn destroy(&mut self, handle: super::CaptureHandle) -> io::Result<()> {
-        let notify_tx = self.notify_tx.clone();
-        tokio::task::spawn_local(async move {
-            let _ = notify_tx.send(ProducerEvent::Destroy(handle)).await;
+            log::debug!("notifying {event:?}");
+            let _ = notify_tx.send(ProducerEvent::ClientEvent(event)).await;
+            log::debug!("done !");
         });
         Ok(())
     }
@@ -565,6 +558,7 @@ impl<'a> LanMouseInputCapture for LibeiInputCapture<'a> {
     fn release(&mut self) -> io::Result<()> {
         let notify_tx = self.notify_tx.clone();
         tokio::task::spawn_local(async move {
+            log::debug!("notifying Release");
             let _ = notify_tx.send(ProducerEvent::Release).await;
         });
         Ok(())
@@ -572,7 +566,7 @@ impl<'a> LanMouseInputCapture for LibeiInputCapture<'a> {
 }
 
 impl<'a> Stream for LibeiInputCapture<'a> {
-    type Item = io::Result<(CaptureHandle, Event)>;
+    type Item = io::Result<(ClientHandle, Event)>;
 
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         match ready!(self.event_rx.poll_recv(cx)) {

src/capture/macos.rs

@@ -0,0 +1,33 @@
+use crate::capture::InputCapture;
+use crate::client::{ClientEvent, ClientHandle};
+use crate::event::Event;
+use anyhow::{anyhow, Result};
+use futures_core::Stream;
+use std::task::{Context, Poll};
+use std::{io, pin::Pin};
+
+pub struct MacOSInputCapture;
+
+impl MacOSInputCapture {
+    pub fn new() -> Result<Self> {
+        Err(anyhow!("not yet implemented"))
+    }
+}
+
+impl Stream for MacOSInputCapture {
+    type Item = io::Result<(ClientHandle, Event)>;
+
+    fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        Poll::Pending
+    }
+}
+
+impl InputCapture for MacOSInputCapture {
+    fn notify(&mut self, _event: ClientEvent) -> io::Result<()> {
+        Ok(())
+    }
+
+    fn release(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}

src/capture/wayland.rs

@@ -1,3 +1,9 @@
+use crate::{
+    capture::InputCapture,
+    client::{ClientEvent, ClientHandle, Position},
+};
+
+use anyhow::{anyhow, Result};
 use futures_core::Stream;
 use memmap::MmapOptions;
 use std::{
@@ -60,12 +66,7 @@ use wayland_client::{
 
 use tempfile;
 
-use input_event::{Event, KeyboardEvent, PointerEvent};
-
-use super::{
-    error::{LayerShellCaptureCreationError, WaylandBindError},
-    CaptureHandle, InputCapture, Position,
-};
+use crate::event::{Event, KeyboardEvent, PointerEvent};
 
 struct Globals {
     compositor: wl_compositor::WlCompositor,
@@ -102,13 +103,13 @@ struct State {
     pointer_lock: Option<ZwpLockedPointerV1>,
     rel_pointer: Option<ZwpRelativePointerV1>,
     shortcut_inhibitor: Option<ZwpKeyboardShortcutsInhibitorV1>,
-    client_for_window: Vec<(Rc<Window>, CaptureHandle)>,
-    focused: Option<(Rc<Window>, CaptureHandle)>,
+    client_for_window: Vec<(Rc<Window>, ClientHandle)>,
+    focused: Option<(Rc<Window>, ClientHandle)>,
     g: Globals,
     wayland_fd: OwnedFd,
     read_guard: Option<ReadEventsGuard>,
     qh: QueueHandle<Self>,
-    pending_events: VecDeque<(CaptureHandle, Event)>,
+    pending_events: VecDeque<(ClientHandle, Event)>,
     output_info: Vec<(WlOutput, OutputInfo)>,
     scroll_discrete_pending: bool,
 }
@@ -257,37 +258,64 @@ fn draw(f: &mut File, (width, height): (u32, u32)) {
 }
 
 impl WaylandInputCapture {
-    pub fn new() -> std::result::Result<Self, LayerShellCaptureCreationError> {
-        let conn = Connection::connect_to_env()?;
-        let (g, mut queue) = registry_queue_init::<State>(&conn)?;
+    pub fn new() -> Result<Self> {
+        let conn = match Connection::connect_to_env() {
+            Ok(c) => c,
+            Err(e) => return Err(anyhow!("could not connect to wayland compositor: {e:?}")),
+        };
+
+        let (g, mut queue) = match registry_queue_init::<State>(&conn) {
+            Ok(q) => q,
+            Err(e) => return Err(anyhow!("failed to initialize wl_registry: {e:?}")),
+        };
 
         let qh = queue.handle();
 
-        let compositor: wl_compositor::WlCompositor = g
-            .bind(&qh, 4..=5, ())
-            .map_err(|e| WaylandBindError::new(e, "wl_compositor 4..=5"))?;
-        let xdg_output_manager: ZxdgOutputManagerV1 = g
-            .bind(&qh, 1..=3, ())
-            .map_err(|e| WaylandBindError::new(e, "xdg_output_manager 1..=3"))?;
-        let shm: wl_shm::WlShm = g
-            .bind(&qh, 1..=1, ())
-            .map_err(|e| WaylandBindError::new(e, "wl_shm"))?;
-        let layer_shell: ZwlrLayerShellV1 = g
-            .bind(&qh, 3..=4, ())
-            .map_err(|e| WaylandBindError::new(e, "wlr_layer_shell 3..=4"))?;
-        let seat: wl_seat::WlSeat = g
-            .bind(&qh, 7..=8, ())
-            .map_err(|e| WaylandBindError::new(e, "wl_seat 7..=8"))?;
+        let compositor: wl_compositor::WlCompositor = match g.bind(&qh, 4..=5, ()) {
+            Ok(compositor) => compositor,
+            Err(_) => return Err(anyhow!("wl_compositor >= v4 not supported")),
+        };
+
+        let xdg_output_manager: ZxdgOutputManagerV1 = match g.bind(&qh, 1..=3, ()) {
+            Ok(xdg_output_manager) => xdg_output_manager,
+            Err(_) => return Err(anyhow!("xdg_output not supported!")),
+        };
+
+        let shm: wl_shm::WlShm = match g.bind(&qh, 1..=1, ()) {
+            Ok(wl_shm) => wl_shm,
+            Err(_) => return Err(anyhow!("wl_shm v1 not supported")),
+        };
+
+        let layer_shell: ZwlrLayerShellV1 = match g.bind(&qh, 3..=4, ()) {
+            Ok(layer_shell) => layer_shell,
+            Err(_) => return Err(anyhow!("zwlr_layer_shell_v1 >= v3 not supported - required to display a surface at the edge of the screen")),
+        };
+
+        let seat: wl_seat::WlSeat = match g.bind(&qh, 7..=8, ()) {
+            Ok(wl_seat) => wl_seat,
+            Err(_) => return Err(anyhow!("wl_seat >= v7 not supported")),
+        };
+
+        let pointer_constraints: ZwpPointerConstraintsV1 = match g.bind(&qh, 1..=1, ()) {
+            Ok(pointer_constraints) => pointer_constraints,
+            Err(_) => return Err(anyhow!("zwp_pointer_constraints_v1 not supported")),
+        };
+
+        let relative_pointer_manager: ZwpRelativePointerManagerV1 = match g.bind(&qh, 1..=1, ()) {
+            Ok(relative_pointer_manager) => relative_pointer_manager,
+            Err(_) => return Err(anyhow!("zwp_relative_pointer_manager_v1 not supported")),
+        };
+
+        let shortcut_inhibit_manager: ZwpKeyboardShortcutsInhibitManagerV1 =
+            match g.bind(&qh, 1..=1, ()) {
+                Ok(shortcut_inhibit_manager) => shortcut_inhibit_manager,
+                Err(_) => {
+                    return Err(anyhow!(
+                        "zwp_keyboard_shortcuts_inhibit_manager_v1 not supported"
+                    ))
+                }
+            };
 
-        let pointer_constraints: ZwpPointerConstraintsV1 = g
-            .bind(&qh, 1..=1, ())
-            .map_err(|e| WaylandBindError::new(e, "zwp_pointer_constraints_v1"))?;
-        let relative_pointer_manager: ZwpRelativePointerManagerV1 = g
-            .bind(&qh, 1..=1, ())
-            .map_err(|e| WaylandBindError::new(e, "zwp_relative_pointer_manager_v1"))?;
-        let shortcut_inhibit_manager: ZwpKeyboardShortcutsInhibitManagerV1 = g
-            .bind(&qh, 1..=1, ())
-            .map_err(|e| WaylandBindError::new(e, "zwp_keyboard_shortcuts_inhibit_manager_v1"))?;
         let outputs = vec![];
 
         let g = Globals {
@@ -367,11 +395,11 @@ impl WaylandInputCapture {
         Ok(WaylandInputCapture(inner))
     }
 
-    fn add_client(&mut self, handle: CaptureHandle, pos: Position) {
+    fn add_client(&mut self, handle: ClientHandle, pos: Position) {
         self.0.get_mut().state.add_client(handle, pos);
     }
 
-    fn delete_client(&mut self, handle: CaptureHandle) {
+    fn delete_client(&mut self, handle: ClientHandle) {
         let inner = self.0.get_mut();
         // remove all windows corresponding to this client
         while let Some(i) = inner
@@ -469,7 +497,7 @@ impl State {
         }
     }
 
-    fn add_client(&mut self, client: CaptureHandle, pos: Position) {
+    fn add_client(&mut self, client: ClientHandle, pos: Position) {
         let outputs = get_output_configuration(self, pos);
 
         log::debug!("outputs: {outputs:?}");
@@ -562,13 +590,15 @@ impl Inner {
 }
 
 impl InputCapture for WaylandInputCapture {
-    fn create(&mut self, handle: CaptureHandle, pos: Position) -> io::Result<()> {
-        self.add_client(handle, pos);
-        let inner = self.0.get_mut();
-        inner.flush_events()
-    }
-    fn destroy(&mut self, handle: CaptureHandle) -> io::Result<()> {
-        self.delete_client(handle);
+    fn notify(&mut self, client_event: ClientEvent) -> io::Result<()> {
+        match client_event {
+            ClientEvent::Create(handle, pos) => {
+                self.add_client(handle, pos);
+            }
+            ClientEvent::Destroy(handle) => {
+                self.delete_client(handle);
+            }
+        }
         let inner = self.0.get_mut();
         inner.flush_events()
     }
@@ -582,7 +612,7 @@ impl InputCapture for WaylandInputCapture {
 }
 
 impl Stream for WaylandInputCapture {
-    type Item = io::Result<(CaptureHandle, Event)>;
+    type Item = io::Result<(ClientHandle, Event)>;
 
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         if let Some(event) = self.0.get_mut().state.pending_events.pop_front() {

src/capture/windows.rs

@@ -9,7 +9,7 @@ use std::ptr::{addr_of, addr_of_mut};
 use futures::executor::block_on;
 use std::default::Default;
 use std::sync::atomic::{AtomicU32, Ordering};
-use std::sync::{mpsc, Mutex};
+use std::sync::mpsc;
 use std::task::ready;
 use std::{io, pin::Pin, thread};
 use tokio::sync::mpsc::{channel, Receiver, Sender};
@@ -32,25 +32,25 @@ use windows::Win32::UI::WindowsAndMessaging::{
     WNDPROC,
 };
 
-use input_event::{
-    scancode::{self, Linux},
-    Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT,
+use crate::client::Position;
+use crate::event::{
+    KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT,
+};
+use crate::scancode::Linux;
+use crate::{
+    capture::InputCapture,
+    client::{ClientEvent, ClientHandle},
+    event::Event,
+    scancode,
 };
 
-use super::{CaptureHandle, InputCapture, Position};
-
-enum Request {
-    Create(CaptureHandle, Position),
-    Destroy(CaptureHandle),
-}
-
 pub struct WindowsInputCapture {
-    event_rx: Receiver<(CaptureHandle, Event)>,
+    event_rx: Receiver<(ClientHandle, Event)>,
     msg_thread: Option<std::thread::JoinHandle<()>>,
 }
 
 enum EventType {
-    Request = 0,
+    ClientEvent = 0,
     Release = 1,
     Exit = 2,
 }
@@ -59,28 +59,15 @@ unsafe fn signal_message_thread(event_type: EventType) {
     if let Some(event_tid) = get_event_tid() {
         PostThreadMessageW(event_tid, WM_USER, WPARAM(event_type as usize), LPARAM(0)).unwrap();
     } else {
-        panic!();
+        log::warn!("lost event");
     }
 }
 
 impl InputCapture for WindowsInputCapture {
-    fn create(&mut self, handle: CaptureHandle, pos: Position) -> io::Result<()> {
+    fn notify(&mut self, event: ClientEvent) -> io::Result<()> {
         unsafe {
-            {
-                let mut requests = REQUEST_BUFFER.lock().unwrap();
-                requests.push(Request::Create(handle, pos));
-            }
-            signal_message_thread(EventType::Request);
-        }
-        Ok(())
-    }
-    fn destroy(&mut self, handle: CaptureHandle) -> io::Result<()> {
-        unsafe {
-            {
-                let mut requests = REQUEST_BUFFER.lock().unwrap();
-                requests.push(Request::Destroy(handle));
-            }
-            signal_message_thread(EventType::Request);
+            EVENT_BUFFER.push(event);
+            signal_message_thread(EventType::ClientEvent);
         }
         Ok(())
     }
@@ -91,10 +78,10 @@ impl InputCapture for WindowsInputCapture {
     }
 }
 
-static mut REQUEST_BUFFER: Mutex<Vec<Request>> = Mutex::new(Vec::new());
-static mut ACTIVE_CLIENT: Option<CaptureHandle> = None;
-static mut CLIENT_FOR_POS: Lazy<HashMap<Position, CaptureHandle>> = Lazy::new(HashMap::new);
-static mut EVENT_TX: Option<Sender<(CaptureHandle, Event)>> = None;
+static mut EVENT_BUFFER: Vec<ClientEvent> = Vec::new();
+static mut ACTIVE_CLIENT: Option<ClientHandle> = None;
+static mut CLIENT_FOR_POS: Lazy<HashMap<Position, ClientHandle>> = Lazy::new(HashMap::new);
+static mut EVENT_TX: Option<Sender<(ClientHandle, Event)>> = None;
 static mut EVENT_THREAD_ID: AtomicU32 = AtomicU32::new(0);
 unsafe fn set_event_tid(tid: u32) {
     EVENT_THREAD_ID.store(tid, Ordering::SeqCst);
@@ -369,6 +356,7 @@ fn enumerate_displays() -> Vec<RECT> {
                 break;
             }
             if device.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP != 0 {
+                log::info!("{:?}", device.DeviceName);
                 devices.push(device.DeviceName);
             }
         }
@@ -547,18 +535,9 @@ fn message_thread(ready_tx: mpsc::Sender<()>) {
                     x if x == EventType::Release as usize => {
                         ACTIVE_CLIENT.take();
                     }
-                    x if x == EventType::Request as usize => {
-                        let requests = {
-                            let mut res = vec![];
-                            let mut requests = REQUEST_BUFFER.lock().unwrap();
-                            for request in requests.drain(..) {
-                                res.push(request);
-                            }
-                            res
-                        };
-
-                        for request in requests {
-                            update_clients(request)
+                    x if x == EventType::ClientEvent as usize => {
+                        while let Some(event) = EVENT_BUFFER.pop() {
+                            update_clients(event)
                         }
                     }
                     _ => {}
@@ -572,12 +551,12 @@ fn message_thread(ready_tx: mpsc::Sender<()>) {
     }
 }
 
-fn update_clients(request: Request) {
-    match request {
-        Request::Create(handle, pos) => {
+fn update_clients(client_event: ClientEvent) {
+    match client_event {
+        ClientEvent::Create(handle, pos) => {
             unsafe { CLIENT_FOR_POS.insert(pos, handle) };
         }
-        Request::Destroy(handle) => unsafe {
+        ClientEvent::Destroy(handle) => unsafe {
             for pos in [
                 Position::Left,
                 Position::Right,
@@ -596,7 +575,7 @@ fn update_clients(request: Request) {
 }
 
 impl WindowsInputCapture {
-    pub(crate) fn new() -> Self {
+    pub(crate) fn new() -> Result<Self> {
         unsafe {
             let (tx, rx) = channel(10);
             EVENT_TX.replace(tx);
@@ -604,16 +583,16 @@ impl WindowsInputCapture {
             let msg_thread = Some(thread::spawn(|| message_thread(ready_tx)));
             /* wait for thread to set its id */
             ready_rx.recv().expect("channel closed");
-            Self {
+            Ok(Self {
                 msg_thread,
                 event_rx: rx,
-            }
+            })
         }
     }
 }
 
 impl Stream for WindowsInputCapture {
-    type Item = io::Result<(CaptureHandle, Event)>;
+    type Item = io::Result<(ClientHandle, Event)>;
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         match ready!(self.event_rx.poll_recv(cx)) {
             None => Poll::Ready(None),

src/capture/x11.rs

@@ -0,0 +1,39 @@
+use anyhow::{anyhow, Result};
+use std::io;
+use std::task::Poll;
+
+use futures_core::Stream;
+
+use crate::capture::InputCapture;
+use crate::event::Event;
+
+use crate::client::{ClientEvent, ClientHandle};
+
+pub struct X11InputCapture {}
+
+impl X11InputCapture {
+    pub fn new() -> Result<Self> {
+        Err(anyhow!("not implemented"))
+    }
+}
+
+impl InputCapture for X11InputCapture {
+    fn notify(&mut self, _event: ClientEvent) -> io::Result<()> {
+        Ok(())
+    }
+
+    fn release(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+impl Stream for X11InputCapture {
+    type Item = io::Result<(ClientHandle, Event)>;
+
+    fn poll_next(
+        self: std::pin::Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Option<Self::Item>> {
+        Poll::Pending
+    }
+}

src/capture_test.rs

@@ -1,8 +1,8 @@
-use crate::config::Config;
+use crate::capture;
+use crate::client::{ClientEvent, Position};
+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<()> {
@@ -12,20 +12,17 @@ pub fn run() -> Result<()> {
         .enable_time()
         .build()?;
 
-    let config = Config::new()?;
-
-    runtime.block_on(LocalSet::new().run_until(input_capture_test(config)))
+    runtime.block_on(LocalSet::new().run_until(input_capture_test()))
 }
 
-async fn input_capture_test(config: Config) -> Result<()> {
+async fn input_capture_test() -> Result<()> {
     log::info!("creating input capture");
-    let backend = config.capture_backend.map(|b| b.into());
-    let mut input_capture = input_capture::create(backend).await?;
+    let mut input_capture = capture::create().await;
     log::info!("creating clients");
-    input_capture.create(0, Position::Left)?;
-    input_capture.create(1, Position::Right)?;
-    input_capture.create(2, Position::Top)?;
-    input_capture.create(3, Position::Bottom)?;
+    input_capture.notify(ClientEvent::Create(0, Position::Left))?;
+    input_capture.notify(ClientEvent::Create(1, Position::Right))?;
+    input_capture.notify(ClientEvent::Create(2, Position::Top))?;
+    input_capture.notify(ClientEvent::Create(3, Position::Bottom))?;
     loop {
         let (client, event) = input_capture
             .next()

src/client.rs

@@ -10,7 +10,6 @@ use serde::{Deserialize, Serialize};
 use slab::Slab;
 
 use crate::config::DEFAULT_PORT;
-use input_capture;
 
 #[derive(Debug, Eq, Hash, PartialEq, Clone, Copy, Serialize, Deserialize)]
 pub enum Position {
@@ -26,17 +25,6 @@ impl Default for Position {
     }
 }
 
-impl From<Position> for input_capture::Position {
-    fn from(position: Position) -> input_capture::Position {
-        match position {
-            Position::Left => input_capture::Position::Left,
-            Position::Right => input_capture::Position::Right,
-            Position::Top => input_capture::Position::Top,
-            Position::Bottom => input_capture::Position::Bottom,
-        }
-    }
-}
-
 #[derive(Debug)]
 pub struct PositionParseError {
     string: String,
@@ -64,6 +52,17 @@ impl FromStr for Position {
     }
 }
 
+impl Position {
+    pub fn opposite(&self) -> Self {
+        match self {
+            Position::Left => Self::Right,
+            Position::Right => Self::Left,
+            Position::Top => Self::Bottom,
+            Position::Bottom => Self::Top,
+        }
+    }
+}
+
 impl Display for Position {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
@@ -119,6 +118,12 @@ impl Default for ClientConfig {
     }
 }
 
+#[derive(Clone, Copy, Debug)]
+pub enum ClientEvent {
+    Create(ClientHandle, Position),
+    Destroy(ClientHandle),
+}
+
 pub type ClientHandle = u64;
 
 #[derive(Debug, Default, Clone, Serialize, Deserialize)]

src/config.rs

@@ -1,28 +1,22 @@
 use anyhow::Result;
-use clap::{Parser, ValueEnum};
+use clap::Parser;
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
 use std::env;
-use std::fmt::Display;
 use std::net::IpAddr;
 use std::{error::Error, fs};
 use toml;
 
 use crate::client::Position;
-
-use input_event::scancode::{
-    self,
-    Linux::{KeyLeftAlt, KeyLeftCtrl, KeyLeftMeta, KeyLeftShift},
-};
+use crate::scancode;
+use crate::scancode::Linux::{KeyLeftAlt, KeyLeftCtrl, KeyLeftMeta, KeyLeftShift};
 
 pub const DEFAULT_PORT: u16 = 4242;
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct ConfigToml {
-    pub capture_backend: Option<CaptureBackend>,
-    pub emulation_backend: Option<EmulationBackend>,
     pub port: Option<u16>,
-    pub frontend: Option<Frontend>,
+    pub frontend: Option<String>,
     pub release_bind: Option<Vec<scancode::Linux>>,
     pub left: Option<TomlClient>,
     pub right: Option<TomlClient>,
@@ -32,7 +26,6 @@ pub struct ConfigToml {
 
 #[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
 pub struct TomlClient {
-    pub capture_backend: Option<CaptureBackend>,
     pub hostname: Option<String>,
     pub host_name: Option<String>,
     pub ips: Option<Vec<IpAddr>>,
@@ -58,7 +51,7 @@ struct CliArgs {
 
     /// the frontend to use [cli | gtk]
     #[arg(short, long)]
-    frontend: Option<Frontend>,
+    frontend: Option<String>,
 
     /// non-default config file location
     #[arg(short, long)]
@@ -75,144 +68,16 @@ struct CliArgs {
     /// test input emulation
     #[arg(long)]
     test_emulation: bool,
-
-    /// capture backend override
-    #[arg(long)]
-    capture_backend: Option<CaptureBackend>,
-
-    /// emulation backend override
-    #[arg(long)]
-    emulation_backend: Option<EmulationBackend>,
 }
 
-#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize, ValueEnum)]
-pub enum CaptureBackend {
-    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-    InputCapturePortal,
-    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-    LayerShell,
-    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-    X11,
-    #[cfg(windows)]
-    Windows,
-    #[cfg(target_os = "macos")]
-    MacOs,
-    Dummy,
-}
-
-impl Display for CaptureBackend {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-            CaptureBackend::InputCapturePortal => write!(f, "input-capture-portal"),
-            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-            CaptureBackend::LayerShell => write!(f, "layer-shell"),
-            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-            CaptureBackend::X11 => write!(f, "X11"),
-            #[cfg(windows)]
-            CaptureBackend::Windows => write!(f, "windows"),
-            #[cfg(target_os = "macos")]
-            CaptureBackend::MacOs => write!(f, "MacOS"),
-            CaptureBackend::Dummy => write!(f, "dummy"),
-        }
-    }
-}
-
-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")))]
-    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 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 {
-            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-            EmulationBackend::Wlroots => write!(f, "wlroots"),
-            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-            EmulationBackend::Libei => write!(f, "libei"),
-            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
-            EmulationBackend::Xdp => write!(f, "xdg-desktop-portal"),
-            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-            EmulationBackend::X11 => write!(f, "X11"),
-            #[cfg(windows)]
-            EmulationBackend::Windows => write!(f, "windows"),
-            #[cfg(target_os = "macos")]
-            EmulationBackend::MacOs => write!(f, "macos"),
-            EmulationBackend::Dummy => write!(f, "dummy"),
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq, Serialize, ValueEnum)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum Frontend {
     Gtk,
     Cli,
 }
 
-impl Default for Frontend {
-    fn default() -> Self {
-        if cfg!(feature = "gtk") {
-            Self::Gtk
-        } else {
-            Self::Cli
-        }
-    }
-}
-
 #[derive(Debug)]
 pub struct Config {
-    pub capture_backend: Option<CaptureBackend>,
-    pub emulation_backend: Option<EmulationBackend>,
     pub frontend: Frontend,
     pub port: u16,
     pub clients: Vec<(TomlClient, Position)>,
@@ -264,14 +129,33 @@ impl Config {
             Ok(c) => Some(c),
         };
 
-        let frontend_arg = args.frontend;
-        let frontend_cfg = config_toml.as_ref().and_then(|c| c.frontend);
-        let frontend = frontend_arg.or(frontend_cfg).unwrap_or_default();
+        let frontend = match args.frontend {
+            None => match &config_toml {
+                Some(c) => c.frontend.clone(),
+                None => None,
+            },
+            frontend => frontend,
+        };
 
-        let port = args
-            .port
-            .or(config_toml.as_ref().and_then(|c| c.port))
-            .unwrap_or(DEFAULT_PORT);
+        let frontend = match frontend {
+            #[cfg(feature = "gtk")]
+            None => Frontend::Gtk,
+            #[cfg(not(feature = "gtk"))]
+            None => Frontend::Cli,
+            Some(s) => match s.as_str() {
+                "cli" => Frontend::Cli,
+                "gtk" => Frontend::Gtk,
+                _ => Frontend::Cli,
+            },
+        };
+
+        let port = match args.port {
+            Some(port) => port,
+            None => match &config_toml {
+                Some(c) => c.port.unwrap_or(DEFAULT_PORT),
+                None => DEFAULT_PORT,
+            },
+        };
 
         log::debug!("{config_toml:?}");
         let release_bind = config_toml
@@ -279,14 +163,6 @@ impl Config {
             .and_then(|c| c.release_bind.clone())
             .unwrap_or(Vec::from_iter(DEFAULT_RELEASE_KEYS.iter().cloned()));
 
-        let capture_backend = args
-            .capture_backend
-            .or(config_toml.as_ref().and_then(|c| c.capture_backend));
-
-        let emulation_backend = args
-            .emulation_backend
-            .or(config_toml.as_ref().and_then(|c| c.emulation_backend));
-
         let mut clients: Vec<(TomlClient, Position)> = vec![];
 
         if let Some(config_toml) = config_toml {
@@ -309,8 +185,6 @@ impl Config {
         let test_emulation = args.test_emulation;
 
         Ok(Config {
-            capture_backend,
-            emulation_backend,
             daemon,
             frontend,
             clients,

src/emulate.rs

@@ -0,0 +1,98 @@
+use async_trait::async_trait;
+use std::future;
+
+use crate::{
+    client::{ClientEvent, ClientHandle},
+    event::Event,
+};
+use anyhow::Result;
+
+#[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;
+
+#[async_trait]
+pub trait InputEmulation: Send {
+    async fn consume(&mut self, event: Event, client_handle: ClientHandle);
+    async fn notify(&mut self, client_event: ClientEvent);
+    /// this function is waited on continuously and can be used to handle events
+    async fn dispatch(&mut self) -> Result<()> {
+        let _: () = future::pending().await;
+        Ok(())
+    }
+
+    async fn destroy(&mut self);
+}
+
+pub async fn create() -> Box<dyn InputEmulation> {
+    #[cfg(windows)]
+    match windows::WindowsEmulation::new() {
+        Ok(c) => return Box::new(c),
+        Err(e) => log::warn!("windows input emulation unavailable: {e}"),
+    }
+
+    #[cfg(target_os = "macos")]
+    match macos::MacOSEmulation::new() {
+        Ok(c) => {
+            log::info!("using macos input emulation");
+            return Box::new(c);
+        }
+        Err(e) => log::error!("macos input emulatino not available: {e}"),
+    }
+
+    #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+    match wlroots::WlrootsEmulation::new() {
+        Ok(c) => {
+            log::info!("using wlroots input emulation");
+            return Box::new(c);
+        }
+        Err(e) => log::info!("wayland backend not available: {e}"),
+    }
+
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    match libei::LibeiEmulation::new().await {
+        Ok(c) => {
+            log::info!("using libei input emulation");
+            return Box::new(c);
+        }
+        Err(e) => log::info!("libei not available: {e}"),
+    }
+
+    #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+    match xdg_desktop_portal::DesktopPortalEmulation::new().await {
+        Ok(c) => {
+            log::info!("using xdg-remote-desktop-portal input emulation");
+            return Box::new(c);
+        }
+        Err(e) => log::info!("remote desktop portal not available: {e}"),
+    }
+
+    #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+    match x11::X11Emulation::new() {
+        Ok(c) => {
+            log::info!("using x11 input emulation");
+            return Box::new(c);
+        }
+        Err(e) => log::info!("x11 input emulation not available: {e}"),
+    }
+
+    log::error!("falling back to dummy input emulation");
+    Box::new(dummy::DummyEmulation::new())
+}

src/emulate/dummy.rs

@@ -0,0 +1,26 @@
+use crate::{
+    client::{ClientEvent, ClientHandle},
+    emulate::InputEmulation,
+    event::Event,
+};
+use async_trait::async_trait;
+
+#[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: ClientHandle) {
+        log::info!("received event: ({client_handle}) {event}");
+    }
+    async fn notify(&mut self, client_event: ClientEvent) {
+        log::info!("{client_event:?}");
+    }
+    async fn destroy(&mut self) {}
+}

src/emulate/libei.rs

@@ -1,11 +1,10 @@
-use anyhow::{anyhow, Result};
 use std::{
     collections::HashMap,
-    io,
     os::{fd::OwnedFd, unix::net::UnixStream},
     time::{SystemTime, UNIX_EPOCH},
 };
 
+use anyhow::{anyhow, Result};
 use ashpd::{
     desktop::{
         remote_desktop::{DeviceType, RemoteDesktop},
@@ -22,9 +21,11 @@ use reis::{
     PendingRequestResult,
 };
 
-use input_event::{Event, KeyboardEvent, PointerEvent};
-
-use super::{error::LibeiEmulationCreationError, EmulationHandle, InputEmulation};
+use crate::{
+    client::{ClientEvent, ClientHandle},
+    emulate::InputEmulation,
+    event::Event,
+};
 
 pub struct LibeiEmulation {
     handshake: bool,
@@ -76,14 +77,14 @@ async fn get_ei_fd() -> Result<OwnedFd, ashpd::Error> {
 }
 
 impl LibeiEmulation {
-    pub async fn new() -> Result<Self, LibeiEmulationCreationError> {
+    pub async fn new() -> Result<Self> {
         // 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))?;
+        context.flush()?;
         let events = EiEventStream::new(context.clone())?;
         Ok(Self {
             handshake: false,
@@ -107,14 +108,14 @@ impl LibeiEmulation {
 
 #[async_trait]
 impl InputEmulation for LibeiEmulation {
-    async fn consume(&mut self, event: Event, _client_handle: EmulationHandle) {
+    async fn consume(&mut self, event: Event, _client_handle: ClientHandle) {
         let now = SystemTime::now()
             .duration_since(UNIX_EPOCH)
             .unwrap()
             .as_micros() as u64;
         match event {
             Event::Pointer(p) => match p {
-                PointerEvent::Motion {
+                crate::event::PointerEvent::Motion {
                     time: _,
                     relative_x,
                     relative_y,
@@ -127,7 +128,7 @@ impl InputEmulation for LibeiEmulation {
                         d.frame(self.serial, now);
                     }
                 }
-                PointerEvent::Button {
+                crate::event::PointerEvent::Button {
                     time: _,
                     button,
                     state,
@@ -146,7 +147,7 @@ impl InputEmulation for LibeiEmulation {
                         d.frame(self.serial, now);
                     }
                 }
-                PointerEvent::Axis {
+                crate::event::PointerEvent::Axis {
                     time: _,
                     axis,
                     value,
@@ -162,7 +163,7 @@ impl InputEmulation for LibeiEmulation {
                         d.frame(self.serial, now);
                     }
                 }
-                PointerEvent::AxisDiscrete120 { axis, value } => {
+                crate::event::PointerEvent::AxisDiscrete120 { axis, value } => {
                     if !self.has_scroll {
                         return;
                     }
@@ -174,10 +175,10 @@ impl InputEmulation for LibeiEmulation {
                         d.frame(self.serial, now);
                     }
                 }
-                PointerEvent::Frame {} => {}
+                crate::event::PointerEvent::Frame {} => {}
             },
             Event::Keyboard(k) => match k {
-                KeyboardEvent::Key {
+                crate::event::KeyboardEvent::Key {
                     time: _,
                     key,
                     state,
@@ -196,7 +197,7 @@ impl InputEmulation for LibeiEmulation {
                         d.frame(self.serial, now);
                     }
                 }
-                KeyboardEvent::Modifiers { .. } => {}
+                crate::event::KeyboardEvent::Modifiers { .. } => {}
             },
             _ => {}
         }
@@ -392,6 +393,7 @@ impl InputEmulation for LibeiEmulation {
         Ok(())
     }
 
-    async fn create(&mut self, _: EmulationHandle) {}
-    async fn destroy(&mut self, _: EmulationHandle) {}
+    async fn notify(&mut self, _client_event: ClientEvent) {}
+
+    async fn destroy(&mut self) {}
 }

src/emulate/macos.rs

@@ -1,18 +1,18 @@
-use super::{EmulationHandle, InputEmulation};
+use crate::client::{ClientEvent, ClientHandle};
+use crate::emulate::InputEmulation;
+use crate::event::{Event, KeyboardEvent, PointerEvent};
+use anyhow::{anyhow, Result};
 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);
 
@@ -53,9 +53,11 @@ impl IndexMut<CGMouseButton> for ButtonState {
 unsafe impl Send for MacOSEmulation {}
 
 impl MacOSEmulation {
-    pub fn new() -> Result<Self, MacOSEmulationCreationError> {
-        let event_source = CGEventSource::new(CGEventSourceStateID::CombinedSessionState)
-            .map_err(|_| MacOSEmulationCreationError::EventSourceCreation)?;
+    pub fn new() -> Result<Self> {
+        let event_source = match CGEventSource::new(CGEventSourceStateID::CombinedSessionState) {
+            Ok(e) => e,
+            Err(_) => return Err(anyhow!("event source creation failed!")),
+        };
         let button_state = ButtonState {
             left: false,
             right: false,
@@ -107,7 +109,7 @@ 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, _client_handle: ClientHandle) {
         match event {
             Event::Pointer(pointer_event) => match pointer_event {
                 PointerEvent::Motion {
@@ -172,22 +174,22 @@ impl InputEmulation for MacOSEmulation {
                     state,
                 } => {
                     let (event_type, mouse_button) = match (button, state) {
-                        (b, 1) if b == input_event::BTN_LEFT => {
+                        (b, 1) if b == crate::event::BTN_LEFT => {
                             (CGEventType::LeftMouseDown, CGMouseButton::Left)
                         }
-                        (b, 0) if b == input_event::BTN_LEFT => {
+                        (b, 0) if b == crate::event::BTN_LEFT => {
                             (CGEventType::LeftMouseUp, CGMouseButton::Left)
                         }
-                        (b, 1) if b == input_event::BTN_RIGHT => {
+                        (b, 1) if b == crate::event::BTN_RIGHT => {
                             (CGEventType::RightMouseDown, CGMouseButton::Right)
                         }
-                        (b, 0) if b == input_event::BTN_RIGHT => {
+                        (b, 0) if b == crate::event::BTN_RIGHT => {
                             (CGEventType::RightMouseUp, CGMouseButton::Right)
                         }
-                        (b, 1) if b == input_event::BTN_MIDDLE => {
+                        (b, 1) if b == crate::event::BTN_MIDDLE => {
                             (CGEventType::OtherMouseDown, CGMouseButton::Center)
                         }
-                        (b, 0) if b == input_event::BTN_MIDDLE => {
+                        (b, 0) if b == crate::event::BTN_MIDDLE => {
                             (CGEventType::OtherMouseUp, CGMouseButton::Center)
                         }
                         _ => {
@@ -296,7 +298,7 @@ impl InputEmulation for MacOSEmulation {
         }
     }
 
-    async fn create(&mut self, _handle: EmulationHandle) {}
+    async fn notify(&mut self, _client_event: ClientEvent) {}
 
-    async fn destroy(&mut self, _handle: EmulationHandle) {}
+    async fn destroy(&mut self) {}
 }

src/emulate/windows.rs

@@ -1,9 +1,9 @@
-use super::error::WindowsEmulationCreationError;
-use input_event::{
-    scancode, Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE,
-    BTN_RIGHT,
+use crate::{
+    emulate::InputEmulation,
+    event::{KeyboardEvent, PointerEvent},
+    scancode,
 };
-
+use anyhow::Result;
 use async_trait::async_trait;
 use std::ops::BitOrAssign;
 use std::time::Duration;
@@ -19,7 +19,11 @@ use windows::Win32::UI::Input::KeyboardAndMouse::{
 };
 use windows::Win32::UI::WindowsAndMessaging::{XBUTTON1, XBUTTON2};
 
-use super::{EmulationHandle, InputEmulation};
+use crate::event::{BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT};
+use crate::{
+    client::{ClientEvent, ClientHandle},
+    event::Event,
+};
 
 const DEFAULT_REPEAT_DELAY: Duration = Duration::from_millis(500);
 const DEFAULT_REPEAT_INTERVAL: Duration = Duration::from_millis(32);
@@ -29,14 +33,14 @@ pub struct WindowsEmulation {
 }
 
 impl WindowsEmulation {
-    pub fn new() -> Result<Self, WindowsEmulationCreationError> {
+    pub fn new() -> Result<Self> {
         Ok(Self { repeat_task: None })
     }
 }
 
 #[async_trait]
 impl InputEmulation for WindowsEmulation {
-    async fn consume(&mut self, event: Event, _: EmulationHandle) {
+    async fn consume(&mut self, event: Event, _: ClientHandle) {
         match event {
             Event::Pointer(pointer_event) => match pointer_event {
                 PointerEvent::Motion {
@@ -79,9 +83,11 @@ impl InputEmulation for WindowsEmulation {
         }
     }
 
-    async fn create(&mut self, _handle: EmulationHandle) {}
+    async fn notify(&mut self, _: ClientEvent) {
+        // nothing to do
+    }
 
-    async fn destroy(&mut self, _handle: EmulationHandle) {}
+    async fn destroy(&mut self) {}
 }
 
 impl WindowsEmulation {

src/emulate/wlroots.rs

@@ -1,4 +1,5 @@
-use super::{error::WlrootsEmulationCreationError, InputEmulation};
+use crate::client::{ClientEvent, ClientHandle};
+use crate::emulate::InputEmulation;
 use async_trait::async_trait;
 use std::collections::HashMap;
 use std::io;
@@ -6,6 +7,7 @@ use std::os::fd::{AsFd, OwnedFd};
 use wayland_client::backend::WaylandError;
 use wayland_client::WEnum;
 
+use anyhow::{anyhow, Result};
 use wayland_client::protocol::wl_keyboard::{self, WlKeyboard};
 use wayland_client::protocol::wl_pointer::{Axis, ButtonState};
 use wayland_client::protocol::wl_seat::WlSeat;
@@ -26,14 +28,11 @@ use wayland_client::{
     Connection, Dispatch, EventQueue, QueueHandle,
 };
 
-use input_event::{Event, KeyboardEvent, PointerEvent};
-
-use super::error::WaylandBindError;
-use super::EmulationHandle;
+use crate::event::{Event, KeyboardEvent, PointerEvent};
 
 struct State {
     keymap: Option<(u32, OwnedFd, u32)>,
-    input_for_client: HashMap<EmulationHandle, VirtualInput>,
+    input_for_client: HashMap<ClientHandle, VirtualInput>,
     seat: wl_seat::WlSeat,
     qh: QueueHandle<Self>,
     vpm: VpManager,
@@ -48,23 +47,20 @@ pub(crate) struct WlrootsEmulation {
 }
 
 impl WlrootsEmulation {
-    pub fn new() -> Result<Self, WlrootsEmulationCreationError> {
+    pub fn new() -> Result<Self> {
         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 seat: wl_seat::WlSeat = match globals.bind(&qh, 7..=8, ()) {
+            Ok(wl_seat) => wl_seat,
+            Err(_) => return Err(anyhow!("wl_seat >= v7 not supported")),
+        };
 
-        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 vpm: VpManager = globals.bind(&qh, 1..=1, ())?;
+        let vkm: VkManager = globals.bind(&qh, 1..=1, ())?;
 
-        let input_for_client: HashMap<EmulationHandle, VirtualInput> = HashMap::new();
+        let input_for_client: HashMap<ClientHandle, VirtualInput> = HashMap::new();
 
         let mut emulate = WlrootsEmulation {
             last_flush_failed: false,
@@ -79,7 +75,7 @@ impl WlrootsEmulation {
             queue,
         };
         while emulate.state.keymap.is_none() {
-            emulate.queue.blocking_dispatch(&mut emulate.state)?;
+            emulate.queue.blocking_dispatch(&mut emulate.state).unwrap();
         }
         // let fd = unsafe { &File::from_raw_fd(emulate.state.keymap.unwrap().1.as_raw_fd()) };
         // let mmap = unsafe { MmapOptions::new().map_copy(fd).unwrap() };
@@ -89,7 +85,7 @@ impl WlrootsEmulation {
 }
 
 impl State {
-    fn add_client(&mut self, client: EmulationHandle) {
+    fn add_client(&mut self, client: ClientHandle) {
         let pointer: Vp = self.vpm.create_virtual_pointer(None, &self.qh, ());
         let keyboard: Vk = self.vkm.create_virtual_keyboard(&self.seat, &self.qh, ());
 
@@ -104,19 +100,12 @@ impl State {
 
         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) {
+    async fn consume(&mut self, event: Event, client_handle: ClientHandle) {
+        if let Some(virtual_input) = self.state.input_for_client.get(&client_handle) {
             if self.last_flush_failed {
                 if let Err(WaylandError::Io(e)) = self.queue.flush() {
                     if e.kind() == io::ErrorKind::WouldBlock {
@@ -125,7 +114,9 @@ impl InputEmulation for WlrootsEmulation {
                          * will overwhelm the output buffer and leave the
                          * wayland connection in a broken state
                          */
-                        log::warn!("can't keep up, discarding event: ({handle}) - {event:?}");
+                        log::warn!(
+                            "can't keep up, discarding event: ({client_handle}) - {event:?}"
+                        );
                         return;
                     }
                 }
@@ -149,18 +140,16 @@ impl InputEmulation for WlrootsEmulation {
         }
     }
 
-    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);
+    async fn notify(&mut self, client_event: ClientEvent) {
+        if let ClientEvent::Create(client, _) = client_event {
+            self.state.add_client(client);
+            if let Err(e) = self.queue.flush() {
+                log::error!("{}", e);
+            }
         }
     }
+
+    async fn destroy(&mut self) {}
 }
 
 struct VirtualInput {

src/emulate/x11.rs

@@ -1,3 +1,4 @@
+use anyhow::{anyhow, Result};
 use async_trait::async_trait;
 use std::ptr;
 use x11::{
@@ -5,12 +6,14 @@ use x11::{
     xtest,
 };
 
-use input_event::{
-    Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT,
+use crate::{
+    client::ClientHandle,
+    emulate::InputEmulation,
+    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,
 }
@@ -18,11 +21,11 @@ pub struct X11Emulation {
 unsafe impl Send for X11Emulation {}
 
 impl X11Emulation {
-    pub fn new() -> Result<Self, X11EmulationCreationError> {
+    pub fn new() -> Result<Self> {
         let display = unsafe {
             match xlib::XOpenDisplay(ptr::null()) {
                 d if d == ptr::null::<xlib::Display>() as *mut xlib::Display => {
-                    Err(X11EmulationCreationError::OpenDisplay)
+                    Err(anyhow!("could not open display"))
                 }
                 display => Ok(display),
             }
@@ -98,7 +101,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, _: ClientHandle) {
         match event {
             Event::Pointer(pointer_event) => match pointer_event {
                 PointerEvent::Motion {
@@ -141,11 +144,9 @@ impl InputEmulation for X11Emulation {
         }
     }
 
-    async fn create(&mut self, _: EmulationHandle) {
+    async fn notify(&mut self, _: crate::client::ClientEvent) {
         // 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
-    }
+    async fn destroy(&mut self) {}
 }

src/emulate/xdg_desktop_portal.rs

@@ -8,20 +8,22 @@ use ashpd::{
 };
 use async_trait::async_trait;
 
-use input_event::{
-    Event::{Keyboard, Pointer},
-    KeyboardEvent, PointerEvent,
+use crate::{
+    client::ClientEvent,
+    emulate::InputEmulation,
+    event::{
+        Event::{Keyboard, Pointer},
+        KeyboardEvent, PointerEvent,
+    },
 };
 
-use super::{error::XdpEmulationCreationError, EmulationHandle, InputEmulation};
-
 pub struct DesktopPortalEmulation<'a> {
     proxy: RemoteDesktop<'a>,
-    session: Option<Session<'a>>,
+    session: Session<'a>,
 }
 
 impl<'a> DesktopPortalEmulation<'a> {
-    pub async fn new() -> Result<DesktopPortalEmulation<'a>, XdpEmulationCreationError> {
+    pub async fn new() -> Result<DesktopPortalEmulation<'a>> {
         log::debug!("connecting to org.freedesktop.portal.RemoteDesktop portal ...");
         let proxy = RemoteDesktop::new().await?;
 
@@ -51,7 +53,6 @@ impl<'a> DesktopPortalEmulation<'a> {
         };
 
         log::debug!("started session");
-        let session = Some(session);
 
         Ok(Self { proxy, session })
     }
@@ -59,7 +60,7 @@ impl<'a> DesktopPortalEmulation<'a> {
 
 #[async_trait]
 impl<'a> InputEmulation for DesktopPortalEmulation<'a> {
-    async fn consume(&mut self, event: input_event::Event, _client: EmulationHandle) {
+    async fn consume(&mut self, event: crate::event::Event, _client: crate::client::ClientHandle) {
         match event {
             Pointer(p) => match p {
                 PointerEvent::Motion {
@@ -69,11 +70,7 @@ impl<'a> InputEmulation for DesktopPortalEmulation<'a> {
                 } => {
                     if let Err(e) = self
                         .proxy
-                        .notify_pointer_motion(
-                            self.session.as_ref().expect("no session"),
-                            relative_x,
-                            relative_y,
-                        )
+                        .notify_pointer_motion(&self.session, relative_x, relative_y)
                         .await
                     {
                         log::warn!("{e}");
@@ -90,11 +87,7 @@ impl<'a> InputEmulation for DesktopPortalEmulation<'a> {
                     };
                     if let Err(e) = self
                         .proxy
-                        .notify_pointer_button(
-                            self.session.as_ref().expect("no session"),
-                            button as i32,
-                            state,
-                        )
+                        .notify_pointer_button(&self.session, button as i32, state)
                         .await
                     {
                         log::warn!("{e}");
@@ -107,11 +100,7 @@ impl<'a> InputEmulation for DesktopPortalEmulation<'a> {
                     };
                     if let Err(e) = self
                         .proxy
-                        .notify_pointer_axis_discrete(
-                            self.session.as_ref().expect("no session"),
-                            axis,
-                            value,
-                        )
+                        .notify_pointer_axis_discrete(&self.session, axis, value)
                         .await
                     {
                         log::warn!("{e}");
@@ -132,12 +121,7 @@ impl<'a> InputEmulation for DesktopPortalEmulation<'a> {
                     };
                     if let Err(e) = self
                         .proxy
-                        .notify_pointer_axis(
-                            self.session.as_ref().expect("no session"),
-                            dx,
-                            dy,
-                            true,
-                        )
+                        .notify_pointer_axis(&self.session, dx, dy, true)
                         .await
                     {
                         log::warn!("{e}");
@@ -158,11 +142,7 @@ impl<'a> InputEmulation for DesktopPortalEmulation<'a> {
                         };
                         if let Err(e) = self
                             .proxy
-                            .notify_keyboard_keycode(
-                                self.session.as_ref().expect("no session"),
-                                key as i32,
-                                state,
-                            )
+                            .notify_keyboard_keycode(&self.session, key as i32, state)
                             .await
                         {
                             log::warn!("{e}");
@@ -177,20 +157,12 @@ impl<'a> InputEmulation for DesktopPortalEmulation<'a> {
         }
     }
 
-    async fn create(&mut self, _client: EmulationHandle) {}
-    async fn destroy(&mut self, _client: EmulationHandle) {}
-}
+    async fn notify(&mut self, _client: ClientEvent) {}
 
-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}");
-                }
-            });
+    async fn destroy(&mut self) {
+        log::debug!("closing remote desktop session");
+        if let Err(e) = self.session.close().await {
+            log::error!("failed to close remote desktop session: {e}");
+        }
     }
 }

src/emulation_test.rs

@@ -1,6 +1,7 @@
-use crate::config::Config;
+use crate::client::{ClientEvent, Position};
+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;
@@ -12,18 +13,17 @@ pub fn run() -> Result<()> {
         .enable_time()
         .build()?;
 
-    let config = Config::new()?;
-
-    runtime.block_on(LocalSet::new().run_until(input_emulation_test(config)))
+    runtime.block_on(LocalSet::new().run_until(input_emulation_test()))
 }
 
 const FREQUENCY_HZ: f64 = 1.0;
 const RADIUS: f64 = 100.0;
 
-async fn input_emulation_test(config: Config) -> Result<()> {
-    let backend = config.emulation_backend.map(|b| b.into());
-    let mut emulation = input_emulation::create(backend).await?;
-    emulation.create(0).await;
+async fn input_emulation_test() -> Result<()> {
+    let mut emulation = emulate::create().await;
+    emulation
+        .notify(ClientEvent::Create(0, Position::Left))
+        .await;
     let start = Instant::now();
     let mut offset = (0, 0);
     loop {

src/event.rs

@@ -1,11 +1,10 @@
+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/lib.rs

@@ -1,8 +1,13 @@
 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/main.rs

@@ -68,12 +68,10 @@ fn run_service(config: &Config) -> Result<()> {
     // run async event loop
     runtime.block_on(LocalSet::new().run_until(async {
         // run main loop
-        log::info!("Press {:?} to release the mouse", config.release_bind);
+        log::info!("Press Ctrl+Alt+Shift+Super to release the mouse");
 
         let server = Server::new(config);
-        server
-            .run(config.capture_backend, config.emulation_backend)
-            .await?;
+        server.run().await?;
 
         log::debug!("service exiting");
         anyhow::Ok(())

src/server.rs

@@ -8,7 +8,7 @@ use tokio::signal;
 
 use crate::{
     client::{ClientConfig, ClientHandle, ClientManager, ClientState},
-    config::{CaptureBackend, Config, EmulationBackend},
+    config::Config,
     dns,
     frontend::{FrontendListener, FrontendRequest},
     server::capture_task::CaptureEvent,
@@ -40,7 +40,7 @@ pub struct Server {
     client_manager: Rc<RefCell<ClientManager>>,
     port: Rc<Cell<u16>>,
     state: Rc<Cell<State>>,
-    release_bind: Vec<input_event::scancode::Linux>,
+    release_bind: Vec<crate::scancode::Linux>,
 }
 
 impl Server {
@@ -77,11 +77,7 @@ impl Server {
         }
     }
 
-    pub async fn run(
-        &self,
-        capture_backend: Option<CaptureBackend>,
-        emulation_backend: Option<EmulationBackend>,
-    ) -> anyhow::Result<()> {
+    pub async fn run(&self) -> anyhow::Result<()> {
         // create frontend communication adapter
         let frontend = match FrontendListener::new().await {
             Some(f) => f?,
@@ -101,22 +97,20 @@ impl Server {
 
         // input capture
         let (mut capture_task, capture_channel) = capture_task::new(
-            capture_backend,
             self.clone(),
             sender_tx.clone(),
             timer_tx.clone(),
             self.release_bind.clone(),
-        )?;
+        );
 
         // input emulation
         let (mut emulation_task, emulate_channel) = emulation_task::new(
-            emulation_backend,
             self.clone(),
             receiver_rx,
             sender_tx.clone(),
             capture_channel.clone(),
             timer_tx,
-        )?;
+        );
 
         // create dns resolver
         let resolver = dns::DnsResolver::new().await?;

src/server/capture_task.rs

@@ -4,11 +4,13 @@ use std::{collections::HashSet, net::SocketAddr};
 
 use tokio::{process::Command, sync::mpsc::Sender, task::JoinHandle};
 
-use input_capture::{self, error::CaptureCreationError, CaptureHandle, InputCapture, Position};
-
-use input_event::{scancode, Event, KeyboardEvent};
-
-use crate::{client::ClientHandle, config::CaptureBackend, server::State};
+use crate::{
+    capture::{self, InputCapture},
+    client::{ClientEvent, ClientHandle},
+    event::{Event, KeyboardEvent},
+    scancode,
+    server::State,
+};
 
 use super::Server;
 
@@ -16,25 +18,21 @@ use super::Server;
 pub enum CaptureEvent {
     /// capture must release the mouse
     Release,
-    /// add a capture client
-    Create(CaptureHandle, Position),
-    /// destory a capture client
-    Destroy(CaptureHandle),
+    /// capture is notified of a change in client states
+    ClientEvent(ClientEvent),
     /// termination signal
     Terminate,
 }
 
 pub fn new(
-    backend: Option<CaptureBackend>,
     server: Server,
     sender_tx: Sender<(Event, SocketAddr)>,
     timer_tx: Sender<()>,
     release_bind: Vec<scancode::Linux>,
-) -> Result<(JoinHandle<Result<()>>, Sender<CaptureEvent>), CaptureCreationError> {
+) -> (JoinHandle<Result<()>>, Sender<CaptureEvent>) {
     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 = input_capture::create(backend).await?;
+        let mut capture = capture::create().await;
         let mut pressed_keys = HashSet::new();
         loop {
             tokio::select! {
@@ -52,9 +50,9 @@ pub fn new(
                             CaptureEvent::Release => {
                                 capture.release()?;
                                 server.state.replace(State::Receiving);
+
                             }
-                            CaptureEvent::Create(h, p) => capture.create(h, p)?,
-                            CaptureEvent::Destroy(h) => capture.destroy(h)?,
+                            CaptureEvent::ClientEvent(e) => capture.notify(e)?,
                             CaptureEvent::Terminate => break,
                         },
                         None => break,
@@ -64,7 +62,7 @@ pub fn new(
         }
         anyhow::Ok(())
     });
-    Ok((task, tx))
+    (task, tx)
 }
 
 fn update_pressed_keys(pressed_keys: &mut HashSet<scancode::Linux>, key: u32, state: u8) {
@@ -82,7 +80,7 @@ async fn handle_capture_event(
     capture: &mut Box<dyn InputCapture>,
     sender_tx: &Sender<(Event, SocketAddr)>,
     timer_tx: &Sender<()>,
-    event: (CaptureHandle, Event),
+    event: (ClientHandle, Event),
     pressed_keys: &mut HashSet<scancode::Linux>,
     release_bind: &[scancode::Linux],
 ) -> Result<()> {

src/server/emulation_task.rs

@@ -6,18 +6,20 @@ use tokio::{
     task::JoinHandle,
 };
 
-use crate::{client::ClientHandle, config::EmulationBackend, server::State};
-use input_emulation::{self, error::EmulationCreationError, EmulationHandle, InputEmulation};
-use input_event::{Event, KeyboardEvent};
+use crate::{
+    client::{ClientEvent, ClientHandle},
+    emulate::{self, InputEmulation},
+    event::{Event, KeyboardEvent},
+    scancode,
+    server::State,
+};
 
 use super::{CaptureEvent, Server};
 
 #[derive(Clone, Debug)]
 pub enum EmulationEvent {
-    /// create a new client
-    Create(EmulationHandle),
-    /// destroy a client
-    Destroy(EmulationHandle),
+    /// input emulation is notified of a change in client states
+    ClientEvent(ClientEvent),
     /// input emulation must release keys for client
     ReleaseKeys(ClientHandle),
     /// termination signal
@@ -25,17 +27,15 @@ pub enum EmulationEvent {
 }
 
 pub fn new(
-    backend: Option<EmulationBackend>,
     server: Server,
     mut udp_rx: Receiver<Result<(Event, SocketAddr)>>,
     sender_tx: Sender<(Event, SocketAddr)>,
     capture_tx: Sender<CaptureEvent>,
     timer_tx: Sender<()>,
-) -> Result<(JoinHandle<Result<()>>, Sender<EmulationEvent>), EmulationCreationError> {
+) -> (JoinHandle<Result<()>>, Sender<EmulationEvent>) {
     let (tx, mut rx) = tokio::sync::mpsc::channel(32);
     let emulate_task = tokio::task::spawn_local(async move {
-        let backend = backend.map(|b| b.into());
-        let mut emulate = input_emulation::create(backend).await?;
+        let mut emulate = emulate::create().await;
         let mut last_ignored = None;
 
         loop {
@@ -47,8 +47,7 @@ pub fn new(
                 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::ClientEvent(e) => emulate.notify(e).await,
                             EmulationEvent::ReleaseKeys(c) => release_keys(&server, &mut emulate, c).await,
                             EmulationEvent::Terminate => break,
                         },
@@ -72,9 +71,11 @@ pub fn new(
             release_keys(&server, &mut emulate, client).await;
         }
 
+        // destroy emulator
+        emulate.destroy().await;
         anyhow::Ok(())
     });
-    Ok((emulate_task, tx))
+    (emulate_task, tx)
 }
 
 async fn handle_udp_rx(
@@ -221,7 +222,7 @@ async fn release_keys(
             state: 0,
         });
         emulate.consume(event, client).await;
-        if let Ok(key) = input_event::scancode::Linux::try_from(key) {
+        if let Ok(key) = scancode::Linux::try_from(key) {
             log::warn!("releasing stuck key: {key:?}");
         }
     }

src/server/frontend_task.rs

@@ -17,7 +17,7 @@ use tokio::{
 };
 
 use crate::{
-    client::{ClientHandle, Position},
+    client::{ClientEvent, ClientHandle, Position},
     frontend::{self, FrontendEvent, FrontendListener, FrontendRequest},
 };
 
@@ -205,8 +205,9 @@ pub async fn deactivate_client(
         None => return,
     };
 
-    let _ = capture.send(CaptureEvent::Destroy(handle)).await;
-    let _ = emulate.send(EmulationEvent::Destroy(handle)).await;
+    let event = ClientEvent::Destroy(handle);
+    let _ = capture.send(CaptureEvent::ClientEvent(event)).await;
+    let _ = emulate.send(EmulationEvent::ClientEvent(event)).await;
 }
 
 pub async fn activate_client(
@@ -236,8 +237,9 @@ pub async fn activate_client(
     };
 
     /* notify emulation, capture and frontends */
-    let _ = capture.send(CaptureEvent::Create(handle, pos.into())).await;
-    let _ = emulate.send(EmulationEvent::Create(handle)).await;
+    let event = ClientEvent::Create(handle, pos);
+    let _ = capture.send(CaptureEvent::ClientEvent(event)).await;
+    let _ = emulate.send(EmulationEvent::ClientEvent(event)).await;
 }
 
 pub async fn remove_client(
@@ -256,8 +258,9 @@ pub async fn remove_client(
     };
 
     if active {
-        let _ = capture.send(CaptureEvent::Destroy(handle)).await;
-        let _ = emulate.send(EmulationEvent::Destroy(handle)).await;
+        let destroy = ClientEvent::Destroy(handle);
+        let _ = capture.send(CaptureEvent::ClientEvent(destroy)).await;
+        let _ = emulate.send(EmulationEvent::ClientEvent(destroy)).await;
     }
 }
 
@@ -332,11 +335,13 @@ async fn update_pos(
     // update state in event input emulator & input capture
     if changed {
         if active {
-            let _ = capture.send(CaptureEvent::Destroy(handle)).await;
-            let _ = emulate.send(EmulationEvent::Destroy(handle)).await;
+            let destroy = ClientEvent::Destroy(handle);
+            let _ = capture.send(CaptureEvent::ClientEvent(destroy)).await;
+            let _ = emulate.send(EmulationEvent::ClientEvent(destroy)).await;
         }
-        let _ = capture.send(CaptureEvent::Create(handle, pos.into())).await;
-        let _ = emulate.send(EmulationEvent::Create(handle)).await;
+        let create = ClientEvent::Create(handle, pos);
+        let _ = capture.send(CaptureEvent::ClientEvent(create)).await;
+        let _ = emulate.send(EmulationEvent::ClientEvent(create)).await;
     }
 }
 

src/server/network_task.rs

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

src/server/ping_task.rs

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