include commit-hash in version

* [WIP] MacOS inputcapture

---------

Co-authored-by: Ferdinand Schober <ferdinand.schober@fau.de>
Co-authored-by: Ferdinand Schober <ferdinandschober20@gmail.com>

Cargo.lock

@@ -98,9 +98,9 @@ dependencies = [
 
 [[package]]
 name = "ashpd"
-version = "0.8.1"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd884d7c72877a94102c3715f3b1cd09ff4fac28221add3e57cfbe25c236d093"
+checksum = "bfe7e0dd0ac5a401dc116ed9f9119cf9decc625600474cb41f0fc0a0050abc9a"
 dependencies = [
  "enumflags2",
  "futures-channel",
@@ -200,9 +200,9 @@ dependencies = [
 
 [[package]]
 name = "async-signal"
-version = "0.2.8"
+version = "0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "794f185324c2f00e771cd9f1ae8b5ac68be2ca7abb129a87afd6e86d228bc54d"
+checksum = "dfb3634b73397aa844481f814fad23bbf07fdb0eabec10f2eb95e58944b1ec32"
 dependencies = [
  "async-io",
  "async-lock",
@@ -296,15 +296,15 @@ dependencies = [
 
 [[package]]
 name = "bytes"
-version = "1.6.0"
+version = "1.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9"
+checksum = "a12916984aab3fa6e39d655a33e09c0071eb36d6ab3aea5c2d78551f1df6d952"
 
 [[package]]
 name = "cairo-rs"
-version = "0.19.4"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2ac2a4d0e69036cf0062976f6efcba1aaee3e448594e6514bb2ddf87acce562"
+checksum = "797fd5a634dcb0ad0d7d583df794deb0a236d88e759cd34b7da20198c6c9d145"
 dependencies = [
  "bitflags 2.6.0",
  "cairo-sys-rs",
@@ -315,9 +315,9 @@ dependencies = [
 
 [[package]]
 name = "cairo-sys-rs"
-version = "0.19.2"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd3bb3119664efbd78b5e6c93957447944f16bdbced84c17a9f41c7829b81e64"
+checksum = "428290f914b9b86089f60f5d8a9f6e440508e1bcff23b25afd51502b0a2da88f"
 dependencies = [
  "glib-sys",
  "libc",
@@ -326,9 +326,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.1.0"
+version = "1.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eaff6f8ce506b9773fa786672d63fc7a191ffea1be33f72bbd4aeacefca9ffc8"
+checksum = "2aba8f4e9906c7ce3c73463f62a7f0c65183ada1a2d47e397cc8810827f9694f"
 
 [[package]]
 name = "cfg-expr"
@@ -758,9 +758,9 @@ dependencies = [
 
 [[package]]
 name = "gdk-pixbuf"
-version = "0.19.8"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "624eaba126021103c7339b2e179ae4ee8cdab842daab419040710f38ed9f8699"
+checksum = "28bb53ecb56857c683c9ec859908e076dd3969c7d67598bd8b1ce095d211304a"
 dependencies = [
  "gdk-pixbuf-sys",
  "gio",
@@ -770,9 +770,9 @@ dependencies = [
 
 [[package]]
 name = "gdk-pixbuf-sys"
-version = "0.19.8"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4efa05a4f83c8cc50eb4d883787b919b85e5f1d8dd10b5a1df53bf5689782379"
+checksum = "9f6681a0c1330d1d3968bec1529f7172d62819ef0bdbb0d18022320654158b03"
 dependencies = [
  "gio-sys",
  "glib-sys",
@@ -783,9 +783,9 @@ dependencies = [
 
 [[package]]
 name = "gdk4"
-version = "0.8.2"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db265c9dd42d6a371e09e52deab3a84808427198b86ac792d75fd35c07990a07"
+checksum = "4b7d7237c1487ed4b300aac7744efcbf1319e12d60d7afcd6f505414bd5b5dea"
 dependencies = [
  "cairo-rs",
  "gdk-pixbuf",
@@ -798,9 +798,9 @@ dependencies = [
 
 [[package]]
 name = "gdk4-sys"
-version = "0.8.2"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9418fb4e8a67074919fe7604429c45aa74eb9df82e7ca529767c6d4e9dc66dd"
+checksum = "a67576c8ec012156d7f680e201a807b4432a77babb3157e0555e990ab6bcd878"
 dependencies = [
  "cairo-sys-rs",
  "gdk-pixbuf-sys",
@@ -842,9 +842,9 @@ checksum = "40ecd4077b5ae9fd2e9e169b102c6c330d0605168eb0e8bf79952b256dbefffd"
 
 [[package]]
 name = "gio"
-version = "0.19.8"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c49f117d373ffcc98a35d114db5478bc223341cff53e39a5d6feced9e2ddffe"
+checksum = "398e3da68749fdc32783cbf7521ec3f65c9cf946db8c7774f8460af49e52c6e2"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -860,9 +860,9 @@ dependencies = [
 
 [[package]]
 name = "gio-sys"
-version = "0.19.8"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2cd743ba4714d671ad6b6234e8ab2a13b42304d0e13ab7eba1dcdd78a7d6d4ef"
+checksum = "e4feb96b31c32730ea3e1e89aecd2e4e37ecb1c473ad8f685e3430a159419f63"
 dependencies = [
  "glib-sys",
  "gobject-sys",
@@ -873,9 +873,9 @@ dependencies = [
 
 [[package]]
 name = "glib"
-version = "0.19.9"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39650279f135469465018daae0ba53357942a5212137515777d5fdca74984a44"
+checksum = "fee90a615ce05be7a32932cfb8adf2c4bbb4700e80d37713c981fb24c0c56238"
 dependencies = [
  "bitflags 2.6.0",
  "futures-channel",
@@ -895,18 +895,18 @@ dependencies = [
 
 [[package]]
 name = "glib-build-tools"
-version = "0.19.0"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "108f374fff60efd14b0d70d8916e7213aed18d7dd071ba3e9334ed2dac1dc86a"
+checksum = "7029c2651d9b5d5a3eea93ec8a1995665c6d3a69ce9bf6042ad9064d134736d8"
 dependencies = [
  "gio",
 ]
 
 [[package]]
 name = "glib-macros"
-version = "0.19.9"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4429b0277a14ae9751350ad9b658b1be0abb5b54faa5bcdf6e74a3372582fad7"
+checksum = "4da558d8177c0c8c54368818b508a4244e1286fce2858cef4e547023f0cfa5ef"
 dependencies = [
  "heck 0.5.0",
  "proc-macro-crate",
@@ -917,9 +917,9 @@ dependencies = [
 
 [[package]]
 name = "glib-sys"
-version = "0.19.8"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c2dc18d3a82b0006d470b13304fbbb3e0a9bd4884cf985a60a7ed733ac2c4a5"
+checksum = "4958c26e5a01c9af00dea669a97369eccbec29a8e6d125c24ea2d85ee7467b60"
 dependencies = [
  "libc",
  "system-deps",
@@ -927,9 +927,9 @@ dependencies = [
 
 [[package]]
 name = "gobject-sys"
-version = "0.19.8"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e697e252d6e0416fd1d9e169bda51c0f1c926026c39ca21fbe8b1bb5c3b8b9e"
+checksum = "c6908864f5ffff15b56df7e90346863904f49b949337ed0456b9287af61903b8"
 dependencies = [
  "glib-sys",
  "libc",
@@ -938,9 +938,9 @@ dependencies = [
 
 [[package]]
 name = "graphene-rs"
-version = "0.19.8"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5fb86031d24d9ec0a2a15978fc7a65d545a2549642cf1eb7c3dda358da42bcf"
+checksum = "630e940ad5824f90221d6579043a9cd1f8bec86b4a17faaf7827d58eb16e8c1f"
 dependencies = [
  "glib",
  "graphene-sys",
@@ -949,9 +949,9 @@ dependencies = [
 
 [[package]]
 name = "graphene-sys"
-version = "0.19.8"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f530e0944bccba4b55065e9c69f4975ad691609191ebac16e13ab8e1f27af05"
+checksum = "6fb8fade7b754982f47ebbed241fd2680816fdd4598321784da10b9e1168836a"
 dependencies = [
  "glib-sys",
  "libc",
@@ -961,9 +961,9 @@ dependencies = [
 
 [[package]]
 name = "gsk4"
-version = "0.8.2"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7563884bf6939f4468e5d94654945bdd9afcaf8c3ba4c5dd17b5342b747221be"
+checksum = "1f3cf2091e1af185b347b3450817d93dea6fe435df7abd4c2cd7fb5bcb4cfda8"
 dependencies = [
  "cairo-rs",
  "gdk4",
@@ -976,9 +976,9 @@ dependencies = [
 
 [[package]]
 name = "gsk4-sys"
-version = "0.8.2"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23024bf2636c38bbd1f822f58acc9d1c25b28da896ff0f291a1a232d4272b3dc"
+checksum = "6aa69614a26d8760c186c3690f1b0fbb917572ca23ef83137445770ceddf8cde"
 dependencies = [
  "cairo-sys-rs",
  "gdk4-sys",
@@ -992,9 +992,9 @@ dependencies = [
 
 [[package]]
 name = "gtk4"
-version = "0.8.2"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b04e11319b08af11358ab543105a9e49b0c491faca35e2b8e7e36bfba8b671ab"
+checksum = "eaffc6c743c9160514cc9b67eace364e5dc5798369fa809cdb04e035c21c5c5d"
 dependencies = [
  "cairo-rs",
  "field-offset",
@@ -1013,9 +1013,9 @@ dependencies = [
 
 [[package]]
 name = "gtk4-macros"
-version = "0.8.2"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec655a7ef88d8ce9592899deb8b2d0fa50bab1e6dd69182deb764e643c522408"
+checksum = "188211f546ce5801f6d0245c37b6249143a2cb4fa040e54829ca1e76796e9f09"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",
@@ -1025,9 +1025,9 @@ dependencies = [
 
 [[package]]
 name = "gtk4-sys"
-version = "0.8.2"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c8aa86b7f85ea71d66ea88c1d4bae1cfacf51ca4856274565133838d77e57b5"
+checksum = "1114a207af8ada02cf4658a76692f4190f06f093380d5be07e3ca8b43aa7c666"
 dependencies = [
  "cairo-sys-rs",
  "gdk-pixbuf-sys",
@@ -1192,14 +1192,19 @@ dependencies = [
 
 [[package]]
 name = "input-capture"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
- "anyhow",
  "ashpd",
+ "async-trait",
+ "bitflags 2.6.0",
+ "core-foundation",
+ "core-foundation-sys",
  "core-graphics",
  "futures",
  "futures-core",
  "input-event",
+ "keycode",
+ "libc",
  "log",
  "memmap",
  "once_cell",
@@ -1207,16 +1212,17 @@ dependencies = [
  "tempfile",
  "thiserror",
  "tokio",
+ "tokio-util",
  "wayland-client",
  "wayland-protocols",
  "wayland-protocols-wlr",
- "windows 0.57.0",
+ "windows 0.58.0",
  "x11",
 ]
 
 [[package]]
 name = "input-emulation"
-version = "0.1.0"
+version = "0.2.1"
 dependencies = [
  "ashpd",
  "async-trait",
@@ -1233,17 +1239,18 @@ dependencies = [
  "wayland-protocols",
  "wayland-protocols-misc",
  "wayland-protocols-wlr",
- "windows 0.57.0",
+ "windows 0.58.0",
  "x11",
 ]
 
 [[package]]
 name = "input-event"
-version = "0.1.0"
+version = "0.2.1"
 dependencies = [
  "futures-core",
  "log",
  "num_enum",
+ "reis",
  "serde",
  "thiserror",
 ]
@@ -1304,7 +1311,7 @@ dependencies = [
 
 [[package]]
 name = "lan-mouse"
-version = "0.8.0"
+version = "0.9.1"
 dependencies = [
  "anyhow",
  "async-channel",
@@ -1319,24 +1326,36 @@ dependencies = [
  "input-capture",
  "input-emulation",
  "input-event",
+ "lan-mouse-proto",
  "libadwaita",
  "libc",
+ "local-channel",
  "log",
  "serde",
  "serde_json",
  "slab",
  "thiserror",
  "tokio",
+ "tokio-util",
  "toml",
 ]
 
 [[package]]
-name = "libadwaita"
+name = "lan-mouse-proto"
-version = "0.6.0"
+version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
-checksum = "91b4990248b9e1ec5e72094a2ccaea70ec3809f88f6fd52192f2af306b87c5d9"
+ "input-event",
+ "num_enum",
+ "paste",
+ "thiserror",
+]
+
+[[package]]
+name = "libadwaita"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ff9c222b5c783729de45185f07b2fec2d43a7f9c63961e777d3667e20443878"
 dependencies = [
- "gdk-pixbuf",
  "gdk4",
  "gio",
  "glib",
@@ -1348,9 +1367,9 @@ dependencies = [
 
 [[package]]
 name = "libadwaita-sys"
-version = "0.6.0"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23a748e4e92be1265cd9e93d569c0b5dfc7814107985aa6743d670ab281ea1a8"
+checksum = "1c44d8bdbad31d6639e1f20cc9c1424f1a8e02d751fc28d44659bf743fb9eca6"
 dependencies = [
  "gdk4-sys",
  "gio-sys",
@@ -1390,6 +1409,23 @@ version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
 
+[[package]]
+name = "local-channel"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6cbc85e69b8df4b8bb8b89ec634e7189099cea8927a276b7384ce5488e53ec8"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+ "local-waker",
+]
+
+[[package]]
+name = "local-waker"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d873d7c67ce09b42110d801813efbc9364414e356be9935700d368351657487"
+
 [[package]]
 name = "lock_api"
 version = "0.4.12"
@@ -1543,9 +1579,9 @@ dependencies = [
 
 [[package]]
 name = "pango"
-version = "0.19.8"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f0d328648058085cfd6897c9ae4272884098a926f3a833cd50c8c73e6eccecd"
+checksum = "54768854025df6903061d0084fd9702a253ddfd60db7d9b751d43b76689a7f0a"
 dependencies = [
  "gio",
  "glib",
@@ -1555,9 +1591,9 @@ dependencies = [
 
 [[package]]
 name = "pango-sys"
-version = "0.19.8"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff03da4fa086c0b244d4a4587d3e20622a3ecdb21daea9edf66597224c634ba0"
+checksum = "b07cc57d10cee4ec661f718a6902cee18c2f4cfae08e87e5a390525946913390"
 dependencies = [
  "glib-sys",
  "gobject-sys",
@@ -1594,6 +1630,12 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
+[[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
 [[package]]
 name = "percent-encoding"
 version = "2.3.1"
@@ -1724,9 +1766,9 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.5.2"
+version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c82cf8cff14456045f55ec4241383baeff27af886adb72ffb2162f99911de0fd"
+checksum = "2a908a6e00f1fdd0dfd9c0eb08ce85126f6d8bbda50017e74bc4a4b7d4a926a4"
 dependencies = [
  "bitflags 2.6.0",
 ]
@@ -1943,9 +1985,9 @@ checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
 name = "syn"
-version = "2.0.70"
+version = "2.0.71"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f0209b68b3613b093e0ec905354eccaedcfe83b8cb37cbdeae64026c3064c16"
+checksum = "b146dcf730474b4bcd16c311627b31ede9ab149045db4d6088b3becaea046462"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1954,9 +1996,9 @@ dependencies = [
 
 [[package]]
 name = "system-deps"
-version = "6.2.2"
+version = "7.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3e535eb8dded36d55ec13eddacd30dec501792ff23a0b1682c38601b8cf2349"
+checksum = "6c81f13d9a334a6c242465140bd262fae382b752ff2011c4f7419919a9c97922"
 dependencies = [
  "cfg-expr",
  "heck 0.5.0",
@@ -1985,18 +2027,18 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "1.0.61"
+version = "1.0.63"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709"
+checksum = "c0342370b38b6a11b6cc11d6a805569958d54cfa061a29969c3b5ce2ea405724"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.61"
+version = "1.0.63"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533"
+checksum = "a4558b58466b9ad7ca0f102865eccc95938dca1a74a856f2b57b6629050da261"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2020,9 +2062,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.38.0"
+version = "1.38.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba4f4a02a7a80d6f274636f0aa95c7e383b912d41fe721a31f29e29698585a4a"
+checksum = "eb2caba9f80616f438e09748d5acda951967e1ea58508ef53d9c6402485a46df"
 dependencies = [
  "backtrace",
  "bytes",
@@ -2049,15 +2091,28 @@ dependencies = [
 ]
 
 [[package]]
-name = "toml"
+name = "tokio-util"
-version = "0.8.14"
+version = "0.7.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f49eb2ab21d2f26bd6db7bf383edc527a7ebaee412d17af4d40fdccd442f335"
+checksum = "9cf6b47b3771c49ac75ad09a6162f53ad4b8088b76ac60e8ec1455b31a189fe1"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "toml"
+version = "0.8.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac2caab0bf757388c6c0ae23b3293fdb463fee59434529014f85e3263b995c28"
 dependencies = [
  "serde",
  "serde_spanned",
  "toml_datetime",
- "toml_edit 0.22.15",
+ "toml_edit 0.22.16",
 ]
 
 [[package]]
@@ -2082,9 +2137,9 @@ dependencies = [
 
 [[package]]
 name = "toml_edit"
-version = "0.22.15"
+version = "0.22.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d59a3a72298453f564e2b111fa896f8d07fabb36f51f06d7e875fc5e0b5a3ef1"
+checksum = "278f3d518e152219c994ce877758516bca5e118eaed6996192a774fb9fbf0788"
 dependencies = [
  "indexmap",
  "serde",
@@ -2206,9 +2261,9 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wayland-backend"
-version = "0.3.5"
+version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "269c04f203640d0da2092d1b8d89a2d081714ae3ac2f1b53e99f205740517198"
+checksum = "f90e11ce2ca99c97b940ee83edbae9da2d56a08f9ea8158550fd77fa31722993"
 dependencies = [
  "cc",
  "downcast-rs",
@@ -2220,9 +2275,9 @@ dependencies = [
 
 [[package]]
 name = "wayland-client"
-version = "0.31.4"
+version = "0.31.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08bd0f46c069d3382a36c8666c1b9ccef32b8b04f41667ca1fef06a1adcc2982"
+checksum = "7e321577a0a165911bdcfb39cf029302479d7527b517ee58ab0f6ad09edf0943"
 dependencies = [
  "bitflags 2.6.0",
  "rustix",
@@ -2232,9 +2287,9 @@ dependencies = [
 
 [[package]]
 name = "wayland-protocols"
-version = "0.32.2"
+version = "0.32.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1794d82d869f38439d15c24b26f06f6c8603d27d47b4f786d5197c99044de415"
+checksum = "62989625a776e827cc0f15d41444a3cea5205b963c3a25be48ae1b52d6b4daaa"
 dependencies = [
  "bitflags 2.6.0",
  "wayland-backend",
@@ -2244,9 +2299,9 @@ dependencies = [
 
 [[package]]
 name = "wayland-protocols-misc"
-version = "0.3.2"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28b497d7edd777ca365f2cce3837046b7832365b2a0b32f9c913b4e6f8d99839"
+checksum = "dfe44d48a0e51909c89da297f6b43bb814b881c78b69e254a4558a5fa8752887"
 dependencies = [
  "bitflags 2.6.0",
  "wayland-backend",
@@ -2257,9 +2312,9 @@ dependencies = [
 
 [[package]]
 name = "wayland-protocols-wlr"
-version = "0.3.2"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa43c961473aed713d44c1f616f775186249dfca657f256d8841ca0690366aba"
+checksum = "fd993de54a40a40fbe5601d9f1fbcaef0aebcc5fda447d7dc8f6dcbaae4f8953"
 dependencies = [
  "bitflags 2.6.0",
  "wayland-backend",
@@ -2270,9 +2325,9 @@ dependencies = [
 
 [[package]]
 name = "wayland-scanner"
-version = "0.31.3"
+version = "0.31.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edf466fc49a4feb65a511ca403fec3601494d0dee85dbf37fff6fa0dd4eec3b6"
+checksum = "d7b56f89937f1cf2ee1f1259cf2936a17a1f45d8f0aa1019fae6d470d304cfa6"
 dependencies = [
  "proc-macro2",
  "quick-xml",
@@ -2281,9 +2336,9 @@ dependencies = [
 
 [[package]]
 name = "wayland-sys"
-version = "0.31.3"
+version = "0.31.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a6754825230fa5b27bafaa28c30b3c9e72c55530581220cef401fa422c0fae7"
+checksum = "43676fe2daf68754ecf1d72026e4e6c15483198b5d24e888b74d3f22f887a148"
 dependencies = [
  "dlib",
  "log",
@@ -2330,11 +2385,11 @@ dependencies = [
 
 [[package]]
 name = "windows"
-version = "0.57.0"
+version = "0.58.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12342cb4d8e3b046f3d80effd474a7a02447231330ef77d71daa6fbc40681143"
+checksum = "dd04d41d93c4992d421894c18c8b43496aa748dd4c081bac0dc93eb0489272b6"
 dependencies = [
- "windows-core 0.57.0",
+ "windows-core 0.58.0",
  "windows-targets 0.52.6",
 ]
 
@@ -2349,21 +2404,22 @@ dependencies = [
 
 [[package]]
 name = "windows-core"
-version = "0.57.0"
+version = "0.58.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2ed2439a290666cd67ecce2b0ffaad89c2a56b976b736e6ece670297897832d"
+checksum = "6ba6d44ec8c2591c134257ce647b7ea6b20335bf6379a27dac5f1641fcf59f99"
 dependencies = [
  "windows-implement",
  "windows-interface",
  "windows-result",
+ "windows-strings",
  "windows-targets 0.52.6",
 ]
 
 [[package]]
 name = "windows-implement"
-version = "0.57.0"
+version = "0.58.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9107ddc059d5b6fbfbffdfa7a7fe3e22a226def0b2608f72e9d552763d3e1ad7"
+checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2372,9 +2428,9 @@ dependencies = [
 
 [[package]]
 name = "windows-interface"
-version = "0.57.0"
+version = "0.58.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29bee4b38ea3cde66011baa44dba677c432a78593e202392d1e9070cf2a7fca7"
+checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2383,13 +2439,23 @@ dependencies = [
 
 [[package]]
 name = "windows-result"
-version = "0.1.2"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e383302e8ec8515204254685643de10811af0ed97ea37210dc26fb0032647f8"
+checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e"
 dependencies = [
  "windows-targets 0.52.6",
 ]
 
+[[package]]
+name = "windows-strings"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10"
+dependencies = [
+ "windows-result",
+ "windows-targets 0.52.6",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.48.0"

Cargo.toml

@@ -1,26 +1,23 @@
 [workspace]
-members = [
+members = ["input-capture", "input-emulation", "input-event", "lan-mouse-proto"]
-    "input-capture",
-    "input-emulation",
-    "input-event",
-]
 
 [package]
 name = "lan-mouse"
 description = "Software KVM Switch / mouse & keyboard sharing software for Local Area Networks"
-version = "0.8.0"
+version = "0.9.1"
 edition = "2021"
 license = "GPL-3.0-or-later"
-repository = "https://github.com/ferdinandschober/lan-mouse"
+repository = "https://github.com/feschber/lan-mouse"
 
 [profile.release]
 strip = true
 lto = "fat"
 
 [dependencies]
-input-event = { path = "input-event", version = "0.1.0" }
+input-event = { path = "input-event", version = "0.2.1" }
-input-emulation = { path = "input-emulation", version = "0.1.0", default-features = false }
+input-emulation = { path = "input-emulation", version = "0.2.1", default-features = false }
-input-capture = { path = "input-capture", version = "0.1.0", default-features = false }
+input-capture = { path = "input-capture", version = "0.2.0", default-features = false }
+lan-mouse-proto = { path = "lan-mouse-proto", version = "0.1.0" }
 
 hickory-resolver = "0.24.1"
 toml = "0.8"
@@ -29,27 +26,42 @@ anyhow = "1.0.71"
 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"] }
+tokio = { version = "1.32.0", features = [
+    "io-util",
+    "io-std",
+    "macros",
+    "net",
+    "process",
+    "rt",
+    "sync",
+    "signal",
+] }
 futures = "0.3.28"
-clap = { version="4.4.11", features = ["derive"] }
+clap = { version = "4.4.11", features = ["derive"] }
-gtk = { package = "gtk4", version = "0.8.1", features = ["v4_2"], optional = true }
+gtk = { package = "gtk4", version = "0.9.0", features = [
-adw = { package = "libadwaita", version = "0.6.0", features = ["v1_1"], optional = true }
+    "v4_2",
+], optional = true }
+adw = { package = "libadwaita", version = "0.7.0", features = [
+    "v1_1",
+], optional = true }
 async-channel = { version = "2.1.1", optional = true }
 hostname = "0.4.0"
 slab = "0.4.9"
 endi = "1.1.0"
 thiserror = "1.0.61"
+tokio-util = "0.7.11"
+local-channel = "0.1.5"
 
 [target.'cfg(unix)'.dependencies]
 libc = "0.2.148"
 
 [build-dependencies]
-glib-build-tools = { version = "0.19.0", optional = true }
+glib-build-tools = { version = "0.20.0", optional = true }
 
 [features]
-default = [ "wayland", "x11", "xdg_desktop_portal", "libei", "gtk" ]
+default = ["wayland", "x11", "xdg_desktop_portal", "libei", "gtk"]
-wayland = [ "input-capture/wayland", "input-emulation/wayland" ]
+wayland = ["input-capture/wayland", "input-emulation/wayland"]
-x11 = [ "input-capture/x11", "input-emulation/x11" ]
+x11 = ["input-capture/x11", "input-emulation/x11"]
-xdg_desktop_portal = [ "input-emulation/xdg_desktop_portal" ]
+xdg_desktop_portal = ["input-emulation/xdg_desktop_portal"]
-libei = [ "input-capture/libei", "input-emulation/libei" ]
+libei = ["input-event/libei", "input-capture/libei", "input-emulation/libei"]
 gtk = ["dep:gtk", "dep:adw", "dep:async-channel", "dep:glib-build-tools"]

README.md

@@ -57,6 +57,10 @@ input capture (to send events *to* other clients) on different operating systems
 > If you are using [Wayfire](https://github.com/WayfireWM/wayfire), make sure to use a recent version (must be newer than October 23rd) and **add `shortcuts-inhibit` to the list of plugins in your wayfire config!**
 > Otherwise input capture will not work.
 
+> [!Important]
+> The mouse cursor will be invisible when sending input to a Windows system if
+> there is no real mouse connected to the machine.
+
 ## Installation
 ### Install via cargo
 ```sh

build.rs

@@ -1,4 +1,18 @@
+use std::process::Command;
+
 fn main() {
+    // commit hash
+    let git_describe = Command::new("git")
+        .arg("describe")
+        .arg("--always")
+        .arg("--dirty")
+        .arg("--tags")
+        .output()
+        .unwrap();
+
+    let git_describe = String::from_utf8(git_describe.stdout).unwrap();
+    println!("cargo::rustc-env=GIT_DESCRIBE={git_describe}");
+
     // composite_templates
     #[cfg(feature = "gtk")]
     glib_build_tools::compile_resources(

flake.nix

@@ -16,6 +16,7 @@
     inherit (nixpkgs) lib;
     genSystems = lib.genAttrs [
       "aarch64-darwin"
+      "aarch64-linux"
       "x86_64-darwin"
       "x86_64-linux"
     ];
@@ -50,10 +51,13 @@
           xorg.libX11
           gtk4
           libadwaita
+          librsvg
           xorg.libXtst
-        ] ++ lib.optionals stdenv.isDarwin [
+        ] ++ lib.optionals stdenv.isDarwin
-          darwin.apple_sdk_11_0.frameworks.CoreGraphics
+        (with darwin.apple_sdk_11_0.frameworks; [
-        ];
+          CoreGraphics
+          ApplicationServices
+        ]);
 
         RUST_SRC_PATH = "${rust}/lib/rustlib/src/rust/library";
       };

input-capture/Cargo.toml

@@ -1,37 +1,60 @@
 [package]
 name = "input-capture"
 description = "cross-platform input-capture library used by lan-mouse"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 license = "GPL-3.0-or-later"
-repository = "https://github.com/ferdinandschober/lan-mouse"
+repository = "https://github.com/feschber/lan-mouse"
 
 [dependencies]
-anyhow = "1.0.86"
 futures = "0.3.28"
 futures-core = "0.3.30"
 log = "0.4.22"
-input-event = { path = "../input-event", version = "0.1.0" }
+input-event = { path = "../input-event", version = "0.2.1" }
 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"] }
+tokio = { version = "1.32.0", features = [
+    "io-util",
+    "io-std",
+    "macros",
+    "net",
+    "process",
+    "rt",
+    "sync",
+    "signal",
+] }
 once_cell = "1.19.0"
+async-trait = "0.1.81"
+tokio-util = "0.7.11"
 
 
 [target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
-wayland-client = { version="0.31.1", optional = true }
+wayland-client = { version = "0.31.1", optional = true }
-wayland-protocols = { version="0.32.1", features=["client", "staging", "unstable"], optional = true }
+wayland-protocols = { version = "0.32.1", features = [
-wayland-protocols-wlr = { version="0.3.1", features=["client"], optional = true }
+    "client",
+    "staging",
+    "unstable",
+], optional = true }
+wayland-protocols-wlr = { version = "0.3.1", features = [
+    "client",
+], optional = true }
 x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.8", default-features = false, features = ["tokio"], optional = true }
+ashpd = { version = "0.9", default-features = false, features = [
-reis = { version = "0.2", features = [ "tokio" ], optional = true }
+    "tokio",
+], optional = true }
+reis = { version = "0.2", features = ["tokio"], optional = true }
 
 [target.'cfg(target_os="macos")'.dependencies]
 core-graphics = { version = "0.23", features = ["highsierra"] }
+core-foundation = "0.9.4"
+core-foundation-sys = "0.8.6"
+libc = "0.2.155"
+keycode = "0.4.0"
+bitflags = "2.5.0"
 
 [target.'cfg(windows)'.dependencies]
-windows = {  version = "0.57.0", features = [
+windows = { version = "0.58.0", features = [
     "Win32_System_LibraryLoader",
     "Win32_System_Threading",
     "Win32_Foundation",
@@ -43,6 +66,10 @@ windows = {  version = "0.57.0", features = [
 
 [features]
 default = ["wayland", "x11", "libei"]
-wayland = ["dep:wayland-client", "dep:wayland-protocols", "dep:wayland-protocols-wlr" ]
+wayland = [
+    "dep:wayland-client",
+    "dep:wayland-protocols",
+    "dep:wayland-protocols-wlr",
+]
 x11 = ["dep:x11"]
 libei = ["dep:reis", "dep:ashpd"]

input-capture/src/dummy.rs

@@ -1,12 +1,10 @@
-use std::io;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
+use async_trait::async_trait;
 use futures_core::Stream;
 
-use input_event::Event;
+use super::{Capture, CaptureError, CaptureEvent, CaptureHandle, Position};
-
-use super::{CaptureHandle, InputCapture, Position};
 
 pub struct DummyInputCapture {}
 
@@ -22,22 +20,27 @@ impl Default for DummyInputCapture {
     }
 }
 
-impl InputCapture for DummyInputCapture {
+#[async_trait]
-    fn create(&mut self, _handle: CaptureHandle, _pos: Position) -> io::Result<()> {
+impl Capture for DummyInputCapture {
+    async fn create(&mut self, _handle: CaptureHandle, _pos: Position) -> Result<(), CaptureError> {
         Ok(())
     }
 
-    fn destroy(&mut self, _handle: CaptureHandle) -> io::Result<()> {
+    async fn destroy(&mut self, _handle: CaptureHandle) -> Result<(), CaptureError> {
         Ok(())
     }
 
-    fn release(&mut self) -> io::Result<()> {
+    async fn release(&mut self) -> Result<(), CaptureError> {
+        Ok(())
+    }
+
+    async fn terminate(&mut self) -> Result<(), CaptureError> {
         Ok(())
     }
 }
 
 impl Stream for DummyInputCapture {
-    type Item = io::Result<(CaptureHandle, Event)>;
+    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;
 
     fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         Poll::Pending

input-capture/src/error.rs

@@ -1,5 +1,13 @@
 use thiserror::Error;
 
+#[derive(Debug, Error)]
+pub enum InputCaptureError {
+    #[error("error creating input-capture: `{0}`")]
+    Create(#[from] CaptureCreationError),
+    #[error("error while capturing input: `{0}`")]
+    Capture(#[from] CaptureError),
+}
+
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 use std::io;
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
@@ -9,9 +17,14 @@ use wayland_client::{
     ConnectError, DispatchError,
 };
 
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+use ashpd::desktop::ResponseError;
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 use reis::tokio::{EiConvertEventStreamError, HandshakeError};
 
+#[cfg(target_os = "macos")]
+use core_graphics::base::CGError;
+
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 #[error("error in libei stream: {inner:?}")]
@@ -43,6 +56,24 @@ pub enum CaptureError {
     #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
     #[error(transparent)]
     Portal(#[from] ashpd::Error),
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    #[error("libei disconnected - reason: `{0}`")]
+    Disconnected(String),
+    #[cfg(target_os = "macos")]
+    #[error("failed to warp mouse cursor: `{0}`")]
+    WarpCursor(CGError),
+    #[cfg(target_os = "macos")]
+    #[error("reset_mouse_position called without a connected client")]
+    ResetMouseWithoutClient,
+    #[cfg(target_os = "macos")]
+    #[error("core-graphics error: {0}")]
+    CoreGraphics(CGError),
+    #[cfg(target_os = "macos")]
+    #[error("unable to map key event: {0}")]
+    KeyMapError(i64),
+    #[cfg(target_os = "macos")]
+    #[error("Event tap disabled")]
+    EventTapDisabled,
 }
 
 #[derive(Debug, Error)]
@@ -58,12 +89,29 @@ pub enum CaptureCreationError {
     #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
     #[error("error creating x11 capture backend: `{0}`")]
     X11(#[from] X11InputCaptureCreationError),
-    #[cfg(target_os = "macos")]
-    #[error("error creating macos capture backend: `{0}`")]
-    Macos(#[from] MacOSInputCaptureCreationError),
     #[cfg(windows)]
     #[error("error creating windows capture backend")]
     Windows,
+    #[cfg(target_os = "macos")]
+    #[error("error creating macos capture backend")]
+    MacOS(#[from] MacosCaptureCreationError),
+}
+
+impl CaptureCreationError {
+    /// request was intentionally denied by the user
+    #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+    pub(crate) fn cancelled_by_user(&self) -> bool {
+        matches!(
+            self,
+            CaptureCreationError::Libei(LibeiCaptureCreationError::Ashpd(ashpd::Error::Response(
+                ResponseError::Cancelled
+            )))
+        )
+    }
+    #[cfg(not(all(unix, feature = "libei", not(target_os = "macos"))))]
+    pub(crate) fn cancelled_by_user(&self) -> bool {
+        false
+    }
 }
 
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
@@ -114,7 +162,12 @@ pub enum X11InputCaptureCreationError {
 
 #[cfg(target_os = "macos")]
 #[derive(Debug, Error)]
-pub enum MacOSInputCaptureCreationError {
+pub enum MacosCaptureCreationError {
-    #[error("MacOS input capture is not yet implemented :(")]
+    #[error("event source creation failed!")]
-    NotImplemented,
+    EventSourceCreation,
+    #[error("failed to set CG Cursor property")]
+    CGCursorProperty,
+    #[cfg(target_os = "macos")]
+    #[error("failed to get display ids: {0}")]
+    ActiveDisplays(CGError),
 }

input-capture/src/lib.rs

@@ -1,33 +1,52 @@
-use std::{fmt::Display, io};
+use std::{collections::HashSet, fmt::Display, task::Poll};
 
+use async_trait::async_trait;
+use futures::StreamExt;
 use futures_core::Stream;
 
-use input_event::Event;
+use input_event::{scancode, Event, KeyboardEvent};
 
-pub use error::{CaptureCreationError, CaptureError};
+pub use error::{CaptureCreationError, CaptureError, InputCaptureError};
 
 pub mod error;
 
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-pub mod libei;
+mod libei;
 
 #[cfg(target_os = "macos")]
-pub mod macos;
+mod macos;
 
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-pub mod wayland;
+mod wayland;
 
 #[cfg(windows)]
-pub mod windows;
+mod windows;
 
 #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-pub mod x11;
+mod x11;
 
 /// fallback input capture (does not produce events)
-pub mod dummy;
+mod dummy;
 
 pub type CaptureHandle = u64;
 
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub enum CaptureEvent {
+    /// capture on this capture handle is now active
+    Begin,
+    /// input event coming from capture handle
+    Input(Event),
+}
+
+impl Display for CaptureEvent {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            CaptureEvent::Begin => write!(f, "begin capture"),
+            CaptureEvent::Input(e) => write!(f, "{e}"),
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy, Eq, Hash, PartialEq)]
 pub enum Position {
     Left,
@@ -92,21 +111,102 @@ impl Display for Backend {
     }
 }
 
-pub trait InputCapture: Stream<Item = io::Result<(CaptureHandle, Event)>> + Unpin {
+pub struct InputCapture {
-    /// create a new client with the given id
+    capture: Box<dyn Capture>,
-    fn create(&mut self, id: CaptureHandle, pos: Position) -> io::Result<()>;
+    pressed_keys: HashSet<scancode::Linux>,
-
-    /// 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(
+impl InputCapture {
+    /// create a new client with the given id
+    pub async fn create(&mut self, id: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
+        self.capture.create(id, pos).await
+    }
+
+    /// destroy the client with the given id, if it exists
+    pub async fn destroy(&mut self, id: CaptureHandle) -> Result<(), CaptureError> {
+        self.capture.destroy(id).await
+    }
+
+    /// release mouse
+    pub async fn release(&mut self) -> Result<(), CaptureError> {
+        self.pressed_keys.clear();
+        self.capture.release().await
+    }
+
+    /// destroy the input capture
+    pub async fn terminate(&mut self) -> Result<(), CaptureError> {
+        self.capture.terminate().await
+    }
+
+    /// creates a new [`InputCapture`]
+    pub async fn new(backend: Option<Backend>) -> Result<Self, CaptureCreationError> {
+        let capture = create(backend).await?;
+        Ok(Self {
+            capture,
+            pressed_keys: HashSet::new(),
+        })
+    }
+
+    /// check whether the given keys are pressed
+    pub fn keys_pressed(&self, keys: &[scancode::Linux]) -> bool {
+        keys.iter().all(|k| self.pressed_keys.contains(k))
+    }
+
+    fn update_pressed_keys(&mut self, key: u32, state: u8) {
+        if let Ok(scancode) = scancode::Linux::try_from(key) {
+            log::debug!("key: {key}, state: {state}, scancode: {scancode:?}");
+            match state {
+                1 => self.pressed_keys.insert(scancode),
+                _ => self.pressed_keys.remove(&scancode),
+            };
+        }
+    }
+}
+
+impl Stream for InputCapture {
+    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;
+
+    fn poll_next(
+        mut self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        match self.capture.poll_next_unpin(cx) {
+            Poll::Ready(e) => {
+                if let Some(Ok((
+                    _,
+                    CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key { key, state, .. })),
+                ))) = e
+                {
+                    self.update_pressed_keys(key, state);
+                }
+                Poll::Ready(e)
+            }
+            Poll::Pending => Poll::Pending,
+        }
+    }
+}
+
+#[async_trait]
+trait Capture: Stream<Item = Result<(CaptureHandle, CaptureEvent), CaptureError>> + Unpin {
+    /// create a new client with the given id
+    async fn create(&mut self, id: CaptureHandle, pos: Position) -> Result<(), CaptureError>;
+
+    /// destroy the client with the given id, if it exists
+    async fn destroy(&mut self, id: CaptureHandle) -> Result<(), CaptureError>;
+
+    /// release mouse
+    async fn release(&mut self) -> Result<(), CaptureError>;
+
+    /// destroy the input capture
+    async fn terminate(&mut self) -> Result<(), CaptureError>;
+}
+
+async fn create_backend(
     backend: Backend,
-) -> Result<Box<dyn InputCapture<Item = io::Result<(CaptureHandle, Event)>>>, CaptureCreationError>
+) -> Result<
-{
+    Box<dyn Capture<Item = Result<(CaptureHandle, CaptureEvent), CaptureError>>>,
+    CaptureCreationError,
+> {
     match backend {
         #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
         Backend::InputCapturePortal => Ok(Box::new(libei::LibeiInputCapture::new().await?)),
@@ -117,15 +217,17 @@ pub async fn create_backend(
         #[cfg(windows)]
         Backend::Windows => Ok(Box::new(windows::WindowsInputCapture::new())),
         #[cfg(target_os = "macos")]
-        Backend::MacOs => Ok(Box::new(macos::MacOSInputCapture::new()?)),
+        Backend::MacOs => Ok(Box::new(macos::MacOSInputCapture::new().await?)),
         Backend::Dummy => Ok(Box::new(dummy::DummyInputCapture::new())),
     }
 }
 
-pub async fn create(
+async fn create(
     backend: Option<Backend>,
-) -> Result<Box<dyn InputCapture<Item = io::Result<(CaptureHandle, Event)>>>, CaptureCreationError>
+) -> Result<
-{
+    Box<dyn Capture<Item = Result<(CaptureHandle, CaptureEvent), CaptureError>>>,
+    CaptureCreationError,
+> {
     if let Some(backend) = backend {
         let b = create_backend(backend).await;
         if b.is_ok() {
@@ -145,13 +247,13 @@ pub async fn create(
         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) if e.cancelled_by_user() => return Err(e),
             Err(e) => log::warn!("{backend} input capture backend unavailable: {e}"),
         }
     }

input-capture/src/libei.rs

@@ -1,14 +1,14 @@
 use ashpd::{
     desktop::{
         input_capture::{Activated, Barrier, BarrierID, Capabilities, InputCapture, Region, Zones},
-        ResponseError, Session,
+        Session,
     },
     enumflags2::BitFlags,
 };
-use futures::StreamExt;
+use async_trait::async_trait;
+use futures::{FutureExt, StreamExt};
 use reis::{
-    ei::{self, keyboard::KeyState},
+    ei,
-    eis::button::ButtonState,
     event::{DeviceCapability, EiEvent},
     tokio::{EiConvertEventStream, EiEventStream},
 };
@@ -19,27 +19,37 @@ use std::{
     os::unix::net::UnixStream,
     pin::Pin,
     rc::Rc,
-    task::{ready, Context, Poll},
+    sync::Arc,
+    task::{Context, Poll},
 };
 use tokio::{
-    sync::mpsc::{Receiver, Sender},
+    sync::{
+        mpsc::{self, Receiver, Sender},
+        Notify,
+    },
     task::JoinHandle,
 };
+use tokio_util::sync::CancellationToken;
 
 use futures_core::Stream;
 use once_cell::sync::Lazy;
 
-use input_event::{Event, KeyboardEvent, PointerEvent};
+use input_event::Event;
 
-use crate::error::{CaptureError, ReisConvertEventStreamError};
+use crate::CaptureEvent;
 
 use super::{
-    error::LibeiCaptureCreationError, CaptureHandle, InputCapture as LanMouseInputCapture, Position,
+    error::{CaptureError, LibeiCaptureCreationError, ReisConvertEventStreamError},
+    Capture as LanMouseInputCapture, CaptureHandle, Position,
 };
 
-#[derive(Debug)]
+/* there is a bug in xdg-remote-desktop-portal-gnome / mutter that
-enum ProducerEvent {
+ * prevents receiving further events after a session has been disabled once.
-    Release,
+ * Therefore the session needs to be recreated when the barriers are updated */
+
+/// events that necessitate restarting the capture session
+#[derive(Clone, Copy, Debug)]
+enum LibeiNotifyEvent {
     Create(CaptureHandle, Position),
     Destroy(CaptureHandle),
 }
@@ -47,9 +57,12 @@ enum ProducerEvent {
 #[allow(dead_code)]
 pub struct LibeiInputCapture<'a> {
     input_capture: Pin<Box<InputCapture<'a>>>,
-    libei_task: JoinHandle<Result<(), CaptureError>>,
+    capture_task: JoinHandle<Result<(), CaptureError>>,
-    event_rx: tokio::sync::mpsc::Receiver<(CaptureHandle, Event)>,
+    event_rx: Receiver<(CaptureHandle, CaptureEvent)>,
-    notify_tx: tokio::sync::mpsc::Sender<ProducerEvent>,
+    notify_capture: Sender<LibeiNotifyEvent>,
+    notify_release: Arc<Notify>,
+    cancellation_token: CancellationToken,
+    terminated: bool,
 }
 
 static INTERFACES: Lazy<HashMap<&'static str, u32>> = Lazy::new(|| {
@@ -68,24 +81,47 @@ static INTERFACES: Lazy<HashMap<&'static str, u32>> = Lazy::new(|| {
     m
 });
 
+/// returns (start pos, end pos), inclusive
 fn pos_to_barrier(r: &Region, pos: Position) -> (i32, i32, i32, i32) {
     let (x, y) = (r.x_offset(), r.y_offset());
-    let (width, height) = (r.width() as i32, r.height() as i32);
+    let (w, h) = (r.width() as i32, r.height() as i32);
     match pos {
-        Position::Left => (x, y, x, y + height - 1), // start pos, end pos, inclusive
+        Position::Left => (x, y, x, y + h - 1),
-        Position::Right => (x + width, y, x + width, y + height - 1),
+        Position::Right => (x + w, y, x + w, y + h - 1),
-        Position::Top => (x, y, x + width - 1, y),
+        Position::Top => (x, y, x + w - 1, y),
-        Position::Bottom => (x, y + height, x + width - 1, y + height),
+        Position::Bottom => (x, y + h, x + w - 1, y + h),
+    }
+}
+
+/// Ashpd does not expose fields
+#[derive(Clone, Copy, Debug)]
+struct ICBarrier {
+    barrier_id: BarrierID,
+    position: (i32, i32, i32, i32),
+}
+
+impl ICBarrier {
+    fn new(barrier_id: BarrierID, position: (i32, i32, i32, i32)) -> Self {
+        Self {
+            barrier_id,
+            position,
+        }
+    }
+}
+
+impl From<ICBarrier> for Barrier {
+    fn from(barrier: ICBarrier) -> Self {
+        Barrier::new(barrier.barrier_id, barrier.position)
     }
 }
 
 fn select_barriers(
     zones: &Zones,
-    clients: &Vec<(CaptureHandle, Position)>,
+    clients: &[(CaptureHandle, Position)],
     next_barrier_id: &mut u32,
-) -> (Vec<Barrier>, HashMap<BarrierID, CaptureHandle>) {
+) -> (Vec<ICBarrier>, HashMap<BarrierID, CaptureHandle>) {
     let mut client_for_barrier = HashMap::new();
-    let mut barriers: Vec<Barrier> = vec![];
+    let mut barriers: Vec<ICBarrier> = vec![];
 
     for (handle, pos) in clients {
         let mut client_barriers = zones
@@ -96,7 +132,7 @@ fn select_barriers(
                 *next_barrier_id = id + 1;
                 let position = pos_to_barrier(r, *pos);
                 client_for_barrier.insert(id, *handle);
-                Barrier::new(id, position)
+                ICBarrier::new(id, position)
             })
             .collect();
         barriers.append(&mut client_barriers);
@@ -106,10 +142,10 @@ fn select_barriers(
 
 async fn update_barriers(
     input_capture: &InputCapture<'_>,
-    session: &Session<'_>,
+    session: &Session<'_, InputCapture<'_>>,
-    active_clients: &Vec<(CaptureHandle, Position)>,
+    active_clients: &[(CaptureHandle, Position)],
     next_barrier_id: &mut u32,
-) -> Result<HashMap<BarrierID, CaptureHandle>, ashpd::Error> {
+) -> Result<(Vec<ICBarrier>, HashMap<BarrierID, CaptureHandle>), ashpd::Error> {
     let zones = input_capture.zones(session).await?.response()?;
     log::debug!("zones: {zones:?}");
 
@@ -117,44 +153,30 @@ async fn update_barriers(
     log::debug!("barriers: {barriers:?}");
     log::debug!("client for barrier id: {id_map:?}");
 
+    let ashpd_barriers: Vec<Barrier> = barriers.iter().copied().map(|b| b.into()).collect();
     let response = input_capture
-        .set_pointer_barriers(session, &barriers, zones.zone_set())
+        .set_pointer_barriers(session, &ashpd_barriers, zones.zone_set())
         .await?;
     let response = response.response()?;
     log::debug!("{response:?}");
-    Ok(id_map)
+    Ok((barriers, id_map))
-}
-
-impl<'a> Drop for LibeiInputCapture<'a> {
-    fn drop(&mut self) {
-        self.libei_task.abort();
-    }
 }
 
 async fn create_session<'a>(
     input_capture: &'a InputCapture<'a>,
-) -> std::result::Result<(Session<'a>, BitFlags<Capabilities>), ashpd::Error> {
+) -> std::result::Result<(Session<'_, InputCapture<'_>>, BitFlags<Capabilities>), ashpd::Error> {
     log::debug!("creating input capture session");
-    let (session, capabilities) = loop {
+    input_capture
-        match input_capture
+        .create_session(
-            .create_session(
+            &ashpd::WindowIdentifier::default(),
-                &ashpd::WindowIdentifier::default(),
+            Capabilities::Keyboard | Capabilities::Pointer | Capabilities::Touchscreen,
-                Capabilities::Keyboard | Capabilities::Pointer | Capabilities::Touchscreen,
+        )
-            )
+        .await
-            .await
-        {
-            Ok(s) => break s,
-            Err(ashpd::Error::Response(ResponseError::Cancelled)) => continue,
-            o => o?,
-        };
-    };
-    log::debug!("capabilities: {capabilities:?}");
-    Ok((session, capabilities))
 }
 
 async fn connect_to_eis(
     input_capture: &InputCapture<'_>,
-    session: &Session<'_>,
+    session: &Session<'_, InputCapture<'_>>,
 ) -> Result<(ei::Context, EiConvertEventStream), CaptureError> {
     log::debug!("connect_to_eis");
     let fd = input_capture.connect_to_eis(session).await?;
@@ -181,7 +203,8 @@ async fn connect_to_eis(
 async fn libei_event_handler(
     mut ei_event_stream: EiConvertEventStream,
     context: ei::Context,
-    event_tx: Sender<(CaptureHandle, Event)>,
+    event_tx: Sender<(CaptureHandle, CaptureEvent)>,
+    release_session: Arc<Notify>,
     current_client: Rc<Cell<Option<CaptureHandle>>>,
 ) -> Result<(), CaptureError> {
     loop {
@@ -192,20 +215,7 @@ async fn libei_event_handler(
             .map_err(ReisConvertEventStreamError::from)?;
         log::trace!("from ei: {ei_event:?}");
         let client = current_client.get();
-        handle_ei_event(ei_event, client, &context, &event_tx).await;
+        handle_ei_event(ei_event, client, &context, &event_tx, &release_session).await?;
-    }
-}
-
-async fn wait_for_active_client(
-    notify_rx: &mut Receiver<ProducerEvent>,
-    active_clients: &mut Vec<(CaptureHandle, Position)>,
-) {
-    // 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);
-            break;
-        }
     }
 }
 
@@ -215,157 +225,275 @@ impl<'a> LibeiInputCapture<'a> {
         let input_capture_ptr = input_capture.as_ref().get_ref() as *const InputCapture<'static>;
         let first_session = Some(create_session(unsafe { &*input_capture_ptr }).await?);
 
-        let (event_tx, event_rx) = tokio::sync::mpsc::channel(32);
+        let (event_tx, event_rx) = mpsc::channel(1);
-        let (notify_tx, notify_rx) = tokio::sync::mpsc::channel(32);
+        let (notify_capture, notify_rx) = mpsc::channel(1);
-        let capture = do_capture(input_capture_ptr, notify_rx, first_session, event_tx);
+        let notify_release = Arc::new(Notify::new());
-        let libei_task = tokio::task::spawn_local(capture);
+
+        let cancellation_token = CancellationToken::new();
+
+        let capture = do_capture(
+            input_capture_ptr,
+            notify_rx,
+            notify_release.clone(),
+            first_session,
+            event_tx,
+            cancellation_token.clone(),
+        );
+        let capture_task = tokio::task::spawn_local(capture);
 
         let producer = Self {
             input_capture,
             event_rx,
-            libei_task,
+            capture_task,
-            notify_tx,
+            notify_capture,
+            notify_release,
+            cancellation_token,
+            terminated: false,
         };
 
         Ok(producer)
     }
 }
 
-async fn do_capture<'a>(
+async fn do_capture(
-    input_capture_ptr: *const InputCapture<'static>,
+    input_capture: *const InputCapture<'static>,
-    mut notify_rx: Receiver<ProducerEvent>,
+    mut capture_event: Receiver<LibeiNotifyEvent>,
-    mut first_session: Option<(Session<'a>, BitFlags<Capabilities>)>,
+    notify_release: Arc<Notify>,
-    event_tx: Sender<(CaptureHandle, Event)>,
+    session: Option<(Session<'_, InputCapture<'_>>, BitFlags<Capabilities>)>,
+    event_tx: Sender<(CaptureHandle, CaptureEvent)>,
+    cancellation_token: CancellationToken,
 ) -> Result<(), CaptureError> {
-    /* safety: libei_task does not outlive Self */
+    let mut session = session.map(|s| s.0);
-    let input_capture = unsafe { &*input_capture_ptr };
 
+    /* safety: libei_task does not outlive Self */
+    let input_capture = unsafe { &*input_capture };
     let mut active_clients: Vec<(CaptureHandle, Position)> = vec![];
     let mut next_barrier_id = 1u32;
 
-    /* there is a bug in xdg-remote-desktop-portal-gnome / mutter that
+    let mut zones_changed = input_capture.receive_zones_changed().await?;
-     * prevents receiving further events after a session has been disabled once.
-     * Therefore the session needs to recreated when the barriers are updated */
 
     loop {
-        // otherwise it asks to capture input even with no active clients
+        // do capture session
-        if active_clients.is_empty() {
+        let cancel_session = CancellationToken::new();
-            wait_for_active_client(&mut notify_rx, &mut active_clients).await;
+        let cancel_update = CancellationToken::new();
-            if notify_rx.is_closed() {
+
-                break Ok(());
+        let mut capture_event_occured: Option<LibeiNotifyEvent> = None;
-            } else {
+        let mut zones_have_changed = false;
-                continue;
+
+        // kill session if clients need to be updated
+        let handle_session_update_request = async {
+            tokio::select! {
+                _ = cancellation_token.cancelled() => {
+                    log::debug!("cancelled")
+                }, /* exit requested */
+                _ = cancel_update.cancelled() => {
+                    log::debug!("update task cancelled");
+                }, /* session exited */
+                _ = zones_changed.next() => {
+                    log::debug!("zones changed!");
+                    zones_have_changed = true
+                }, /* zones have changed */
+                e = capture_event.recv() => if let Some(e) = e { /* clients changed */
+                    log::debug!("capture event: {e:?}");
+                    capture_event_occured.replace(e);
+                },
+            }
+            // kill session (might already be dead!)
+            log::debug!("=> cancelling session");
+            cancel_session.cancel();
+        };
+
+        if !active_clients.is_empty() {
+            // create session
+            let mut session = match session.take() {
+                Some(s) => s,
+                None => create_session(input_capture).await?.0,
+            };
+
+            let capture_session = do_capture_session(
+                input_capture,
+                &mut session,
+                &event_tx,
+                &active_clients,
+                &mut next_barrier_id,
+                &notify_release,
+                (cancel_session.clone(), cancel_update.clone()),
+            );
+
+            let (capture_result, ()) = tokio::join!(capture_session, handle_session_update_request);
+            log::debug!("capture session + session_update task done!");
+
+            // disable capture
+            log::debug!("disabling input capture");
+            if let Err(e) = input_capture.disable(&session).await {
+                log::warn!("input_capture.disable(&session) {e}");
+            }
+            if let Err(e) = session.close().await {
+                log::warn!("session.close(): {e}");
+            }
+
+            // propagate error from capture session
+            capture_result?;
+        } else {
+            handle_session_update_request.await;
+        }
+
+        // update clients if requested
+        if let Some(event) = capture_event_occured.take() {
+            match event {
+                LibeiNotifyEvent::Create(c, p) => active_clients.push((c, p)),
+                LibeiNotifyEvent::Destroy(c) => active_clients.retain(|(h, _)| *h != c),
             }
         }
 
-        let current_client = Rc::new(Cell::new(None));
+        // break
+        if cancellation_token.is_cancelled() {
+            break Ok(());
+        }
+    }
+}
 
-        // create session
+async fn do_capture_session(
-        let (session, _) = match first_session.take() {
+    input_capture: &InputCapture<'_>,
-            Some(s) => s,
+    session: &mut Session<'_, InputCapture<'_>>,
-            _ => create_session(input_capture).await?,
+    event_tx: &Sender<(CaptureHandle, CaptureEvent)>,
-        };
+    active_clients: &[(CaptureHandle, Position)],
+    next_barrier_id: &mut u32,
+    notify_release: &Notify,
+    cancel: (CancellationToken, CancellationToken),
+) -> Result<(), CaptureError> {
+    let (cancel_session, cancel_update) = cancel;
+    // current client
+    let current_client = Rc::new(Cell::new(None));
 
-        // connect to eis server
+    // connect to eis server
-        let (context, ei_event_stream) = connect_to_eis(input_capture, &session).await?;
+    let (context, ei_event_stream) = connect_to_eis(input_capture, session).await?;
 
-        // async event task
+    // set barriers
-        let mut ei_task: JoinHandle<Result<(), CaptureError>> =
+    let (barriers, client_for_barrier_id) =
-            tokio::task::spawn_local(libei_event_handler(
+        update_barriers(input_capture, session, active_clients, next_barrier_id).await?;
+
+    log::debug!("enabling session");
+    input_capture.enable(session).await?;
+
+    // cancellation token to release session
+    let release_session = Arc::new(Notify::new());
+
+    // async event task
+    let cancel_ei_handler = CancellationToken::new();
+    let event_chan = event_tx.clone();
+    let client = current_client.clone();
+    let cancel_session_clone = cancel_session.clone();
+    let release_session_clone = release_session.clone();
+    let cancel_ei_handler_clone = cancel_ei_handler.clone();
+    let ei_task = async move {
+        tokio::select! {
+            r = libei_event_handler(
                 ei_event_stream,
                 context,
-                event_tx.clone(),
+                event_chan,
-                current_client.clone(),
+                release_session_clone,
-            ));
+                client,
+            ) => {
+                log::debug!("libei exited: {r:?} cancelling session task");
+                cancel_session_clone.cancel();
+            }
+            _ = cancel_ei_handler_clone.cancelled() => {},
+        }
+        Ok::<(), CaptureError>(())
+    };
 
+    let capture_session_task = async {
+        // receiver for activation tokens
         let mut activated = input_capture.receive_activated().await?;
-        let mut zones_changed = input_capture.receive_zones_changed().await?;
+        let mut ei_devices_changed = false;
-
-        // set barriers
-        let client_for_barrier_id = update_barriers(
-            input_capture,
-            &session,
-            &active_clients,
-            &mut next_barrier_id,
-        )
-        .await?;
-
-        log::debug!("enabling session");
-        input_capture.enable(&session).await?;
-
         loop {
             tokio::select! {
                 activated = activated.next() => {
                     let activated = activated.ok_or(CaptureError::ActivationClosed)?;
                     log::debug!("activated: {activated:?}");
 
-                    let client = *client_for_barrier_id
+                    // get barrier id from activation
-                        .get(&activated.barrier_id())
+                    let barrier_id = match activated.barrier_id() {
-                        .expect("invalid barrier id");
+                        Some(bid) => bid,
-                    current_client.replace(Some(client));
+                        // workaround for KDE plasma not reporting barrier ids
-
+                        None => find_corresponding_client(&barriers, activated.cursor_position().expect("no cursor position reported by compositor")),
-                    if event_tx.send((client, Event::Enter())).await.is_err() {
-                        break;
                     };
 
+                    // find client corresponding to barrier
+                    let client = *client_for_barrier_id.get(&barrier_id).expect("invalid barrier id");
+                    current_client.replace(Some(client));
+
+                    // client entered => send event
+                    event_tx.send((client, CaptureEvent::Begin)).await.expect("no channel");
+
                     tokio::select! {
-                        producer_event = notify_rx.recv() => {
+                        _ = notify_release.notified() => { /* capture release */
-                            let producer_event = producer_event.expect("channel closed");
+                            log::debug!("release session requested");
-                            if handle_producer_event(producer_event, &mut active_clients) {
+                        },
-                                break; /* clients updated */
+                        _ = release_session.notified() => { /* release session */
-                            }
+                            log::debug!("ei devices changed");
-                        }
+                            ei_devices_changed = true;
-                        zones_changed = zones_changed.next() => {
+                        },
-                            log::debug!("zones changed: {zones_changed:?}");
+                        _ = cancel_session.cancelled() => { /* kill session notify */
-                            break;
+                            log::debug!("session cancel requested");
-                        }
+                            break
-                        res = &mut ei_task => {
+                        },
-                            if let Err(e) = res.expect("ei task paniced") {
-                                log::warn!("libei task exited: {e}");
-                            }
-                            break;
-                        }
                     }
-                    release_capture(
+
-                        input_capture,
+                    release_capture(input_capture, session, activated, client, active_clients).await?;
-                        &session,
+
-                        activated,
-                        client,
-                        &active_clients,
-                    ).await?;
                 }
-                producer_event = notify_rx.recv() => {
+                _ = notify_release.notified() => { /* capture release -> we are not capturing anyway, so ignore */
-                    let producer_event = producer_event.expect("channel closed");
+                    log::debug!("release session requested");
-                    if handle_producer_event(producer_event, &mut active_clients) {
-                        /* clients updated */
-                        break;
-                    }
                 },
-                res = &mut ei_task => {
+                _ = release_session.notified() => { /* release session */
-                    if let Err(e) = res.expect("ei task paniced") {
+                    log::debug!("ei devices changed");
-                        log::warn!("libei task exited: {e}");
+                    ei_devices_changed = true;
-                    }
+                },
-                    break;
+                _ = cancel_session.cancelled() => { /* kill session notify */
-                }
+                    log::debug!("session cancel requested");
+                    break
+                },
+            }
+            if ei_devices_changed {
+                /* for whatever reason, GNOME seems to kill the session
+                 * as soon as devices are added or removed, so we need
+                 * to cancel */
+                break;
             }
         }
-        ei_task.abort();
+        // cancel libei task
-        input_capture.disable(&session).await?;
+        log::debug!("session exited: killing libei task");
-        if event_tx.is_closed() {
+        cancel_ei_handler.cancel();
-            break Ok(());
+        Ok::<(), CaptureError>(())
-        }
+    };
-    }
+
+    let (a, b) = tokio::join!(ei_task, capture_session_task);
+
+    cancel_update.cancel();
+
+    log::debug!("both session and ei task finished!");
+    a?;
+    b?;
+
+    Ok(())
 }
 
-async fn release_capture(
+async fn release_capture<'a>(
-    input_capture: &InputCapture<'_>,
+    input_capture: &InputCapture<'a>,
-    session: &Session<'_>,
+    session: &Session<'a, InputCapture<'a>>,
     activated: Activated,
     current_client: CaptureHandle,
     active_clients: &[(CaptureHandle, Position)],
 ) -> Result<(), CaptureError> {
-    log::debug!("releasing input capture {}", activated.activation_id());
+    if let Some(activation_id) = activated.activation_id() {
-    let (x, y) = activated.cursor_position();
+        log::debug!("releasing input capture {activation_id}");
+    }
+    let (x, y) = activated
+        .cursor_position()
+        .expect("compositor did not report cursor position!");
+    log::debug!("client entered @ ({x}, {y})");
     let pos = active_clients
         .iter()
         .filter(|(c, _)| *c == current_client)
@@ -382,214 +510,134 @@ async fn release_capture(
     // release 1px to the right of the entered zone
     let cursor_position = (x as f64 + dx, y as f64 + dy);
     input_capture
-        .release(session, activated.activation_id(), cursor_position)
+        .release(session, activated.activation_id(), Some(cursor_position))
         .await?;
     Ok(())
 }
 
-fn handle_producer_event(
+fn find_corresponding_client(barriers: &[ICBarrier], pos: (f32, f32)) -> BarrierID {
-    producer_event: ProducerEvent,
+    barriers
-    active_clients: &mut Vec<(CaptureHandle, Position)>,
+        .iter()
-) -> bool {
+        .copied()
-    log::debug!("handling event: {producer_event:?}");
+        .min_by_key(|b| {
-    match producer_event {
+            let (x1, y1, x2, y2) = b.position;
-        ProducerEvent::Release => false,
+            let (x1, y1, x2, y2) = (x1 as f32, y1 as f32, x2 as f32, y2 as f32);
-        ProducerEvent::Create(c, p) => {
+            distance_to_line(((x1, y1), (x2, y2)), pos) as i32
-            active_clients.push((c, p));
+        })
-            true
+        .expect("could not find barrier corresponding to client")
-        }
+        .barrier_id
-        ProducerEvent::Destroy(c) => {
-            active_clients.retain(|(h, _)| *h != c);
-            true
-        }
-    }
 }
 
+fn distance_to_line(line: ((f32, f32), (f32, f32)), p: (f32, f32)) -> f32 {
+    let ((x1, y1), (x2, y2)) = line;
+    let (x0, y0) = p;
+    /*
+     * we use the fact that for the triangle spanned by the line and p,
+     * the height of the triangle is the desired distance and can be calculated by
+     * h = 2A / b with b being the line_length and
+     */
+    let double_triangle_area = ((y2 - y1) * x0 - (x2 - x1) * y0 + x2 * y1 - y2 * x1).abs();
+    let line_length = ((y2 - y1).powf(2.0) + (x2 - x1).powf(2.0)).sqrt();
+    let distance = double_triangle_area / line_length;
+    log::debug!("distance to line({line:?}, {p:?}) = {distance}");
+    distance
+}
+
+static ALL_CAPABILITIES: &[DeviceCapability] = &[
+    DeviceCapability::Pointer,
+    DeviceCapability::PointerAbsolute,
+    DeviceCapability::Keyboard,
+    DeviceCapability::Touch,
+    DeviceCapability::Scroll,
+    DeviceCapability::Button,
+];
+
 async fn handle_ei_event(
     ei_event: EiEvent,
     current_client: Option<CaptureHandle>,
     context: &ei::Context,
-    event_tx: &Sender<(CaptureHandle, Event)>,
+    event_tx: &Sender<(CaptureHandle, CaptureEvent)>,
-) {
+    release_session: &Notify,
+) -> Result<(), CaptureError> {
     match ei_event {
         EiEvent::SeatAdded(s) => {
-            s.seat.bind_capabilities(&[
+            s.seat.bind_capabilities(ALL_CAPABILITIES);
-                DeviceCapability::Pointer,
+            context.flush().map_err(|e| io::Error::new(e.kind(), e))?;
-                DeviceCapability::PointerAbsolute,
-                DeviceCapability::Keyboard,
-                DeviceCapability::Touch,
-                DeviceCapability::Scroll,
-                DeviceCapability::Button,
-            ]);
-            context.flush().unwrap();
         }
-        EiEvent::SeatRemoved(_) => {}
+        EiEvent::SeatRemoved(_) | /* EiEvent::DeviceAdded(_) | */ EiEvent::DeviceRemoved(_) => {
-        EiEvent::DeviceAdded(_) => {}
+            log::debug!("releasing session: {ei_event:?}");
-        EiEvent::DeviceRemoved(_) => {}
+            release_session.notify_waiters();
-        EiEvent::DevicePaused(_) => {}
-        EiEvent::DeviceResumed(_) => {}
-        EiEvent::KeyboardModifiers(mods) => {
-            let modifier_event = KeyboardEvent::Modifiers {
-                mods_depressed: mods.depressed,
-                mods_latched: mods.latched,
-                mods_locked: mods.locked,
-                group: mods.group,
-            };
-            if let Some(current_client) = current_client {
-                event_tx
-                    .send((current_client, Event::Keyboard(modifier_event)))
-                    .await
-                    .unwrap();
-            }
         }
-        EiEvent::Frame(_) => {}
+        EiEvent::DevicePaused(_) | EiEvent::DeviceResumed(_) => {}
-        EiEvent::DeviceStartEmulating(_) => {
+        EiEvent::DeviceStartEmulating(_) => log::debug!("START EMULATING"),
-            log::debug!("START EMULATING =============>");
+        EiEvent::DeviceStopEmulating(_) => log::debug!("STOP EMULATING"),
-        }
-        EiEvent::DeviceStopEmulating(_) => {
-            log::debug!("==================> STOP EMULATING");
-        }
-        EiEvent::PointerMotion(motion) => {
-            let motion_event = PointerEvent::Motion {
-                time: motion.time as u32,
-                dx: motion.dx as f64,
-                dy: motion.dy as f64,
-            };
-            if let Some(current_client) = current_client {
-                event_tx
-                    .send((current_client, Event::Pointer(motion_event)))
-                    .await
-                    .unwrap();
-            }
-        }
-        EiEvent::PointerMotionAbsolute(_) => {}
-        EiEvent::Button(button) => {
-            let button_event = PointerEvent::Button {
-                time: button.time as u32,
-                button: button.button,
-                state: match button.state {
-                    ButtonState::Released => 0,
-                    ButtonState::Press => 1,
-                },
-            };
-            if let Some(current_client) = current_client {
-                event_tx
-                    .send((current_client, Event::Pointer(button_event)))
-                    .await
-                    .unwrap();
-            }
-        }
-        EiEvent::ScrollDelta(delta) => {
-            if let Some(handle) = current_client {
-                let mut events = vec![];
-                if delta.dy != 0. {
-                    events.push(PointerEvent::Axis {
-                        time: 0,
-                        axis: 0,
-                        value: delta.dy as f64,
-                    });
-                }
-                if delta.dx != 0. {
-                    events.push(PointerEvent::Axis {
-                        time: 0,
-                        axis: 1,
-                        value: delta.dx as f64,
-                    });
-                }
-                for event in events {
-                    event_tx
-                        .send((handle, Event::Pointer(event)))
-                        .await
-                        .unwrap();
-                }
-            }
-        }
-        EiEvent::ScrollStop(_) => {}
-        EiEvent::ScrollCancel(_) => {}
-        EiEvent::ScrollDiscrete(scroll) => {
-            if scroll.discrete_dy != 0 {
-                let event = PointerEvent::AxisDiscrete120 {
-                    axis: 0,
-                    value: scroll.discrete_dy,
-                };
-                if let Some(current_client) = current_client {
-                    event_tx
-                        .send((current_client, Event::Pointer(event)))
-                        .await
-                        .unwrap();
-                }
-            }
-            if scroll.discrete_dx != 0 {
-                let event = PointerEvent::AxisDiscrete120 {
-                    axis: 1,
-                    value: scroll.discrete_dx,
-                };
-                if let Some(current_client) = current_client {
-                    event_tx
-                        .send((current_client, Event::Pointer(event)))
-                        .await
-                        .unwrap();
-                }
-            };
-        }
-        EiEvent::KeyboardKey(key) => {
-            let key_event = KeyboardEvent::Key {
-                key: key.key,
-                state: match key.state {
-                    KeyState::Press => 1,
-                    KeyState::Released => 0,
-                },
-                time: key.time as u32,
-            };
-            if let Some(current_client) = current_client {
-                event_tx
-                    .send((current_client, Event::Keyboard(key_event)))
-                    .await
-                    .unwrap();
-            }
-        }
-        EiEvent::TouchDown(_) => {}
-        EiEvent::TouchUp(_) => {}
-        EiEvent::TouchMotion(_) => {}
         EiEvent::Disconnected(d) => {
-            log::error!("disconnect: {d:?}");
+            return Err(CaptureError::Disconnected(format!("{:?}", d.reason)))
         }
+        _ => {
+            if let Some(handle) = current_client {
+                for event in Event::from_ei_event(ei_event) {
+                    event_tx.send((handle, CaptureEvent::Input(event))).await.expect("no channel");
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+#[async_trait]
+impl<'a> LanMouseInputCapture for LibeiInputCapture<'a> {
+    async fn create(&mut self, handle: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
+        let _ = self
+            .notify_capture
+            .send(LibeiNotifyEvent::Create(handle, pos))
+            .await;
+        Ok(())
+    }
+
+    async fn destroy(&mut self, handle: CaptureHandle) -> Result<(), CaptureError> {
+        let _ = self
+            .notify_capture
+            .send(LibeiNotifyEvent::Destroy(handle))
+            .await;
+        Ok(())
+    }
+
+    async fn release(&mut self) -> Result<(), CaptureError> {
+        self.notify_release.notify_waiters();
+        Ok(())
+    }
+
+    async fn terminate(&mut self) -> Result<(), CaptureError> {
+        self.cancellation_token.cancel();
+        let task = &mut self.capture_task;
+        log::debug!("waiting for capture to terminate...");
+        let res = task.await.expect("libei task panic");
+        log::debug!("done!");
+        self.terminated = true;
+        res
     }
 }
 
-impl<'a> LanMouseInputCapture for LibeiInputCapture<'a> {
+impl<'a> Drop for LibeiInputCapture<'a> {
-    fn create(&mut self, handle: super::CaptureHandle, pos: super::Position) -> io::Result<()> {
+    fn drop(&mut self) {
-        let notify_tx = self.notify_tx.clone();
+        if !self.terminated {
-        tokio::task::spawn_local(async move {
+            /* this workaround is needed until async drop is stabilized */
-            let _ = notify_tx.send(ProducerEvent::Create(handle, pos)).await;
+            panic!("LibeiInputCapture dropped without being terminated!");
-        });
+        }
-        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;
-        });
-        Ok(())
-    }
-
-    fn release(&mut self) -> io::Result<()> {
-        let notify_tx = self.notify_tx.clone();
-        tokio::task::spawn_local(async move {
-            let _ = notify_tx.send(ProducerEvent::Release).await;
-        });
-        Ok(())
     }
 }
 
 impl<'a> Stream for LibeiInputCapture<'a> {
-    type Item = io::Result<(CaptureHandle, Event)>;
+    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;
 
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        match ready!(self.event_rx.poll_recv(cx)) {
+        match self.capture_task.poll_unpin(cx) {
-            None => Poll::Ready(None),
+            Poll::Ready(r) => match r.expect("failed to join") {
-            Some(e) => Poll::Ready(Some(Ok(e))),
+                Ok(()) => Poll::Ready(None),
+                Err(e) => Poll::Ready(Some(Err(e))),
+            },
+            Poll::Pending => self.event_rx.poll_recv(cx).map(|e| e.map(Result::Ok)),
         }
     }
 }

input-capture/src/macos.rs

@@ -1,35 +1,602 @@
-use crate::{error::MacOSInputCaptureCreationError, CaptureHandle, InputCapture, Position};
+use super::{
+    error::MacosCaptureCreationError, Capture, CaptureError, CaptureEvent, CaptureHandle, Position,
+};
+use async_trait::async_trait;
+use bitflags::bitflags;
+use core_foundation::base::{kCFAllocatorDefault, CFRelease};
+use core_foundation::date::CFTimeInterval;
+use core_foundation::number::{kCFBooleanTrue, CFBooleanRef};
+use core_foundation::runloop::{kCFRunLoopCommonModes, CFRunLoop, CFRunLoopSource};
+use core_foundation::string::{kCFStringEncodingUTF8, CFStringCreateWithCString, CFStringRef};
+use core_graphics::base::{kCGErrorSuccess, CGError};
+use core_graphics::display::{CGDisplay, CGPoint};
+use core_graphics::event::{
+    CGEvent, CGEventFlags, CGEventTap, CGEventTapLocation, CGEventTapOptions, CGEventTapPlacement,
+    CGEventTapProxy, CGEventType, EventField,
+};
+use core_graphics::event_source::{CGEventSource, CGEventSourceStateID};
 use futures_core::Stream;
-use input_event::Event;
+use input_event::{Event, KeyboardEvent, PointerEvent, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT};
-use std::task::{Context, Poll};
+use keycode::{KeyMap, KeyMapping};
-use std::{io, pin::Pin};
+use libc::c_void;
+use once_cell::unsync::Lazy;
+use std::collections::HashMap;
+use std::ffi::{c_char, CString};
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::{ready, Context, Poll};
+use std::thread::{self};
+use tokio::sync::mpsc::{Receiver, Sender};
+use tokio::sync::Mutex;
 
-pub struct MacOSInputCapture;
+#[derive(Debug, Default)]
+struct Bounds {
+    xmin: f64,
+    xmax: f64,
+    ymin: f64,
+    ymax: f64,
+}
+
+#[derive(Debug)]
+struct InputCaptureState {
+    client_for_pos: Lazy<HashMap<Position, CaptureHandle>>,
+    current_client: Option<(CaptureHandle, Position)>,
+    bounds: Bounds,
+}
+
+#[derive(Debug)]
+enum ProducerEvent {
+    Release,
+    Create(CaptureHandle, Position),
+    Destroy(CaptureHandle),
+    Grab((CaptureHandle, Position)),
+    EventTapDisabled,
+}
+
+impl InputCaptureState {
+    fn new() -> Result<Self, MacosCaptureCreationError> {
+        let mut res = Self {
+            client_for_pos: Lazy::new(HashMap::new),
+            current_client: None,
+            bounds: Bounds::default(),
+        };
+        res.update_bounds()?;
+        Ok(res)
+    }
+
+    fn crossed(&mut self, event: &CGEvent) -> Option<(CaptureHandle, Position)> {
+        let location = event.location();
+        let relative_x = event.get_double_value_field(EventField::MOUSE_EVENT_DELTA_X);
+        let relative_y = event.get_double_value_field(EventField::MOUSE_EVENT_DELTA_Y);
+
+        for (position, client) in self.client_for_pos.iter() {
+            if (position == &Position::Left && (location.x + relative_x) <= self.bounds.xmin)
+                || (position == &Position::Right && (location.x + relative_x) >= self.bounds.xmax)
+                || (position == &Position::Top && (location.y + relative_y) <= self.bounds.ymin)
+                || (position == &Position::Bottom && (location.y + relative_y) >= self.bounds.ymax)
+            {
+                log::debug!("Crossed barrier into client: {client}, {position:?}");
+                return Some((*client, *position));
+            }
+        }
+        None
+    }
+
+    // Get the max bounds of all displays
+    fn update_bounds(&mut self) -> Result<(), MacosCaptureCreationError> {
+        let active_ids =
+            CGDisplay::active_displays().map_err(MacosCaptureCreationError::ActiveDisplays)?;
+        active_ids.iter().for_each(|d| {
+            let bounds = CGDisplay::new(*d).bounds();
+            self.bounds.xmin = self.bounds.xmin.min(bounds.origin.x);
+            self.bounds.xmax = self.bounds.xmax.max(bounds.origin.x + bounds.size.width);
+            self.bounds.ymin = self.bounds.ymin.min(bounds.origin.y);
+            self.bounds.ymax = self.bounds.ymax.max(bounds.origin.y + bounds.size.height);
+        });
+
+        log::debug!("Updated displays bounds: {0:?}", self.bounds);
+        Ok(())
+    }
+
+    // We can't disable mouse movement when in a client so we need to reset the cursor position
+    // to the edge of the screen, the cursor will be hidden but we dont want it to appear in a
+    // random location when we exit the client
+    fn reset_mouse_position(&self, event: &CGEvent) -> Result<(), CaptureError> {
+        if let Some((_, pos)) = self.current_client {
+            let location = event.location();
+            let edge_offset = 1.0;
+
+            // After the cursor is warped no event is produced but the next event
+            // will carry the delta from the warp so only half the delta is needed to move the cursor
+            let delta_y = event.get_double_value_field(EventField::MOUSE_EVENT_DELTA_Y) / 2.0;
+            let delta_x = event.get_double_value_field(EventField::MOUSE_EVENT_DELTA_X) / 2.0;
+
+            let mut new_x = location.x + delta_x;
+            let mut new_y = location.y + delta_y;
+
+            match pos {
+                Position::Left => {
+                    new_x = self.bounds.xmin + edge_offset;
+                }
+                Position::Right => {
+                    new_x = self.bounds.xmax - edge_offset;
+                }
+                Position::Top => {
+                    new_y = self.bounds.ymin + edge_offset;
+                }
+                Position::Bottom => {
+                    new_y = self.bounds.ymax - edge_offset;
+                }
+            }
+            let new_pos = CGPoint::new(new_x, new_y);
+
+            log::trace!("Resetting cursor position to: {new_x}, {new_y}");
+
+            return CGDisplay::warp_mouse_cursor_position(new_pos)
+                .map_err(CaptureError::WarpCursor);
+        }
+
+        Err(CaptureError::ResetMouseWithoutClient)
+    }
+
+    async fn handle_producer_event(
+        &mut self,
+        producer_event: ProducerEvent,
+    ) -> Result<(), CaptureError> {
+        log::debug!("handling event: {producer_event:?}");
+        match producer_event {
+            ProducerEvent::Release => {
+                if self.current_client.is_some() {
+                    CGDisplay::show_cursor(&CGDisplay::main())
+                        .map_err(CaptureError::CoreGraphics)?;
+                    self.current_client = None;
+                }
+            }
+            ProducerEvent::Grab(client) => {
+                if self.current_client.is_none() {
+                    CGDisplay::hide_cursor(&CGDisplay::main())
+                        .map_err(CaptureError::CoreGraphics)?;
+                    self.current_client = Some(client);
+                }
+            }
+            ProducerEvent::Create(c, p) => {
+                self.client_for_pos.insert(p, c);
+            }
+            ProducerEvent::Destroy(c) => {
+                for pos in [
+                    Position::Left,
+                    Position::Right,
+                    Position::Top,
+                    Position::Bottom,
+                ] {
+                    if let Some((current_c, _)) = self.current_client {
+                        if current_c == c {
+                            CGDisplay::show_cursor(&CGDisplay::main())
+                                .map_err(CaptureError::CoreGraphics)?;
+                            self.current_client = None;
+                        };
+                    }
+                    if self.client_for_pos.get(&pos).copied() == Some(c) {
+                        self.client_for_pos.remove(&pos);
+                    }
+                }
+            }
+            ProducerEvent::EventTapDisabled => return Err(CaptureError::EventTapDisabled),
+        };
+        Ok(())
+    }
+}
+
+fn get_events(
+    ev_type: &CGEventType,
+    ev: &CGEvent,
+    result: &mut Vec<CaptureEvent>,
+) -> Result<(), CaptureError> {
+    fn map_pointer_event(ev: &CGEvent) -> PointerEvent {
+        PointerEvent::Motion {
+            time: 0,
+            dx: ev.get_double_value_field(EventField::MOUSE_EVENT_DELTA_X),
+            dy: ev.get_double_value_field(EventField::MOUSE_EVENT_DELTA_Y),
+        }
+    }
+
+    fn map_key(ev: &CGEvent) -> Result<u32, CaptureError> {
+        let code = ev.get_integer_value_field(EventField::KEYBOARD_EVENT_KEYCODE);
+        match KeyMap::from_key_mapping(KeyMapping::Mac(code as u16)) {
+            Ok(k) => Ok(k.evdev as u32),
+            Err(()) => Err(CaptureError::KeyMapError(code)),
+        }
+    }
+
+    match ev_type {
+        CGEventType::KeyDown => {
+            let k = map_key(ev)?;
+            result.push(CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key {
+                time: 0,
+                key: k,
+                state: 1,
+            })));
+        }
+        CGEventType::KeyUp => {
+            let k = map_key(ev)?;
+            result.push(CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key {
+                time: 0,
+                key: k,
+                state: 0,
+            })));
+        }
+        CGEventType::FlagsChanged => {
+            let mut mods = XMods::empty();
+            let mut mods_locked = XMods::empty();
+            let cg_flags = ev.get_flags();
+
+            if cg_flags.contains(CGEventFlags::CGEventFlagShift) {
+                mods |= XMods::ShiftMask;
+            }
+            if cg_flags.contains(CGEventFlags::CGEventFlagControl) {
+                mods |= XMods::ControlMask;
+            }
+            if cg_flags.contains(CGEventFlags::CGEventFlagAlternate) {
+                mods |= XMods::Mod1Mask;
+            }
+            if cg_flags.contains(CGEventFlags::CGEventFlagCommand) {
+                mods |= XMods::Mod4Mask;
+            }
+            if cg_flags.contains(CGEventFlags::CGEventFlagAlphaShift) {
+                mods |= XMods::LockMask;
+                mods_locked |= XMods::LockMask;
+            }
+
+            let modifier_event = KeyboardEvent::Modifiers {
+                depressed: mods.bits(),
+                latched: 0,
+                locked: mods_locked.bits(),
+                group: 0,
+            };
+
+            result.push(CaptureEvent::Input(Event::Keyboard(modifier_event)));
+        }
+        CGEventType::MouseMoved => {
+            result.push(CaptureEvent::Input(Event::Pointer(map_pointer_event(ev))))
+        }
+        CGEventType::LeftMouseDragged => {
+            result.push(CaptureEvent::Input(Event::Pointer(map_pointer_event(ev))))
+        }
+        CGEventType::RightMouseDragged => {
+            result.push(CaptureEvent::Input(Event::Pointer(map_pointer_event(ev))))
+        }
+        CGEventType::OtherMouseDragged => {
+            result.push(CaptureEvent::Input(Event::Pointer(map_pointer_event(ev))))
+        }
+        CGEventType::LeftMouseDown => {
+            result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Button {
+                time: 0,
+                button: BTN_LEFT,
+                state: 1,
+            })))
+        }
+        CGEventType::LeftMouseUp => {
+            result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Button {
+                time: 0,
+                button: BTN_LEFT,
+                state: 0,
+            })))
+        }
+        CGEventType::RightMouseDown => {
+            result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Button {
+                time: 0,
+                button: BTN_RIGHT,
+                state: 1,
+            })))
+        }
+        CGEventType::RightMouseUp => {
+            result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Button {
+                time: 0,
+                button: BTN_RIGHT,
+                state: 0,
+            })))
+        }
+        CGEventType::OtherMouseDown => {
+            result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Button {
+                time: 0,
+                button: BTN_MIDDLE,
+                state: 1,
+            })))
+        }
+        CGEventType::OtherMouseUp => {
+            result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Button {
+                time: 0,
+                button: BTN_MIDDLE,
+                state: 0,
+            })))
+        }
+        CGEventType::ScrollWheel => {
+            let v = ev.get_integer_value_field(EventField::SCROLL_WHEEL_EVENT_POINT_DELTA_AXIS_1);
+            let h = ev.get_integer_value_field(EventField::SCROLL_WHEEL_EVENT_POINT_DELTA_AXIS_2);
+            if v != 0 {
+                result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Axis {
+                    time: 0,
+                    axis: 0, // Vertical
+                    value: v as f64,
+                })));
+            }
+            if h != 0 {
+                result.push(CaptureEvent::Input(Event::Pointer(PointerEvent::Axis {
+                    time: 0,
+                    axis: 1, // Horizontal
+                    value: h as f64,
+                })));
+            }
+        }
+        _ => (),
+    }
+    Ok(())
+}
+
+fn event_tap_thread(
+    client_state: Arc<Mutex<InputCaptureState>>,
+    event_tx: Sender<(CaptureHandle, CaptureEvent)>,
+    notify_tx: Sender<ProducerEvent>,
+    exit: tokio::sync::oneshot::Sender<Result<(), &'static str>>,
+) {
+    let cg_events_of_interest: Vec<CGEventType> = vec![
+        CGEventType::LeftMouseDown,
+        CGEventType::LeftMouseUp,
+        CGEventType::RightMouseDown,
+        CGEventType::RightMouseUp,
+        CGEventType::OtherMouseDown,
+        CGEventType::OtherMouseUp,
+        CGEventType::MouseMoved,
+        CGEventType::LeftMouseDragged,
+        CGEventType::RightMouseDragged,
+        CGEventType::OtherMouseDragged,
+        CGEventType::ScrollWheel,
+        CGEventType::KeyDown,
+        CGEventType::KeyUp,
+        CGEventType::FlagsChanged,
+    ];
+
+    let tap = CGEventTap::new(
+        CGEventTapLocation::Session,
+        CGEventTapPlacement::HeadInsertEventTap,
+        CGEventTapOptions::Default,
+        cg_events_of_interest,
+        |_proxy: CGEventTapProxy, event_type: CGEventType, cg_ev: &CGEvent| {
+            log::trace!("Got event from tap: {event_type:?}");
+            let mut state = client_state.blocking_lock();
+            let mut client = None;
+            let mut res_events = vec![];
+
+            if matches!(
+                event_type,
+                CGEventType::TapDisabledByTimeout | CGEventType::TapDisabledByUserInput
+            ) {
+                log::error!("CGEventTap disabled");
+                notify_tx
+                    .blocking_send(ProducerEvent::EventTapDisabled)
+                    .unwrap_or_else(|e| {
+                        log::error!("Failed to send notification: {e}");
+                    });
+            }
+
+            // Are we in a client?
+            if let Some((current_client, _)) = state.current_client {
+                client = Some(current_client);
+                get_events(&event_type, cg_ev, &mut res_events).unwrap_or_else(|e| {
+                    log::error!("Failed to get events: {e}");
+                });
+
+                // Keep (hidden) cursor at the edge of the screen
+                if matches!(event_type, CGEventType::MouseMoved) {
+                    state.reset_mouse_position(cg_ev).unwrap_or_else(|e| {
+                        log::error!("Failed to reset mouse position: {e}");
+                    })
+                }
+            }
+            // Did we cross a barrier?
+            else if matches!(event_type, CGEventType::MouseMoved) {
+                if let Some((new_client, pos)) = state.crossed(cg_ev) {
+                    client = Some(new_client);
+                    res_events.push(CaptureEvent::Begin);
+                    notify_tx
+                        .blocking_send(ProducerEvent::Grab((new_client, pos)))
+                        .expect("Failed to send notification");
+                }
+            }
+
+            if let Some(client) = client {
+                res_events.iter().for_each(|e| {
+                    event_tx
+                        .blocking_send((client, *e))
+                        .expect("Failed to send event");
+                });
+                // Returning None should stop the event from being processed
+                // but core fundation still returns the event
+                cg_ev.set_type(CGEventType::Null);
+            }
+            Some(cg_ev.to_owned())
+        },
+    )
+    .expect("Failed creating tap");
+
+    let tap_source: CFRunLoopSource = tap
+        .mach_port
+        .create_runloop_source(0)
+        .expect("Failed creating loop source");
+
+    unsafe {
+        CFRunLoop::get_current().add_source(&tap_source, kCFRunLoopCommonModes);
+    }
+
+    CFRunLoop::run_current();
+
+    let _ = exit.send(Err("tap thread exited"));
+}
+
+pub struct MacOSInputCapture {
+    event_rx: Receiver<(CaptureHandle, CaptureEvent)>,
+    notify_tx: Sender<ProducerEvent>,
+}
 
 impl MacOSInputCapture {
-    pub fn new() -> std::result::Result<Self, MacOSInputCaptureCreationError> {
+    pub async fn new() -> Result<Self, MacosCaptureCreationError> {
-        Err(MacOSInputCaptureCreationError::NotImplemented)
+        let state = Arc::new(Mutex::new(InputCaptureState::new()?));
+        let (event_tx, event_rx) = tokio::sync::mpsc::channel(32);
+        let (notify_tx, mut notify_rx) = tokio::sync::mpsc::channel(32);
+        let (tap_exit_tx, mut tap_exit_rx) = tokio::sync::oneshot::channel();
+
+        unsafe {
+            configure_cf_settings()?;
+        }
+
+        log::info!("Enabling CGEvent tap");
+        let event_tap_thread_state = state.clone();
+        let event_tap_notify = notify_tx.clone();
+        thread::spawn(move || {
+            event_tap_thread(
+                event_tap_thread_state,
+                event_tx,
+                event_tap_notify,
+                tap_exit_tx,
+            )
+        });
+
+        let _tap_task: tokio::task::JoinHandle<()> = tokio::task::spawn_local(async move {
+            loop {
+                tokio::select! {
+                    producer_event = notify_rx.recv() => {
+                        let producer_event = producer_event.expect("channel closed");
+                        let mut state = state.lock().await;
+                        state.handle_producer_event(producer_event).await.unwrap_or_else(|e| {
+                            log::error!("Failed to handle producer event: {e}");
+                        })
+                    }
+
+                    res = &mut tap_exit_rx => {
+                        if let Err(e) = res.expect("channel closed") {
+                            log::error!("Tap thread failed: {:?}", e);
+                            break;
+                        }
+                    }
+                }
+            }
+        });
+
+        Ok(Self {
+            event_rx,
+            notify_tx,
+        })
+    }
+}
+
+#[async_trait]
+impl Capture for MacOSInputCapture {
+    async fn create(&mut self, id: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
+        let notify_tx = self.notify_tx.clone();
+        tokio::task::spawn_local(async move {
+            log::debug!("creating client {id}, {pos}");
+            let _ = notify_tx.send(ProducerEvent::Create(id, pos)).await;
+            log::debug!("done !");
+        });
+        Ok(())
+    }
+
+    async fn destroy(&mut self, id: CaptureHandle) -> Result<(), CaptureError> {
+        let notify_tx = self.notify_tx.clone();
+        tokio::task::spawn_local(async move {
+            log::debug!("destroying client {id}");
+            let _ = notify_tx.send(ProducerEvent::Destroy(id)).await;
+            log::debug!("done !");
+        });
+        Ok(())
+    }
+
+    async fn release(&mut self) -> Result<(), CaptureError> {
+        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(())
+    }
+
+    async fn terminate(&mut self) -> Result<(), CaptureError> {
+        Ok(())
     }
 }
 
 impl Stream for MacOSInputCapture {
-    type Item = io::Result<(CaptureHandle, Event)>;
+    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;
 
-    fn poll_next(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        Poll::Pending
+        match ready!(self.event_rx.poll_recv(cx)) {
+            None => Poll::Ready(None),
+            Some(e) => Poll::Ready(Some(Ok(e))),
+        }
     }
 }
 
-impl InputCapture for MacOSInputCapture {
+type CGSConnectionID = u32;
-    fn create(&mut self, _id: CaptureHandle, _pos: Position) -> io::Result<()> {
-        Ok(())
-    }
 
-    fn destroy(&mut self, _id: CaptureHandle) -> io::Result<()> {
+#[link(name = "ApplicationServices", kind = "framework")]
-        Ok(())
+extern "C" {
-    }
+    fn CGSSetConnectionProperty(
+        cid: CGSConnectionID,
+        targetCID: CGSConnectionID,
+        key: CFStringRef,
+        value: CFBooleanRef,
+    ) -> CGError;
+    fn _CGSDefaultConnection() -> CGSConnectionID;
+}
 
-    fn release(&mut self) -> io::Result<()> {
+extern "C" {
-        Ok(())
+    fn CGEventSourceSetLocalEventsSuppressionInterval(
+        event_source: CGEventSource,
+        seconds: CFTimeInterval,
+    );
+}
+
+unsafe fn configure_cf_settings() -> Result<(), MacosCaptureCreationError> {
+    // When we warp the cursor using CGWarpMouseCursorPosition local events are suppressed for a short time
+    // this leeds to the cursor not flowing when crossing back from a clinet, set this to to 0 stops the warp
+    // from working, set a low value by trial and error, 0.05s seems good. 0.25s is the default
+    let event_source = CGEventSource::new(CGEventSourceStateID::CombinedSessionState)
+        .map_err(|_| MacosCaptureCreationError::EventSourceCreation)?;
+    CGEventSourceSetLocalEventsSuppressionInterval(event_source, 0.05);
+
+    // This is a private settings that allows the cursor to be hidden while in the background.
+    // It is used by Barrier and other apps.
+    let key = CString::new("SetsCursorInBackground").unwrap();
+    let cf_key = CFStringCreateWithCString(
+        kCFAllocatorDefault,
+        key.as_ptr() as *const c_char,
+        kCFStringEncodingUTF8,
+    );
+    if CGSSetConnectionProperty(
+        _CGSDefaultConnection(),
+        _CGSDefaultConnection(),
+        cf_key,
+        kCFBooleanTrue,
+    ) != kCGErrorSuccess
+    {
+        return Err(MacosCaptureCreationError::CGCursorProperty);
+    }
+    CFRelease(cf_key as *const c_void);
+    Ok(())
+}
+
+// From X11/X.h
+bitflags! {
+    #[repr(C)]
+    #[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+    struct XMods: u32 {
+        const ShiftMask = (1<<0);
+        const LockMask = (1<<1);
+        const ControlMask = (1<<2);
+        const Mod1Mask = (1<<3);
+        const Mod2Mask = (1<<4);
+        const Mod3Mask = (1<<5);
+        const Mod4Mask = (1<<6);
+        const Mod5Mask = (1<<7);
     }
 }

input-capture/src/wayland.rs

@@ -1,10 +1,10 @@
+use async_trait::async_trait;
 use futures_core::Stream;
-use memmap::MmapOptions;
 use std::{
     collections::VecDeque,
     env,
     io::{self, ErrorKind},
-    os::fd::{AsFd, OwnedFd, RawFd},
+    os::fd::{AsFd, RawFd},
     pin::Pin,
     task::{ready, Context, Poll},
 };
@@ -13,8 +13,8 @@ use tokio::io::unix::AsyncFd;
 use std::{
     fs::File,
     io::{BufWriter, Write},
-    os::unix::prelude::{AsRawFd, FromRawFd},
+    os::unix::prelude::AsRawFd,
-    rc::Rc,
+    sync::Arc,
 };
 
 use wayland_protocols::{
@@ -58,13 +58,13 @@ use wayland_client::{
     Connection, Dispatch, DispatchError, EventQueue, QueueHandle, WEnum,
 };
 
-use tempfile;
-
 use input_event::{Event, KeyboardEvent, PointerEvent};
 
+use crate::{CaptureError, CaptureEvent};
+
 use super::{
     error::{LayerShellCaptureCreationError, WaylandBindError},
-    CaptureHandle, InputCapture, Position,
+    Capture, CaptureHandle, Position,
 };
 
 struct Globals {
@@ -102,13 +102,13 @@ struct State {
     pointer_lock: Option<ZwpLockedPointerV1>,
     rel_pointer: Option<ZwpRelativePointerV1>,
     shortcut_inhibitor: Option<ZwpKeyboardShortcutsInhibitorV1>,
-    client_for_window: Vec<(Rc<Window>, CaptureHandle)>,
+    client_for_window: Vec<(Arc<Window>, CaptureHandle)>,
-    focused: Option<(Rc<Window>, CaptureHandle)>,
+    focused: Option<(Arc<Window>, CaptureHandle)>,
     g: Globals,
-    wayland_fd: OwnedFd,
+    wayland_fd: RawFd,
     read_guard: Option<ReadEventsGuard>,
     qh: QueueHandle<Self>,
-    pending_events: VecDeque<(CaptureHandle, Event)>,
+    pending_events: VecDeque<(CaptureHandle, CaptureEvent)>,
     output_info: Vec<(WlOutput, OutputInfo)>,
     scroll_discrete_pending: bool,
 }
@@ -120,7 +120,7 @@ struct Inner {
 
 impl AsRawFd for Inner {
     fn as_raw_fd(&self) -> RawFd {
-        self.state.wayland_fd.as_raw_fd()
+        self.state.wayland_fd
     }
 }
 
@@ -305,10 +305,7 @@ impl WaylandInputCapture {
         // flush outgoing events
         queue.flush()?;
 
-        // prepare reading wayland events
+        let wayland_fd = queue.as_fd().as_raw_fd();
-        let read_guard = queue.prepare_read().unwrap(); // there can not yet be events to dispatch
-        let wayland_fd = read_guard.connection_fd().try_clone_to_owned().unwrap();
-        std::mem::drop(read_guard);
 
         let mut state = State {
             pointer: None,
@@ -475,7 +472,7 @@ impl State {
         log::debug!("outputs: {outputs:?}");
         outputs.iter().for_each(|(o, i)| {
             let window = Window::new(self, &self.qh, o, pos, i.size);
-            let window = Rc::new(window);
+            let window = Arc::new(window);
             self.client_for_window.push((window, client));
         });
     }
@@ -561,28 +558,34 @@ impl Inner {
     }
 }
 
-impl InputCapture for WaylandInputCapture {
+#[async_trait]
-    fn create(&mut self, handle: CaptureHandle, pos: Position) -> io::Result<()> {
+impl Capture for WaylandInputCapture {
+    async fn create(&mut self, handle: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
         self.add_client(handle, pos);
         let inner = self.0.get_mut();
-        inner.flush_events()
+        Ok(inner.flush_events()?)
-    }
-    fn destroy(&mut self, handle: CaptureHandle) -> io::Result<()> {
-        self.delete_client(handle);
-        let inner = self.0.get_mut();
-        inner.flush_events()
     }
 
-    fn release(&mut self) -> io::Result<()> {
+    async fn destroy(&mut self, handle: CaptureHandle) -> Result<(), CaptureError> {
+        self.delete_client(handle);
+        let inner = self.0.get_mut();
+        Ok(inner.flush_events()?)
+    }
+
+    async fn release(&mut self) -> Result<(), CaptureError> {
         log::debug!("releasing pointer");
         let inner = self.0.get_mut();
         inner.state.ungrab();
-        inner.flush_events()
+        Ok(inner.flush_events()?)
+    }
+
+    async fn terminate(&mut self) -> Result<(), CaptureError> {
+        Ok(())
     }
 }
 
 impl Stream for WaylandInputCapture {
-    type Item = io::Result<(CaptureHandle, Event)>;
+    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;
 
     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() {
@@ -600,7 +603,7 @@ impl Stream for WaylandInputCapture {
                     // prepare next read
                     match inner.prepare_read() {
                         Ok(_) => {}
-                        Err(e) => return Poll::Ready(Some(Err(e))),
+                        Err(e) => return Poll::Ready(Some(Err(e.into()))),
                     }
                 }
 
@@ -610,14 +613,14 @@ impl Stream for WaylandInputCapture {
                 // flush outgoing events
                 if let Err(e) = inner.flush_events() {
                     if e.kind() != ErrorKind::WouldBlock {
-                        return Poll::Ready(Some(Err(e)));
+                        return Poll::Ready(Some(Err(e.into())));
                     }
                 }
 
                 // prepare for the next read
                 match inner.prepare_read() {
                     Ok(_) => {}
-                    Err(e) => return Poll::Ready(Some(Err(e))),
+                    Err(e) => return Poll::Ready(Some(Err(e.into()))),
                 }
             }
 
@@ -691,7 +694,7 @@ impl Dispatch<WlPointer, ()> for State {
                     .iter()
                     .find(|(w, _c)| w.surface == surface)
                     .unwrap();
-                app.pending_events.push_back((*client, Event::Enter()));
+                app.pending_events.push_back((*client, CaptureEvent::Begin));
             }
             wl_pointer::Event::Leave { .. } => {
                 /* There are rare cases, where when a window is opened in
@@ -715,11 +718,11 @@ impl Dispatch<WlPointer, ()> for State {
                 let (_, client) = app.focused.as_ref().unwrap();
                 app.pending_events.push_back((
                     *client,
-                    Event::Pointer(PointerEvent::Button {
+                    CaptureEvent::Input(Event::Pointer(PointerEvent::Button {
                         time,
                         button,
                         state: u32::from(state),
-                    }),
+                    })),
                 ));
             }
             wl_pointer::Event::Axis { time, axis, value } => {
@@ -732,11 +735,11 @@ impl Dispatch<WlPointer, ()> for State {
                 } else {
                     app.pending_events.push_back((
                         *client,
-                        Event::Pointer(PointerEvent::Axis {
+                        CaptureEvent::Input(Event::Pointer(PointerEvent::Axis {
                             time,
                             axis: u32::from(axis) as u8,
                             value,
-                        }),
+                        })),
                     ));
                 }
             }
@@ -745,10 +748,10 @@ impl Dispatch<WlPointer, ()> for State {
                 app.scroll_discrete_pending = true;
                 app.pending_events.push_back((
                     *client,
-                    Event::Pointer(PointerEvent::AxisDiscrete120 {
+                    CaptureEvent::Input(Event::Pointer(PointerEvent::AxisDiscrete120 {
                         axis: u32::from(axis) as u8,
                         value: value120,
-                    }),
+                    })),
                 ));
             }
             wl_pointer::Event::Frame {} => {
@@ -784,11 +787,11 @@ impl Dispatch<WlKeyboard, ()> for State {
                 if let Some(client) = client {
                     app.pending_events.push_back((
                         *client,
-                        Event::Keyboard(KeyboardEvent::Key {
+                        CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key {
                             time,
                             key,
                             state: u32::from(state) as u8,
-                        }),
+                        })),
                     ));
                 }
             }
@@ -802,24 +805,15 @@ impl Dispatch<WlKeyboard, ()> for State {
                 if let Some(client) = client {
                     app.pending_events.push_back((
                         *client,
-                        Event::Keyboard(KeyboardEvent::Modifiers {
+                        CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Modifiers {
-                            mods_depressed,
+                            depressed: mods_depressed,
-                            mods_latched,
+                            latched: mods_latched,
-                            mods_locked,
+                            locked: mods_locked,
                             group,
-                        }),
+                        })),
                     ));
                 }
             }
-            wl_keyboard::Event::Keymap {
-                format: _,
-                fd,
-                size: _,
-            } => {
-                let fd = unsafe { &File::from_raw_fd(fd.as_raw_fd()) };
-                let _mmap = unsafe { MmapOptions::new().map_copy(fd).unwrap() };
-                // TODO keymap
-            }
             _ => (),
         }
     }
@@ -846,7 +840,7 @@ impl Dispatch<ZwpRelativePointerV1, ()> for State {
                 let time = (((utime_hi as u64) << 32 | utime_lo as u64) / 1000) as u32;
                 app.pending_events.push_back((
                     *client,
-                    Event::Pointer(PointerEvent::Motion { time, dx, dy }),
+                    CaptureEvent::Input(Event::Pointer(PointerEvent::Motion { time, dx, dy })),
                 ));
             }
         }

input-capture/src/windows.rs

@@ -1,3 +1,4 @@
+use async_trait::async_trait;
 use core::task::{Context, Poll};
 use futures::Stream;
 use once_cell::unsync::Lazy;
@@ -10,7 +11,7 @@ use std::default::Default;
 use std::sync::atomic::{AtomicU32, Ordering};
 use std::sync::{mpsc, Mutex};
 use std::task::ready;
-use std::{io, pin::Pin, thread};
+use std::{pin::Pin, thread};
 use tokio::sync::mpsc::{channel, Receiver, Sender};
 use windows::core::{w, PCWSTR};
 use windows::Win32::Foundation::{FALSE, HINSTANCE, HWND, LPARAM, LRESULT, RECT, WPARAM};
@@ -36,7 +37,7 @@ use input_event::{
     Event, KeyboardEvent, PointerEvent, BTN_BACK, BTN_FORWARD, BTN_LEFT, BTN_MIDDLE, BTN_RIGHT,
 };
 
-use super::{CaptureHandle, InputCapture, Position};
+use super::{Capture, CaptureError, CaptureEvent, CaptureHandle, Position};
 
 enum Request {
     Create(CaptureHandle, Position),
@@ -44,7 +45,7 @@ enum Request {
 }
 
 pub struct WindowsInputCapture {
-    event_rx: Receiver<(CaptureHandle, Event)>,
+    event_rx: Receiver<(CaptureHandle, CaptureEvent)>,
     msg_thread: Option<std::thread::JoinHandle<()>>,
 }
 
@@ -62,8 +63,9 @@ unsafe fn signal_message_thread(event_type: EventType) {
     }
 }
 
-impl InputCapture for WindowsInputCapture {
+#[async_trait]
-    fn create(&mut self, handle: CaptureHandle, pos: Position) -> io::Result<()> {
+impl Capture for WindowsInputCapture {
+    async fn create(&mut self, handle: CaptureHandle, pos: Position) -> Result<(), CaptureError> {
         unsafe {
             {
                 let mut requests = REQUEST_BUFFER.lock().unwrap();
@@ -73,7 +75,8 @@ impl InputCapture for WindowsInputCapture {
         }
         Ok(())
     }
-    fn destroy(&mut self, handle: CaptureHandle) -> io::Result<()> {
+
+    async fn destroy(&mut self, handle: CaptureHandle) -> Result<(), CaptureError> {
         unsafe {
             {
                 let mut requests = REQUEST_BUFFER.lock().unwrap();
@@ -84,16 +87,20 @@ impl InputCapture for WindowsInputCapture {
         Ok(())
     }
 
-    fn release(&mut self) -> io::Result<()> {
+    async fn release(&mut self) -> Result<(), CaptureError> {
         unsafe { signal_message_thread(EventType::Release) };
         Ok(())
     }
+
+    async fn terminate(&mut self) -> Result<(), CaptureError> {
+        Ok(())
+    }
 }
 
 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_TX: Option<Sender<(CaptureHandle, CaptureEvent)>> = None;
 static mut EVENT_THREAD_ID: AtomicU32 = AtomicU32::new(0);
 unsafe fn set_event_tid(tid: u32) {
     EVENT_THREAD_ID.store(tid, Ordering::SeqCst);
@@ -242,7 +249,7 @@ fn clamp_to_display_bounds(prev_point: (i32, i32), point: (i32, i32)) -> (i32, i
     (x.clamp(min_x, max_x), y.clamp(min_y, max_y))
 }
 
-unsafe fn send_blocking(event: Event) {
+unsafe fn send_blocking(event: CaptureEvent) {
     if let Some(active) = ACTIVE_CLIENT {
         block_on(async move {
             let _ = EVENT_TX.as_ref().unwrap().send((active, event)).await;
@@ -284,7 +291,7 @@ unsafe fn check_client_activation(wparam: WPARAM, lparam: LPARAM) -> bool {
 
     /* notify main thread */
     log::debug!("ENTERED @ {prev_pos:?} -> {curr_pos:?}");
-    send_blocking(Event::Enter());
+    send_blocking(CaptureEvent::Begin);
 
     ret
 }
@@ -306,7 +313,7 @@ unsafe extern "system" fn mouse_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM)
     let Some(pointer_event) = to_mouse_event(wparam, lparam) else {
         return LRESULT(1);
     };
-    let event = (client, Event::Pointer(pointer_event));
+    let event = (client, CaptureEvent::Input(Event::Pointer(pointer_event)));
 
     /* notify mainthread (drop events if sending too fast) */
     if let Err(e) = EVENT_TX.as_ref().unwrap().try_send(event) {
@@ -327,7 +334,7 @@ unsafe extern "system" fn kybrd_proc(ncode: i32, wparam: WPARAM, lparam: LPARAM)
     let Some(key_event) = to_key_event(wparam, lparam) else {
         return LRESULT(1);
     };
-    let event = (client, Event::Keyboard(key_event));
+    let event = (client, CaptureEvent::Input(Event::Keyboard(key_event)));
 
     if let Err(e) = EVENT_TX.as_ref().unwrap().try_send(event) {
         log::warn!("e: {e}");
@@ -512,7 +519,7 @@ fn message_thread(ready_tx: mpsc::Sender<()>) {
         }
 
         /* window is used ro receive WM_DISPLAYCHANGE messages */
-        let ret = CreateWindowExW(
+        CreateWindowExW(
             Default::default(),
             w!("lan-mouse-message-window-class"),
             w!("lan-mouse-msg-window"),
@@ -525,10 +532,8 @@ fn message_thread(ready_tx: mpsc::Sender<()>) {
             HMENU::default(),
             instance,
             None,
-        );
+        )
-        if ret.0 == 0 {
+        .expect("CreateWindowExW");
-            panic!("CreateWindowExW");
-        }
 
         /* run message loop */
         loop {
@@ -536,7 +541,7 @@ fn message_thread(ready_tx: mpsc::Sender<()>) {
             let Some(msg) = get_msg() else {
                 break;
             };
-            if msg.hwnd.0 == 0 {
+            if msg.hwnd.0.is_null() {
                 /* messages sent via PostThreadMessage */
                 match msg.wParam.0 {
                     x if x == EventType::Exit as usize => break,
@@ -609,7 +614,7 @@ impl WindowsInputCapture {
 }
 
 impl Stream for WindowsInputCapture {
-    type Item = io::Result<(CaptureHandle, Event)>;
+    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;
     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),

input-capture/src/x11.rs

@@ -1,13 +1,12 @@
-use std::io;
 use std::task::Poll;
 
+use async_trait::async_trait;
 use futures_core::Stream;
 
-use super::InputCapture;
+use super::{
-use input_event::Event;
+    error::X11InputCaptureCreationError, Capture, CaptureError, CaptureEvent, CaptureHandle,
-
+    Position,
-use super::error::X11InputCaptureCreationError;
+};
-use super::{CaptureHandle, Position};
 
 pub struct X11InputCapture {}
 
@@ -17,22 +16,27 @@ impl X11InputCapture {
     }
 }
 
-impl InputCapture for X11InputCapture {
+#[async_trait]
-    fn create(&mut self, _id: CaptureHandle, _pos: Position) -> io::Result<()> {
+impl Capture for X11InputCapture {
+    async fn create(&mut self, _id: CaptureHandle, _pos: Position) -> Result<(), CaptureError> {
         Ok(())
     }
 
-    fn destroy(&mut self, _id: CaptureHandle) -> io::Result<()> {
+    async fn destroy(&mut self, _id: CaptureHandle) -> Result<(), CaptureError> {
         Ok(())
     }
 
-    fn release(&mut self) -> io::Result<()> {
+    async fn release(&mut self) -> Result<(), CaptureError> {
+        Ok(())
+    }
+
+    async fn terminate(&mut self) -> Result<(), CaptureError> {
         Ok(())
     }
 }
 
 impl Stream for X11InputCapture {
-    type Item = io::Result<(CaptureHandle, Event)>;
+    type Item = Result<(CaptureHandle, CaptureEvent), CaptureError>;
 
     fn poll_next(
         self: std::pin::Pin<&mut Self>,

input-emulation/Cargo.toml

@@ -1,35 +1,54 @@
 [package]
 name = "input-emulation"
 description = "cross-platform input emulation library used by lan-mouse"
-version = "0.1.0"
+version = "0.2.1"
 edition = "2021"
 license = "GPL-3.0-or-later"
-repository = "https://github.com/ferdinandschober/lan-mouse"
+repository = "https://github.com/feschber/lan-mouse"
 
 [dependencies]
 async-trait = "0.1.80"
 futures = "0.3.28"
 log = "0.4.22"
-input-event = { path = "../input-event", version = "0.1.0" }
+input-event = { path = "../input-event", version = "0.2.1" }
 thiserror = "1.0.61"
-tokio = { version = "1.32.0", features = ["io-util", "io-std", "macros", "net", "process", "rt", "sync", "signal"] }
+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-client = { version = "0.31.1", optional = true }
-wayland-protocols = { version="0.32.1", features=["client", "staging", "unstable"], optional = true }
+wayland-protocols = { version = "0.32.1", features = [
-wayland-protocols-wlr = { version="0.3.1", features=["client"], optional = true }
+    "client",
-wayland-protocols-misc = { version="0.3.1", features=["client"], optional = true }
+    "staging",
+    "unstable",
+], optional = true }
+wayland-protocols-wlr = { version = "0.3.1", features = [
+    "client",
+], optional = true }
+wayland-protocols-misc = { version = "0.3.1", features = [
+    "client",
+], optional = true }
 x11 = { version = "2.21.0", features = ["xlib", "xtest"], optional = true }
-ashpd = { version = "0.8", default-features = false, features = ["tokio"], optional = true }
+ashpd = { version = "0.9", default-features = false, features = [
-reis = { version = "0.2", features = [ "tokio" ], optional = true }
+    "tokio",
+], optional = true }
+reis = { version = "0.2", features = ["tokio"], optional = true }
 
 [target.'cfg(target_os="macos")'.dependencies]
 core-graphics = { version = "0.23", features = ["highsierra"] }
 keycode = "0.4.0"
 
 [target.'cfg(windows)'.dependencies]
-windows = {  version = "0.57.0", features = [
+windows = { version = "0.58.0", features = [
     "Win32_System_LibraryLoader",
     "Win32_System_Threading",
     "Win32_Foundation",
@@ -41,7 +60,12 @@ windows = {  version = "0.57.0", features = [
 
 [features]
 default = ["wayland", "x11", "xdg_desktop_portal", "libei"]
-wayland = ["dep:wayland-client", "dep:wayland-protocols", "dep:wayland-protocols-wlr", "dep:wayland-protocols-misc" ]
+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

@@ -3,19 +3,19 @@ use input_event::Event;
 
 use crate::error::EmulationError;
 
-use super::{EmulationHandle, InputEmulation};
+use super::{Emulation, EmulationHandle};
 
 #[derive(Default)]
-pub struct DummyEmulation;
+pub(crate) struct DummyEmulation;
 
 impl DummyEmulation {
-    pub fn new() -> Self {
+    pub(crate) fn new() -> Self {
         Self {}
     }
 }
 
 #[async_trait]
-impl InputEmulation for DummyEmulation {
+impl Emulation for DummyEmulation {
     async fn consume(
         &mut self,
         event: Event,
@@ -26,4 +26,7 @@ impl InputEmulation for DummyEmulation {
     }
     async fn create(&mut self, _: EmulationHandle) {}
     async fn destroy(&mut self, _: EmulationHandle) {}
+    async fn terminate(&mut self) {
+        /* nothing to do */
+    }
 }

input-emulation/src/error.rs

@@ -1,3 +1,13 @@
+#[derive(Debug, Error)]
+pub enum InputEmulationError {
+    #[error("error creating input-emulation: `{0}`")]
+    Create(#[from] EmulationCreationError),
+    #[error("error emulating input: `{0}`")]
+    Emulate(#[from] EmulationError),
+}
+
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+use ashpd::{desktop::ResponseError, Error::Response};
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
 use reis::tokio::EiConvertEventStreamError;
 use std::io;
@@ -75,6 +85,31 @@ pub enum EmulationCreationError {
     NoAvailableBackend,
 }
 
+impl EmulationCreationError {
+    /// request was intentionally denied by the user
+    pub(crate) fn cancelled_by_user(&self) -> bool {
+        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+        if matches!(
+            self,
+            EmulationCreationError::Libei(LibeiEmulationCreationError::Ashpd(Response(
+                ResponseError::Cancelled,
+            )))
+        ) {
+            return true;
+        }
+        #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+        if matches!(
+            self,
+            EmulationCreationError::Xdp(XdpEmulationCreationError::Ashpd(Response(
+                ResponseError::Cancelled,
+            )))
+        ) {
+            return true;
+        }
+        false
+    }
+}
+
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
 #[derive(Debug, Error)]
 pub enum WlrootsEmulationCreationError {

input-emulation/src/lib.rs

@@ -1,32 +1,34 @@
 use async_trait::async_trait;
-use error::EmulationError;
+use std::{
-use std::fmt::Display;
+    collections::{HashMap, HashSet},
+    fmt::Display,
+};
 
-use input_event::Event;
+use input_event::{Event, KeyboardEvent};
 
-use self::error::EmulationCreationError;
+pub use self::error::{EmulationCreationError, EmulationError, InputEmulationError};
 
 #[cfg(windows)]
-pub mod windows;
+mod windows;
 
 #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-pub mod x11;
+mod x11;
 
 #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-pub mod wlroots;
+mod wlroots;
 
 #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
-pub mod xdg_desktop_portal;
+mod xdg_desktop_portal;
 
 #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-pub mod libei;
+mod libei;
 
 #[cfg(target_os = "macos")]
-pub mod macos;
+mod macos;
 
 /// fallback input emulation (logs events)
-pub mod dummy;
+mod dummy;
-pub mod error;
+mod error;
 
 pub type EmulationHandle = u64;
 
@@ -67,8 +69,166 @@ impl Display for Backend {
     }
 }
 
+pub struct InputEmulation {
+    emulation: Box<dyn Emulation>,
+    handles: HashSet<EmulationHandle>,
+    pressed_keys: HashMap<EmulationHandle, HashSet<u32>>,
+}
+
+impl InputEmulation {
+    async fn with_backend(backend: Backend) -> Result<InputEmulation, EmulationCreationError> {
+        let emulation: Box<dyn Emulation> = match backend {
+            #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
+            Backend::Wlroots => Box::new(wlroots::WlrootsEmulation::new()?),
+            #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+            Backend::Libei => Box::new(libei::LibeiEmulation::new().await?),
+            #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
+            Backend::X11 => Box::new(x11::X11Emulation::new()?),
+            #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
+            Backend::Xdp => Box::new(xdg_desktop_portal::DesktopPortalEmulation::new().await?),
+            #[cfg(windows)]
+            Backend::Windows => Box::new(windows::WindowsEmulation::new()?),
+            #[cfg(target_os = "macos")]
+            Backend::MacOs => Box::new(macos::MacOSEmulation::new()?),
+            Backend::Dummy => Box::new(dummy::DummyEmulation::new()),
+        };
+        Ok(Self {
+            emulation,
+            handles: HashSet::new(),
+            pressed_keys: HashMap::new(),
+        })
+    }
+
+    pub async fn new(backend: Option<Backend>) -> Result<InputEmulation, EmulationCreationError> {
+        if let Some(backend) = backend {
+            let b = Self::with_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 Self::with_backend(backend).await {
+                Ok(b) => {
+                    log::info!("using emulation backend: {backend}");
+                    return Ok(b);
+                }
+                Err(e) if e.cancelled_by_user() => return Err(e),
+                Err(e) => log::warn!("{e}"),
+            }
+        }
+
+        Err(EmulationCreationError::NoAvailableBackend)
+    }
+
+    pub async fn consume(
+        &mut self,
+        event: Event,
+        handle: EmulationHandle,
+    ) -> Result<(), EmulationError> {
+        match event {
+            Event::Keyboard(KeyboardEvent::Key { key, state, .. }) => {
+                // prevent double pressed / released keys
+                if self.update_pressed_keys(handle, key, state) {
+                    self.emulation.consume(event, handle).await?;
+                }
+                Ok(())
+            }
+            _ => self.emulation.consume(event, handle).await,
+        }
+    }
+
+    pub async fn create(&mut self, handle: EmulationHandle) -> bool {
+        if self.handles.insert(handle) {
+            self.pressed_keys.insert(handle, HashSet::new());
+            self.emulation.create(handle).await;
+            true
+        } else {
+            false
+        }
+    }
+
+    pub async fn destroy(&mut self, handle: EmulationHandle) {
+        let _ = self.release_keys(handle).await;
+        if self.handles.remove(&handle) {
+            self.pressed_keys.remove(&handle);
+            self.emulation.destroy(handle).await
+        }
+    }
+
+    pub async fn terminate(&mut self) {
+        for handle in self.handles.iter().cloned().collect::<Vec<_>>() {
+            self.destroy(handle).await
+        }
+        self.emulation.terminate().await
+    }
+
+    pub async fn release_keys(&mut self, handle: EmulationHandle) -> Result<(), EmulationError> {
+        if let Some(keys) = self.pressed_keys.get_mut(&handle) {
+            let keys = keys.drain().collect::<Vec<_>>();
+            for key in keys {
+                let event = Event::Keyboard(KeyboardEvent::Key {
+                    time: 0,
+                    key,
+                    state: 0,
+                });
+                self.emulation.consume(event, handle).await?;
+                if let Ok(key) = input_event::scancode::Linux::try_from(key) {
+                    log::warn!("releasing stuck key: {key:?}");
+                }
+            }
+        }
+
+        let event = Event::Keyboard(KeyboardEvent::Modifiers {
+            depressed: 0,
+            latched: 0,
+            locked: 0,
+            group: 0,
+        });
+        self.emulation.consume(event, handle).await?;
+        Ok(())
+    }
+
+    pub fn has_pressed_keys(&self, handle: EmulationHandle) -> bool {
+        self.pressed_keys
+            .get(&handle)
+            .is_some_and(|p| !p.is_empty())
+    }
+
+    /// update the pressed_keys for the given handle
+    /// returns whether the event should be processed
+    fn update_pressed_keys(&mut self, handle: EmulationHandle, key: u32, state: u8) -> bool {
+        let Some(pressed_keys) = self.pressed_keys.get_mut(&handle) else {
+            return false;
+        };
+
+        if state == 0 {
+            // currently pressed => can release
+            pressed_keys.remove(&key)
+        } else {
+            // currently not pressed => can press
+            pressed_keys.insert(key)
+        }
+    }
+}
+
 #[async_trait]
-pub trait InputEmulation: Send {
+trait Emulation: Send {
     async fn consume(
         &mut self,
         event: Event,
@@ -76,64 +236,5 @@ pub trait InputEmulation: Send {
     ) -> Result<(), EmulationError>;
     async fn create(&mut self, handle: EmulationHandle);
     async fn destroy(&mut self, handle: EmulationHandle);
-}
+    async fn terminate(&mut self);
-
-pub async fn create_backend(
-    backend: Backend,
-) -> Result<Box<dyn InputEmulation>, EmulationCreationError> {
-    match backend {
-        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-        Backend::Wlroots => Ok(Box::new(wlroots::WlrootsEmulation::new()?)),
-        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-        Backend::Libei => Ok(Box::new(libei::LibeiEmulation::new().await?)),
-        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-        Backend::X11 => Ok(Box::new(x11::X11Emulation::new()?)),
-        #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
-        Backend::Xdp => Ok(Box::new(
-            xdg_desktop_portal::DesktopPortalEmulation::new().await?,
-        )),
-        #[cfg(windows)]
-        Backend::Windows => Ok(Box::new(windows::WindowsEmulation::new()?)),
-        #[cfg(target_os = "macos")]
-        Backend::MacOs => Ok(Box::new(macos::MacOSEmulation::new()?)),
-        Backend::Dummy => Ok(Box::new(dummy::DummyEmulation::new())),
-    }
-}
-
-pub async fn create(
-    backend: Option<Backend>,
-) -> Result<Box<dyn InputEmulation>, EmulationCreationError> {
-    if let Some(backend) = backend {
-        let b = create_backend(backend).await;
-        if b.is_ok() {
-            log::info!("using emulation backend: {backend}");
-        }
-        return b;
-    }
-
-    for backend in [
-        #[cfg(all(unix, feature = "wayland", not(target_os = "macos")))]
-        Backend::Wlroots,
-        #[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
-        Backend::Libei,
-        #[cfg(all(unix, feature = "xdg_desktop_portal", not(target_os = "macos")))]
-        Backend::Xdp,
-        #[cfg(all(unix, feature = "x11", not(target_os = "macos")))]
-        Backend::X11,
-        #[cfg(windows)]
-        Backend::Windows,
-        #[cfg(target_os = "macos")]
-        Backend::MacOs,
-        Backend::Dummy,
-    ] {
-        match create_backend(backend).await {
-            Ok(b) => {
-                log::info!("using emulation backend: {backend}");
-                return Ok(b);
-            }
-            Err(e) => log::warn!("{e}"),
-        }
-    }
-
-    Err(EmulationCreationError::NoAvailableBackend)
 }

input-emulation/src/libei.rs

@@ -1,12 +1,12 @@
-use futures::StreamExt;
+use futures::{future, StreamExt};
 use once_cell::sync::Lazy;
 use std::{
     collections::HashMap,
     io,
     os::{fd::OwnedFd, unix::net::UnixStream},
     sync::{
-        atomic::{AtomicU32, Ordering},
+        atomic::{AtomicBool, AtomicU32, Ordering},
-        Arc, RwLock,
+        Arc, Mutex, RwLock,
     },
     time::{SystemTime, UNIX_EPOCH},
 };
@@ -15,7 +15,7 @@ use tokio::task::JoinHandle;
 use ashpd::{
     desktop::{
         remote_desktop::{DeviceType, RemoteDesktop},
-        ResponseError,
+        PersistMode, Session,
     },
     WindowIdentifier,
 };
@@ -34,7 +34,7 @@ use input_event::{Event, KeyboardEvent, PointerEvent};
 
 use crate::error::{EmulationError, ReisConvertStreamError};
 
-use super::{error::LibeiEmulationCreationError, EmulationHandle, InputEmulation};
+use super::{error::LibeiEmulationCreationError, Emulation, EmulationHandle};
 
 static INTERFACES: Lazy<HashMap<&'static str, u32>> = Lazy::new(|| {
     let mut m = HashMap::new();
@@ -60,51 +60,50 @@ struct Devices {
     keyboard: Arc<RwLock<Option<(ei::Device, ei::Keyboard)>>>,
 }
 
-pub struct LibeiEmulation {
+pub(crate) struct LibeiEmulation<'a> {
     context: ei::Context,
     devices: Devices,
+    ei_task: JoinHandle<()>,
+    error: Arc<Mutex<Option<EmulationError>>>,
+    libei_error: Arc<AtomicBool>,
     serial: AtomicU32,
-    ei_task: JoinHandle<Result<(), EmulationError>>,
+    _remote_desktop: RemoteDesktop<'a>,
+    session: Session<'a, RemoteDesktop<'a>>,
 }
 
-async fn get_ei_fd() -> Result<OwnedFd, ashpd::Error> {
+async fn get_ei_fd<'a>(
-    let proxy = RemoteDesktop::new().await?;
+) -> Result<(RemoteDesktop<'a>, Session<'a, RemoteDesktop<'a>>, OwnedFd), ashpd::Error> {
+    let remote_desktop = RemoteDesktop::new().await?;
 
-    // retry when user presses the cancel button
+    log::debug!("creating session ...");
-    let (session, _) = loop {
+    let session = remote_desktop.create_session().await?;
-        log::debug!("creating session ...");
-        let session = proxy.create_session().await?;
 
-        log::debug!("selecting devices ...");
+    log::debug!("selecting devices ...");
-        proxy
+    remote_desktop
-            .select_devices(&session, DeviceType::Keyboard | DeviceType::Pointer)
+        .select_devices(
-            .await?;
+            &session,
+            DeviceType::Keyboard | DeviceType::Pointer,
+            None,
+            PersistMode::ExplicitlyRevoked,
+        )
+        .await?;
 
-        log::info!("requesting permission for input emulation");
+    log::info!("requesting permission for input emulation");
-        match proxy
+    let _devices = remote_desktop
-            .start(&session, &WindowIdentifier::default())
+        .start(&session, &WindowIdentifier::default())
-            .await?
+        .await?
-            .response()
+        .response()?;
-        {
-            Ok(d) => break (session, d),
-            Err(ashpd::Error::Response(ResponseError::Cancelled)) => {
-                log::warn!("request cancelled!");
-                continue;
-            }
-            e => e?,
-        };
-    };
 
-    proxy.connect_to_eis(&session).await
+    let fd = remote_desktop.connect_to_eis(&session).await?;
+    Ok((remote_desktop, session, fd))
 }
 
-impl LibeiEmulation {
+impl<'a> LibeiEmulation<'a> {
-    pub async fn new() -> Result<Self, LibeiEmulationCreationError> {
+    pub(crate) async fn new() -> Result<Self, LibeiEmulationCreationError> {
-        let eifd = get_ei_fd().await?;
+        let (_remote_desktop, session, eifd) = get_ei_fd().await?;
         let stream = UnixStream::from(eifd);
         stream.set_nonblocking(true)?;
         let context = ei::Context::new(stream)?;
-        context.flush().map_err(|e| io::Error::new(e.kind(), e))?;
         let mut events = EiEventStream::new(context.clone())?;
         let handshake = ei_handshake(
             &mut events,
@@ -115,28 +114,40 @@ impl LibeiEmulation {
         .await?;
         let events = EiConvertEventStream::new(events, handshake.serial);
         let devices = Devices::default();
-        let ei_handler = ei_event_handler(events, context.clone(), devices.clone());
+        let libei_error = Arc::new(AtomicBool::default());
+        let error = Arc::new(Mutex::new(None));
+        let ei_handler = ei_task(
+            events,
+            context.clone(),
+            devices.clone(),
+            libei_error.clone(),
+            error.clone(),
+        );
         let ei_task = tokio::task::spawn_local(ei_handler);
 
         let serial = AtomicU32::new(handshake.serial);
 
         Ok(Self {
-            serial,
             context,
-            ei_task,
             devices,
+            ei_task,
+            error,
+            libei_error,
+            serial,
+            _remote_desktop,
+            session,
         })
     }
 }
 
-impl Drop for LibeiEmulation {
+impl<'a> Drop for LibeiEmulation<'a> {
     fn drop(&mut self) {
         self.ei_task.abort();
     }
 }
 
 #[async_trait]
-impl InputEmulation for LibeiEmulation {
+impl<'a> Emulation for LibeiEmulation<'a> {
     async fn consume(
         &mut self,
         event: Event,
@@ -146,6 +157,12 @@ impl InputEmulation for LibeiEmulation {
             .duration_since(UNIX_EPOCH)
             .unwrap()
             .as_micros() as u64;
+        if self.libei_error.load(Ordering::SeqCst) {
+            // don't break sending additional events but signal error
+            if let Some(e) = self.error.lock().unwrap().take() {
+                return Err(e);
+            }
+        }
         match event {
             Event::Pointer(p) => match p {
                 PointerEvent::Motion { time: _, dx, dy } => {
@@ -196,7 +213,6 @@ impl InputEmulation for LibeiEmulation {
                         d.frame(self.serial.load(Ordering::SeqCst), now);
                     }
                 }
-                PointerEvent::Frame {} => {}
             },
             Event::Keyboard(k) => match k {
                 KeyboardEvent::Key {
@@ -218,7 +234,6 @@ impl InputEmulation for LibeiEmulation {
                 }
                 KeyboardEvent::Modifiers { .. } => {}
             },
-            _ => {}
         }
         self.context
             .flush()
@@ -228,12 +243,37 @@ impl InputEmulation for LibeiEmulation {
 
     async fn create(&mut self, _: EmulationHandle) {}
     async fn destroy(&mut self, _: EmulationHandle) {}
+
+    async fn terminate(&mut self) {
+        let _ = self.session.close().await;
+        self.ei_task.abort();
+    }
 }
 
-async fn ei_event_handler(
+async fn ei_task(
     mut events: EiConvertEventStream,
     context: ei::Context,
     devices: Devices,
+    libei_error: Arc<AtomicBool>,
+    error: Arc<Mutex<Option<EmulationError>>>,
+) {
+    loop {
+        match ei_event_handler(&mut events, &context, &devices).await {
+            Ok(()) => {}
+            Err(e) => {
+                libei_error.store(true, Ordering::SeqCst);
+                error.lock().unwrap().replace(e);
+                // wait for termination -> otherwise we will loop forever
+                future::pending::<()>().await;
+            }
+        }
+    }
+}
+
+async fn ei_event_handler(
+    events: &mut EiConvertEventStream,
+    context: &ei::Context,
+    devices: &Devices,
 ) -> Result<(), EmulationError> {
     loop {
         let event = events
@@ -253,7 +293,7 @@ async fn ei_event_handler(
         match event {
             EiEvent::Disconnected(e) => {
                 log::debug!("ei disconnected: {e:?}");
-                break;
+                return Err(EmulationError::EndOfStream);
             }
             EiEvent::SeatAdded(e) => {
                 e.seat().bind_capabilities(CAPABILITIES);
@@ -327,5 +367,4 @@ async fn ei_event_handler(
         }
         context.flush().map_err(|e| io::Error::new(e.kind(), e))?;
     }
-    Ok(())
 }

input-emulation/src/macos.rs

@@ -1,4 +1,4 @@
-use super::{error::EmulationError, EmulationHandle, InputEmulation};
+use super::{error::EmulationError, Emulation, EmulationHandle};
 use async_trait::async_trait;
 use core_graphics::display::{CGDisplayBounds, CGMainDisplayID, CGPoint};
 use core_graphics::event::{
@@ -16,8 +16,8 @@ use super::error::MacOSEmulationCreationError;
 const DEFAULT_REPEAT_DELAY: Duration = Duration::from_millis(500);
 const DEFAULT_REPEAT_INTERVAL: Duration = Duration::from_millis(32);
 
-pub struct MacOSEmulation {
+pub(crate) struct MacOSEmulation {
-    pub event_source: CGEventSource,
+    event_source: CGEventSource,
     repeat_task: Option<AbortHandle>,
     button_state: ButtonState,
 }
@@ -53,7 +53,7 @@ impl IndexMut<CGMouseButton> for ButtonState {
 unsafe impl Send for MacOSEmulation {}
 
 impl MacOSEmulation {
-    pub fn new() -> Result<Self, MacOSEmulationCreationError> {
+    pub(crate) fn new() -> Result<Self, MacOSEmulationCreationError> {
         let event_source = CGEventSource::new(CGEventSourceStateID::CombinedSessionState)
             .map_err(|_| MacOSEmulationCreationError::EventSourceCreation)?;
         let button_state = ButtonState {
@@ -106,7 +106,7 @@ fn key_event(event_source: CGEventSource, key: u16, state: u8) {
 }
 
 #[async_trait]
-impl InputEmulation for MacOSEmulation {
+impl Emulation for MacOSEmulation {
     async fn consume(
         &mut self,
         event: Event,
@@ -262,7 +262,6 @@ impl InputEmulation for MacOSEmulation {
                     };
                     event.post(CGEventTapLocation::HID);
                 }
-                PointerEvent::Frame { .. } => {}
             },
             Event::Keyboard(keyboard_event) => match keyboard_event {
                 KeyboardEvent::Key {
@@ -286,7 +285,6 @@ impl InputEmulation for MacOSEmulation {
                 }
                 KeyboardEvent::Modifiers { .. } => {}
             },
-            _ => (),
         }
         // FIXME
         Ok(())
@@ -295,4 +293,6 @@ impl InputEmulation for MacOSEmulation {
     async fn create(&mut self, _handle: EmulationHandle) {}
 
     async fn destroy(&mut self, _handle: EmulationHandle) {}
+
+    async fn terminate(&mut self) {}
 }

input-emulation/src/windows.rs

@@ -19,23 +19,23 @@ use windows::Win32::UI::Input::KeyboardAndMouse::{
 };
 use windows::Win32::UI::WindowsAndMessaging::{XBUTTON1, XBUTTON2};
 
-use super::{EmulationHandle, InputEmulation};
+use super::{Emulation, EmulationHandle};
 
 const DEFAULT_REPEAT_DELAY: Duration = Duration::from_millis(500);
 const DEFAULT_REPEAT_INTERVAL: Duration = Duration::from_millis(32);
 
-pub struct WindowsEmulation {
+pub(crate) struct WindowsEmulation {
     repeat_task: Option<AbortHandle>,
 }
 
 impl WindowsEmulation {
-    pub fn new() -> Result<Self, WindowsEmulationCreationError> {
+    pub(crate) fn new() -> Result<Self, WindowsEmulationCreationError> {
         Ok(Self { repeat_task: None })
     }
 }
 
 #[async_trait]
-impl InputEmulation for WindowsEmulation {
+impl Emulation for WindowsEmulation {
     async fn consume(&mut self, event: Event, _: EmulationHandle) -> Result<(), EmulationError> {
         match event {
             Event::Pointer(pointer_event) => match pointer_event {
@@ -53,7 +53,6 @@ impl InputEmulation for WindowsEmulation {
                     value,
                 } => scroll(axis, value as i32),
                 PointerEvent::AxisDiscrete120 { axis, value } => scroll(axis, value),
-                PointerEvent::Frame {} => {}
             },
             Event::Keyboard(keyboard_event) => match keyboard_event {
                 KeyboardEvent::Key {
@@ -71,7 +70,6 @@ impl InputEmulation for WindowsEmulation {
                 }
                 KeyboardEvent::Modifiers { .. } => {}
             },
-            _ => {}
         }
         // FIXME
         Ok(())
@@ -80,6 +78,8 @@ impl InputEmulation for WindowsEmulation {
     async fn create(&mut self, _handle: EmulationHandle) {}
 
     async fn destroy(&mut self, _handle: EmulationHandle) {}
+
+    async fn terminate(&mut self) {}
 }
 
 impl WindowsEmulation {

input-emulation/src/wlroots.rs

@@ -1,6 +1,6 @@
 use crate::error::EmulationError;
 
-use super::{error::WlrootsEmulationCreationError, InputEmulation};
+use super::{error::WlrootsEmulationCreationError, Emulation};
 use async_trait::async_trait;
 use std::collections::HashMap;
 use std::io;
@@ -50,7 +50,7 @@ pub(crate) struct WlrootsEmulation {
 }
 
 impl WlrootsEmulation {
-    pub fn new() -> Result<Self, WlrootsEmulationCreationError> {
+    pub(crate) fn new() -> Result<Self, WlrootsEmulationCreationError> {
         let conn = Connection::connect_to_env()?;
         let (globals, queue) = registry_queue_init::<State>(&conn)?;
         let qh = queue.handle();
@@ -116,7 +116,7 @@ impl State {
 }
 
 #[async_trait]
-impl InputEmulation for WlrootsEmulation {
+impl Emulation for WlrootsEmulation {
     async fn consume(
         &mut self,
         event: Event,
@@ -165,6 +165,9 @@ impl InputEmulation for WlrootsEmulation {
             log::error!("{}", e);
         }
     }
+    async fn terminate(&mut self) {
+        /* nothing to do */
+    }
 }
 
 struct VirtualInput {
@@ -197,7 +200,6 @@ impl VirtualInput {
                             .axis_discrete(0, axis, value as f64 / 6., value / 120);
                         self.pointer.frame();
                     }
-                    PointerEvent::Frame {} => self.pointer.frame(),
                 }
                 self.pointer.frame();
             }
@@ -206,16 +208,15 @@ impl VirtualInput {
                     self.keyboard.key(time, key, state as u32);
                 }
                 KeyboardEvent::Modifiers {
-                    mods_depressed,
+                    depressed: mods_depressed,
-                    mods_latched,
+                    latched: mods_latched,
-                    mods_locked,
+                    locked: mods_locked,
                     group,
                 } => {
                     self.keyboard
                         .modifiers(mods_depressed, mods_latched, mods_locked, group);
                 }
             },
-            _ => {}
         }
         Ok(())
     }

input-emulation/src/x11.rs

@@ -11,16 +11,16 @@ use input_event::{
 
 use crate::error::EmulationError;
 
-use super::{error::X11EmulationCreationError, EmulationHandle, InputEmulation};
+use super::{error::X11EmulationCreationError, Emulation, EmulationHandle};
 
-pub struct X11Emulation {
+pub(crate) struct X11Emulation {
     display: *mut xlib::Display,
 }
 
 unsafe impl Send for X11Emulation {}
 
 impl X11Emulation {
-    pub fn new() -> Result<Self, X11EmulationCreationError> {
+    pub(crate) fn new() -> Result<Self, X11EmulationCreationError> {
         let display = unsafe {
             match xlib::XOpenDisplay(ptr::null()) {
                 d if d == ptr::null::<xlib::Display>() as *mut xlib::Display => {
@@ -99,7 +99,7 @@ impl Drop for X11Emulation {
 }
 
 #[async_trait]
-impl InputEmulation for X11Emulation {
+impl Emulation for X11Emulation {
     async fn consume(&mut self, event: Event, _: EmulationHandle) -> Result<(), EmulationError> {
         match event {
             Event::Pointer(pointer_event) => match pointer_event {
@@ -123,7 +123,6 @@ impl InputEmulation for X11Emulation {
                 PointerEvent::AxisDiscrete120 { axis, value } => {
                     self.emulate_scroll(axis, value as f64);
                 }
-                PointerEvent::Frame {} => {}
             },
             Event::Keyboard(KeyboardEvent::Key {
                 time: _,
@@ -148,4 +147,8 @@ impl InputEmulation for X11Emulation {
     async fn destroy(&mut self, _: EmulationHandle) {
         // for our purposes it does not matter what client sent the event
     }
+
+    async fn terminate(&mut self) {
+        /* nothing to do */
+    }
 }

input-emulation/src/xdg_desktop_portal.rs

@@ -1,7 +1,7 @@
 use ashpd::{
     desktop::{
         remote_desktop::{Axis, DeviceType, KeyState, RemoteDesktop},
-        ResponseError, Session,
+        PersistMode, Session,
     },
     zbus::AsyncDrop,
     WindowIdentifier,
@@ -16,42 +16,37 @@ use input_event::{
 
 use crate::error::EmulationError;
 
-use super::{error::XdpEmulationCreationError, EmulationHandle, InputEmulation};
+use super::{error::XdpEmulationCreationError, Emulation, EmulationHandle};
 
-pub struct DesktopPortalEmulation<'a> {
+pub(crate) struct DesktopPortalEmulation<'a> {
     proxy: RemoteDesktop<'a>,
-    session: Session<'a>,
+    session: Session<'a, RemoteDesktop<'a>>,
 }
 
 impl<'a> DesktopPortalEmulation<'a> {
-    pub async fn new() -> Result<DesktopPortalEmulation<'a>, XdpEmulationCreationError> {
+    pub(crate) async fn new() -> Result<DesktopPortalEmulation<'a>, XdpEmulationCreationError> {
         log::debug!("connecting to org.freedesktop.portal.RemoteDesktop portal ...");
         let proxy = RemoteDesktop::new().await?;
 
         // retry when user presses the cancel button
-        let (session, _) = loop {
+        log::debug!("creating session ...");
-            log::debug!("creating session ...");
+        let session = proxy.create_session().await?;
-            let session = proxy.create_session().await?;
 
-            log::debug!("selecting devices ...");
+        log::debug!("selecting devices ...");
-            proxy
+        proxy
-                .select_devices(&session, DeviceType::Keyboard | DeviceType::Pointer)
+            .select_devices(
-                .await?;
+                &session,
+                DeviceType::Keyboard | DeviceType::Pointer,
+                None,
+                PersistMode::ExplicitlyRevoked,
+            )
+            .await?;
 
-            log::info!("requesting permission for input emulation");
+        log::info!("requesting permission for input emulation");
-            match proxy
+        let _devices = proxy
-                .start(&session, &WindowIdentifier::default())
+            .start(&session, &WindowIdentifier::default())
-                .await?
+            .await?
-                .response()
+            .response()?;
-            {
-                Ok(d) => break (session, d),
-                Err(ashpd::Error::Response(ResponseError::Cancelled)) => {
-                    log::warn!("request cancelled!");
-                    continue;
-                }
-                e => e?,
-            };
-        };
 
         log::debug!("started session");
         let session = session;
@@ -61,7 +56,7 @@ impl<'a> DesktopPortalEmulation<'a> {
 }
 
 #[async_trait]
-impl<'a> InputEmulation for DesktopPortalEmulation<'a> {
+impl<'a> Emulation for DesktopPortalEmulation<'a> {
     async fn consume(
         &mut self,
         event: input_event::Event,
@@ -93,7 +88,7 @@ impl<'a> InputEmulation for DesktopPortalEmulation<'a> {
                         _ => Axis::Horizontal,
                     };
                     self.proxy
-                        .notify_pointer_axis_discrete(&self.session, axis, value)
+                        .notify_pointer_axis_discrete(&self.session, axis, value / 120)
                         .await?;
                 }
                 PointerEvent::Axis {
@@ -113,7 +108,6 @@ impl<'a> InputEmulation for DesktopPortalEmulation<'a> {
                         .notify_pointer_axis(&self.session, dx, dy, true)
                         .await?;
                 }
-                PointerEvent::Frame {} => {}
             },
             Keyboard(k) => {
                 match k {
@@ -135,13 +129,20 @@ impl<'a> InputEmulation for DesktopPortalEmulation<'a> {
                     }
                 }
             }
-            _ => {}
         }
         Ok(())
     }
 
     async fn create(&mut self, _client: EmulationHandle) {}
     async fn destroy(&mut self, _client: EmulationHandle) {}
+    async fn terminate(&mut self) {
+        if let Err(e) = self.session.close().await {
+            log::warn!("session.close(): {e}");
+        };
+        if let Err(e) = self.session.receive_closed().await {
+            log::warn!("session.receive_closed(): {e}");
+        };
+    }
 }
 
 impl<'a> AsyncDrop for DesktopPortalEmulation<'a> {

input-event/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
 name = "input-event"
 description = "cross-platform input-event types for input-capture / input-emulation"
-version = "0.1.0"
+version = "0.2.1"
 edition = "2021"
 license = "GPL-3.0-or-later"
-repository = "https://github.com/ferdinandschober/lan-mouse"
+repository = "https://github.com/feschber/lan-mouse"
 
 [dependencies]
 futures-core = "0.3.30"
@@ -12,3 +12,10 @@ log = "0.4.22"
 num_enum = "0.7.2"
 serde = { version = "1.0", features = ["derive"] }
 thiserror = "1.0.61"
+
+[target.'cfg(all(unix, not(target_os="macos")))'.dependencies]
+reis = { version = "0.2.0", optional = true }
+
+[features]
+default = ["libei"]
+libei = ["dep:reis"]

input-event/src/error.rs

@@ -1,17 +1 @@
-use std::array::TryFromSliceError;
 
-use thiserror::Error;
-
-#[derive(Debug, Error)]
-pub enum ProtocolError {
-    #[error(transparent)]
-    MissingData(#[from] TryFromSliceError),
-    #[error("invalid event id: `{0}`")]
-    InvalidEventId(u8),
-    #[error("invalid pointer event type: `{0}`")]
-    InvalidPointerEventId(u8),
-    #[error("invalid keyboard event type: `{0}`")]
-    InvalidKeyboardEventId(u8),
-    #[error("expected data at idx `{0:?}`")]
-    Data(String),
-}

input-event/src/lib.rs

@@ -1,10 +1,11 @@
-pub use error::ProtocolError;
 use std::fmt::{self, Display};
 
 pub mod error;
-pub mod proto;
 pub mod scancode;
 
+#[cfg(all(unix, feature = "libei", not(target_os = "macos")))]
+mod libei;
+
 // FIXME
 pub const BTN_LEFT: u32 = 0x110;
 pub const BTN_RIGHT: u32 = 0x111;
@@ -22,8 +23,6 @@ pub enum PointerEvent {
     Axis { time: u32, axis: u8, value: f64 },
     /// discrete axis event, scroll event for mice - 120 = one scroll tick
     AxisDiscrete120 { axis: u8, value: i32 },
-    /// frame event
-    Frame {},
 }
 
 #[derive(Debug, PartialEq, Clone, Copy)]
@@ -32,9 +31,9 @@ pub enum KeyboardEvent {
     Key { time: u32, key: u32, state: u8 },
     /// modifiers changed state
     Modifiers {
-        mods_depressed: u32,
+        depressed: u32,
-        mods_latched: u32,
+        latched: u32,
-        mods_locked: u32,
+        locked: u32,
         group: u32,
     },
 }
@@ -45,23 +44,6 @@ pub enum Event {
     Pointer(PointerEvent),
     /// keyboard events (key / modifiers)
     Keyboard(KeyboardEvent),
-    /// enter event: request to enter a client.
-    /// The client must release the pointer if it is grabbed
-    /// and reply with a leave event, as soon as its ready to
-    /// receive events
-    Enter(),
-    /// leave event: this client is now ready to receive events and will
-    /// not send any events after until it sends an enter event
-    Leave(),
-    /// ping a client, to see if it is still alive. A client that does
-    /// not respond with a pong event will be assumed to be offline.
-    Ping(),
-    /// response to a ping event: this event signals that a client
-    /// is still alive but must otherwise be ignored
-    Pong(),
-    /// explicit disconnect request. The client will no longer
-    /// send events until the next Enter event. All of its keys should be released.
-    Disconnect(),
 }
 
 impl Display for PointerEvent {
@@ -95,7 +77,6 @@ impl Display for PointerEvent {
             PointerEvent::AxisDiscrete120 { axis, value } => {
                 write!(f, "scroll-120 ({axis}, {value})")
             }
-            PointerEvent::Frame {} => write!(f, "frame()"),
         }
     }
 }
@@ -116,9 +97,9 @@ impl Display for KeyboardEvent {
                 }
             }
             KeyboardEvent::Modifiers {
-                mods_depressed,
+                depressed: mods_depressed,
-                mods_latched,
+                latched: mods_latched,
-                mods_locked,
+                locked: mods_locked,
                 group,
             } => write!(
                 f,
@@ -133,11 +114,6 @@ impl Display for Event {
         match self {
             Event::Pointer(p) => write!(f, "{}", p),
             Event::Keyboard(k) => write!(f, "{}", k),
-            Event::Enter() => write!(f, "enter"),
-            Event::Leave() => write!(f, "leave"),
-            Event::Ping() => write!(f, "ping"),
-            Event::Pong() => write!(f, "pong"),
-            Event::Disconnect() => write!(f, "disconnect"),
         }
     }
 }

input-event/src/libei.rs

@@ -0,0 +1,146 @@
+use reis::{
+    ei::{button::ButtonState, keyboard::KeyState},
+    event::EiEvent,
+};
+
+use crate::{Event, KeyboardEvent, PointerEvent};
+
+impl Event {
+    pub fn from_ei_event(ei_event: EiEvent) -> impl Iterator<Item = Self> {
+        to_input_events(ei_event).into_iter()
+    }
+}
+
+enum Events {
+    None,
+    One(Event),
+    Two(Event, Event),
+}
+
+impl Events {
+    fn into_iter(self) -> impl Iterator<Item = Event> {
+        EventIterator::new(self)
+    }
+}
+
+struct EventIterator {
+    events: [Option<Event>; 2],
+    pos: usize,
+}
+
+impl EventIterator {
+    fn new(events: Events) -> Self {
+        let events = match events {
+            Events::None => [None, None],
+            Events::One(e) => [Some(e), None],
+            Events::Two(e, f) => [Some(e), Some(f)],
+        };
+        Self { events, pos: 0 }
+    }
+}
+
+impl Iterator for EventIterator {
+    type Item = Event;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let res = if self.pos >= self.events.len() {
+            None
+        } else {
+            self.events[self.pos]
+        };
+        self.pos += 1;
+        res
+    }
+}
+
+fn to_input_events(ei_event: EiEvent) -> Events {
+    match ei_event {
+        EiEvent::KeyboardModifiers(mods) => {
+            let modifier_event = KeyboardEvent::Modifiers {
+                depressed: mods.depressed,
+                latched: mods.latched,
+                locked: mods.locked,
+                group: mods.group,
+            };
+            Events::One(Event::Keyboard(modifier_event))
+        }
+        EiEvent::Frame(_) => Events::None, /* FIXME */
+        EiEvent::PointerMotion(motion) => {
+            let motion_event = PointerEvent::Motion {
+                time: motion.time as u32,
+                dx: motion.dx as f64,
+                dy: motion.dy as f64,
+            };
+            Events::One(Event::Pointer(motion_event))
+        }
+        EiEvent::PointerMotionAbsolute(_) => Events::None,
+        EiEvent::Button(button) => {
+            let button_event = PointerEvent::Button {
+                time: button.time as u32,
+                button: button.button,
+                state: match button.state {
+                    ButtonState::Released => 0,
+                    ButtonState::Press => 1,
+                },
+            };
+            Events::One(Event::Pointer(button_event))
+        }
+        EiEvent::ScrollDelta(delta) => {
+            let dy = Event::Pointer(PointerEvent::Axis {
+                time: 0,
+                axis: 0,
+                value: delta.dy as f64,
+            });
+            let dx = Event::Pointer(PointerEvent::Axis {
+                time: 0,
+                axis: 1,
+                value: delta.dx as f64,
+            });
+            if delta.dy != 0. && delta.dx != 0. {
+                Events::Two(dy, dx)
+            } else if delta.dy != 0. {
+                Events::One(dy)
+            } else if delta.dx != 0. {
+                Events::One(dx)
+            } else {
+                Events::None
+            }
+        }
+        EiEvent::ScrollStop(_) => Events::None,   /* TODO */
+        EiEvent::ScrollCancel(_) => Events::None, /* TODO */
+        EiEvent::ScrollDiscrete(scroll) => {
+            let dy = Event::Pointer(PointerEvent::AxisDiscrete120 {
+                axis: 0,
+                value: scroll.discrete_dy,
+            });
+            let dx = Event::Pointer(PointerEvent::AxisDiscrete120 {
+                axis: 1,
+                value: scroll.discrete_dx,
+            });
+            if scroll.discrete_dy != 0 && scroll.discrete_dx != 0 {
+                Events::Two(dy, dx)
+            } else if scroll.discrete_dy != 0 {
+                Events::One(dy)
+            } else if scroll.discrete_dx != 0 {
+                Events::One(dx)
+            } else {
+                Events::None
+            }
+        }
+        EiEvent::KeyboardKey(key) => {
+            let key_event = KeyboardEvent::Key {
+                key: key.key,
+                state: match key.state {
+                    KeyState::Press => 1,
+                    KeyState::Released => 0,
+                },
+                time: key.time as u32,
+            };
+            Events::One(Event::Keyboard(key_event))
+        }
+        EiEvent::TouchDown(_) => Events::None,   /* TODO */
+        EiEvent::TouchUp(_) => Events::None,     /* TODO */
+        EiEvent::TouchMotion(_) => Events::None, /* TODO */
+        _ => Events::None,
+    }
+}

input-event/src/proto.rs

@@ -1,307 +0,0 @@
-use std::{fmt::Debug, slice::SliceIndex};
-
-use crate::ProtocolError;
-
-use super::{Event, KeyboardEvent, PointerEvent};
-
-enum PointerEventType {
-    Motion,
-    Button,
-    Axis,
-    AxisDiscrete120,
-    Frame,
-}
-
-enum KeyboardEventType {
-    Key,
-    Modifiers,
-}
-
-enum EventType {
-    Pointer,
-    Keyboard,
-    Enter,
-    Leave,
-    Ping,
-    Pong,
-    Disconnect,
-}
-
-impl Event {
-    fn event_type(&self) -> EventType {
-        match self {
-            Self::Pointer(_) => EventType::Pointer,
-            Self::Keyboard(_) => EventType::Keyboard,
-            Self::Enter() => EventType::Enter,
-            Self::Leave() => EventType::Leave,
-            Self::Ping() => EventType::Ping,
-            Self::Pong() => EventType::Pong,
-            Self::Disconnect() => EventType::Disconnect,
-        }
-    }
-}
-
-impl PointerEvent {
-    fn event_type(&self) -> PointerEventType {
-        match self {
-            Self::Motion { .. } => PointerEventType::Motion,
-            Self::Button { .. } => PointerEventType::Button,
-            Self::Axis { .. } => PointerEventType::Axis,
-            Self::AxisDiscrete120 { .. } => PointerEventType::AxisDiscrete120,
-            Self::Frame { .. } => PointerEventType::Frame,
-        }
-    }
-}
-
-impl KeyboardEvent {
-    fn event_type(&self) -> KeyboardEventType {
-        match self {
-            KeyboardEvent::Key { .. } => KeyboardEventType::Key,
-            KeyboardEvent::Modifiers { .. } => KeyboardEventType::Modifiers,
-        }
-    }
-}
-
-impl TryFrom<u8> for PointerEventType {
-    type Error = ProtocolError;
-
-    fn try_from(value: u8) -> Result<Self, ProtocolError> {
-        match value {
-            x if x == Self::Motion as u8 => Ok(Self::Motion),
-            x if x == Self::Button as u8 => Ok(Self::Button),
-            x if x == Self::Axis as u8 => Ok(Self::Axis),
-            x if x == Self::AxisDiscrete120 as u8 => Ok(Self::AxisDiscrete120),
-            x if x == Self::Frame as u8 => Ok(Self::Frame),
-            _ => Err(ProtocolError::InvalidPointerEventId(value)),
-        }
-    }
-}
-
-impl TryFrom<u8> for KeyboardEventType {
-    type Error = ProtocolError;
-
-    fn try_from(value: u8) -> Result<Self, ProtocolError> {
-        match value {
-            x if x == Self::Key as u8 => Ok(Self::Key),
-            x if x == Self::Modifiers as u8 => Ok(Self::Modifiers),
-            _ => Err(ProtocolError::InvalidKeyboardEventId(value)),
-        }
-    }
-}
-
-impl From<&Event> for Vec<u8> {
-    fn from(event: &Event) -> Self {
-        let event_id = vec![event.event_type() as u8];
-        let event_data = match event {
-            Event::Pointer(p) => p.into(),
-            Event::Keyboard(k) => k.into(),
-            Event::Enter() => vec![],
-            Event::Leave() => vec![],
-            Event::Ping() => vec![],
-            Event::Pong() => vec![],
-            Event::Disconnect() => vec![],
-        };
-        [event_id, event_data].concat()
-    }
-}
-
-impl TryFrom<Vec<u8>> for Event {
-    type Error = ProtocolError;
-
-    fn try_from(value: Vec<u8>) -> Result<Self, ProtocolError> {
-        let event_id = u8::from_be_bytes(value[..1].try_into()?);
-        match event_id {
-            i if i == (EventType::Pointer as u8) => Ok(Event::Pointer(value.try_into()?)),
-            i if i == (EventType::Keyboard as u8) => Ok(Event::Keyboard(value.try_into()?)),
-            i if i == (EventType::Enter as u8) => Ok(Event::Enter()),
-            i if i == (EventType::Leave as u8) => Ok(Event::Leave()),
-            i if i == (EventType::Ping as u8) => Ok(Event::Ping()),
-            i if i == (EventType::Pong as u8) => Ok(Event::Pong()),
-            i if i == (EventType::Disconnect as u8) => Ok(Event::Disconnect()),
-            _ => Err(ProtocolError::InvalidEventId(event_id)),
-        }
-    }
-}
-
-impl From<&PointerEvent> for Vec<u8> {
-    fn from(event: &PointerEvent) -> Self {
-        let id = vec![event.event_type() as u8];
-        let data = match event {
-            PointerEvent::Motion { time, dx, dy } => {
-                let time = time.to_be_bytes();
-                let dx = dx.to_be_bytes();
-                let dy = dy.to_be_bytes();
-                [&time[..], &dx[..], &dy[..]].concat()
-            }
-            PointerEvent::Button {
-                time,
-                button,
-                state,
-            } => {
-                let time = time.to_be_bytes();
-                let button = button.to_be_bytes();
-                let state = state.to_be_bytes();
-                [&time[..], &button[..], &state[..]].concat()
-            }
-            PointerEvent::Axis { time, axis, value } => {
-                let time = time.to_be_bytes();
-                let axis = axis.to_be_bytes();
-                let value = value.to_be_bytes();
-                [&time[..], &axis[..], &value[..]].concat()
-            }
-            PointerEvent::AxisDiscrete120 { axis, value } => {
-                let axis = axis.to_be_bytes();
-                let value = value.to_be_bytes();
-                [&axis[..], &value[..]].concat()
-            }
-            PointerEvent::Frame {} => {
-                vec![]
-            }
-        };
-        [id, data].concat()
-    }
-}
-
-fn decode_u8<I>(data: &[u8], idx: I) -> Result<u8, ProtocolError>
-where
-    I: SliceIndex<[u8], Output = [u8]> + Debug + Clone,
-{
-    let data = data
-        .get(idx.clone())
-        .ok_or(ProtocolError::Data(format!("{:?}", idx)))?;
-    Ok(u8::from_be_bytes(data.try_into()?))
-}
-
-fn decode_u32<I>(data: &[u8], idx: I) -> Result<u32, ProtocolError>
-where
-    I: SliceIndex<[u8], Output = [u8]> + Debug + Clone,
-{
-    let data = data
-        .get(idx.clone())
-        .ok_or(ProtocolError::Data(format!("{:?}", idx)))?;
-    Ok(u32::from_be_bytes(data.try_into()?))
-}
-
-fn decode_i32<I>(data: &[u8], idx: I) -> Result<i32, ProtocolError>
-where
-    I: SliceIndex<[u8], Output = [u8]> + Debug + Clone,
-{
-    let data = data
-        .get(idx.clone())
-        .ok_or(ProtocolError::Data(format!("{:?}", idx)))?;
-    Ok(i32::from_be_bytes(data.try_into()?))
-}
-fn decode_f64<I>(data: &[u8], idx: I) -> Result<f64, ProtocolError>
-where
-    I: SliceIndex<[u8], Output = [u8]> + Debug + Clone,
-{
-    let data = data
-        .get(idx.clone())
-        .ok_or(ProtocolError::Data(format!("{:?}", idx)))?;
-    Ok(f64::from_be_bytes(data.try_into()?))
-}
-
-impl TryFrom<Vec<u8>> for PointerEvent {
-    type Error = ProtocolError;
-
-    fn try_from(data: Vec<u8>) -> Result<Self, ProtocolError> {
-        match data.get(1) {
-            Some(id) => match id.to_owned().try_into()? {
-                PointerEventType::Motion => {
-                    let time = decode_u32(&data, 2..6)?;
-                    let dx = decode_f64(&data, 6..14)?;
-                    let dy = decode_f64(&data, 14..22)?;
-
-                    Ok(Self::Motion { time, dx, dy })
-                }
-                PointerEventType::Button => {
-                    let time = decode_u32(&data, 2..6)?;
-                    let button = decode_u32(&data, 6..10)?;
-                    let state = decode_u32(&data, 10..14)?;
-
-                    Ok(Self::Button {
-                        time,
-                        button,
-                        state,
-                    })
-                }
-                PointerEventType::Axis => {
-                    let time = decode_u32(&data, 2..6)?;
-                    let axis = decode_u8(&data, 6..7)?;
-                    let value = decode_f64(&data, 7..15)?;
-                    Ok(Self::Axis { time, axis, value })
-                }
-                PointerEventType::AxisDiscrete120 => {
-                    let axis = decode_u8(&data, 2..3)?;
-                    let value = decode_i32(&data, 3..7)?;
-                    Ok(Self::AxisDiscrete120 { axis, value })
-                }
-                PointerEventType::Frame => Ok(Self::Frame {}),
-            },
-            None => Err(ProtocolError::Data("0".to_string())),
-        }
-    }
-}
-
-impl From<&KeyboardEvent> for Vec<u8> {
-    fn from(event: &KeyboardEvent) -> Self {
-        let id = vec![event.event_type() as u8];
-        let data = match event {
-            KeyboardEvent::Key { time, key, state } => {
-                let time = time.to_be_bytes();
-                let key = key.to_be_bytes();
-                let state = state.to_be_bytes();
-                [&time[..], &key[..], &state[..]].concat()
-            }
-            KeyboardEvent::Modifiers {
-                mods_depressed,
-                mods_latched,
-                mods_locked,
-                group,
-            } => {
-                let mods_depressed = mods_depressed.to_be_bytes();
-                let mods_latched = mods_latched.to_be_bytes();
-                let mods_locked = mods_locked.to_be_bytes();
-                let group = group.to_be_bytes();
-                [
-                    &mods_depressed[..],
-                    &mods_latched[..],
-                    &mods_locked[..],
-                    &group[..],
-                ]
-                .concat()
-            }
-        };
-        [id, data].concat()
-    }
-}
-
-impl TryFrom<Vec<u8>> for KeyboardEvent {
-    type Error = ProtocolError;
-
-    fn try_from(data: Vec<u8>) -> Result<Self, ProtocolError> {
-        match data.get(1) {
-            Some(id) => match id.to_owned().try_into()? {
-                KeyboardEventType::Key => {
-                    let time = decode_u32(&data, 2..6)?;
-                    let key = decode_u32(&data, 6..10)?;
-                    let state = decode_u8(&data, 10..11)?;
-                    Ok(KeyboardEvent::Key { time, key, state })
-                }
-                KeyboardEventType::Modifiers => {
-                    let mods_depressed = decode_u32(&data, 2..6)?;
-                    let mods_latched = decode_u32(&data, 6..10)?;
-                    let mods_locked = decode_u32(&data, 10..14)?;
-                    let group = decode_u32(&data, 14..18)?;
-                    Ok(KeyboardEvent::Modifiers {
-                        mods_depressed,
-                        mods_latched,
-                        mods_locked,
-                        group,
-                    })
-                }
-            },
-            None => Err(ProtocolError::Data("0".to_string())),
-        }
-    }
-}

lan-mouse-proto/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "lan-mouse-proto"
+description = "network protocol for lan-mouse"
+version = "0.1.0"
+edition = "2021"
+license = "GPL-3.0-or-later"
+repository = "https://github.com/feschber/lan-mouse"
+
+[dependencies]
+num_enum = "0.7.2"
+thiserror = "1.0.61"
+input-event = { path = "../input-event", version = "0.2.1" }
+paste = "1.0"

lan-mouse-proto/src/lib.rs

@@ -0,0 +1,251 @@
+use input_event::{Event as InputEvent, KeyboardEvent, PointerEvent};
+use num_enum::{IntoPrimitive, TryFromPrimitive, TryFromPrimitiveError};
+use paste::paste;
+use std::{
+    fmt::{Debug, Display},
+    mem::size_of,
+};
+use thiserror::Error;
+
+/// defines the maximum size an encoded event can take up
+/// this is currently the pointer motion event
+/// type: u8, time: u32, dx: f64, dy: f64
+pub const MAX_EVENT_SIZE: usize = size_of::<u8>() + size_of::<u32>() + 2 * size_of::<f64>();
+
+/// error type for protocol violations
+#[derive(Debug, Error)]
+pub enum ProtocolError {
+    /// event type does not exist
+    #[error("invalid event id: `{0}`")]
+    InvalidEventId(#[from] TryFromPrimitiveError<EventType>),
+}
+
+/// main lan-mouse protocol event type
+#[derive(Clone, Copy, Debug)]
+pub enum ProtoEvent {
+    /// notify a client that the cursor entered its region
+    /// [`ProtoEvent::Ack`] with the same serial is used for synchronization between devices
+    Enter(u32),
+    /// notify a client that the cursor left its region
+    /// [`ProtoEvent::Ack`] with the same serial is used for synchronization between devices
+    Leave(u32),
+    /// acknowledge of an [`ProtoEvent::Enter`] or [`ProtoEvent::Leave`] event
+    Ack(u32),
+    /// Input event
+    Input(InputEvent),
+    /// Ping event for tracking unresponsive clients.
+    /// A client has to respond with [`ProtoEvent::Pong`].
+    Ping,
+    /// Response to [`ProtoEvent::Ping`]
+    Pong,
+}
+
+impl Display for ProtoEvent {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ProtoEvent::Enter(s) => write!(f, "Enter({s})"),
+            ProtoEvent::Leave(s) => write!(f, "Leave({s})"),
+            ProtoEvent::Ack(s) => write!(f, "Ack({s})"),
+            ProtoEvent::Input(e) => write!(f, "{e}"),
+            ProtoEvent::Ping => write!(f, "ping"),
+            ProtoEvent::Pong => write!(f, "pong"),
+        }
+    }
+}
+
+#[derive(TryFromPrimitive, IntoPrimitive)]
+#[repr(u8)]
+pub enum EventType {
+    PointerMotion,
+    PointerButton,
+    PointerAxis,
+    PointerAxisValue120,
+    KeyboardKey,
+    KeyboardModifiers,
+    Ping,
+    Pong,
+    Enter,
+    Leave,
+    Ack,
+}
+
+impl ProtoEvent {
+    fn event_type(&self) -> EventType {
+        match self {
+            ProtoEvent::Input(e) => match e {
+                InputEvent::Pointer(p) => match p {
+                    PointerEvent::Motion { .. } => EventType::PointerMotion,
+                    PointerEvent::Button { .. } => EventType::PointerButton,
+                    PointerEvent::Axis { .. } => EventType::PointerAxis,
+                    PointerEvent::AxisDiscrete120 { .. } => EventType::PointerAxisValue120,
+                },
+                InputEvent::Keyboard(k) => match k {
+                    KeyboardEvent::Key { .. } => EventType::KeyboardKey,
+                    KeyboardEvent::Modifiers { .. } => EventType::KeyboardModifiers,
+                },
+            },
+            ProtoEvent::Ping => EventType::Ping,
+            ProtoEvent::Pong => EventType::Pong,
+            ProtoEvent::Enter(_) => EventType::Enter,
+            ProtoEvent::Leave(_) => EventType::Leave,
+            ProtoEvent::Ack(_) => EventType::Ack,
+        }
+    }
+}
+
+impl TryFrom<[u8; MAX_EVENT_SIZE]> for ProtoEvent {
+    type Error = ProtocolError;
+
+    fn try_from(buf: [u8; MAX_EVENT_SIZE]) -> Result<Self, Self::Error> {
+        let mut buf = &buf[..];
+        let event_type = decode_u8(&mut buf)?;
+        match EventType::try_from(event_type)? {
+            EventType::PointerMotion => {
+                Ok(Self::Input(InputEvent::Pointer(PointerEvent::Motion {
+                    time: decode_u32(&mut buf)?,
+                    dx: decode_f64(&mut buf)?,
+                    dy: decode_f64(&mut buf)?,
+                })))
+            }
+            EventType::PointerButton => {
+                Ok(Self::Input(InputEvent::Pointer(PointerEvent::Button {
+                    time: decode_u32(&mut buf)?,
+                    button: decode_u32(&mut buf)?,
+                    state: decode_u32(&mut buf)?,
+                })))
+            }
+            EventType::PointerAxis => Ok(Self::Input(InputEvent::Pointer(PointerEvent::Axis {
+                time: decode_u32(&mut buf)?,
+                axis: decode_u8(&mut buf)?,
+                value: decode_f64(&mut buf)?,
+            }))),
+            EventType::PointerAxisValue120 => Ok(Self::Input(InputEvent::Pointer(
+                PointerEvent::AxisDiscrete120 {
+                    axis: decode_u8(&mut buf)?,
+                    value: decode_i32(&mut buf)?,
+                },
+            ))),
+            EventType::KeyboardKey => Ok(Self::Input(InputEvent::Keyboard(KeyboardEvent::Key {
+                time: decode_u32(&mut buf)?,
+                key: decode_u32(&mut buf)?,
+                state: decode_u8(&mut buf)?,
+            }))),
+            EventType::KeyboardModifiers => Ok(Self::Input(InputEvent::Keyboard(
+                KeyboardEvent::Modifiers {
+                    depressed: decode_u32(&mut buf)?,
+                    latched: decode_u32(&mut buf)?,
+                    locked: decode_u32(&mut buf)?,
+                    group: decode_u32(&mut buf)?,
+                },
+            ))),
+            EventType::Ping => Ok(Self::Ping),
+            EventType::Pong => Ok(Self::Pong),
+            EventType::Enter => Ok(Self::Enter(decode_u32(&mut buf)?)),
+            EventType::Leave => Ok(Self::Leave(decode_u32(&mut buf)?)),
+            EventType::Ack => Ok(Self::Ack(decode_u32(&mut buf)?)),
+        }
+    }
+}
+
+impl From<ProtoEvent> for ([u8; MAX_EVENT_SIZE], usize) {
+    fn from(event: ProtoEvent) -> Self {
+        let mut buf = [0u8; MAX_EVENT_SIZE];
+        let mut len = 0usize;
+        {
+            let mut buf = &mut buf[..];
+            let buf = &mut buf;
+            let len = &mut len;
+            encode_u8(buf, len, event.event_type() as u8);
+            match event {
+                ProtoEvent::Input(event) => match event {
+                    InputEvent::Pointer(p) => match p {
+                        PointerEvent::Motion { time, dx, dy } => {
+                            encode_u32(buf, len, time);
+                            encode_f64(buf, len, dx);
+                            encode_f64(buf, len, dy);
+                        }
+                        PointerEvent::Button {
+                            time,
+                            button,
+                            state,
+                        } => {
+                            encode_u32(buf, len, time);
+                            encode_u32(buf, len, button);
+                            encode_u32(buf, len, state);
+                        }
+                        PointerEvent::Axis { time, axis, value } => {
+                            encode_u32(buf, len, time);
+                            encode_u8(buf, len, axis);
+                            encode_f64(buf, len, value);
+                        }
+                        PointerEvent::AxisDiscrete120 { axis, value } => {
+                            encode_u8(buf, len, axis);
+                            encode_i32(buf, len, value);
+                        }
+                    },
+                    InputEvent::Keyboard(k) => match k {
+                        KeyboardEvent::Key { time, key, state } => {
+                            encode_u32(buf, len, time);
+                            encode_u32(buf, len, key);
+                            encode_u8(buf, len, state);
+                        }
+                        KeyboardEvent::Modifiers {
+                            depressed,
+                            latched,
+                            locked,
+                            group,
+                        } => {
+                            encode_u32(buf, len, depressed);
+                            encode_u32(buf, len, latched);
+                            encode_u32(buf, len, locked);
+                            encode_u32(buf, len, group);
+                        }
+                    },
+                },
+                ProtoEvent::Ping => {}
+                ProtoEvent::Pong => {}
+                ProtoEvent::Enter(serial) => encode_u32(buf, len, serial),
+                ProtoEvent::Leave(serial) => encode_u32(buf, len, serial),
+                ProtoEvent::Ack(serial) => encode_u32(buf, len, serial),
+            }
+        }
+        (buf, len)
+    }
+}
+
+macro_rules! decode_impl {
+    ($t:ty) => {
+        paste! {
+            fn [<decode_ $t>](data: &mut &[u8]) -> Result<$t, ProtocolError> {
+                let (int_bytes, rest) = data.split_at(size_of::<$t>());
+                *data = rest;
+                Ok($t::from_be_bytes(int_bytes.try_into().unwrap()))
+            }
+        }
+    };
+}
+
+decode_impl!(u8);
+decode_impl!(u32);
+decode_impl!(i32);
+decode_impl!(f64);
+
+macro_rules! encode_impl {
+    ($t:ty) => {
+        paste! {
+            fn [<encode_ $t>](buf: &mut &mut [u8], amt: &mut usize, n: $t) {
+                let src = n.to_be_bytes();
+                let data = std::mem::take(buf);
+                let (int_bytes, rest) = data.split_at_mut(size_of::<$t>());
+                int_bytes.copy_from_slice(&src);
+                *amt += size_of::<$t>();
+                *buf = rest
+            }
+        }
+    };
+}
+
+encode_impl!(u8);
+encode_impl!(u32);
+encode_impl!(i32);
+encode_impl!(f64);

nix/default.nix

@@ -12,8 +12,10 @@ rustPlatform.buildRustPackage {
   version = version;
 
   nativeBuildInputs = with pkgs; [
+    git
     pkg-config
     cmake
+    makeWrapper
     buildPackages.gtk4
   ];
 
@@ -22,9 +24,11 @@ rustPlatform.buildRustPackage {
     gtk4
     libadwaita
     xorg.libXtst
-  ] ++ lib.optionals stdenv.isDarwin [
+  ] ++ lib.optionals stdenv.isDarwin
-    darwin.apple_sdk_11_0.frameworks.CoreGraphics
+  (with darwin.apple_sdk_11_0.frameworks; [
-  ];
+    CoreGraphics
+    ApplicationServices
+  ]);
 
   src = builtins.path {
     name = pname;
@@ -36,6 +40,12 @@ rustPlatform.buildRustPackage {
   # Set Environment Variables
   RUST_BACKTRACE = "full";
 
+  # Needed to enable support for SVG icons in GTK
+  postInstall = ''
+    wrapProgram "$out/bin/lan-mouse" \
+      --set GDK_PIXBUF_MODULE_FILE ${pkgs.librsvg.out}/lib/gdk-pixbuf-2.0/2.10.0/loaders.cache
+  '';
+
   meta = with lib; {
     description = "Lan Mouse is a mouse and keyboard sharing software";
     longDescription = ''

resources/client_row.ui

@@ -44,6 +44,7 @@
 				<child>
 					<object class="GtkEntry" id="port">
 						<!-- <property name="title" translatable="yes">port</property> -->
+                        <property name="max-width-chars">5</property>
 						<property name="input_purpose">GTK_INPUT_PURPOSE_NUMBER</property>
 						<property name="xalign">0.5</property>
 						<property name="valign">center</property>

resources/window.ui

@@ -1,167 +1,227 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <interface>
-	<requires lib="gtk" version="4.0"/>
+  <requires lib="gtk" version="4.0"/>
-	<requires lib="libadwaita" version="1.0"/>
+  <requires lib="libadwaita" version="1.0"/>
-	<menu id="main-menu">
+  <menu id="main-menu">
-		<item>
+    <item>
-			<attribute name="label" translatable="yes">_Close window</attribute>
+      <attribute name="label" translatable="yes">_Close window</attribute>
-			<attribute name="action">window.close</attribute>
+      <attribute name="action">window.close</attribute>
-		</item>
+    </item>
-	</menu>
+  </menu>
-	<template class="LanMouseWindow" parent="AdwApplicationWindow">
+  <template class="LanMouseWindow" parent="AdwApplicationWindow">
-		<property name="width-request">600</property>
+    <property name="width-request">600</property>
-		<property name="height-request">700</property>
+    <property name="height-request">700</property>
-		<property name="title" translatable="yes">Lan Mouse</property>
+    <property name="title" translatable="yes">Lan Mouse</property>
-		<property name="show-menubar">True</property>
+    <property name="show-menubar">True</property>
-		<property name="content">
+    <property name="content">
-			<object class="GtkBox">
+      <object class="GtkBox">
-				<property name="orientation">vertical</property>
+        <property name="orientation">vertical</property>
-				<child type="top">
+        <child type="top">
-					<object class="AdwHeaderBar">
+          <object class="AdwHeaderBar">
-						<child type ="end">
+            <child type ="end">
-							<object class="GtkMenuButton">
+              <object class="GtkMenuButton">
-								<property name="icon-name">open-menu-symbolic</property>
+                <property name="icon-name">open-menu-symbolic</property>
-								<property name="menu-model">main-menu</property>
+                <property name="menu-model">main-menu</property>
-							</object>
+              </object>
-						</child>
+            </child>
-						<style>
+            <style>
-							<class name="flat"/>
+              <class name="flat"/>
-						</style>
+            </style>
-					</object>
+          </object>
-				</child>
+        </child>
-				<child>
+        <child>
-					<object class="AdwToastOverlay" id="toast_overlay">
+          <object class="AdwToastOverlay" id="toast_overlay">
-						<child>
+            <child>
-							<object class="AdwStatusPage">
+              <object class="AdwStatusPage">
-								<property name="title" translatable="yes">Lan Mouse</property>
+                <property name="title" translatable="yes">Lan Mouse</property>
-								<property name="description" translatable="yes">easily use your mouse and keyboard on multiple computers</property>
+                <property name="description" translatable="yes">easily use your mouse and keyboard on multiple computers</property>
-								<property name="icon-name">de.feschber.LanMouse</property>
+                <property name="icon-name">de.feschber.LanMouse</property>
-								<property name="child">
+                <property name="child">
-								  <object class="AdwClamp">
+                  <object class="AdwClamp">
-									<property name="maximum-size">600</property>
+                  <property name="maximum-size">600</property>
-									<property name="tightening-threshold">0</property>
+                  <property name="tightening-threshold">0</property>
-									<property name="child">
+                  <property name="child">
-									  <object class="GtkBox">
+                    <object class="GtkBox">
-										<property name="orientation">vertical</property>
+                    <property name="orientation">vertical</property>
-										<property name="spacing">12</property>
+                    <property name="spacing">12</property>
-										<child>
+                    <child>
-											<object class="AdwPreferencesGroup">
+                      <object class="AdwPreferencesGroup" id="capture_emulation_group">
-												<property name="title" translatable="yes">General</property>
+                      <property name="title" translatable="yes">Capture / Emulation Status</property>
-												<!--
+                        <child>
-												<child>
+                          <object class="AdwActionRow" id="capture_status_row">
-													<object class="AdwActionRow">
+                            <property name="title">input capture is disabled</property>
-														<property name="title" translatable="yes">enable</property>
+                            <property name="subtitle">required for outgoing and incoming connections</property>
-														<child type="suffix">
+                            <property name="icon-name">dialog-warning-symbolic</property>
-															<object class="GtkSwitch">
+                            <child>
-																<property name="valign">center</property>
+                              <object class="GtkButton" id="input_capture_button">
-																<property name="tooltip-text" translatable="yes">enable</property>
+                                <property name="child">
-															</object>
+                                  <object class="AdwButtonContent">
-														</child>
+                                    <property name="icon-name">object-rotate-right-symbolic</property>
-													</object>
+                                    <property name="label" translatable="yes">Reenable</property>
-												</child>
+                                  </object>
-												-->
+                                </property>
-												<child>
+                                <signal name="clicked" handler="handle_capture" swapped="true"/>
-													<object class="AdwActionRow">
+                                <property name="valign">center</property>
-														<property name="title">port</property>
+                                <style>
-														<child>
+                                  <class name="circular"/>
-															<object class="GtkEntry" id="port_entry">
+                                  <class name="flat"/>
-																<signal name="activate" handler="handle_port_edit_apply" swapped="true"/>
+                                </style>
-																<signal name="changed" handler="handle_port_changed" swapped="true"/>
+                              </object>
-																<!-- <signal name="delete-text" handler="handle_port_changed" swapped="true"/> -->
+                            </child>
-																<!-- <property name="title" translatable="yes">port</property> -->
+                            <style>
-																<property name="placeholder-text">4242</property>
+                              <class name="warning"/>
-																<property name="width-chars">5</property>
+                            </style>
-																<property name="xalign">0.5</property>
+                          </object>
-																<property name="valign">center</property>
+                        </child>
-																<!-- <property name="show-apply-button">True</property> -->
+                        <child>
-																<property name="input-purpose">GTK_INPUT_PURPOSE_DIGITS</property>
+                          <object class="AdwActionRow" id="emulation_status_row">
-															</object>
+                            <property name="title">input emulation is disabled</property>
-														</child>
+                            <property name="subtitle">required for incoming connections</property>
-														<child>
+                            <property name="icon-name">dialog-warning-symbolic</property>
-															<object class="GtkButton" id="port_edit_apply">
+                            <child>
-																<signal name="clicked" handler="handle_port_edit_apply" swapped="true"/>
+                              <object class="GtkButton" id="input_emulation_button">
-																<property name="icon-name">object-select-symbolic</property>
+                                <property name="child">
-																<property name="valign">center</property>
+                                  <object class="AdwButtonContent">
-																<property name="visible">false</property>
+                                    <property name="icon-name">object-rotate-right-symbolic</property>
-																<property name="name">port-edit-apply</property>
+                                    <property name="label" translatable="yes">Reenable</property>
-																<style><class name="success"/></style>
+                                  </object>
-															</object>
+                                </property>
-														</child>
+                                <property name="valign">center</property>
-														<child>
+                                <signal name="clicked" handler="handle_emulation" swapped="true"/>
-															<object class="GtkButton" id="port_edit_cancel">
+                                <style>
-																<signal name="clicked" handler="handle_port_edit_cancel" swapped="true"/>
+                                  <class name="circular"/>
-																<property name="icon-name">process-stop-symbolic</property>
+                                  <class name="flat"/>
-																<property name="valign">center</property>
+                                </style>
-																<property name="visible">false</property>
+                              </object>
-																<property name="name">port-edit-cancel</property>
+                            </child>
-																<style><class name="error"/></style>
+                            <child>
-															</object>
+                            </child>
-														</child>
+                            <style>
-													</object>
+                              <class name="warning"/>
-												</child>
+                            </style>
-												<child>
+                          </object>
-													<object class="AdwActionRow">
+                        </child>
-														<property name="title">hostname</property>
+                      </object>
-														<child>
+                    </child>
-															<object class="GtkLabel" id="hostname_label">
+                    <child>
-																<property name="label">&lt;span font_style=&quot;italic&quot; font_weight=&quot;light&quot; foreground=&quot;darkgrey&quot;&gt;could not determine hostname&lt;/span&gt;</property>
+                      <object class="AdwPreferencesGroup">
-																<property name="use-markup">true</property>
+                        <property name="title" translatable="yes">General</property>
-																<property name="valign">center</property>
+                        <!--
-															</object>
+                        <child>
-														</child>
+                          <object class="AdwActionRow">
-														<child>
+                            <property name="title" translatable="yes">enable</property>
-															<object class="GtkButton" id="copy-hostname-button">
+                            <child type="suffix">
-																<property name="icon-name">edit-copy-symbolic</property>
+                              <object class="GtkSwitch">
-																<property name="valign">center</property>
+                                <property name="valign">center</property>
-																<signal name="clicked" handler="handle_copy_hostname" swapped="true"/>
+                                <property name="tooltip-text" translatable="yes">enable</property>
-															</object>
+                              </object>
-														</child>
+                            </child>
-													</object>
+                          </object>
-												</child>
+                        </child>
-											</object>
+                        -->
-										</child>
+                        <child>
-										<child>
+                          <object class="AdwActionRow">
-											<object class="AdwPreferencesGroup">
+                            <property name="title">port</property>
-												<property name="title" translatable="yes">Connections</property>
+                            <child>
-												<property name="header-suffix">
+                              <object class="GtkEntry" id="port_entry">
-													<object class="GtkButton">
+                                <property name="max-width-chars">5</property>
-														<signal name="clicked" handler="handle_add_client_pressed" swapped="true"/>
+                                <signal name="activate" handler="handle_port_edit_apply" swapped="true"/>
-														<property name="child">
+                                <signal name="changed" handler="handle_port_changed" swapped="true"/>
-															<object class="AdwButtonContent">
+                                <!-- <signal name="delete-text" handler="handle_port_changed" swapped="true"/> -->
-																<property name="icon-name">list-add-symbolic</property>
+                                <!-- <property name="title" translatable="yes">port</property> -->
-																<property name="label" translatable="yes">Add</property>
+                                <property name="placeholder-text">4242</property>
-															</object>
+                                <property name="width-chars">5</property>
-														</property>
+                                <property name="xalign">0.5</property>
-													<style>
+                                <property name="valign">center</property>
-														<class name="flat"/>
+                                <!-- <property name="show-apply-button">True</property> -->
-													</style>
+                                <property name="input-purpose">GTK_INPUT_PURPOSE_DIGITS</property>
-													</object>
+                              </object>
-												</property>
+                            </child>
-												<child>
+                            <child>
-												  <object class="GtkListBox" id="client_list">
+                              <object class="GtkButton" id="port_edit_apply">
-														<property name="selection-mode">none</property>
+                                <signal name="clicked" handler="handle_port_edit_apply" swapped="true"/>
-														<child type="placeholder">
+                                <property name="icon-name">object-select-symbolic</property>
-															<object class="AdwActionRow" id="client_placeholder">
+                                <property name="valign">center</property>
-																<property name="title">No connections!</property>
+                                <property name="visible">false</property>
-																<property name="subtitle">add a new client via the + button</property>
+                                <property name="name">port-edit-apply</property>
-															</object>
+                                <style><class name="success"/></style>
-														</child>
+                              </object>
-														<style>
+                            </child>
-															<class name="boxed-list" />
+                            <child>
-														</style>
+                              <object class="GtkButton" id="port_edit_cancel">
-												  </object>
+                                <signal name="clicked" handler="handle_port_edit_cancel" swapped="true"/>
-												</child>
+                                <property name="icon-name">process-stop-symbolic</property>
-											</object>
+                                <property name="valign">center</property>
-										</child>
+                                <property name="visible">false</property>
-									  </object>
+                                <property name="name">port-edit-cancel</property>
-									</property>
+                                <style><class name="error"/></style>
-								  </object>
+                              </object>
-							  </property>
+                            </child>
-							</object>
+                          </object>
-						</child>
+                        </child>
-					</object>
+                        <child>
-				</child>
+                          <object class="AdwActionRow">
-			</object>
+                            <property name="title">hostname</property>
-		</property>
+                            <child>
-	</template>
+                              <object class="GtkLabel" id="hostname_label">
+                                <property name="label">&lt;span font_style=&quot;italic&quot; font_weight=&quot;light&quot; foreground=&quot;darkgrey&quot;&gt;could not determine hostname&lt;/span&gt;</property>
+                                <property name="use-markup">true</property>
+                                <property name="valign">center</property>
+                              </object>
+                            </child>
+                            <child>
+                              <object class="GtkButton" id="copy-hostname-button">
+                                <property name="icon-name">edit-copy-symbolic</property>
+                                <property name="valign">center</property>
+                                <signal name="clicked" handler="handle_copy_hostname" swapped="true"/>
+                              </object>
+                            </child>
+                          </object>
+                        </child>
+                      </object>
+                    </child>
+                    <child>
+                      <object class="AdwPreferencesGroup">
+                        <property name="title" translatable="yes">Connections</property>
+                        <property name="header-suffix">
+                          <object class="GtkButton">
+                            <signal name="clicked" handler="handle_add_client_pressed" swapped="true"/>
+                            <property name="child">
+                              <object class="AdwButtonContent">
+                                <property name="icon-name">list-add-symbolic</property>
+                                <property name="label" translatable="yes">Add</property>
+                              </object>
+                            </property>
+                          <style>
+                            <class name="flat"/>
+                          </style>
+                          </object>
+                        </property>
+                        <child>
+                          <object class="GtkListBox" id="client_list">
+                            <property name="selection-mode">none</property>
+                            <child type="placeholder">
+                              <object class="AdwActionRow" id="client_placeholder">
+                                <property name="title">No connections!</property>
+                                <property name="subtitle">add a new client via the + button</property>
+                              </object>
+                            </child>
+                            <style>
+                              <class name="boxed-list" />
+                            </style>
+                          </object>
+                        </child>
+                      </object>
+                    </child>
+                    </object>
+                  </property>
+                  </object>
+                </property>
+              </object>
+            </child>
+          </object>
+        </child>
+      </object>
+    </property>
+  </template>
 </interface>

src/capture_test.rs

@@ -1,11 +1,10 @@
 use crate::config::Config;
-use anyhow::{anyhow, Result};
 use futures::StreamExt;
-use input_capture::{self, Position};
+use input_capture::{self, CaptureError, CaptureEvent, InputCapture, InputCaptureError, Position};
 use input_event::{Event, KeyboardEvent};
 use tokio::task::LocalSet;
 
-pub fn run() -> Result<()> {
+pub fn run() -> anyhow::Result<()> {
     log::info!("running input capture test");
     let runtime = tokio::runtime::Builder::new_current_thread()
         .enable_io()
@@ -14,23 +13,32 @@ pub fn run() -> Result<()> {
 
     let config = Config::new()?;
 
-    runtime.block_on(LocalSet::new().run_until(input_capture_test(config)))
+    Ok(runtime.block_on(LocalSet::new().run_until(input_capture_test(config)))?)
 }
 
-async fn input_capture_test(config: Config) -> Result<()> {
+async fn input_capture_test(config: Config) -> Result<(), InputCaptureError> {
     log::info!("creating input capture");
     let backend = config.capture_backend.map(|b| b.into());
-    let mut input_capture = input_capture::create(backend).await?;
+    loop {
-    log::info!("creating clients");
+        let mut input_capture = InputCapture::new(backend).await?;
-    input_capture.create(0, Position::Left)?;
+        log::info!("creating clients");
-    input_capture.create(1, Position::Right)?;
+        input_capture.create(0, Position::Left).await?;
-    input_capture.create(2, Position::Top)?;
+        input_capture.create(1, Position::Right).await?;
-    input_capture.create(3, Position::Bottom)?;
+        input_capture.create(2, Position::Top).await?;
+        input_capture.create(3, Position::Bottom).await?;
+        if let Err(e) = do_capture(&mut input_capture).await {
+            log::warn!("{e} - recreating capture");
+        }
+        let _ = input_capture.terminate().await;
+    }
+}
+
+async fn do_capture(input_capture: &mut InputCapture) -> Result<(), CaptureError> {
     loop {
         let (client, event) = input_capture
             .next()
             .await
-            .ok_or(anyhow!("capture stream closed"))??;
+            .ok_or(CaptureError::EndOfStream)??;
         let pos = match client {
             0 => Position::Left,
             1 => Position::Right,
@@ -38,8 +46,9 @@ async fn input_capture_test(config: Config) -> Result<()> {
             _ => Position::Bottom,
         };
         log::info!("position: {pos}, event: {event}");
-        if let Event::Keyboard(KeyboardEvent::Key { key: 1, .. }) = event {
+        if let CaptureEvent::Input(Event::Keyboard(KeyboardEvent::Key { key: 1, .. })) = event {
-            input_capture.release()?;
+            input_capture.release().await?;
+            break Ok(());
         }
     }
 }

src/client.rs

@@ -1,6 +1,5 @@
 use std::{
     collections::HashSet,
-    error::Error,
     fmt::Display,
     net::{IpAddr, SocketAddr},
     str::FromStr,
@@ -8,24 +7,20 @@ use std::{
 
 use serde::{Deserialize, Serialize};
 use slab::Slab;
+use thiserror::Error;
 
 use crate::config::DEFAULT_PORT;
 use input_capture;
 
-#[derive(Debug, Eq, Hash, PartialEq, Clone, Copy, Serialize, Deserialize)]
+#[derive(Debug, Default, Eq, Hash, PartialEq, Clone, Copy, Serialize, Deserialize)]
 pub enum Position {
+    #[default]
     Left,
     Right,
     Top,
     Bottom,
 }
 
-impl Default for Position {
-    fn default() -> Self {
-        Self::Left
-    }
-}
-
 impl From<Position> for input_capture::Position {
     fn from(position: Position) -> input_capture::Position {
         match position {
@@ -37,19 +32,12 @@ impl From<Position> for input_capture::Position {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Error)]
+#[error("not a valid position: {pos}")]
 pub struct PositionParseError {
-    string: String,
+    pos: String,
 }
 
-impl Display for PositionParseError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "not a valid position: {}", self.string)
-    }
-}
-
-impl Error for PositionParseError {}
-
 impl FromStr for Position {
     type Err = PositionParseError;
 
@@ -59,7 +47,7 @@ impl FromStr for Position {
             "right" => Ok(Self::Right),
             "top" => Ok(Self::Top),
             "bottom" => Ok(Self::Bottom),
-            _ => Err(PositionParseError { string: s.into() }),
+            _ => Err(PositionParseError { pos: s.into() }),
         }
     }
 }
@@ -131,37 +119,27 @@ pub struct ClientState {
     pub active_addr: Option<SocketAddr>,
     /// tracks whether or not the client is responding to pings
     pub alive: bool,
+    /// ips from dns
+    pub dns_ips: Vec<IpAddr>,
     /// all ip addresses associated with a particular client
     /// e.g. Laptops usually have at least an ethernet and a wifi port
     /// which have different ip addresses
     pub ips: HashSet<IpAddr>,
-    /// keys currently pressed by this client
+    /// client has pressed keys
-    pub pressed_keys: HashSet<u32>,
+    pub has_pressed_keys: bool,
     /// dns resolving in progress
     pub resolving: bool,
 }
 
+#[derive(Default)]
 pub struct ClientManager {
     clients: Slab<(ClientConfig, ClientState)>,
 }
 
-impl Default for ClientManager {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl ClientManager {
-    pub fn new() -> Self {
-        let clients = Slab::new();
-        Self { clients }
-    }
-
     /// add a new client to this manager
     pub fn add_client(&mut self) -> ClientHandle {
-        let client_config = Default::default();
+        self.clients.insert(Default::default()) as ClientHandle
-        let client_state = Default::default();
-        self.clients.insert((client_config, client_state)) as ClientHandle
     }
 
     /// find a client by its address

src/config.rs

@@ -50,7 +50,7 @@ impl ConfigToml {
 }
 
 #[derive(Parser, Debug)]
-#[command(author, version, about, long_about = None)]
+#[command(author, version=env!("GIT_DESCRIBE"), about, long_about = None)]
 struct CliArgs {
     /// the listen port for lan-mouse
     #[arg(short, long)]

src/dns.rs

@@ -1,23 +1,62 @@
-use anyhow::Result;
+use local_channel::mpsc::Receiver;
-use std::{error::Error, net::IpAddr};
+use std::net::IpAddr;
 
-use hickory_resolver::TokioAsyncResolver;
+use hickory_resolver::{error::ResolveError, TokioAsyncResolver};
 
-pub struct DnsResolver {
+use crate::{client::ClientHandle, server::Server};
+
+pub(crate) struct DnsResolver {
     resolver: TokioAsyncResolver,
+    dns_request: Receiver<ClientHandle>,
 }
+
 impl DnsResolver {
-    pub(crate) async fn new() -> Result<Self> {
+    pub(crate) fn new(dns_request: Receiver<ClientHandle>) -> Result<Self, ResolveError> {
         let resolver = TokioAsyncResolver::tokio_from_system_conf()?;
-        Ok(Self { resolver })
+        Ok(Self {
+            resolver,
+            dns_request,
+        })
     }
 
-    pub(crate) async fn resolve(&self, host: &str) -> Result<Vec<IpAddr>, Box<dyn Error>> {
+    async fn resolve(&self, host: &str) -> Result<Vec<IpAddr>, ResolveError> {
-        log::info!("resolving {host} ...");
         let response = self.resolver.lookup_ip(host).await?;
         for ip in response.iter() {
             log::info!("{host}: adding ip {ip}");
         }
         Ok(response.iter().collect())
     }
+
+    pub(crate) async fn run(mut self, server: Server) {
+        tokio::select! {
+            _ = server.cancelled() => {},
+            _ = self.do_dns(&server) => {},
+        }
+    }
+
+    async fn do_dns(&mut self, server: &Server) {
+        loop {
+            let handle = self.dns_request.recv().await.expect("channel closed");
+
+            /* update resolving status */
+            let hostname = match server.get_hostname(handle) {
+                Some(hostname) => hostname,
+                None => continue,
+            };
+
+            log::info!("resolving ({handle}) `{hostname}` ...");
+            server.set_resolving(handle, true);
+
+            let ips = match self.resolve(&hostname).await {
+                Ok(ips) => ips,
+                Err(e) => {
+                    log::warn!("could not resolve host '{hostname}': {e}");
+                    vec![]
+                }
+            };
+
+            server.update_dns_ips(handle, ips);
+            server.set_resolving(handle, false);
+        }
+    }
 }

src/emulation_test.rs

@@ -1,5 +1,6 @@
 use crate::config::Config;
 use anyhow::Result;
+use input_emulation::InputEmulation;
 use input_event::{Event, PointerEvent};
 use std::f64::consts::PI;
 use std::time::{Duration, Instant};
@@ -22,7 +23,7 @@ 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?;
+    let mut emulation = InputEmulation::new(backend).await?;
     emulation.create(0).await;
     let start = Instant::now();
     let mut offset = (0, 0);

src/frontend.rs

@@ -97,8 +97,6 @@ pub enum FrontendRequest {
     Enumerate(),
     /// resolve dns
     ResolveDns(ClientHandle),
-    /// service shutdown
-    Terminate(),
     /// update hostname
     UpdateHostname(ClientHandle, Option<String>),
     /// update port
@@ -109,6 +107,26 @@ pub enum FrontendRequest {
     UpdateFixIps(ClientHandle, Vec<IpAddr>),
     /// request the state of the given client
     GetState(ClientHandle),
+    /// request reenabling input capture
+    EnableCapture,
+    /// request reenabling input emulation
+    EnableEmulation,
+}
+
+#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize)]
+pub enum Status {
+    #[default]
+    Disabled,
+    Enabled,
+}
+
+impl From<Status> for bool {
+    fn from(status: Status) -> Self {
+        match status {
+            Status::Enabled => true,
+            Status::Disabled => false,
+        }
+    }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -127,6 +145,10 @@ pub enum FrontendEvent {
     Enumerate(Vec<(ClientHandle, ClientConfig, ClientState)>),
     /// an error occured
     Error(String),
+    /// capture status
+    CaptureStatus(Status),
+    /// emulation status
+    EmulationStatus(Status),
 }
 
 pub struct FrontendListener {
@@ -232,7 +254,7 @@ impl FrontendListener {
         Ok(rx)
     }
 
-    pub(crate) async fn broadcast_event(&mut self, notify: FrontendEvent) -> Result<()> {
+    pub(crate) async fn broadcast(&mut self, notify: FrontendEvent) {
         // encode event
         let json = serde_json::to_string(&notify).unwrap();
         let payload = json.as_bytes();
@@ -256,7 +278,6 @@ impl FrontendListener {
         // could not find a better solution because async
         let mut keep = keep.into_iter();
         self.tx_streams.retain(|_| keep.next().unwrap());
-        Ok(())
     }
 }
 

src/frontend/cli.rs

@@ -273,6 +273,12 @@ impl<'a> Cli<'a> {
             FrontendEvent::Error(e) => {
                 eprintln!("ERROR: {e}");
             }
+            FrontendEvent::CaptureStatus(s) => {
+                eprintln!("capture status: {s:?}")
+            }
+            FrontendEvent::EmulationStatus(s) => {
+                eprintln!("emulation status: {s:?}")
+            }
         }
     }
 

src/frontend/gtk.rs

@@ -8,7 +8,7 @@ use std::{
     process, str,
 };
 
-use crate::frontend::{gtk::window::Window, FrontendRequest};
+use crate::frontend::gtk::window::Window;
 
 use adw::Application;
 use endi::{Endian, ReadBytes};
@@ -113,46 +113,55 @@ fn build_ui(app: &Application) {
     });
 
     let window = Window::new(app, tx);
-    window.request(FrontendRequest::Enumerate());
 
-    glib::spawn_future_local(clone!(@weak window => async move {
+    glib::spawn_future_local(clone!(
-        loop {
+        #[weak]
-            let notify = receiver.recv().await.unwrap_or_else(|_| process::exit(1));
+        window,
-            match notify {
+        async move {
-                FrontendEvent::Created(handle, client, state) => {
+            loop {
-                    window.new_client(handle, client, state);
+                let notify = receiver.recv().await.unwrap_or_else(|_| process::exit(1));
-                },
+                match notify {
-                FrontendEvent::Deleted(client) => {
+                    FrontendEvent::Created(handle, client, state) => {
-                    window.delete_client(client);
+                        window.new_client(handle, client, state);
-                }
+                    }
-                FrontendEvent::State(handle, config, state) => {
+                    FrontendEvent::Deleted(client) => {
-                    window.update_client_config(handle, config);
+                        window.delete_client(client);
-                    window.update_client_state(handle, state);
+                    }
-                }
+                    FrontendEvent::State(handle, config, state) => {
-                FrontendEvent::NoSuchClient(_) => { }
+                        window.update_client_config(handle, config);
-                FrontendEvent::Error(e) => {
+                        window.update_client_state(handle, state);
-                    window.show_toast(e.as_str());
+                    }
-                },
+                    FrontendEvent::NoSuchClient(_) => {}
-                FrontendEvent::Enumerate(clients) => {
+                    FrontendEvent::Error(e) => {
-                    for (handle, client, state) in clients {
+                        window.show_toast(e.as_str());
-                        if window.client_idx(handle).is_some() {
+                    }
-                            window.update_client_config(handle, client);
+                    FrontendEvent::Enumerate(clients) => {
-                            window.update_client_state(handle, state);
+                        for (handle, client, state) in clients {
-                        } else {
+                            if window.client_idx(handle).is_some() {
-                            window.new_client(handle, client, state);
+                                window.update_client_config(handle, client);
+                                window.update_client_state(handle, state);
+                            } else {
+                                window.new_client(handle, client, state);
+                            }
                         }
                     }
-                },
+                    FrontendEvent::PortChanged(port, msg) => {
-                FrontendEvent::PortChanged(port, msg) => {
+                        match msg {
-                    match msg {
+                            None => window.show_toast(format!("port changed: {port}").as_str()),
-                        None => window.show_toast(format!("port changed: {port}").as_str()),
+                            Some(msg) => window.show_toast(msg.as_str()),
-                        Some(msg) => window.show_toast(msg.as_str()),
+                        }
+                        window.imp().set_port(port);
+                    }
+                    FrontendEvent::CaptureStatus(s) => {
+                        window.set_capture(s.into());
+                    }
+                    FrontendEvent::EmulationStatus(s) => {
+                        window.set_emulation(s.into());
                     }
-                    window.imp().set_port(port);
                 }
             }
         }
-    }));
+    ));
 
     window.present();
 }

src/frontend/gtk/client_row/imp.rs

@@ -52,10 +52,13 @@ impl ObjectSubclass for ClientRow {
 impl ObjectImpl for ClientRow {
     fn constructed(&self) {
         self.parent_constructed();
-        self.delete_button
+        self.delete_button.connect_clicked(clone!(
-            .connect_clicked(clone!(@weak self as row => move |button| {
+            #[weak(rename_to = row)]
+            self,
+            move |button| {
                 row.handle_client_delete(button);
-            }));
+            }
+        ));
     }
 
     fn signals() -> &'static [glib::subclass::Signal] {

src/frontend/gtk/window.rs

@@ -63,31 +63,61 @@ impl Window {
         let selection_model = NoSelection::new(Some(self.clients()));
         self.imp().client_list.bind_model(
             Some(&selection_model),
-            clone!(@weak self as window => @default-panic, move |obj| {
+            clone!(
-                let client_object = obj.downcast_ref().expect("Expected object of type `ClientObject`.");
+                #[weak(rename_to = window)]
-                let row = window.create_client_row(client_object);
+                self,
-                row.connect_closure("request-update", false, closure_local!(@strong window => move |row: ClientRow, active: bool| {
+                #[upgrade_or_panic]
-                    if let Some(client) = window.client_by_idx(row.index() as u32) {
+                move |obj| {
-                        window.request_client_activate(&client, active);
+                    let client_object = obj
-                        window.request_client_update(&client);
+                        .downcast_ref()
-                        window.request_client_state(&client);
+                        .expect("Expected object of type `ClientObject`.");
-                    }
+                    let row = window.create_client_row(client_object);
-                }));
+                    row.connect_closure(
-                row.connect_closure("request-delete", false, closure_local!(@strong window => move |row: ClientRow| {
+                        "request-update",
-                    if let Some(client) = window.client_by_idx(row.index() as u32) {
+                        false,
-                        window.request_client_delete(&client);
+                        closure_local!(
-                    }
+                            #[strong]
-                }));
+                            window,
-                row.connect_closure("request-dns", false, closure_local!(@strong window => move
+                            move |row: ClientRow, active: bool| {
-                |row: ClientRow| {
+                                if let Some(client) = window.client_by_idx(row.index() as u32) {
-                    if let Some(client) = window.client_by_idx(row.index() as u32) {
+                                    window.request_client_activate(&client, active);
-                        window.request_client_update(&client);
+                                    window.request_client_update(&client);
-                        window.request_dns(&client);
+                                    window.request_client_state(&client);
-                        window.request_client_state(&client);
+                                }
-                    }
+                            }
-                }));
+                        ),
-                row.upcast()
+                    );
-            })
+                    row.connect_closure(
+                        "request-delete",
+                        false,
+                        closure_local!(
+                            #[strong]
+                            window,
+                            move |row: ClientRow| {
+                                if let Some(client) = window.client_by_idx(row.index() as u32) {
+                                    window.request_client_delete(&client);
+                                }
+                            }
+                        ),
+                    );
+                    row.connect_closure(
+                        "request-dns",
+                        false,
+                        closure_local!(
+                            #[strong]
+                            window,
+                            move |row: ClientRow| {
+                                if let Some(client) = window.client_by_idx(row.index() as u32) {
+                                    window.request_client_update(&client);
+                                    window.request_dns(&client);
+                                    window.request_client_state(&client);
+                                }
+                            }
+                        ),
+                    );
+                    row.upcast()
+                }
+            ),
         );
     }
 
@@ -207,29 +237,35 @@ impl Window {
     }
 
     pub fn request_port_change(&self) {
-        let port = self.imp().port_entry.get().text().to_string();
+        let port = self
-        if let Ok(port) = port.as_str().parse::<u16>() {
+            .imp()
-            self.request(FrontendRequest::ChangePort(port));
+            .port_entry
-        } else {
+            .get()
-            self.request(FrontendRequest::ChangePort(DEFAULT_PORT));
+            .text()
-        }
+            .as_str()
+            .parse::<u16>()
+            .unwrap_or(DEFAULT_PORT);
+        self.request(FrontendRequest::ChangePort(port));
+    }
+
+    pub fn request_capture(&self) {
+        self.request(FrontendRequest::EnableCapture);
+    }
+
+    pub fn request_emulation(&self) {
+        self.request(FrontendRequest::EnableEmulation);
     }
 
     pub fn request_client_state(&self, client: &ClientObject) {
-        let handle = client.handle();
+        self.request(FrontendRequest::GetState(client.handle()));
-        let event = FrontendRequest::GetState(handle);
-        self.request(event);
     }
 
     pub fn request_client_create(&self) {
-        let event = FrontendRequest::Create;
+        self.request(FrontendRequest::Create);
-        self.request(event);
     }
 
     pub fn request_dns(&self, client: &ClientObject) {
-        let data = client.get_data();
+        self.request(FrontendRequest::ResolveDns(client.get_data().handle));
-        let event = FrontendRequest::ResolveDns(data.handle);
-        self.request(event);
     }
 
     pub fn request_client_update(&self, client: &ClientObject) {
@@ -249,15 +285,11 @@ impl Window {
     }
 
     pub fn request_client_activate(&self, client: &ClientObject, active: bool) {
-        let handle = client.handle();
+        self.request(FrontendRequest::Activate(client.handle(), active));
-        let event = FrontendRequest::Activate(handle, active);
-        self.request(event);
     }
 
     pub fn request_client_delete(&self, client: &ClientObject) {
-        let handle = client.handle();
+        self.request(FrontendRequest::Delete(client.handle()));
-        let event = FrontendRequest::Delete(handle);
-        self.request(event);
     }
 
     pub fn request(&self, event: FrontendRequest) {
@@ -279,4 +311,24 @@ impl Window {
         let toast_overlay = &self.imp().toast_overlay;
         toast_overlay.add_toast(toast);
     }
+
+    pub fn set_capture(&self, active: bool) {
+        self.imp().capture_active.replace(active);
+        self.update_capture_emulation_status();
+    }
+
+    pub fn set_emulation(&self, active: bool) {
+        self.imp().emulation_active.replace(active);
+        self.update_capture_emulation_status();
+    }
+
+    fn update_capture_emulation_status(&self) {
+        let capture = self.imp().capture_active.get();
+        let emulation = self.imp().emulation_active.get();
+        self.imp().capture_status_row.set_visible(!capture);
+        self.imp().emulation_status_row.set_visible(!emulation);
+        self.imp()
+            .capture_emulation_group
+            .set_visible(!capture || !emulation);
+    }
 }

src/frontend/gtk/window/imp.rs

@@ -6,7 +6,7 @@ use std::net::TcpStream;
 use std::os::unix::net::UnixStream;
 
 use adw::subclass::prelude::*;
-use adw::{prelude::*, ActionRow, ToastOverlay};
+use adw::{prelude::*, ActionRow, PreferencesGroup, ToastOverlay};
 use glib::subclass::InitializingObject;
 use gtk::glib::clone;
 use gtk::{gdk, gio, glib, Button, CompositeTemplate, Entry, Label, ListBox};
@@ -30,12 +30,24 @@ pub struct Window {
     pub hostname_label: TemplateChild<Label>,
     #[template_child]
     pub toast_overlay: TemplateChild<ToastOverlay>,
+    #[template_child]
+    pub capture_emulation_group: TemplateChild<PreferencesGroup>,
+    #[template_child]
+    pub capture_status_row: TemplateChild<ActionRow>,
+    #[template_child]
+    pub emulation_status_row: TemplateChild<ActionRow>,
+    #[template_child]
+    pub input_emulation_button: TemplateChild<Button>,
+    #[template_child]
+    pub input_capture_button: TemplateChild<Button>,
     pub clients: RefCell<Option<gio::ListStore>>,
     #[cfg(unix)]
     pub stream: RefCell<Option<UnixStream>>,
     #[cfg(windows)]
     pub stream: RefCell<Option<TcpStream>>,
     pub port: Cell<u16>,
+    pub capture_active: Cell<bool>,
+    pub emulation_active: Cell<bool>,
 }
 
 #[glib::object_subclass]
@@ -72,11 +84,15 @@ impl Window {
             clipboard.set_text(hostname.to_str().expect("hostname: invalid utf8"));
             button.set_icon_name("emblem-ok-symbolic");
             button.set_css_classes(&["success"]);
-            glib::spawn_future_local(clone!(@weak button => async move {
+            glib::spawn_future_local(clone!(
-                glib::timeout_future_seconds(1).await;
+                #[weak]
-                button.set_icon_name("edit-copy-symbolic");
+                button,
-                button.set_css_classes(&[]);
+                async move {
-            }));
+                    glib::timeout_future_seconds(1).await;
+                    button.set_icon_name("edit-copy-symbolic");
+                    button.set_css_classes(&[]);
+                }
+            ));
         }
     }
 
@@ -100,6 +116,16 @@ impl Window {
         self.port_edit_cancel.set_visible(false);
     }
 
+    #[template_callback]
+    fn handle_emulation(&self) {
+        self.obj().request_emulation();
+    }
+
+    #[template_callback]
+    fn handle_capture(&self) {
+        self.obj().request_capture();
+    }
+
     pub fn set_port(&self, port: u16) {
         self.port.set(port);
         if port == DEFAULT_PORT {

src/main.rs

@@ -37,7 +37,7 @@ pub fn run() -> Result<()> {
         emulation_test::run()?;
     } else if config.daemon {
         // if daemon is specified we run the service
-        run_service(&config)?;
+        run_service(config)?;
     } else {
         //  otherwise start the service as a child process and
         //  run a frontend
@@ -58,7 +58,7 @@ pub fn run() -> Result<()> {
     anyhow::Ok(())
 }
 
-fn run_service(config: &Config) -> Result<()> {
+fn run_service(config: Config) -> Result<()> {
     // create single threaded tokio runtime
     let runtime = tokio::runtime::Builder::new_current_thread()
         .enable_io()
@@ -70,10 +70,8 @@ fn run_service(config: &Config) -> Result<()> {
         // run main loop
         log::info!("Press {:?} to release the mouse", config.release_bind);
 
-        let server = Server::new(config);
+        let mut server = Server::new(config);
-        server
+        server.run().await?;
-            .run(config.capture_backend, config.emulation_backend)
-            .await?;
 
         log::debug!("service exiting");
         anyhow::Ok(())

src/server.rs

@@ -1,27 +1,34 @@
+use capture_task::CaptureRequest;
+use emulation_task::EmulationRequest;
+use local_channel::mpsc::{channel, Sender};
 use log;
 use std::{
     cell::{Cell, RefCell},
-    collections::HashSet,
+    collections::{HashSet, VecDeque},
+    io::ErrorKind,
+    net::{IpAddr, SocketAddr},
     rc::Rc,
 };
-use tokio::signal;
+use tokio::{io::ReadHalf, join, signal, sync::Notify, task::JoinHandle};
+use tokio_util::sync::CancellationToken;
 
 use crate::{
-    client::{ClientConfig, ClientHandle, ClientManager, ClientState},
+    client::{ClientConfig, ClientHandle, ClientManager, ClientState, Position},
-    config::{CaptureBackend, Config, EmulationBackend},
+    config::Config,
-    dns,
+    dns::DnsResolver,
-    frontend::{FrontendListener, FrontendRequest},
+    frontend::{self, FrontendEvent, FrontendListener, FrontendRequest, Status},
-    server::capture_task::CaptureEvent,
 };
 
-use self::{emulation_task::EmulationEvent, resolver_task::DnsRequest};
+#[cfg(unix)]
+use tokio::net::UnixStream;
+
+#[cfg(windows)]
+use tokio::net::TcpStream;
 
 mod capture_task;
 mod emulation_task;
-mod frontend_task;
 mod network_task;
 mod ping_task;
-mod resolver_task;
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 enum State {
@@ -31,22 +38,39 @@ enum State {
     Receiving,
     /// Entered the deadzone of another device but waiting
     /// for acknowledgement (Leave event) from the device
-    AwaitingLeave,
+    AwaitAck,
 }
 
 #[derive(Clone)]
 pub struct Server {
     active_client: Rc<Cell<Option<ClientHandle>>>,
-    client_manager: Rc<RefCell<ClientManager>>,
+    pub(crate) client_manager: Rc<RefCell<ClientManager>>,
     port: Rc<Cell<u16>>,
     state: Rc<Cell<State>>,
     release_bind: Vec<input_event::scancode::Linux>,
+    notifies: Rc<Notifies>,
+    config: Rc<Config>,
+    pending_frontend_events: Rc<RefCell<VecDeque<FrontendEvent>>>,
+    pending_dns_requests: Rc<RefCell<VecDeque<ClientHandle>>>,
+    capture_status: Rc<Cell<Status>>,
+    emulation_status: Rc<Cell<Status>>,
+}
+
+#[derive(Default)]
+struct Notifies {
+    capture: Notify,
+    emulation: Notify,
+    ping: Notify,
+    port_changed: Notify,
+    frontend_event_pending: Notify,
+    dns_request_pending: Notify,
+    cancel: CancellationToken,
 }
 
 impl Server {
-    pub fn new(config: &Config) -> Self {
+    pub fn new(config: Config) -> Self {
         let active_client = Rc::new(Cell::new(None));
-        let client_manager = Rc::new(RefCell::new(ClientManager::new()));
+        let client_manager = Rc::new(RefCell::new(ClientManager::default()));
         let state = Rc::new(Cell::new(State::Receiving));
         let port = Rc::new(Cell::new(config.port));
         for config_client in config.get_clients() {
@@ -67,153 +91,517 @@ impl Server {
             let c = client_manager.get_mut(handle).expect("invalid handle");
             *c = (client, state);
         }
+
+        // task notification tokens
+        let notifies = Rc::new(Notifies::default());
         let release_bind = config.release_bind.clone();
+
+        let config = Rc::new(config);
+
         Self {
+            config,
             active_client,
             client_manager,
             port,
             state,
             release_bind,
+            notifies,
+            pending_frontend_events: Rc::new(RefCell::new(VecDeque::new())),
+            pending_dns_requests: Rc::new(RefCell::new(VecDeque::new())),
+            capture_status: Default::default(),
+            emulation_status: Default::default(),
         }
     }
 
-    pub async fn run(
+    pub async fn run(&mut self) -> anyhow::Result<()> {
-        &self,
+        // create frontend communication adapter, exit if already running
-        capture_backend: Option<CaptureBackend>,
+        let mut frontend = match FrontendListener::new().await {
-        emulation_backend: Option<EmulationBackend>,
-    ) -> anyhow::Result<()> {
-        // create frontend communication adapter
-        let frontend = match FrontendListener::new().await {
             Some(f) => f?,
             None => {
-                // none means some other instance is already running
                 log::info!("service already running, exiting");
-                return anyhow::Ok(());
+                return Ok(());
             }
         };
 
-        let (timer_tx, timer_rx) = tokio::sync::mpsc::channel(1);
+        let (capture_tx, capture_rx) = channel(); /* requests for input capture */
-        let (frontend_notify_tx, frontend_notify_rx) = tokio::sync::mpsc::channel(1);
+        let (emulation_tx, emulation_rx) = channel(); /* emulation requests */
+        let (udp_recv_tx, udp_recv_rx) = channel(); /* udp receiver */
+        let (udp_send_tx, udp_send_rx) = channel(); /* udp sender */
+        let (request_tx, mut request_rx) = channel(); /* frontend requests */
+        let (dns_tx, dns_rx) = channel(); /* dns requests */
 
         // udp task
-        let (mut udp_task, sender_tx, receiver_rx, port_tx) =
+        let network = network_task::new(self.clone(), udp_recv_tx.clone(), udp_send_rx).await?;
-            network_task::new(self.clone(), frontend_notify_tx.clone()).await?;
 
         // input capture
-        let (mut capture_task, capture_channel) = capture_task::new(
+        let capture = capture_task::new(self.clone(), capture_rx, udp_send_tx.clone());
-            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(
+        let emulation =
-            emulation_backend,
+            emulation_task::new(self.clone(), emulation_rx, udp_recv_rx, udp_send_tx.clone());
-            self.clone(),
-            receiver_rx,
-            sender_tx.clone(),
-            capture_channel.clone(),
-            timer_tx,
-        );
 
         // create dns resolver
-        let resolver = dns::DnsResolver::new().await?;
+        let resolver = DnsResolver::new(dns_rx)?;
-        let (mut resolver_task, resolve_tx) =
+        let dns_task = tokio::task::spawn_local(resolver.run(self.clone()));
-            resolver_task::new(resolver, self.clone(), frontend_notify_tx);
-
-        // frontend listener
-        let (mut frontend_task, frontend_tx) = frontend_task::new(
-            frontend,
-            frontend_notify_rx,
-            self.clone(),
-            capture_channel.clone(),
-            emulate_channel.clone(),
-            resolve_tx.clone(),
-            port_tx,
-        );
 
         // task that pings clients to see if they are responding
-        let mut ping_task = ping_task::new(
+        let ping = ping_task::new(
             self.clone(),
-            sender_tx.clone(),
+            udp_send_tx.clone(),
-            emulate_channel.clone(),
+            emulation_tx.clone(),
-            capture_channel.clone(),
+            capture_tx.clone(),
-            timer_rx,
         );
 
-        let active = self
+        for handle in self.active_clients() {
-            .client_manager
+            self.request_dns(handle);
-            .borrow()
-            .get_client_states()
-            .filter_map(|(h, (c, s))| {
-                if s.active {
-                    Some((h, c.hostname.clone()))
-                } else {
-                    None
-                }
-            })
-            .collect::<Vec<_>>();
-        for (handle, hostname) in active {
-            frontend_tx
-                .send(FrontendRequest::Activate(handle, true))
-                .await?;
-            if let Some(hostname) = hostname {
-                let _ = resolve_tx.send(DnsRequest { hostname, handle }).await;
-            }
         }
+
         log::info!("running service");
 
-        tokio::select! {
+        let mut join_handles = vec![];
-            _ = signal::ctrl_c() => {
+
-                log::info!("terminating service");
+        loop {
-            }
+            tokio::select! {
-            e = &mut capture_task => {
+                stream = frontend.accept() => {
-                if let Ok(Err(e)) = e {
+                    match stream {
-                    log::error!("error in input capture task: {e}");
+                        Ok(s) => join_handles.push(handle_frontend_stream(self.notifies.cancel.clone(), s, request_tx.clone())),
+                        Err(e) => log::warn!("error accepting frontend connection: {e}"),
+                    };
+                    self.enumerate();
+                    self.notify_frontend(FrontendEvent::EmulationStatus(self.emulation_status.get()));
+                    self.notify_frontend(FrontendEvent::CaptureStatus(self.capture_status.get()));
+                    self.notify_frontend(FrontendEvent::PortChanged(self.port.get(), None));
+                }
+                request = request_rx.recv() => {
+                    let request = request.expect("channel closed");
+                    log::debug!("received frontend request: {request:?}");
+                    self.handle_request(&capture_tx.clone(), &emulation_tx.clone(), request).await;
+                    log::debug!("handled frontend request");
+                }
+                _ = self.notifies.frontend_event_pending.notified() => {
+                    while let Some(event) = {
+                        /* need to drop borrow before next iteration! */
+                        let event = self.pending_frontend_events.borrow_mut().pop_front();
+                        event
+                    } {
+                        frontend.broadcast(event).await;
+                    }
+                },
+                _ = self.notifies.dns_request_pending.notified() => {
+                    while let Some(request) = {
+                        /* need to drop borrow before next iteration! */
+                        let request = self.pending_dns_requests.borrow_mut().pop_front();
+                        request
+                    } {
+                        dns_tx.send(request).expect("channel closed");
+                    }
+                }
+                _ = self.cancelled() => break,
+                r = signal::ctrl_c() => {
+                    r.expect("failed to wait for CTRL+C");
+                    break;
                 }
             }
-            e = &mut emulation_task => {
-                if let Ok(Err(e)) = e {
-                    log::error!("error in input emulation task: {e}");
-                }
-            }
-            e = &mut frontend_task => {
-                if let Ok(Err(e)) = e {
-                    log::error!("error in frontend listener: {e}");
-                }
-            }
-            _ = &mut resolver_task => { }
-            _ = &mut udp_task => { }
-            _ = &mut ping_task => { }
         }
 
-        let _ = emulate_channel.send(EmulationEvent::Terminate).await;
+        log::info!("terminating service");
-        let _ = capture_channel.send(CaptureEvent::Terminate).await;
-        let _ = frontend_tx.send(FrontendRequest::Terminate()).await;
 
-        if !capture_task.is_finished() {
+        self.cancel();
-            if let Err(e) = capture_task.await {
+        futures::future::join_all(join_handles).await;
-                log::error!("error in input capture task: {e}");
+        let _ = join!(capture, dns_task, emulation, network, ping);
-            }
-        }
-        if !emulation_task.is_finished() {
-            if let Err(e) = emulation_task.await {
-                log::error!("error in input emulation task: {e}");
-            }
-        }
-
-        if !frontend_task.is_finished() {
-            if let Err(e) = frontend_task.await {
-                log::error!("error in frontend listener: {e}");
-            }
-        }
-
-        resolver_task.abort();
-        udp_task.abort();
-        ping_task.abort();
 
         Ok(())
     }
+
+    fn notify_frontend(&self, event: FrontendEvent) {
+        self.pending_frontend_events.borrow_mut().push_back(event);
+        self.notifies.frontend_event_pending.notify_one();
+    }
+
+    fn cancel(&self) {
+        self.notifies.cancel.cancel();
+    }
+
+    pub(crate) async fn cancelled(&self) {
+        self.notifies.cancel.cancelled().await
+    }
+
+    fn is_cancelled(&self) -> bool {
+        self.notifies.cancel.is_cancelled()
+    }
+
+    fn notify_capture(&self) {
+        self.notifies.capture.notify_waiters()
+    }
+
+    async fn capture_enabled(&self) {
+        self.notifies.capture.notified().await
+    }
+
+    fn notify_emulation(&self) {
+        self.notifies.emulation.notify_waiters()
+    }
+
+    async fn emulation_notified(&self) {
+        self.notifies.emulation.notified().await
+    }
+
+    fn restart_ping_timer(&self) {
+        self.notifies.ping.notify_waiters()
+    }
+
+    async fn ping_timer_notified(&self) {
+        self.notifies.ping.notified().await
+    }
+
+    fn request_port_change(&self, port: u16) {
+        self.port.replace(port);
+        self.notifies.port_changed.notify_one();
+    }
+
+    fn notify_port_changed(&self, port: u16, msg: Option<String>) {
+        self.port.replace(port);
+        self.notify_frontend(FrontendEvent::PortChanged(port, msg));
+    }
+
+    pub(crate) fn client_updated(&self, handle: ClientHandle) {
+        let state = self.client_manager.borrow().get(handle).cloned();
+        if let Some((config, state)) = state {
+            self.notify_frontend(FrontendEvent::State(handle, config, state));
+        }
+    }
+
+    fn active_clients(&self) -> Vec<ClientHandle> {
+        self.client_manager
+            .borrow()
+            .get_client_states()
+            .filter(|(_, (_, s))| s.active)
+            .map(|(h, _)| h)
+            .collect()
+    }
+
+    fn request_dns(&self, handle: ClientHandle) {
+        self.pending_dns_requests.borrow_mut().push_back(handle);
+        self.notifies.dns_request_pending.notify_one();
+    }
+
+    async fn handle_request(
+        &self,
+        capture: &Sender<CaptureRequest>,
+        emulate: &Sender<EmulationRequest>,
+        event: FrontendRequest,
+    ) -> bool {
+        log::debug!("frontend: {event:?}");
+        match event {
+            FrontendRequest::EnableCapture => {
+                log::info!("received capture enable request");
+                self.notify_capture();
+            }
+            FrontendRequest::EnableEmulation => {
+                log::info!("received emulation enable request");
+                self.notify_emulation();
+            }
+            FrontendRequest::Create => {
+                let handle = self.add_client().await;
+                self.request_dns(handle);
+            }
+            FrontendRequest::Activate(handle, active) => {
+                if active {
+                    self.activate_client(capture, emulate, handle).await;
+                } else {
+                    self.deactivate_client(capture, emulate, handle).await;
+                }
+            }
+            FrontendRequest::ChangePort(port) => self.request_port_change(port),
+            FrontendRequest::Delete(handle) => {
+                self.remove_client(capture, emulate, handle).await;
+                self.notify_frontend(FrontendEvent::Deleted(handle));
+            }
+            FrontendRequest::Enumerate() => self.enumerate(),
+            FrontendRequest::GetState(handle) => self.broadcast_client(handle),
+            FrontendRequest::UpdateFixIps(handle, fix_ips) => {
+                self.update_fix_ips(handle, fix_ips);
+                self.request_dns(handle);
+            }
+            FrontendRequest::UpdateHostname(handle, host) => self.update_hostname(handle, host),
+            FrontendRequest::UpdatePort(handle, port) => self.update_port(handle, port),
+            FrontendRequest::UpdatePosition(handle, pos) => {
+                self.update_pos(handle, capture, emulate, pos).await;
+            }
+            FrontendRequest::ResolveDns(handle) => self.request_dns(handle),
+        };
+        false
+    }
+
+    fn enumerate(&self) {
+        let clients = self
+            .client_manager
+            .borrow()
+            .get_client_states()
+            .map(|(h, (c, s))| (h, c.clone(), s.clone()))
+            .collect();
+        self.notify_frontend(FrontendEvent::Enumerate(clients));
+    }
+
+    async fn add_client(&self) -> ClientHandle {
+        let handle = self.client_manager.borrow_mut().add_client();
+        log::info!("added client {handle}");
+        let (c, s) = self.client_manager.borrow().get(handle).unwrap().clone();
+        self.notify_frontend(FrontendEvent::Created(handle, c, s));
+        handle
+    }
+
+    async fn deactivate_client(
+        &self,
+        capture: &Sender<CaptureRequest>,
+        emulate: &Sender<EmulationRequest>,
+        handle: ClientHandle,
+    ) {
+        log::debug!("deactivating client {handle}");
+        match self.client_manager.borrow_mut().get_mut(handle) {
+            Some((_, s)) => s.active = false,
+            None => return,
+        };
+
+        let _ = capture.send(CaptureRequest::Destroy(handle));
+        let _ = emulate.send(EmulationRequest::Destroy(handle));
+        log::debug!("deactivating client {handle} done");
+    }
+
+    async fn activate_client(
+        &self,
+        capture: &Sender<CaptureRequest>,
+        emulate: &Sender<EmulationRequest>,
+        handle: ClientHandle,
+    ) {
+        log::debug!("activating client");
+        /* deactivate potential other client at this position */
+        let pos = match self.client_manager.borrow().get(handle) {
+            Some((client, _)) => client.pos,
+            None => return,
+        };
+
+        let other = self.client_manager.borrow_mut().find_client(pos);
+        if let Some(other) = other {
+            if other != handle {
+                self.deactivate_client(capture, emulate, other).await;
+            }
+        }
+
+        /* activate the client */
+        if let Some((_, s)) = self.client_manager.borrow_mut().get_mut(handle) {
+            s.active = true;
+        } else {
+            return;
+        };
+
+        /* notify emulation, capture and frontends */
+        let _ = capture.send(CaptureRequest::Create(handle, pos.into()));
+        let _ = emulate.send(EmulationRequest::Create(handle));
+        log::debug!("activating client {handle} done");
+    }
+
+    async fn remove_client(
+        &self,
+        capture: &Sender<CaptureRequest>,
+        emulate: &Sender<EmulationRequest>,
+        handle: ClientHandle,
+    ) {
+        let Some(active) = self
+            .client_manager
+            .borrow_mut()
+            .remove_client(handle)
+            .map(|(_, s)| s.active)
+        else {
+            return;
+        };
+
+        if active {
+            let _ = capture.send(CaptureRequest::Destroy(handle));
+            let _ = emulate.send(EmulationRequest::Destroy(handle));
+        }
+    }
+
+    fn update_pressed_keys(&self, handle: ClientHandle, has_pressed_keys: bool) {
+        if let Some((_, s)) = self.client_manager.borrow_mut().get_mut(handle) {
+            s.has_pressed_keys = has_pressed_keys;
+        }
+    }
+
+    fn update_fix_ips(&self, handle: ClientHandle, fix_ips: Vec<IpAddr>) {
+        if let Some((c, _)) = self.client_manager.borrow_mut().get_mut(handle) {
+            c.fix_ips = fix_ips;
+        };
+        self.update_ips(handle);
+    }
+
+    pub(crate) fn update_dns_ips(&self, handle: ClientHandle, dns_ips: Vec<IpAddr>) {
+        if let Some((_, s)) = self.client_manager.borrow_mut().get_mut(handle) {
+            s.dns_ips = dns_ips;
+        };
+        self.update_ips(handle);
+    }
+
+    fn update_ips(&self, handle: ClientHandle) {
+        if let Some((c, s)) = self.client_manager.borrow_mut().get_mut(handle) {
+            s.ips = c
+                .fix_ips
+                .iter()
+                .cloned()
+                .chain(s.dns_ips.iter().cloned())
+                .collect::<HashSet<_>>();
+        }
+    }
+
+    fn update_hostname(&self, handle: ClientHandle, hostname: Option<String>) {
+        let mut client_manager = self.client_manager.borrow_mut();
+        let Some((c, s)) = client_manager.get_mut(handle) else {
+            return;
+        };
+
+        // hostname changed
+        if c.hostname != hostname {
+            c.hostname = hostname;
+            s.ips = HashSet::from_iter(c.fix_ips.iter().cloned());
+            s.active_addr = None;
+            self.request_dns(handle);
+        }
+    }
+
+    fn update_port(&self, handle: ClientHandle, port: u16) {
+        let mut client_manager = self.client_manager.borrow_mut();
+        let Some((c, s)) = client_manager.get_mut(handle) else {
+            return;
+        };
+
+        if c.port != port {
+            c.port = port;
+            s.active_addr = s.active_addr.map(|a| SocketAddr::new(a.ip(), port));
+        }
+    }
+
+    async fn update_pos(
+        &self,
+        handle: ClientHandle,
+        capture: &Sender<CaptureRequest>,
+        emulate: &Sender<EmulationRequest>,
+        pos: Position,
+    ) {
+        let (changed, active) = {
+            let mut client_manager = self.client_manager.borrow_mut();
+            let Some((c, s)) = client_manager.get_mut(handle) else {
+                return;
+            };
+
+            let changed = c.pos != pos;
+            c.pos = pos;
+            (changed, s.active)
+        };
+
+        // update state in event input emulator & input capture
+        if changed {
+            if active {
+                let _ = capture.send(CaptureRequest::Destroy(handle));
+                let _ = emulate.send(EmulationRequest::Destroy(handle));
+            }
+            let _ = capture.send(CaptureRequest::Create(handle, pos.into()));
+            let _ = emulate.send(EmulationRequest::Create(handle));
+        }
+    }
+
+    fn broadcast_client(&self, handle: ClientHandle) {
+        let client = self.client_manager.borrow().get(handle).cloned();
+        let event = if let Some((config, state)) = client {
+            FrontendEvent::State(handle, config, state)
+        } else {
+            FrontendEvent::NoSuchClient(handle)
+        };
+        self.notify_frontend(event);
+    }
+
+    fn set_emulation_status(&self, status: Status) {
+        self.emulation_status.replace(status);
+        let status = FrontendEvent::EmulationStatus(status);
+        self.notify_frontend(status);
+    }
+
+    fn set_capture_status(&self, status: Status) {
+        self.capture_status.replace(status);
+        let status = FrontendEvent::CaptureStatus(status);
+        self.notify_frontend(status);
+    }
+
+    pub(crate) fn set_resolving(&self, handle: ClientHandle, status: bool) {
+        if let Some((_, s)) = self.client_manager.borrow_mut().get_mut(handle) {
+            s.resolving = status;
+        }
+        self.client_updated(handle);
+    }
+
+    pub(crate) fn get_hostname(&self, handle: u64) -> Option<String> {
+        self.client_manager
+            .borrow_mut()
+            .get_mut(handle)
+            .and_then(|(c, _)| c.hostname.clone())
+    }
+
+    fn get_state(&self) -> State {
+        self.state.get()
+    }
+
+    fn set_state(&self, state: State) {
+        log::debug!("state => {state:?}");
+        self.state.replace(state);
+    }
+
+    fn set_active(&self, handle: Option<u64>) {
+        log::debug!("active client => {handle:?}");
+        self.active_client.replace(handle);
+    }
+
+    fn active_addr(&self, handle: u64) -> Option<SocketAddr> {
+        self.client_manager
+            .borrow()
+            .get(handle)
+            .and_then(|(_, s)| s.active_addr)
+    }
+}
+
+async fn listen_frontend(
+    request_tx: Sender<FrontendRequest>,
+    #[cfg(unix)] mut stream: ReadHalf<UnixStream>,
+    #[cfg(windows)] mut stream: ReadHalf<TcpStream>,
+) {
+    use std::io;
+    loop {
+        let request = frontend::wait_for_request(&mut stream).await;
+        match request {
+            Ok(request) => {
+                let _ = request_tx.send(request);
+            }
+            Err(e) => {
+                if let Some(e) = e.downcast_ref::<io::Error>() {
+                    if e.kind() == ErrorKind::UnexpectedEof {
+                        return;
+                    }
+                }
+                log::error!("error reading frontend event: {e}");
+                return;
+            }
+        }
+    }
+}
+
+fn handle_frontend_stream(
+    cancel: CancellationToken,
+    #[cfg(unix)] stream: ReadHalf<UnixStream>,
+    #[cfg(windows)] stream: ReadHalf<TcpStream>,
+    request_tx: Sender<FrontendRequest>,
+) -> JoinHandle<()> {
+    tokio::task::spawn_local(async move {
+        tokio::select! {
+            _ = listen_frontend(request_tx, stream) => {},
+            _ = cancel.cancelled() => {},
+        }
+    })
 }

src/server/capture_task.rs

@@ -1,156 +1,166 @@
-use anyhow::{anyhow, Result};
 use futures::StreamExt;
-use std::{collections::HashSet, net::SocketAddr};
+use lan_mouse_proto::ProtoEvent;
+use local_channel::mpsc::{Receiver, Sender};
+use std::net::SocketAddr;
 
-use tokio::{process::Command, sync::mpsc::Sender, task::JoinHandle};
+use tokio::{process::Command, task::JoinHandle};
 
-use input_capture::{self, error::CaptureCreationError, CaptureHandle, InputCapture, Position};
+use input_capture::{
+    self, CaptureError, CaptureEvent, CaptureHandle, InputCapture, InputCaptureError, Position,
+};
 
-use input_event::{scancode, Event, KeyboardEvent};
+use crate::{client::ClientHandle, frontend::Status, server::State};
-
-use crate::{client::ClientHandle, config::CaptureBackend, server::State};
 
 use super::Server;
 
 #[derive(Clone, Copy, Debug)]
-pub enum CaptureEvent {
+pub(crate) enum CaptureRequest {
     /// capture must release the mouse
     Release,
     /// add a capture client
     Create(CaptureHandle, Position),
     /// destory a capture client
     Destroy(CaptureHandle),
-    /// termination signal
-    Terminate,
 }
 
-pub fn new(
+pub(crate) fn new(
-    backend: Option<CaptureBackend>,
     server: Server,
-    sender_tx: Sender<(Event, SocketAddr)>,
+    capture_rx: Receiver<CaptureRequest>,
-    timer_tx: Sender<()>,
+    udp_send: Sender<(ProtoEvent, SocketAddr)>,
-    release_bind: Vec<scancode::Linux>,
+) -> JoinHandle<()> {
-) -> Result<(JoinHandle<Result<()>>, Sender<CaptureEvent>), CaptureCreationError> {
+    let backend = server.config.capture_backend.map(|b| b.into());
-    let (tx, mut rx) = tokio::sync::mpsc::channel(32);
+    tokio::task::spawn_local(capture_task(server, backend, udp_send, capture_rx))
-    let backend = backend.map(|b| b.into());
+}
-    let task = tokio::task::spawn_local(async move {
+
-        let mut capture = input_capture::create(backend).await?;
+async fn capture_task(
-        let mut pressed_keys = HashSet::new();
+    server: Server,
+    backend: Option<input_capture::Backend>,
+    sender_tx: Sender<(ProtoEvent, SocketAddr)>,
+    mut notify_rx: Receiver<CaptureRequest>,
+) {
+    loop {
+        if let Err(e) = do_capture(backend, &server, &sender_tx, &mut notify_rx).await {
+            log::warn!("input capture exited: {e}");
+        }
+        server.set_capture_status(Status::Disabled);
+        if server.is_cancelled() {
+            break;
+        }
+
+        // allow cancellation
         loop {
             tokio::select! {
-                event = capture.next() => {
+                _ = notify_rx.recv() => continue, /* need to ignore requests here! */
-                    match event {
+                _ = server.capture_enabled() => break,
-                        Some(Ok(event)) => handle_capture_event(&server, &mut capture, &sender_tx, &timer_tx, event, &mut pressed_keys, &release_bind).await?,
+                _ = server.cancelled() => return,
-                        Some(Err(e)) => return Err(anyhow!("input capture: {e:?}")),
-                        None => return Err(anyhow!("input capture terminated")),
-                    }
-                }
-                e = rx.recv() => {
-                    log::debug!("input capture notify rx: {e:?}");
-                    match e {
-                        Some(e) => match e {
-                            CaptureEvent::Release => {
-                                capture.release()?;
-                                server.state.replace(State::Receiving);
-                            }
-                            CaptureEvent::Create(h, p) => capture.create(h, p)?,
-                            CaptureEvent::Destroy(h) => capture.destroy(h)?,
-                            CaptureEvent::Terminate => break,
-                        },
-                        None => break,
-                    }
-                }
             }
         }
-        anyhow::Ok(())
+    }
-    });
-    Ok((task, tx))
 }
 
-fn update_pressed_keys(pressed_keys: &mut HashSet<scancode::Linux>, key: u32, state: u8) {
+async fn do_capture(
-    if let Ok(scancode) = scancode::Linux::try_from(key) {
+    backend: Option<input_capture::Backend>,
-        log::debug!("key: {key}, state: {state}, scancode: {scancode:?}");
+    server: &Server,
-        match state {
+    sender_tx: &Sender<(ProtoEvent, SocketAddr)>,
-            1 => pressed_keys.insert(scancode),
+    notify_rx: &mut Receiver<CaptureRequest>,
-            _ => pressed_keys.remove(&scancode),
+) -> Result<(), InputCaptureError> {
-        };
+    /* allow cancelling capture request */
+    let mut capture = tokio::select! {
+        r = InputCapture::new(backend) => r?,
+        _ = server.cancelled() => return Ok(()),
+    };
+
+    server.set_capture_status(Status::Enabled);
+
+    let clients = server.active_clients();
+    let clients = clients.iter().copied().map(|handle| {
+        (
+            handle,
+            server
+                .client_manager
+                .borrow()
+                .get(handle)
+                .map(|(c, _)| c.pos)
+                .expect("no such client"),
+        )
+    });
+    for (handle, pos) in clients {
+        capture.create(handle, pos.into()).await?;
     }
+
+    loop {
+        tokio::select! {
+            event = capture.next() => match event {
+                Some(event) => handle_capture_event(server, &mut capture, sender_tx, event?).await?,
+                None => return Ok(()),
+            },
+            e = notify_rx.recv() => {
+                log::debug!("input capture notify rx: {e:?}");
+                match e {
+                    Some(e) => match e {
+                        CaptureRequest::Release => {
+                            capture.release().await?;
+                            server.state.replace(State::Receiving);
+                        }
+                        CaptureRequest::Create(h, p) => capture.create(h, p).await?,
+                        CaptureRequest::Destroy(h) => capture.destroy(h).await?,
+                    },
+                    None => break,
+                }
+            }
+            _ = server.cancelled() => break,
+        }
+    }
+    capture.terminate().await?;
+    Ok(())
 }
 
 async fn handle_capture_event(
     server: &Server,
-    capture: &mut Box<dyn InputCapture>,
+    capture: &mut InputCapture,
-    sender_tx: &Sender<(Event, SocketAddr)>,
+    sender_tx: &Sender<(ProtoEvent, SocketAddr)>,
-    timer_tx: &Sender<()>,
+    event: (CaptureHandle, CaptureEvent),
-    event: (CaptureHandle, Event),
+) -> Result<(), CaptureError> {
-    pressed_keys: &mut HashSet<scancode::Linux>,
+    let (handle, event) = event;
-    release_bind: &[scancode::Linux],
+    log::trace!("({handle}) {event:?}");
-) -> Result<()> {
-    let (handle, mut e) = event;
-    log::trace!("({handle}) {e:?}");
 
-    if let Event::Keyboard(KeyboardEvent::Key { key, state, .. }) = e {
+    // capture started
-        update_pressed_keys(pressed_keys, key, state);
+    if event == CaptureEvent::Begin {
-        log::debug!("{pressed_keys:?}");
+        // wait for remote to acknowlegde enter
-        if release_bind.iter().all(|k| pressed_keys.contains(k)) {
+        server.set_state(State::AwaitAck);
-            pressed_keys.clear();
+        server.set_active(Some(handle));
-            log::info!("releasing pointer");
+        // restart ping timer to release capture if unreachable
-            capture.release()?;
+        server.restart_ping_timer();
-            server.state.replace(State::Receiving);
+        // spawn enter hook cmd
-            log::trace!("STATE ===> Receiving");
-            // send an event to release all the modifiers
-            e = Event::Disconnect();
-        }
-    }
-
-    let (addr, enter, start_timer) = {
-        let mut enter = false;
-        let mut start_timer = false;
-
-        // get client state for handle
-        let mut client_manager = server.client_manager.borrow_mut();
-        let client_state = match client_manager.get_mut(handle) {
-            Some((_, s)) => s,
-            None => {
-                // should not happen
-                log::warn!("unknown client!");
-                capture.release()?;
-                server.state.replace(State::Receiving);
-                log::trace!("STATE ===> Receiving");
-                return Ok(());
-            }
-        };
-
-        // if we just entered the client we want to send additional enter events until
-        // we get a leave event
-        if let Event::Enter() = e {
-            server.state.replace(State::AwaitingLeave);
-            server.active_client.replace(Some(handle));
-            log::trace!("Active client => {}", handle);
-            start_timer = true;
-            log::trace!("STATE ===> AwaitingLeave");
-            enter = true;
-        } else {
-            // ignore any potential events in receiving mode
-            if server.state.get() == State::Receiving && e != Event::Disconnect() {
-                return Ok(());
-            }
-        }
-
-        (client_state.active_addr, enter, start_timer)
-    };
-    if start_timer {
-        let _ = timer_tx.try_send(());
-    }
-    if enter {
         spawn_hook_command(server, handle);
     }
-    if let Some(addr) = addr {
+
-        if enter {
+    // release capture if emulation set state to Receiveing
-            let _ = sender_tx.send((Event::Enter(), addr)).await;
+    if server.get_state() == State::Receiving {
-        }
+        capture.release().await?;
-        let _ = sender_tx.send((e, addr)).await;
+        return Ok(());
     }
+
+    // check release bind
+    if capture.keys_pressed(&server.release_bind) {
+        capture.release().await?;
+        server.set_state(State::Receiving);
+    }
+
+    if let Some(addr) = server.active_addr(handle) {
+        let event = match server.get_state() {
+            State::Sending => match event {
+                CaptureEvent::Begin => ProtoEvent::Enter(0),
+                CaptureEvent::Input(e) => ProtoEvent::Input(e),
+            },
+            /* send additional enter events until acknowleged */
+            State::AwaitAck => ProtoEvent::Enter(0),
+            /* released capture */
+            State::Receiving => ProtoEvent::Leave(0),
+        };
+        sender_tx.send((event, addr)).expect("sender closed");
+    };
+
     Ok(())
 }
 

src/server/emulation_task.rs

@@ -1,117 +1,128 @@
+use local_channel::mpsc::{Receiver, Sender};
 use std::net::SocketAddr;
 
-use thiserror::Error;
+use lan_mouse_proto::ProtoEvent;
-use tokio::{
+use tokio::task::JoinHandle;
-    sync::mpsc::{Receiver, Sender},
-    task::JoinHandle,
-};
 
 use crate::{
     client::{ClientHandle, ClientManager},
-    config::EmulationBackend,
+    frontend::Status,
     server::State,
 };
-use input_emulation::{
+use input_emulation::{self, EmulationError, EmulationHandle, InputEmulation, InputEmulationError};
-    self,
-    error::{EmulationCreationError, EmulationError},
-    EmulationHandle, InputEmulation,
-};
-use input_event::{Event, KeyboardEvent};
 
-use super::{network_task::NetworkError, CaptureEvent, Server};
+use super::{network_task::NetworkError, Server};
 
 #[derive(Clone, Debug)]
-pub enum EmulationEvent {
+pub(crate) enum EmulationRequest {
     /// create a new client
     Create(EmulationHandle),
     /// destroy a client
     Destroy(EmulationHandle),
     /// input emulation must release keys for client
     ReleaseKeys(ClientHandle),
-    /// termination signal
-    Terminate,
 }
 
-pub fn new(
+pub(crate) fn new(
-    backend: Option<EmulationBackend>,
     server: Server,
-    udp_rx: Receiver<Result<(Event, SocketAddr), NetworkError>>,
+    emulation_rx: Receiver<EmulationRequest>,
-    sender_tx: Sender<(Event, SocketAddr)>,
+    udp_rx: Receiver<Result<(ProtoEvent, SocketAddr), NetworkError>>,
-    capture_tx: Sender<CaptureEvent>,
+    sender_tx: Sender<(ProtoEvent, SocketAddr)>,
-    timer_tx: Sender<()>,
+) -> JoinHandle<()> {
-) -> (
+    let emulation_task = emulation_task(server, emulation_rx, udp_rx, sender_tx);
-    JoinHandle<Result<(), LanMouseEmulationError>>,
+    tokio::task::spawn_local(emulation_task)
-    Sender<EmulationEvent>,
-) {
-    let (tx, rx) = tokio::sync::mpsc::channel(32);
-    let emulation_task =
-        emulation_task(backend, rx, server, udp_rx, sender_tx, capture_tx, timer_tx);
-    let emulate_task = tokio::task::spawn_local(emulation_task);
-    (emulate_task, tx)
-}
-
-#[derive(Debug, Error)]
-pub enum LanMouseEmulationError {
-    #[error("error creating input-emulation: `{0}`")]
-    Create(#[from] EmulationCreationError),
-    #[error("error emulating input: `{0}`")]
-    Emulate(#[from] EmulationError),
 }
 
 async fn emulation_task(
-    backend: Option<EmulationBackend>,
-    mut rx: Receiver<EmulationEvent>,
     server: Server,
-    mut udp_rx: Receiver<Result<(Event, SocketAddr), NetworkError>>,
+    mut rx: Receiver<EmulationRequest>,
-    sender_tx: Sender<(Event, SocketAddr)>,
+    mut udp_rx: Receiver<Result<(ProtoEvent, SocketAddr), NetworkError>>,
-    capture_tx: Sender<CaptureEvent>,
+    sender_tx: Sender<(ProtoEvent, SocketAddr)>,
-    timer_tx: Sender<()>,
+) {
-) -> Result<(), LanMouseEmulationError> {
-    let backend = backend.map(|b| b.into());
-    let mut emulation = input_emulation::create(backend).await?;
-
-    let mut last_ignored = None;
     loop {
-        tokio::select! {
+        if let Err(e) = do_emulation(&server, &mut rx, &mut udp_rx, &sender_tx).await {
-            udp_event = udp_rx.recv() => {
+            log::warn!("input emulation exited: {e}");
-                let udp_event = match udp_event {
+        }
-                    Some(Ok(e)) => e,
+        server.set_emulation_status(Status::Disabled);
-                    Some(Err(e)) => {
+        if server.is_cancelled() {
-                        log::warn!("network error: {e}");
+            break;
-                        continue;
+        }
-                    }
+
-                    None => break,
+        // allow cancellation
-                };
+        loop {
-                handle_udp_rx(&server, &capture_tx, &mut emulation, &sender_tx, &mut last_ignored, udp_event, &timer_tx).await?;
+            tokio::select! {
-            }
+                _ = rx.recv() => continue, /* need to ignore requests here! */
-            emulate_event = rx.recv() => {
+                _ = server.emulation_notified() => break,
-                match emulate_event {
+                _ = server.cancelled() => return,
-                    Some(e) => match e {
-                        EmulationEvent::Create(h) => emulation.create(h).await,
-                        EmulationEvent::Destroy(h) => emulation.destroy(h).await,
-                        EmulationEvent::ReleaseKeys(c) => release_keys(&server, &mut emulation, c).await?,
-                        EmulationEvent::Terminate => break,
-                    },
-                    None => break,
-                }
             }
         }
     }
-
-    // release potentially still pressed keys
-    release_all_keys(&server, &mut emulation).await?;
-
-    Ok(())
 }
 
-async fn handle_udp_rx(
+async fn do_emulation(
     server: &Server,
-    capture_tx: &Sender<CaptureEvent>,
+    rx: &mut Receiver<EmulationRequest>,
-    emulate: &mut Box<dyn InputEmulation>,
+    udp_rx: &mut Receiver<Result<(ProtoEvent, SocketAddr), NetworkError>>,
-    sender_tx: &Sender<(Event, SocketAddr)>,
+    sender_tx: &Sender<(ProtoEvent, SocketAddr)>,
+) -> Result<(), InputEmulationError> {
+    let backend = server.config.emulation_backend.map(|b| b.into());
+    log::info!("creating input emulation...");
+    let mut emulation = tokio::select! {
+        r = InputEmulation::new(backend) => r?,
+        _ = server.cancelled() => return Ok(()),
+    };
+
+    server.set_emulation_status(Status::Enabled);
+
+    // add clients
+    for handle in server.active_clients() {
+        emulation.create(handle).await;
+    }
+
+    let res = do_emulation_session(server, &mut emulation, rx, udp_rx, sender_tx).await;
+    emulation.terminate().await; // manual drop
+    res
+}
+
+async fn do_emulation_session(
+    server: &Server,
+    emulation: &mut InputEmulation,
+    rx: &mut Receiver<EmulationRequest>,
+    udp_rx: &mut Receiver<Result<(ProtoEvent, SocketAddr), NetworkError>>,
+    sender_tx: &Sender<(ProtoEvent, SocketAddr)>,
+) -> Result<(), InputEmulationError> {
+    let mut last_ignored = None;
+
+    loop {
+        tokio::select! {
+            udp_event = udp_rx.recv() => {
+                let udp_event = match udp_event.expect("channel closed") {
+                    Ok(e) => e,
+                    Err(e) => {
+                        log::warn!("network error: {e}");
+                        continue;
+                    }
+                };
+                handle_incoming_event(server, emulation, sender_tx, &mut last_ignored, udp_event).await?;
+            }
+            emulate_event = rx.recv() => {
+                match emulate_event.expect("channel closed") {
+                    EmulationRequest::Create(h) => { let _ = emulation.create(h).await; },
+                    EmulationRequest::Destroy(h) => emulation.destroy(h).await,
+                    EmulationRequest::ReleaseKeys(c) => emulation.release_keys(c).await?,
+                }
+            }
+            _ = server.notifies.cancel.cancelled() => break Ok(()),
+        }
+    }
+}
+
+async fn handle_incoming_event(
+    server: &Server,
+    emulate: &mut InputEmulation,
+    sender_tx: &Sender<(ProtoEvent, SocketAddr)>,
     last_ignored: &mut Option<SocketAddr>,
-    event: (Event, SocketAddr),
+    event: (ProtoEvent, SocketAddr),
-    timer_tx: &Sender<()>,
 ) -> Result<(), EmulationError> {
     let (event, addr) = event;
 
@@ -125,72 +136,26 @@ async fn handle_udp_rx(
     };
 
     match (event, addr) {
-        (Event::Pong(), _) => { /* ignore pong events */ }
+        (ProtoEvent::Pong, _) => { /* ignore pong events */ }
-        (Event::Ping(), addr) => {
+        (ProtoEvent::Ping, addr) => {
-            let _ = sender_tx.send((Event::Pong(), addr)).await;
+            let _ = sender_tx.send((ProtoEvent::Pong, addr));
         }
-        (Event::Disconnect(), _) => {
+        (ProtoEvent::Leave(_), _) => emulate.release_keys(handle).await?,
-            release_keys(server, emulate, handle).await?;
+        (ProtoEvent::Ack(_), _) => server.set_state(State::Sending),
+        (ProtoEvent::Enter(_), _) => {
+            server.set_state(State::Receiving);
+            sender_tx
+                .send((ProtoEvent::Ack(0), addr))
+                .expect("no channel")
         }
-        (event, addr) => {
+        (ProtoEvent::Input(e), _) => {
-            // tell clients that we are ready to receive events
+            if let State::Receiving = server.get_state() {
-            if let Event::Enter() = event {
+                log::trace!("{event} => emulate");
-                let _ = sender_tx.send((Event::Leave(), addr)).await;
+                emulate.consume(e, handle).await?;
-            }
+                let has_pressed_keys = emulate.has_pressed_keys(handle);
-
+                server.update_pressed_keys(handle, has_pressed_keys);
-            match server.state.get() {
+                if has_pressed_keys {
-                State::Sending => {
+                    server.restart_ping_timer();
-                    if let Event::Leave() = event {
-                        // ignore additional leave events that may
-                        // have been sent for redundancy
-                    } else {
-                        // upon receiving any event, we go back to receiving mode
-                        server.state.replace(State::Receiving);
-                        let _ = capture_tx.send(CaptureEvent::Release).await;
-                        log::trace!("STATE ===> Receiving");
-                    }
-                }
-                State::Receiving => {
-                    let ignore_event =
-                        if let Event::Keyboard(KeyboardEvent::Key { key, state, .. }) = event {
-                            let (ignore_event, restart_timer) = update_client_keys(
-                                &mut server.client_manager.borrow_mut(),
-                                handle,
-                                key,
-                                state,
-                            );
-                            // restart timer if necessary
-                            if restart_timer {
-                                let _ = timer_tx.try_send(());
-                            }
-                            ignore_event
-                        } else {
-                            false
-                        };
-                    // workaround buggy rdp backend.
-                    if !ignore_event {
-                        // consume event
-                        emulate.consume(event, handle).await?;
-                        log::trace!("{event} => emulate");
-                    }
-                }
-                State::AwaitingLeave => {
-                    // we just entered the deadzone of a client, so
-                    // we need to ignore events that may still
-                    // be on the way until a leave event occurs
-                    // telling us the client registered the enter
-                    if let Event::Leave() = event {
-                        server.state.replace(State::Sending);
-                        log::trace!("STATE ===> Sending");
-                    }
-
-                    // entering a client that is waiting for a leave
-                    // event should still be possible
-                    if let Event::Enter() = event {
-                        server.state.replace(State::Receiving);
-                        let _ = capture_tx.send(CaptureEvent::Release).await;
-                        log::trace!("STATE ===> Receiving");
-                    }
                 }
             }
         }
@@ -198,57 +163,6 @@ async fn handle_udp_rx(
     Ok(())
 }
 
-async fn release_all_keys(
-    server: &Server,
-    emulation: &mut Box<dyn InputEmulation>,
-) -> Result<(), EmulationError> {
-    let clients = server
-        .client_manager
-        .borrow()
-        .get_client_states()
-        .map(|(h, _)| h)
-        .collect::<Vec<_>>();
-    for client in clients {
-        release_keys(server, emulation, client).await?;
-    }
-    Ok(())
-}
-
-async fn release_keys(
-    server: &Server,
-    emulate: &mut Box<dyn InputEmulation>,
-    client: ClientHandle,
-) -> Result<(), EmulationError> {
-    let keys = server
-        .client_manager
-        .borrow_mut()
-        .get_mut(client)
-        .iter_mut()
-        .flat_map(|(_, s)| s.pressed_keys.drain())
-        .collect::<Vec<_>>();
-
-    for key in keys {
-        let event = Event::Keyboard(KeyboardEvent::Key {
-            time: 0,
-            key,
-            state: 0,
-        });
-        emulate.consume(event, client).await?;
-        if let Ok(key) = input_event::scancode::Linux::try_from(key) {
-            log::warn!("releasing stuck key: {key:?}");
-        }
-    }
-
-    let event = Event::Keyboard(KeyboardEvent::Modifiers {
-        mods_depressed: 0,
-        mods_latched: 0,
-        mods_locked: 0,
-        group: 0,
-    });
-    emulate.consume(event, client).await?;
-    Ok(())
-}
-
 fn activate_client_if_exists(
     client_manager: &mut ClientManager,
     addr: SocketAddr,
@@ -273,25 +187,3 @@ fn activate_client_if_exists(
     client_state.active_addr = Some(addr);
     Some(handle)
 }
-
-fn update_client_keys(
-    client_manager: &mut ClientManager,
-    handle: ClientHandle,
-    key: u32,
-    state: u8,
-) -> (bool, bool) {
-    let Some(client_state) = client_manager.get_mut(handle).map(|(_, s)| s) else {
-        return (true, false);
-    };
-
-    // ignore double press / release events
-    let ignore_event = if state == 0 {
-        // ignore release event if key not pressed
-        !client_state.pressed_keys.remove(&key)
-    } else {
-        // ignore press event if key not released
-        !client_state.pressed_keys.insert(key)
-    };
-    let restart_timer = !client_state.pressed_keys.is_empty();
-    (ignore_event, restart_timer)
-}

src/server/frontend_task.rs

@@ -1,350 +0,0 @@
-use std::{
-    collections::HashSet,
-    io::ErrorKind,
-    net::{IpAddr, SocketAddr},
-};
-#[cfg(unix)]
-use tokio::net::UnixStream;
-
-#[cfg(windows)]
-use tokio::net::TcpStream;
-
-use anyhow::{anyhow, Result};
-use tokio::{
-    io::ReadHalf,
-    sync::mpsc::{Receiver, Sender},
-    task::JoinHandle,
-};
-
-use crate::{
-    client::{ClientHandle, Position},
-    frontend::{self, FrontendEvent, FrontendListener, FrontendRequest},
-};
-
-use super::{
-    capture_task::CaptureEvent, emulation_task::EmulationEvent, resolver_task::DnsRequest, Server,
-};
-
-pub(crate) fn new(
-    mut frontend: FrontendListener,
-    mut notify_rx: Receiver<FrontendEvent>,
-    server: Server,
-    capture: Sender<CaptureEvent>,
-    emulate: Sender<EmulationEvent>,
-    resolve_ch: Sender<DnsRequest>,
-    port_tx: Sender<u16>,
-) -> (JoinHandle<Result<()>>, Sender<FrontendRequest>) {
-    let (event_tx, mut event_rx) = tokio::sync::mpsc::channel(32);
-    let event_tx_clone = event_tx.clone();
-    let frontend_task = tokio::task::spawn_local(async move {
-        loop {
-            tokio::select! {
-                stream = frontend.accept() => {
-                    let stream = match stream {
-                        Ok(s) => s,
-                        Err(e) => {
-                            log::warn!("error accepting frontend connection: {e}");
-                            continue;
-                        }
-                    };
-                    handle_frontend_stream(&event_tx_clone, stream).await;
-                }
-                event = event_rx.recv() => {
-                    let frontend_event = event.ok_or(anyhow!("frontend channel closed"))?;
-                    if handle_frontend_event(&server, &capture, &emulate, &resolve_ch, &mut frontend, &port_tx, frontend_event).await {
-                        break;
-                    }
-                }
-                notify = notify_rx.recv() => {
-                    let notify = notify.ok_or(anyhow!("frontend notify closed"))?;
-                    let _ = frontend.broadcast_event(notify).await;
-                }
-            }
-        }
-        anyhow::Ok(())
-    });
-    (frontend_task, event_tx)
-}
-
-async fn handle_frontend_stream(
-    frontend_tx: &Sender<FrontendRequest>,
-    #[cfg(unix)] mut stream: ReadHalf<UnixStream>,
-    #[cfg(windows)] mut stream: ReadHalf<TcpStream>,
-) {
-    use std::io;
-
-    let tx = frontend_tx.clone();
-    tokio::task::spawn_local(async move {
-        loop {
-            let request = frontend::wait_for_request(&mut stream).await;
-            match request {
-                Ok(request) => {
-                    let _ = tx.send(request).await;
-                }
-                Err(e) => {
-                    if let Some(e) = e.downcast_ref::<io::Error>() {
-                        if e.kind() == ErrorKind::UnexpectedEof {
-                            return;
-                        }
-                    }
-                    log::error!("error reading frontend event: {e}");
-                    return;
-                }
-            }
-        }
-    });
-}
-
-async fn handle_frontend_event(
-    server: &Server,
-    capture: &Sender<CaptureEvent>,
-    emulate: &Sender<EmulationEvent>,
-    resolve_tx: &Sender<DnsRequest>,
-    frontend: &mut FrontendListener,
-    port_tx: &Sender<u16>,
-    event: FrontendRequest,
-) -> bool {
-    log::debug!("frontend: {event:?}");
-    match event {
-        FrontendRequest::Create => {
-            let handle = add_client(server, frontend).await;
-            resolve_dns(server, resolve_tx, handle).await;
-        }
-        FrontendRequest::Activate(handle, active) => {
-            if active {
-                activate_client(server, capture, emulate, handle).await;
-            } else {
-                deactivate_client(server, capture, emulate, handle).await;
-            }
-        }
-        FrontendRequest::ChangePort(port) => {
-            let _ = port_tx.send(port).await;
-        }
-        FrontendRequest::Delete(handle) => {
-            remove_client(server, capture, emulate, handle).await;
-            broadcast(frontend, FrontendEvent::Deleted(handle)).await;
-        }
-        FrontendRequest::Enumerate() => {
-            let clients = server
-                .client_manager
-                .borrow()
-                .get_client_states()
-                .map(|(h, (c, s))| (h, c.clone(), s.clone()))
-                .collect();
-            broadcast(frontend, FrontendEvent::Enumerate(clients)).await;
-        }
-        FrontendRequest::GetState(handle) => {
-            broadcast_client(server, frontend, handle).await;
-        }
-        FrontendRequest::Terminate() => {
-            log::info!("terminating gracefully...");
-            return true;
-        }
-        FrontendRequest::UpdateFixIps(handle, fix_ips) => {
-            update_fix_ips(server, handle, fix_ips).await;
-            resolve_dns(server, resolve_tx, handle).await;
-        }
-        FrontendRequest::UpdateHostname(handle, hostname) => {
-            update_hostname(server, resolve_tx, handle, hostname).await;
-            resolve_dns(server, resolve_tx, handle).await;
-        }
-        FrontendRequest::UpdatePort(handle, port) => {
-            update_port(server, handle, port).await;
-        }
-        FrontendRequest::UpdatePosition(handle, pos) => {
-            update_pos(server, handle, capture, emulate, pos).await;
-        }
-        FrontendRequest::ResolveDns(handle) => {
-            resolve_dns(server, resolve_tx, handle).await;
-        }
-    };
-    false
-}
-
-async fn resolve_dns(server: &Server, resolve_tx: &Sender<DnsRequest>, handle: ClientHandle) {
-    let hostname = server
-        .client_manager
-        .borrow()
-        .get(handle)
-        .and_then(|(c, _)| c.hostname.clone());
-    if let Some(hostname) = hostname {
-        let _ = resolve_tx
-            .send(DnsRequest {
-                hostname: hostname.clone(),
-                handle,
-            })
-            .await;
-    }
-}
-
-async fn broadcast(frontend: &mut FrontendListener, event: FrontendEvent) {
-    if let Err(e) = frontend.broadcast_event(event).await {
-        log::error!("error notifying frontend: {e}");
-    }
-}
-
-pub async fn add_client(server: &Server, frontend: &mut FrontendListener) -> ClientHandle {
-    let handle = server.client_manager.borrow_mut().add_client();
-    log::info!("added client {handle}");
-
-    let (c, s) = server.client_manager.borrow().get(handle).unwrap().clone();
-    broadcast(frontend, FrontendEvent::Created(handle, c, s)).await;
-    handle
-}
-
-pub async fn deactivate_client(
-    server: &Server,
-    capture: &Sender<CaptureEvent>,
-    emulate: &Sender<EmulationEvent>,
-    handle: ClientHandle,
-) {
-    match server.client_manager.borrow_mut().get_mut(handle) {
-        Some((_, s)) => {
-            s.active = false;
-        }
-        None => return,
-    };
-
-    let _ = capture.send(CaptureEvent::Destroy(handle)).await;
-    let _ = emulate.send(EmulationEvent::Destroy(handle)).await;
-}
-
-pub async fn activate_client(
-    server: &Server,
-    capture: &Sender<CaptureEvent>,
-    emulate: &Sender<EmulationEvent>,
-    handle: ClientHandle,
-) {
-    /* deactivate potential other client at this position */
-    let pos = match server.client_manager.borrow().get(handle) {
-        Some((client, _)) => client.pos,
-        None => return,
-    };
-
-    let other = server.client_manager.borrow_mut().find_client(pos);
-    if let Some(other) = other {
-        if other != handle {
-            deactivate_client(server, capture, emulate, other).await;
-        }
-    }
-
-    /* activate the client */
-    if let Some((_, s)) = server.client_manager.borrow_mut().get_mut(handle) {
-        s.active = true;
-    } else {
-        return;
-    };
-
-    /* notify emulation, capture and frontends */
-    let _ = capture.send(CaptureEvent::Create(handle, pos.into())).await;
-    let _ = emulate.send(EmulationEvent::Create(handle)).await;
-}
-
-pub async fn remove_client(
-    server: &Server,
-    capture: &Sender<CaptureEvent>,
-    emulate: &Sender<EmulationEvent>,
-    handle: ClientHandle,
-) {
-    let Some(active) = server
-        .client_manager
-        .borrow_mut()
-        .remove_client(handle)
-        .map(|(_, s)| s.active)
-    else {
-        return;
-    };
-
-    if active {
-        let _ = capture.send(CaptureEvent::Destroy(handle)).await;
-        let _ = emulate.send(EmulationEvent::Destroy(handle)).await;
-    }
-}
-
-async fn update_fix_ips(server: &Server, handle: ClientHandle, fix_ips: Vec<IpAddr>) {
-    let mut client_manager = server.client_manager.borrow_mut();
-    let Some((c, _)) = client_manager.get_mut(handle) else {
-        return;
-    };
-
-    c.fix_ips = fix_ips;
-}
-
-async fn update_hostname(
-    server: &Server,
-    resolve_tx: &Sender<DnsRequest>,
-    handle: ClientHandle,
-    hostname: Option<String>,
-) {
-    let hostname = {
-        let mut client_manager = server.client_manager.borrow_mut();
-        let Some((c, s)) = client_manager.get_mut(handle) else {
-            return;
-        };
-
-        // update hostname
-        if c.hostname != hostname {
-            c.hostname = hostname;
-            s.ips = HashSet::from_iter(c.fix_ips.iter().cloned());
-            s.active_addr = None;
-            c.hostname.clone()
-        } else {
-            None
-        }
-    };
-
-    // resolve to update ips in state
-    if let Some(hostname) = hostname {
-        let _ = resolve_tx.send(DnsRequest { hostname, handle }).await;
-    }
-}
-
-async fn update_port(server: &Server, handle: ClientHandle, port: u16) {
-    let mut client_manager = server.client_manager.borrow_mut();
-    let Some((c, s)) = client_manager.get_mut(handle) else {
-        return;
-    };
-
-    if c.port != port {
-        c.port = port;
-        s.active_addr = s.active_addr.map(|a| SocketAddr::new(a.ip(), port));
-    }
-}
-
-async fn update_pos(
-    server: &Server,
-    handle: ClientHandle,
-    capture: &Sender<CaptureEvent>,
-    emulate: &Sender<EmulationEvent>,
-    pos: Position,
-) {
-    let (changed, active) = {
-        let mut client_manager = server.client_manager.borrow_mut();
-        let Some((c, s)) = client_manager.get_mut(handle) else {
-            return;
-        };
-
-        let changed = c.pos != pos;
-        c.pos = pos;
-        (changed, s.active)
-    };
-
-    // 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 _ = capture.send(CaptureEvent::Create(handle, pos.into())).await;
-        let _ = emulate.send(EmulationEvent::Create(handle)).await;
-    }
-}
-
-async fn broadcast_client(server: &Server, frontend: &mut FrontendListener, handle: ClientHandle) {
-    let client = server.client_manager.borrow().get(handle).cloned();
-    if let Some((config, state)) = client {
-        broadcast(frontend, FrontendEvent::State(handle, config, state)).await;
-    } else {
-        broadcast(frontend, FrontendEvent::NoSuchClient(handle)).await;
-    }
-}

src/server/network_task.rs

@@ -1,97 +1,74 @@
+use local_channel::mpsc::{Receiver, Sender};
 use std::{io, net::SocketAddr};
 
 use thiserror::Error;
-use tokio::{
+use tokio::{net::UdpSocket, task::JoinHandle};
-    net::UdpSocket,
-    sync::mpsc::{Receiver, Sender},
-    task::JoinHandle,
-};
-
-use crate::frontend::FrontendEvent;
-use input_event::{Event, ProtocolError};
 
 use super::Server;
+use lan_mouse_proto::{ProtoEvent, ProtocolError};
 
-pub async fn new(
+pub(crate) async fn new(
     server: Server,
-    frontend_notify_tx: Sender<FrontendEvent>,
+    udp_recv_tx: Sender<Result<(ProtoEvent, SocketAddr), NetworkError>>,
-) -> io::Result<(
+    udp_send_rx: Receiver<(ProtoEvent, SocketAddr)>,
-    JoinHandle<()>,
+) -> io::Result<JoinHandle<()>> {
-    Sender<(Event, SocketAddr)>,
-    Receiver<Result<(Event, SocketAddr), NetworkError>>,
-    Sender<u16>,
-)> {
     // bind the udp socket
     let listen_addr = SocketAddr::new("0.0.0.0".parse().unwrap(), server.port.get());
     let mut socket = UdpSocket::bind(listen_addr).await?;
-    let (receiver_tx, receiver_rx) = tokio::sync::mpsc::channel(32);
-    let (sender_tx, sender_rx) = tokio::sync::mpsc::channel(32);
-    let (port_tx, mut port_rx) = tokio::sync::mpsc::channel(32);
 
-    let udp_task = tokio::task::spawn_local(async move {
+    Ok(tokio::task::spawn_local(async move {
-        let mut sender_rx = sender_rx;
+        let mut sender_rx = udp_send_rx;
         loop {
-            let udp_receiver = udp_receiver(&socket, &receiver_tx);
+            let udp_receiver = udp_receiver(&socket, &udp_recv_tx);
             let udp_sender = udp_sender(&socket, &mut sender_rx);
             tokio::select! {
                 _ = udp_receiver => break, /* channel closed */
                 _ = udp_sender => break, /* channel closed */
-                port = port_rx.recv() => match port {
+                _ = server.notifies.port_changed.notified() => update_port(&server, &mut socket).await,
-                    Some(port) => update_port(&server, &frontend_notify_tx, &mut socket, port).await,
+                _ = server.cancelled() => break, /* cancellation requested */
-                    _ => break,
-                }
             }
         }
-    });
+    }))
-    Ok((udp_task, sender_tx, receiver_rx, port_tx))
 }
 
-async fn update_port(
+async fn update_port(server: &Server, socket: &mut UdpSocket) {
-    server: &Server,
+    let new_port = server.port.get();
-    frontend_chan: &Sender<FrontendEvent>,
+    let current_port = socket.local_addr().expect("socket not bound").port();
-    socket: &mut UdpSocket,
+
-    port: u16,
-) {
     // if port is the same, we dont need to change it
-    if socket.local_addr().unwrap().port() == port {
+    if current_port == new_port {
         return;
     }
 
-    // create new socket
+    // bind new socket
-    let listen_addr = SocketAddr::new("0.0.0.0".parse().unwrap(), port);
+    let listen_addr = SocketAddr::new("0.0.0.0".parse().unwrap(), new_port);
-    let frontend_event = match UdpSocket::bind(listen_addr).await {
+    let new_socket = UdpSocket::bind(listen_addr).await;
+    let err = match new_socket {
         Ok(new_socket) => {
             *socket = new_socket;
-            server.port.replace(port);
+            None
-            FrontendEvent::PortChanged(port, None)
-        }
-        Err(e) => {
-            log::warn!("could not change port: {e}");
-            let port = socket.local_addr().unwrap().port();
-            FrontendEvent::PortChanged(port, Some(format!("could not change port: {e}")))
         }
+        Err(e) => Some(e.to_string()),
     };
-    let _ = frontend_chan.send(frontend_event).await;
+
+    // notify frontend of the actual port
+    let port = socket.local_addr().expect("socket not bound").port();
+    server.notify_port_changed(port, err);
 }
 
 async fn udp_receiver(
     socket: &UdpSocket,
-    receiver_tx: &Sender<Result<(Event, SocketAddr), NetworkError>>,
+    receiver_tx: &Sender<Result<(ProtoEvent, SocketAddr), NetworkError>>,
 ) {
     loop {
         let event = receive_event(socket).await;
-        if receiver_tx.send(event).await.is_err() {
+        receiver_tx.send(event).expect("channel closed");
-            break;
-        }
     }
 }
 
-async fn udp_sender(socket: &UdpSocket, rx: &mut Receiver<(Event, SocketAddr)>) {
+async fn udp_sender(socket: &UdpSocket, rx: &mut Receiver<(ProtoEvent, SocketAddr)>) {
     loop {
-        let (event, addr) = match rx.recv().await {
+        let (event, addr) = rx.recv().await.expect("channel closed");
-            Some(e) => e,
-            None => return,
-        };
         if let Err(e) = send_event(socket, event, addr) {
             log::warn!("udp send failed: {e}");
         };
@@ -106,16 +83,17 @@ pub(crate) enum NetworkError {
     Io(#[from] io::Error),
 }
 
-async fn receive_event(socket: &UdpSocket) -> Result<(Event, SocketAddr), NetworkError> {
+async fn receive_event(socket: &UdpSocket) -> Result<(ProtoEvent, SocketAddr), NetworkError> {
-    let mut buf = vec![0u8; 22];
+    let mut buf = [0u8; lan_mouse_proto::MAX_EVENT_SIZE];
-    let (_amt, src) = socket.recv_from(&mut buf).await?;
+    let (_len, src) = socket.recv_from(&mut buf).await?;
-    Ok((Event::try_from(buf)?, src))
+    let event = ProtoEvent::try_from(buf)?;
+    Ok((event, src))
 }
 
-fn send_event(sock: &UdpSocket, e: Event, addr: SocketAddr) -> Result<usize, NetworkError> {
+fn send_event(sock: &UdpSocket, e: ProtoEvent, addr: SocketAddr) -> Result<usize, NetworkError> {
     log::trace!("{:20} ------>->->-> {addr}", e.to_string());
-    let data: Vec<u8> = (&e).into();
+    let (data, len): ([u8; lan_mouse_proto::MAX_EVENT_SIZE], usize) = e.into();
     // When udp blocks, we dont want to block the event loop.
     // Dropping events is better than potentially crashing the input capture.
-    Ok(sock.try_send_to(&data, addr)?)
+    Ok(sock.try_send_to(&data[..len], addr)?)
 }

src/server/ping_task.rs

@@ -1,131 +1,138 @@
 use std::{net::SocketAddr, time::Duration};
 
-use tokio::{
+use lan_mouse_proto::ProtoEvent;
-    sync::mpsc::{Receiver, Sender},
+use local_channel::mpsc::Sender;
-    task::JoinHandle,
+use tokio::task::JoinHandle;
-};
-
-use input_event::Event;
 
 use crate::client::ClientHandle;
 
-use super::{capture_task::CaptureEvent, emulation_task::EmulationEvent, Server, State};
+use super::{capture_task::CaptureRequest, emulation_task::EmulationRequest, Server, State};
 
 const MAX_RESPONSE_TIME: Duration = Duration::from_millis(500);
 
-pub fn new(
+pub(crate) fn new(
     server: Server,
-    sender_ch: Sender<(Event, SocketAddr)>,
+    sender_ch: Sender<(ProtoEvent, SocketAddr)>,
-    emulate_notify: Sender<EmulationEvent>,
+    emulate_notify: Sender<EmulationRequest>,
-    capture_notify: Sender<CaptureEvent>,
+    capture_notify: Sender<CaptureRequest>,
-    mut timer_rx: Receiver<()>,
 ) -> JoinHandle<()> {
     // timer task
-    let ping_task = tokio::task::spawn_local(async move {
+    tokio::task::spawn_local(async move {
+        tokio::select! {
+            _ = server.notifies.cancel.cancelled() => {}
+            _ = ping_task(&server, sender_ch, emulate_notify, capture_notify) => {}
+        }
+    })
+}
+
+async fn ping_task(
+    server: &Server,
+    sender_ch: Sender<(ProtoEvent, SocketAddr)>,
+    emulate_notify: Sender<EmulationRequest>,
+    capture_notify: Sender<CaptureRequest>,
+) {
+    loop {
+        // wait for wake up signal
+        server.ping_timer_notified().await;
         loop {
-            // wait for wake up signal
+            let receiving = server.state.get() == State::Receiving;
-            let Some(_): Option<()> = timer_rx.recv().await else {
+            let (ping_clients, ping_addrs) = {
-                break;
+                let mut client_manager = server.client_manager.borrow_mut();
-            };
-            loop {
-                let receiving = server.state.get() == State::Receiving;
-                let (ping_clients, ping_addrs) = {
-                    let mut client_manager = server.client_manager.borrow_mut();
 
-                    let ping_clients: Vec<ClientHandle> = if receiving {
+                let ping_clients: Vec<ClientHandle> = if receiving {
-                        // if receiving we care about clients with pressed keys
+                    // if receiving we care about clients with pressed keys
-                        client_manager
+                    client_manager
-                            .get_client_states_mut()
+                        .get_client_states()
-                            .filter(|(_, (_, s))| !s.pressed_keys.is_empty())
+                        .filter(|(_, (_, s))| s.has_pressed_keys)
-                            .map(|(h, _)| h)
+                        .map(|(h, _)| h)
-                            .collect()
+                        .collect()
-                    } else {
+                } else {
-                        // if sending we care about the active client
+                    // if sending we care about the active client
-                        server.active_client.get().iter().cloned().collect()
+                    server.active_client.get().iter().cloned().collect()
-                    };
-
-                    // get relevant socket addrs for clients
-                    let ping_addrs: Vec<SocketAddr> = {
-                        ping_clients
-                            .iter()
-                            .flat_map(|&h| client_manager.get(h))
-                            .flat_map(|(c, s)| {
-                                if s.alive && s.active_addr.is_some() {
-                                    vec![s.active_addr.unwrap()]
-                                } else {
-                                    s.ips
-                                        .iter()
-                                        .cloned()
-                                        .map(|ip| SocketAddr::new(ip, c.port))
-                                        .collect()
-                                }
-                            })
-                            .collect()
-                    };
-
-                    // reset alive
-                    for (_, (_, s)) in client_manager.get_client_states_mut() {
-                        s.alive = false;
-                    }
-
-                    (ping_clients, ping_addrs)
                 };
 
-                if receiving && ping_clients.is_empty() {
+                // get relevant socket addrs for clients
-                    // receiving and no client has pressed keys
+                let ping_addrs: Vec<SocketAddr> = {
-                    // -> no need to keep pinging
-                    break;
-                }
-
-                // ping clients
-                for addr in ping_addrs {
-                    if sender_ch.send((Event::Ping(), addr)).await.is_err() {
-                        break;
-                    }
-                }
-
-                // give clients time to resond
-                if receiving {
-                    log::trace!("waiting {MAX_RESPONSE_TIME:?} for response from client with pressed keys ...");
-                } else {
-                    log::trace!(
-                        "state: {:?} => waiting {MAX_RESPONSE_TIME:?} for client to respond ...",
-                        server.state.get()
-                    );
-                }
-
-                tokio::time::sleep(MAX_RESPONSE_TIME).await;
-
-                // when anything is received from a client,
-                // the alive flag gets set
-                let unresponsive_clients: Vec<_> = {
-                    let client_manager = server.client_manager.borrow();
                     ping_clients
                         .iter()
-                        .filter_map(|&h| match client_manager.get(h) {
+                        .flat_map(|&h| client_manager.get(h))
-                            Some((_, s)) if !s.alive => Some(h),
+                        .flat_map(|(c, s)| {
-                            _ => None,
+                            if s.alive && s.active_addr.is_some() {
+                                vec![s.active_addr.unwrap()]
+                            } else {
+                                s.ips
+                                    .iter()
+                                    .cloned()
+                                    .map(|ip| SocketAddr::new(ip, c.port))
+                                    .collect()
+                            }
                         })
                         .collect()
                 };
 
-                // we may not be receiving anymore but we should respond
+                // reset alive
-                // to the original state and not the "new" one
+                for (_, (_, s)) in client_manager.get_client_states_mut() {
-                if receiving {
+                    s.alive = false;
-                    for h in unresponsive_clients {
+                }
-                        log::warn!("device not responding, releasing keys!");
+
-                        let _ = emulate_notify.send(EmulationEvent::ReleaseKeys(h)).await;
+                (ping_clients, ping_addrs)
-                    }
+            };
-                } else {
+
-                    // release pointer if the active client has not responded
+            if receiving && ping_clients.is_empty() {
-                    if !unresponsive_clients.is_empty() {
+                // receiving and no client has pressed keys
-                        log::warn!("client not responding, releasing pointer!");
+                // -> no need to keep pinging
-                        server.state.replace(State::Receiving);
+                break;
-                        let _ = capture_notify.send(CaptureEvent::Release).await;
+            }
-                    }
+
+            // ping clients
+            for addr in ping_addrs {
+                if sender_ch.send((ProtoEvent::Ping, addr)).is_err() {
+                    break;
+                }
+            }
+
+            // give clients time to resond
+            if receiving {
+                log::trace!(
+                    "waiting {MAX_RESPONSE_TIME:?} for response from client with pressed keys ..."
+                );
+            } else {
+                log::trace!(
+                    "state: {:?} => waiting {MAX_RESPONSE_TIME:?} for client to respond ...",
+                    server.state.get()
+                );
+            }
+
+            tokio::time::sleep(MAX_RESPONSE_TIME).await;
+
+            // when anything is received from a client,
+            // the alive flag gets set
+            let unresponsive_clients: Vec<_> = {
+                let client_manager = server.client_manager.borrow();
+                ping_clients
+                    .iter()
+                    .filter_map(|&h| match client_manager.get(h) {
+                        Some((_, s)) if !s.alive => Some(h),
+                        _ => None,
+                    })
+                    .collect()
+            };
+
+            // we may not be receiving anymore but we should respond
+            // to the original state and not the "new" one
+            if receiving {
+                for h in unresponsive_clients {
+                    log::warn!("device not responding, releasing keys!");
+                    let _ = emulate_notify.send(EmulationRequest::ReleaseKeys(h));
+                }
+            } else {
+                // release pointer if the active client has not responded
+                if !unresponsive_clients.is_empty() {
+                    log::warn!("client not responding, releasing pointer!");
+                    server.state.replace(State::Receiving);
+                    let _ = capture_notify.send(CaptureRequest::Release);
                 }
             }
         }
-    });
+    }
-    ping_task
 }

src/server/resolver_task.rs

@@ -1,68 +0,0 @@
-use std::collections::HashSet;
-
-use tokio::{sync::mpsc::Sender, task::JoinHandle};
-
-use crate::{client::ClientHandle, dns::DnsResolver, frontend::FrontendEvent};
-
-use super::Server;
-
-#[derive(Clone)]
-pub struct DnsRequest {
-    pub hostname: String,
-    pub handle: ClientHandle,
-}
-
-pub fn new(
-    resolver: DnsResolver,
-    mut server: Server,
-    mut frontend: Sender<FrontendEvent>,
-) -> (JoinHandle<()>, Sender<DnsRequest>) {
-    let (dns_tx, mut dns_rx) = tokio::sync::mpsc::channel::<DnsRequest>(32);
-    let resolver_task = tokio::task::spawn_local(async move {
-        loop {
-            let (host, handle) = match dns_rx.recv().await {
-                Some(r) => (r.hostname, r.handle),
-                None => break,
-            };
-
-            /* update resolving status */
-            if let Some((_, s)) = server.client_manager.borrow_mut().get_mut(handle) {
-                s.resolving = true;
-            }
-            notify_state_change(&mut frontend, &mut server, handle).await;
-
-            let ips = match resolver.resolve(&host).await {
-                Ok(ips) => ips,
-                Err(e) => {
-                    log::warn!("could not resolve host '{host}': {e}");
-                    vec![]
-                }
-            };
-
-            /* update ips and resolving state */
-            if let Some((c, s)) = server.client_manager.borrow_mut().get_mut(handle) {
-                let mut addrs = HashSet::from_iter(c.fix_ips.iter().cloned());
-                for ip in ips {
-                    addrs.insert(ip);
-                }
-                s.ips = addrs;
-                s.resolving = false;
-            }
-            notify_state_change(&mut frontend, &mut server, handle).await;
-        }
-    });
-    (resolver_task, dns_tx)
-}
-
-async fn notify_state_change(
-    frontend: &mut Sender<FrontendEvent>,
-    server: &mut Server,
-    handle: ClientHandle,
-) {
-    let state = server.client_manager.borrow_mut().get_mut(handle).cloned();
-    if let Some((config, state)) = state {
-        let _ = frontend
-            .send(FrontendEvent::State(handle, config, state))
-            .await;
-    }
-}