mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 08:50:40 +01:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
13a40f9733 | ||
|
|
5f28047a34 | ||
|
|
661263fe37 | ||
|
|
ff2bd9c582 | ||
|
|
0e1e935fb4 | ||
|
|
4649149ff5 | ||
|
|
50a7447b7b | ||
|
|
890c46e280 | ||
|
|
fe052cdca7 | ||
|
|
b84e6e4543 | ||
|
|
bfbbe2f677 | ||
|
|
f437328ad1 | ||
|
|
0308498097 | ||
|
|
d8e3025fb3 | ||
|
|
21e9e690ae | ||
|
|
c489f3056f | ||
|
|
101123797a |
No files matched your search
@@ -127,6 +127,7 @@ viewer does not reconnect them automatically.
|
||||
| `UU_NVENC_RGB=0` / `=1` | NVENC 4:2:0 without scaling takes packed BGRA/BGR0 directly (no CPU swscale). Default: on, except when a connected DRM connector belongs to an nvidia-bound card (desktop composited on the encoding GPU; #16 measured 82.6 vs 98 fps at 4K). `0` forces CPU conversion, `1` forces the direct path |
|
||||
| `UU_TOUCH_INPUT` | Android/iOS controllers (connect header `controller_platform` 2/3) send a finger as a left-button drag at absolute positions. Default on the portal backend (gesture): per press, moving past 12 px within 450 ms scrolls (`NotifyPointerAxis` / EIS scroll, content follows the finger, `finish` on release), holding still selects with button 1 down, a short press clicks; needs no touchscreen consent. `touch`: replay as one finger on the portal touchscreen (`NotifyTouch*` / EIS touch; requested where `AvailableDeviceTypes` offers it; consents saved before touch support restore keyboard+pointer only, so the first mobile drag asks once per run in the background via `PortalSession::upgrade_touch`, swapped in only with the touchscreen granted for the same monitor; the saved consent is never removed first). `0`: plain mouse drags |
|
||||
| `UU_INPUT_BACKEND` | `auto` (uinput on Wayland/portal when `/dev/uinput` is accessible, udev `uaccess` rule in README) / `uinput` / `native`. X11 keeps XTest (held-key autorepeat handling) |
|
||||
| `UU_PORTAL_CURSOR_MODE` | portal capture startup cursor mode: `embedded` draws the compositor pointer into the stream, default hidden. `input::inject_move` reports relative/absolute motion; `portal::note_pointer_motion` flips the mode after a 200 ms run of one kind and rebuilds the session via `Session::set_cursor_embedded`, because the portal only reads `cursor_mode` in `SelectSources`. Relative motion gives the viewer no position to draw its own pointer at, so the stream must carry one; absolute motion means the viewer draws its own and an embedded copy would trail it |
|
||||
| Mac viewer Cmd | With 「使用 macOS 快捷键」 off the Mac viewer sends Cmd=VK_LWIN 0x5B, Option=0xA4, Ctrl=0xA2; connect header `controller_platform`=4 is macOS. For Mac controllers Cmd is held back: Cmd+C/V/A/F/X/Z → Ctrl+key (terminal: Cmd+C/V → Ctrl+Shift+C/V), other combos/alone → Super |
|
||||
| `UU_TERMINAL_SHORTCUTS=0` | disable Ctrl+V → Ctrl+Shift+V in focused X11 terminals (Mac Cmd and Ctrl both arrive as VK_LCONTROL) |
|
||||
| `contrib/virtual-desktop/` | Xvfb + session (`UU_VIRTUAL_SESSION`, `UU_VIRTUAL_BUS=user|private`) for monitorless hosts; serve it with `DISPLAY=:99` |
|
||||
|
||||
Generated
+342
-2
@@ -172,6 +172,29 @@ dependencies = [
|
||||
"syn 1.0.109",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "async-broadcast"
|
||||
version = "0.7.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "435a87a52755b8f27fcf321ac4f04b2802e337c8c4872923137471ec39c37532"
|
||||
dependencies = [
|
||||
"event-listener",
|
||||
"event-listener-strategy",
|
||||
"futures-core",
|
||||
"pin-project-lite",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "async-recursion"
|
||||
version = "1.2.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4f8abc12baad266b1c8cec146854c195b5864b4221d4b2ca7296a7ae82d9e451"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 3.0.9",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "async-trait"
|
||||
version = "0.1.92"
|
||||
@@ -640,6 +663,33 @@ dependencies = [
|
||||
"zeroize",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "endi"
|
||||
version = "1.1.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099"
|
||||
|
||||
[[package]]
|
||||
name = "enumflags2"
|
||||
version = "0.7.12"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1027f7680c853e056ebcec683615fb6fbbc07dbaa13b4d5d9442b146ded4ecef"
|
||||
dependencies = [
|
||||
"enumflags2_derive",
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "enumflags2_derive"
|
||||
version = "0.7.12"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.119",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "env_filter"
|
||||
version = "2.0.0"
|
||||
@@ -663,6 +713,12 @@ dependencies = [
|
||||
"log",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "equivalent"
|
||||
version = "1.0.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "00d174d5400e5e8fd687ad1049e2f578285fa914201b1af7e8b112a4546bd826"
|
||||
|
||||
[[package]]
|
||||
name = "errno"
|
||||
version = "0.3.14"
|
||||
@@ -673,6 +729,32 @@ dependencies = [
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "event-listener"
|
||||
version = "5.4.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5a23add41df1562121a9393cb065eab5146a1242410f23a644851e90cfd669d2"
|
||||
dependencies = [
|
||||
"parking",
|
||||
"pin-project-lite",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "event-listener-strategy"
|
||||
version = "0.5.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
|
||||
dependencies = [
|
||||
"event-listener",
|
||||
"pin-project-lite",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "fastrand"
|
||||
version = "2.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"
|
||||
|
||||
[[package]]
|
||||
name = "fdeflate"
|
||||
version = "0.3.7"
|
||||
@@ -797,6 +879,19 @@ version = "0.3.34"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "53c0fa8157de1303bfffdaa1cc2a673bfffb60102f76b0ef4441659124373fed"
|
||||
|
||||
[[package]]
|
||||
name = "futures-lite"
|
||||
version = "2.6.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"
|
||||
dependencies = [
|
||||
"fastrand",
|
||||
"futures-core",
|
||||
"futures-io",
|
||||
"parking",
|
||||
"pin-project-lite",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "futures-macro"
|
||||
version = "0.3.34"
|
||||
@@ -912,6 +1007,12 @@ dependencies = [
|
||||
"subtle",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "hashbrown"
|
||||
version = "0.17.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
|
||||
|
||||
[[package]]
|
||||
name = "hermit-abi"
|
||||
version = "0.5.3"
|
||||
@@ -1145,6 +1246,16 @@ dependencies = [
|
||||
"icu_properties",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "indexmap"
|
||||
version = "2.14.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"
|
||||
dependencies = [
|
||||
"equivalent",
|
||||
"hashbrown",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "inout"
|
||||
version = "0.1.4"
|
||||
@@ -1326,6 +1437,15 @@ dependencies = [
|
||||
"autocfg",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "memoffset"
|
||||
version = "0.9.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
|
||||
dependencies = [
|
||||
"autocfg",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "minimal-lexical"
|
||||
version = "0.2.1"
|
||||
@@ -1372,7 +1492,7 @@ dependencies = [
|
||||
"bitflags 1.3.2",
|
||||
"cfg-if",
|
||||
"libc",
|
||||
"memoffset",
|
||||
"memoffset 0.7.1",
|
||||
"pin-utils",
|
||||
]
|
||||
|
||||
@@ -1475,6 +1595,16 @@ version = "0.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
|
||||
|
||||
[[package]]
|
||||
name = "ordered-stream"
|
||||
version = "0.2.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9aa2b01e1d916879f73a53d01d1d6cee68adbb31d6d9177a8cfce093cced1d50"
|
||||
dependencies = [
|
||||
"futures-core",
|
||||
"pin-project-lite",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "owned_ttf_parser"
|
||||
version = "0.25.1"
|
||||
@@ -1508,6 +1638,12 @@ dependencies = [
|
||||
"sha2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "parking"
|
||||
version = "2.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
|
||||
|
||||
[[package]]
|
||||
name = "parking_lot"
|
||||
version = "0.12.5"
|
||||
@@ -1663,6 +1799,15 @@ dependencies = [
|
||||
"elliptic-curve",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro-crate"
|
||||
version = "3.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f"
|
||||
dependencies = [
|
||||
"toml_edit",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro2"
|
||||
version = "1.0.107"
|
||||
@@ -2229,6 +2374,17 @@ dependencies = [
|
||||
"zmij",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_repr"
|
||||
version = "0.1.21"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8d3b1629de253c70a0508c3899572da79ca359fdab27c7920ff00406df418906"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 3.0.9",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_urlencoded"
|
||||
version = "0.7.1"
|
||||
@@ -2463,6 +2619,19 @@ dependencies = [
|
||||
"syn 3.0.9",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tempfile"
|
||||
version = "3.27.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
|
||||
dependencies = [
|
||||
"fastrand",
|
||||
"getrandom 0.4.3",
|
||||
"once_cell",
|
||||
"rustix",
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "thiserror"
|
||||
version = "1.0.69"
|
||||
@@ -2563,6 +2732,7 @@ dependencies = [
|
||||
"signal-hook-registry",
|
||||
"socket2 0.6.5",
|
||||
"tokio-macros",
|
||||
"tracing",
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
@@ -2616,6 +2786,36 @@ dependencies = [
|
||||
"tokio",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "toml_datetime"
|
||||
version = "1.1.3+spec-1.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "173f25c883cd2176a2d8212155638c0a60d484a9d84546d270866f40f56b6e49"
|
||||
dependencies = [
|
||||
"serde_core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "toml_edit"
|
||||
version = "0.25.19+spec-1.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "dd43688c4858d7264ae1cf9a9f874a67c3feb74a883b1cd7bebd6a4ea8307218"
|
||||
dependencies = [
|
||||
"indexmap",
|
||||
"toml_datetime",
|
||||
"toml_parser",
|
||||
"winnow",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "toml_parser"
|
||||
version = "1.1.5+spec-1.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "baa693a8032d7e1cada7d0041e96126df243179ff061456783ac7f12bda4744c"
|
||||
dependencies = [
|
||||
"winnow",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tower"
|
||||
version = "0.5.3"
|
||||
@@ -2668,9 +2868,21 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
|
||||
dependencies = [
|
||||
"pin-project-lite",
|
||||
"tracing-attributes",
|
||||
"tracing-core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tracing-attributes"
|
||||
version = "0.1.31"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.119",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tracing-core"
|
||||
version = "0.1.36"
|
||||
@@ -2738,6 +2950,17 @@ version = "1.20.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
|
||||
|
||||
[[package]]
|
||||
name = "uds_windows"
|
||||
version = "1.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f2f6fb2847f6742cd76af783a2a2c49e9375d0a111c7bef6f71cd9e738c72d6e"
|
||||
dependencies = [
|
||||
"memoffset 0.9.1",
|
||||
"tempfile",
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "unicode-ident"
|
||||
version = "1.0.27"
|
||||
@@ -2804,7 +3027,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
|
||||
|
||||
[[package]]
|
||||
name = "uu-remote-linux"
|
||||
version = "0.2.55"
|
||||
version = "0.2.59"
|
||||
dependencies = [
|
||||
"ab_glyph",
|
||||
"async-trait",
|
||||
@@ -2834,6 +3057,7 @@ dependencies = [
|
||||
"tokio-tungstenite",
|
||||
"webrtc",
|
||||
"x11rb",
|
||||
"zbus",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -2844,6 +3068,7 @@ checksum = "7cc1186384beb7dd8eedea376413fd654937285ea6c9cfbb928dc3043ea4b606"
|
||||
dependencies = [
|
||||
"getrandom 0.4.3",
|
||||
"js-sys",
|
||||
"serde_core",
|
||||
"wasm-bindgen",
|
||||
]
|
||||
|
||||
@@ -3291,6 +3516,15 @@ version = "0.52.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
|
||||
|
||||
[[package]]
|
||||
name = "winnow"
|
||||
version = "1.0.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8c3b93199df0ab874cdf0c6a94f0a0dc3423fe41f1cafb62b8bd7b1deb277aef"
|
||||
dependencies = [
|
||||
"memchr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "writeable"
|
||||
version = "0.6.4"
|
||||
@@ -3378,6 +3612,71 @@ dependencies = [
|
||||
"synstructure 0.14.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zbus"
|
||||
version = "5.19.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5db4be7c075cb421e4b7ee645541604239bd243ba7c357511f4ff3a74b555907"
|
||||
dependencies = [
|
||||
"async-broadcast",
|
||||
"async-recursion",
|
||||
"async-trait",
|
||||
"enumflags2",
|
||||
"event-listener",
|
||||
"futures-core",
|
||||
"futures-lite",
|
||||
"hex",
|
||||
"libc",
|
||||
"ordered-stream",
|
||||
"rustix",
|
||||
"serde",
|
||||
"serde_repr",
|
||||
"tokio",
|
||||
"tracing",
|
||||
"uds_windows",
|
||||
"uuid",
|
||||
"windows-sys 0.61.2",
|
||||
"winnow",
|
||||
"zbus_macros",
|
||||
"zbus_names",
|
||||
"zvariant",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zbus_macros"
|
||||
version = "5.19.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2990635d09ade6df1868f72f8cac69a876a90981e8bd3c40b1be413f8dc88f40"
|
||||
dependencies = [
|
||||
"proc-macro-crate",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 3.0.9",
|
||||
"zbus_names",
|
||||
"zvariant",
|
||||
"zvariant_utils",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zbus_names"
|
||||
version = "4.3.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "812a12be4ead7a59e18ea8f047d08add0066b73bc62fc1467066a2472ae088dd"
|
||||
dependencies = [
|
||||
"serde",
|
||||
"winnow",
|
||||
"zvariant",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zcheapstr"
|
||||
version = "1.2.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "939f186d9ecebe044315a5cb6d6f78568bbc21152adc954d5a0c2f58bdbc9920"
|
||||
dependencies = [
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zerocopy"
|
||||
version = "0.8.62"
|
||||
@@ -3483,3 +3782,44 @@ name = "zmij"
|
||||
version = "1.0.23"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
|
||||
|
||||
[[package]]
|
||||
name = "zvariant"
|
||||
version = "5.15.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "80bf6d6cd6a4b601acb64cfb8284cdc643fcfa75ef26ae3c46ec8aa4e8a1fbb7"
|
||||
dependencies = [
|
||||
"endi",
|
||||
"enumflags2",
|
||||
"serde",
|
||||
"winnow",
|
||||
"zcheapstr",
|
||||
"zvariant_derive",
|
||||
"zvariant_utils",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zvariant_derive"
|
||||
version = "5.15.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ef2672456ba1cb54b5eaec136e63135b3c7495fb938e53b28a62e633496d486d"
|
||||
dependencies = [
|
||||
"proc-macro-crate",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 3.0.9",
|
||||
"zvariant_utils",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zvariant_utils"
|
||||
version = "4.2.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "bad0294361a320b694a328460dc73add56c306150f5cb6bfafc44446120008a3"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"serde",
|
||||
"syn 3.0.9",
|
||||
"winnow",
|
||||
]
|
||||
+2
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "uu-remote-linux"
|
||||
version = "0.2.55"
|
||||
version = "0.2.59"
|
||||
edition = "2021"
|
||||
default-run = "uuremote-server"
|
||||
authors = ["uu-remote-linux contributors"]
|
||||
@@ -38,6 +38,7 @@ inproc-av = ["dep:x11rb"]
|
||||
tokio = { version = "1", features = ["full"] }
|
||||
tokio-tungstenite = { version = "0.23", features = ["rustls-tls-webpki-roots"] }
|
||||
futures-util = "0.3"
|
||||
zbus = { version = "5", default-features = false, features = ["tokio"] }
|
||||
serde = { version = "1.0", features = ["derive"] }
|
||||
serde_json = "1.0"
|
||||
reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls", "rustls-tls-native-roots"] }
|
||||
|
||||
+10
-4
@@ -126,7 +126,11 @@ GNOME Portal CONTROL no longer waits for a consent dialog or the first video fra
|
||||
|
||||
The host also accepts a desktop connection while GNOME is locked with no Portal session yet (a cold connection): it reports lock state and accepts auto unlock, then restores picture, input and clipboard after unlock. While Portal is pending, the host sends generated black video once per second on the negotiated track by default, allowing the official iPhone viewer to enter its auto-unlock flow without extra configuration. Verified on Ubuntu GNOME Wayland with the official Mac viewer; iPhone 4.42.0 with H.265 completed a same-executable control experiment: black video ON succeeded, OFF failed, and ON succeeded again ([#29](../../issues/29)). **Limitation**: this is synthetic black video, not the GNOME lock screen, and it does not enable native mouse/keyboard input while locked. Enable 「自动解锁被控端」 in the UU client under 控制中心 → 安全 and enter the password. Without saved Portal permission, local consent is still required after unlock before the real desktop can appear.
|
||||
|
||||
Existing screen-off and lock settings remain unchanged. Only capture recovery in an unlocked session temporarily holds a GNOME idle inhibitor; the first frame, lock, disconnect or initialization failure releases it. An idle viewer still allows the normal screen-off and lock timeout, and manual lock remains effective. Desktop input is blocked and real video is hidden while locked or when lock state is unknown. Independent terminal, file-transfer and port-mapping peers do not wait for video initialization and survive desktop reconnection. Automated protocol and lifecycle regression tests cover this path; auto unlock and capture recovery after a cold locked connection are verified on GNOME hardware with the official Mac and iPhone 4.42.0 viewers, while screen-off and the other scenarios still need acceptance testing. Waking a fully suspended or hibernating machine is outside this CONTROL path.
|
||||
On KDE Plasma (KWin), the Portal screencast stays alive after the session locks. The host now opens capture while locked by default, so a cold connection shows the real lock screen and the password can be entered with the remote keyboard instead of receiving black video ([#227](../../issues/227), [#229](../../pull/229)). Set `UU_LOCKED_CAPTURE=0` to disable this and return to the black-video and auto-unlock path. Detection requires `XDG_CURRENT_DESKTOP` or `XDG_SESSION_DESKTOP` in the systemd user environment. Without either the host falls back to black video, and `UU_LOCKED_CAPTURE=1` forces the new behavior. Portal pointer input remains blocked while locked, and the keyboard uses uinput and can enter the password. This does not apply to GNOME: Mutter closes the Portal session on lock, so the black-video and auto-unlock behavior above is unchanged.
|
||||
|
||||
Existing screen-off and lock settings remain unchanged. Only capture recovery in an unlocked session temporarily holds a GNOME idle inhibitor; the first frame, lock, disconnect or initialization failure releases it. An idle viewer still allows the normal screen-off and lock timeout, and manual lock remains effective. Portal input is blocked while locked. KDE keeps sending the real lock screen, while GNOME hides real video and uses black video. Independent terminal, file-transfer and port-mapping peers do not wait for video initialization and survive desktop reconnection. Automated protocol and lifecycle regression tests cover this path; auto unlock and capture recovery after a cold locked connection are verified on GNOME hardware with the official Mac and iPhone 4.42.0 viewers, while screen-off and the other scenarios still need acceptance testing. Waking a fully suspended or hibernating machine is outside this CONTROL path.
|
||||
|
||||
Lock monitoring reads logind `LockedHint` over the system D-Bus and subscribes to changes instead of spawning `loginctl` every second. Without a graphical session it stays subscribed with unknown state, so login signals trigger a fresh read. It reconciles the session over D-Bus every 30 seconds; if D-Bus fails, it retries with a bounded `loginctl` fallback every 30 seconds, resolving the executable path once. Notifications may be delayed during fallback; unreadable state remains unknown. The locker must still report its state to logind. Suspend, locking and remote connection policies are unchanged.
|
||||
|
||||
Locked black video requires FFmpeg's libx264/libx265 encoder for the negotiated H.264/H.265 codec; hardware encoding support alone does not satisfy this dependency. Encoder failures are logged explicitly. Synthetic video does not change capture permissions or advertised monitor dimensions. It pauses on unlock or unknown lock state, ends when capture is ready/rejected or the connection closes, and then hands the same video track to real capture. See [#29](../../issues/29) and [#34](../../pull/34) for the controlled experiment and validation scope.
|
||||
|
||||
@@ -161,7 +165,7 @@ On niri, `niri msg --json outputs` enumerates enabled monitors. Normal and 90/18
|
||||
| HDR | Not implemented |
|
||||
| Super screen / virtual display | Not implemented |
|
||||
| Privacy screen on the host | Experimental, KDE Plasma Wayland (portal) only; off, picture and screen-off status labels verified with Mac 4.43.0; `UU_PRIVACY_AUTO=picture` / `screen-off` enables it automatically on desktop connect; see [docs/privacy-screen.md](docs/privacy-screen.md) |
|
||||
| Microphone (viewer audio played on the host) | Not implemented (needs a virtual sound card) |
|
||||
| Microphone (viewer audio played on the host) | Experimental: Opus to a virtual input with `UU_MICROPHONE=1`; supports PulseAudio / PipeWire-pulse, see [notes](docs/remote-microphone.md) |
|
||||
| Plugins such as the WoW queue notifier | Not supported; the client is told that no plugins exist |
|
||||
| Linux login screen | The system login screen (before anyone logs in to the Linux desktop) cannot be controlled yet; use headless mode or a virtual desktop (see below). This is about the Linux login: **without a UU account** the host can now be used through remote assistance |
|
||||
| Relay connections on restrictive networks | Uses the ICE servers provided by the UU cloud; complex network setups are not thoroughly tested |
|
||||
@@ -227,6 +231,7 @@ sudo apt install libpulse-dev libopus-dev
|
||||
- `libgtk-3-dev` is optional. Without GTK, login works with a QR code in the terminal (`UU_NO_GTK=1` disables
|
||||
the login window explicitly).
|
||||
- On NVIDIA GPUs use an FFmpeg build with `h264_nvenc`; otherwise the CPU encoder (libx264) is used.
|
||||
- The NVENC API version FFmpeg requires comes from the nv-codec-headers it was built against. For example, Arch's FFmpeg 9 is built against nv-codec-headers 13.1 and needs driver 610 or newer; Pascal (GTX 10 series) tops out at driver 580 with NVENC API 13.0, so the log shows `Driver does not support the required nvenc API version` and encoding falls back to the CPU. Build a separate FFmpeg against nv-codec-headers 13.0 into its own prefix and point `ffmpeg_root` in `config.json` at it (#230).
|
||||
|
||||
### 2. Build
|
||||
|
||||
@@ -394,17 +399,18 @@ Common environment variables:
|
||||
| `UU_X11_OUTPUT` | Initial X11 monitor name (`xrandr --listmonitors`); default: the primary |
|
||||
| `UU_WAYLAND_NO_VIRTUAL_KEYBOARD=1` | Native Wayland skips the virtual keyboard (e.g. Denial reserves it for its input method); keys go through uinput. Without wlr-virtual-pointer the pointer also uses uinput (#72) |
|
||||
| `UU_INPUT_BACKEND` | `auto` (default: uinput on Wayland when accessible) / `uinput` / `native` |
|
||||
| `UU_PORTAL_CURSOR_MODE` | Startup cursor mode: `embedded` draws the compositor pointer into the stream; hidden by default. The host switches at runtime as the viewer sends relative or absolute motion. A switch rebuilds the portal session and interrupts picture and input for a moment |
|
||||
| `UU_TERMINAL_SHORTCUTS=0` | Disable the Ctrl+V paste rewrite in terminal windows |
|
||||
| `UU_VIDEO_ENCODER` | `cpu`: libx264; `vaapi`: opt-in Intel/AMD; `nvenc`: force NVENC; unset or `auto`: a background probe (one synthetic IDR per candidate, 3 s each). With an NVIDIA driver the order is NVENC then CPU; without one the only candidate is CPU and the probe is skipped. A session that starts before the probe finishes uses the previous rule (NVENC if NVIDIA is present, else CPU). On a self-built `--features inproc-av` binary, a process-only failure of NVENC when the in-process engine would try it first on X11 is logged `native_unprobed` and keeps the previous NVENC choice (Wayland, portal, and KMS fall back to CPU). The skipped CPU-only probe is logged `not probed (only candidate)`. A successful probe and that CPU-only skip stay cached while NVIDIA presence matches the report. A later desktop connection whose presence differs starts one background re-probe and still uses the cached encoder until the new result is stored. A hardware-candidate failure (NVENC failed, CPU chosen) is kept for 10 minutes; the next desktop connection after that starts the same re-probe and still uses the cached encoder until the new result is stored. Explicit `cpu` / `vaapi` / `nvenc` does not start the probe. Another failure restarts the 10 minutes. `native_unprobed` is not a temporary failure. A non-`auto` `video_encoder` in `host_settings.json` wins. VAAPI stays out of auto until #33 |
|
||||
| `UU_VAAPI_BUFFER_MS` | VAAPI VBV buffer in ms (10-1000, VAAPI only); raise it when keyframes are squeezed into a blur at high resolution |
|
||||
| `UU_NVENC_BUFFER_MS` | NVENC VBV buffer in ms (10-1000, NVENC only, including the in-process engine); the default is 100-500 kbit, set `1000` when high-resolution keyframes blur and flicker once per GOP (#103) |
|
||||
| `UU_NVENC_BUFFER_MS` | NVENC VBV buffer in ms (10-1000, NVENC only, including the in-process engine); the default matches libx264, one second of the bitrate cap within 500-8000 kbit, so high-resolution keyframes no longer blur and flicker once per GOP (#103). Set a small value (e.g. `50`) for a smaller low-latency buffer on a weak link |
|
||||
| `UU_FFMPEG_ROOT` | Use FFmpeg from this prefix |
|
||||
| `UU_AUDIO=0` | Disable sound; `UU_AUDIO_SOURCE` picks the PulseAudio source |
|
||||
| `UU_REMOTE_ASSIST=0` | Disable remote assistance (no guest assistance before sign-in either) |
|
||||
| `UU_ASSIST_ALLOW=1` | Allow remote assistance at start (overrides the saved switch) |
|
||||
| `UU_LOGIN_WINDOW=0` | Do not open the login window automatically when credentials are missing |
|
||||
| `UU_PORT_MAPPING=0` | Disable port mapping (the official host's controlled-side switch) |
|
||||
| `UU_WOL_HELPER=1` | Experimental: act as a remote-boot helper like the official Windows host — report this host's LAN info after sign-in and send a magic packet to the LAN when the cloud asks to wake a PC (not verified end to end) |
|
||||
| `UU_WOL_HELPER=1` | Experimental: act as a remote-boot helper like the official Windows host — report this host's LAN info after sign-in and send a magic packet to the LAN when the cloud asks to wake a PC (verified end to end with a headless Linux host on a NAS and the official iOS controller) |
|
||||
| `UU_USE_PROXY=1` | Share environment HTTP/HTTPS proxy policy between REST and host/viewer WebSocket signaling; proxies are ignored by default |
|
||||
|
||||
|
||||
|
||||
@@ -112,7 +112,11 @@ GNOME Portal 的控制通道不再等待授权窗口或第一帧画面:先通
|
||||
|
||||
桌面锁屏且尚未建立 Portal 时(冷连接),主机也会建立控制通道:上报锁屏状态并接受自动解锁,解锁后再恢复画面、键鼠和剪贴板。Portal 等待就绪期间,主机默认通过已协商的视频轨每秒发送一帧生成的纯黑画面,让官方 iPhone 客户端进入自动解锁流程,无需额外配置。Ubuntu GNOME Wayland 上已用官方 Mac 客户端验证;iPhone 4.42.0 的 H.265 冷连接完成了同一实验二进制「开启黑帧成功 → 关闭失败 → 再开成功」对照([#29](../../issues/29))。**局限**:黑帧不是真实 GNOME 锁屏画面,也不支持在锁屏界面操作原生键鼠;需要在 UU 客户端 控制中心 → 安全 → 自动解锁被控端 中启用自动解锁并输入密码。若本机没有已保存的 Portal 授权,解锁后仍需本机确认授权才能显示真实桌面。
|
||||
|
||||
无需修改现有熄屏和锁屏设置。主机仅在会话已解锁的采集恢复期间临时申请 GNOME 的 idle 抑制,拿到首帧后立即释放;锁屏、断开或初始化失败也会释放。远控窗口空闲时仍按原策略熄屏和锁屏,手动锁屏也继续生效。锁屏及锁状态未知时停止桌面输入并隐藏真实画面;独立终端、文件传输和端口映射连接不依赖画面初始化,也不会因桌面重连被关闭。这一恢复路径已覆盖自动化协议与生命周期回归测试,锁屏冷连接后的自动解锁与采集恢复已用官方 Mac 和 iPhone 4.42.0 客户端在 GNOME 实机验证,熄屏等其余场景仍待验收;不支持从整机挂起或休眠状态通过现有控制通道唤醒。
|
||||
KDE Plasma(KWin)的 Portal 采集在锁屏后仍会继续。主机默认在锁屏时也打开采集,冷连接可以直接看到真实锁屏界面,并用远程键盘输入密码,不再只发黑帧([#227](../../issues/227)、[#229](../../pull/229))。`UU_LOCKED_CAPTURE=0` 关闭这一行为,回到黑帧和自动解锁的路径。KDE 判断依赖 systemd 用户环境里的 `XDG_CURRENT_DESKTOP` 或 `XDG_SESSION_DESKTOP`,两者都没有时回落到黑帧行为,可以手动设 `UU_LOCKED_CAPTURE=1` 开启。锁屏时 Portal 指针输入仍会被拦截,键盘通过 uinput 注入,可以输入密码。GNOME 不适用这一段,Mutter 在锁屏时关闭 Portal 会话,仍走上面的黑帧和自动解锁。
|
||||
|
||||
无需修改现有熄屏和锁屏设置。主机仅在会话已解锁的采集恢复期间临时申请 GNOME 的 idle 抑制,拿到首帧后立即释放;锁屏、断开或初始化失败也会释放。远控窗口空闲时仍按原策略熄屏和锁屏,手动锁屏也继续生效。锁屏时停止 Portal 输入。KDE 下继续传输真实锁屏画面,GNOME 下隐藏真实画面并发黑帧。独立终端、文件传输和端口映射连接不依赖画面初始化,也不会因桌面重连被关闭。这一恢复路径已覆盖自动化协议与生命周期回归测试,锁屏冷连接后的自动解锁与采集恢复已用官方 Mac 和 iPhone 4.42.0 客户端在 GNOME 实机验证,熄屏等其余场景仍待验收;不支持从整机挂起或休眠状态通过现有控制通道唤醒。
|
||||
|
||||
锁屏状态优先通过系统 D-Bus 读取 logind 的 `LockedHint` 并监听变化,正常监测不按秒启动 `loginctl`。尚无图形会话时保持未知并继续监听,登录后由信号触发重新读取。每 30 秒通过 D-Bus 校验会话;D-Bus 异常时每 30 秒重试并使用带超时的 `loginctl` 回退查询,命令路径只解析一次。回退期间状态通知可能延迟;无法读取时保持未知。锁屏程序仍需正确上报 logind 状态,这不改变睡眠、锁屏或远程连接策略。
|
||||
|
||||
锁屏黑帧使用 FFmpeg 的 libx264/libx265 编码器(按已协商的 H.264/H.265 选择),硬件编码器可用并不代表这些软件编码器已安装。编码失败会明确记录日志。黑帧不改变采集权限或上报的真实屏幕尺寸;解锁或锁状态未知时暂停,采集就绪、拒绝或连接关闭时结束,再由真实视频接续同一条视频轨。对照实验与验证范围见 [#29](../../issues/29)、[#34](../../pull/34)。
|
||||
|
||||
@@ -142,7 +146,7 @@ niri 会话通过 `niri msg --json outputs` 枚举已启用的显示器。普通
|
||||
| HDR | 未实现 |
|
||||
| 超级屏 / 虚拟显示器 | 未实现 |
|
||||
| 被控端防窥模式 | 实验性,仅 KDE Plasma Wayland(portal);Mac 4.43.0 已验证不启用、隐私屏保、关闭显示屏三种状态回显;`UU_PRIVACY_AUTO=picture` / `screen-off` 可在桌面连接时自动开启,见 [docs/privacy-screen.md](docs/privacy-screen.md) |
|
||||
| 麦克风(控制端声音传到被控端) | 未实现(需要虚拟声卡) |
|
||||
| 麦克风(控制端声音传到被控端) | 实验性:Opus → 虚拟麦克风,需 `UU_MICROPHONE=1`;支持 PulseAudio / PipeWire-pulse,见 [说明](docs/remote-microphone.md) |
|
||||
| 魔兽世界排队提醒等插件 | 不支持,会明确告诉客户端「无插件」 |
|
||||
| Linux 系统登录界面 | 还不支持控制开机后的系统登录界面(还没有人登录 Linux 桌面时);这种情况可以用无头模式或虚拟桌面(见下文)。注意:这里说的是 Linux 系统登录,**不登录 UU 账号**现在可以通过「远程协助」使用 |
|
||||
| 跨运营商 / 受限网络的中继连接 | 已接入官方下发的 ICE 服务器,但复杂网络环境未充分测试 |
|
||||
@@ -205,6 +209,7 @@ sudo apt install libpulse-dev libopus-dev
|
||||
- 需要 Rust 工具链(<https://rustup.rs>)。
|
||||
- `libgtk-3-dev` 是可选的:没有 GTK 时只能在终端里扫码登录(也可以设置 `UU_NO_GTK=1` 主动关闭登录窗口)。
|
||||
- NVIDIA 显卡用户需要使用带 `h264_nvenc` 的 FFmpeg,否则自动回落到 CPU 编码(libx264)。
|
||||
- FFmpeg 要求的 NVENC API 版本由编译时的 nv-codec-headers 决定。例如 Arch 的 FFmpeg 9 对着 nv-codec-headers 13.1 编译,需要 610 及以上驱动;Pascal(GTX 10 系)驱动最高 580,只有 NVENC API 13.0,日志会出现 `Driver does not support the required nvenc API version`,于是回落 CPU。可对着 nv-codec-headers 13.0 另编一份 FFmpeg 装到独立目录,在 `config.json` 里用 `ffmpeg_root` 指向它(#230)。
|
||||
|
||||
### 2. 编译
|
||||
|
||||
@@ -357,17 +362,18 @@ systemctl --user restart uuremote-native.service
|
||||
| `UU_X11_OUTPUT` | X11 默认采集的显示器名称(`xrandr --listmonitors`),默认主显示器 |
|
||||
| `UU_WAYLAND_NO_VIRTUAL_KEYBOARD=1` | 原生 Wayland 不创建虚拟键盘(如 Denial 只把它给自己的输入法),键盘改走 uinput。合成器没有 wlr-virtual-pointer 时鼠标也自动改走 uinput(#72) |
|
||||
| `UU_INPUT_BACKEND` | `auto`(默认,Wayland 下可用时用 uinput)/ `uinput` / `native` |
|
||||
| `UU_PORTAL_CURSOR_MODE` | 启动时的光标模式:`embedded` 让合成器把指针画进抓屏流,默认隐藏。运行中按客户端发来的相对/绝对位移自动切换;每次切换重建一次 portal 会话,画面和输入短暂中断 |
|
||||
| `UU_TERMINAL_SHORTCUTS=0` | 关闭终端窗口里的 Ctrl+V 粘贴转换 |
|
||||
| `UU_VIDEO_ENCODER` | `cpu` 强制 CPU;`vaapi` 显式启用 Intel/AMD 硬编;`nvenc` 强制 NVENC;未设置或 `auto` 时后台探测(每个候选编码一帧,限时 3 秒)。有 NVIDIA 驱动时顺序是 NVENC → CPU;没有 NVIDIA 时只有 CPU,不探测。探测未完成就建流则沿用旧规则(有 NVIDIA 用 NVENC,否则 CPU)。自行编译的 `--features inproc-av` 上,仅 X11 会先走进程内引擎:外部 FFmpeg 探测失败时记为 `native_unprobed`,沿用旧规则(NVENC);Wayland、portal、KMS 回退 CPU。只有 CPU 时跳过探测,记为 `not probed (only candidate)`。探测成功和这种只含 CPU 的跳过会缓存到 NVIDIA 是否存在发生变化为止(`/proc/driver/nvidia/version` 或 `/dev/nvidia0`)。之后的桌面连接在后台再探测一次(不挡住这一路,仍用缓存的编码器)。NVENC 探测失败、选用 CPU 时只缓存 10 分钟;到期后下一次桌面连接同样在后台再探测一次,再次失败则重新计 10 分钟。显式 `cpu` / `vaapi` / `nvenc` 不启动探测。`native_unprobed` 不算失败缓存。优先级低于 `host_settings.json` 里非 `auto` 的 `video_encoder`。VAAPI 要等 #33 解决后才会进入 auto |
|
||||
| `UU_VAAPI_BUFFER_MS` | VAAPI 的 VBV 缓冲(10–1000 ms,仅 `UU_VIDEO_ENCODER=vaapi` 时生效);高分辨率下关键帧被压糊时用它换稳定画质 |
|
||||
| `UU_NVENC_BUFFER_MS` | NVENC 的 VBV 缓冲(10–1000 ms,仅 NVENC 生效,含进程内引擎);默认 100–500 kbit,1440p 等高分辨率下关键帧被压糊、按 GOP 周期闪烁时设 `1000`(#103) |
|
||||
| `UU_NVENC_BUFFER_MS` | NVENC 的 VBV 缓冲(10–1000 ms,仅 NVENC 生效,含进程内引擎);默认与 libx264 相同,取 1 秒码率上限并限制在 500–8000 kbit,高分辨率关键帧不再被压糊、按 GOP 周期闪烁(#103)。弱网下想要更小的低延迟缓冲可设小值(如 `50`) |
|
||||
| `UU_FFMPEG_ROOT` | 使用指定目录下的 FFmpeg |
|
||||
| `UU_AUDIO=0` | 关闭声音转发;`UU_AUDIO_SOURCE` 指定 PulseAudio 采集源 |
|
||||
| `UU_LOGIN_WINDOW=0` | 凭证缺失时不自动弹出登录窗口 |
|
||||
| `UU_REMOTE_ASSIST=0` | 关闭远程协助(未登录时也不再以访客身份提供协助) |
|
||||
| `UU_ASSIST_ALLOW=1` | 启动时就允许他人远程协助(覆盖窗口里保存的开关状态) |
|
||||
| `UU_PORT_MAPPING=0` | 关闭端口映射(对应官方被控端的开关) |
|
||||
| `UU_WOL_HELPER=1` | 实验性:让这台主机像官方 Windows 被控端一样充当「远程开机」辅助设备——登录后向网易上报本机局域网信息,收到云端唤醒请求时向同一局域网发送唤醒包(未经端到端验证) |
|
||||
| `UU_WOL_HELPER=1` | 实验性:让这台主机像官方 Windows 被控端一样充当「远程开机」辅助设备——登录后向网易上报本机局域网信息,收到云端唤醒请求时向同一局域网发送唤醒包(已在 NAS 上的无头 Linux 主机配合官方 iOS 控制端实测可远程开机) |
|
||||
| `UU_USE_PROXY=1` | REST API 与 host/viewer WebSocket 信令共用环境 HTTP/HTTPS 代理策略;默认忽略代理、直连 |
|
||||
|
||||
|
||||
|
||||
@@ -173,6 +173,11 @@ fn shared_engine(name: &str, sources: &[&str], includes: &[&std::path::Path], cf
|
||||
command.args(cflags.split_whitespace()).args(sources).args(libs.split_whitespace()).arg("-lpthread");
|
||||
let status = command.status().expect("C compiler for the engine plugin");
|
||||
assert!(status.success(), "building {name} failed");
|
||||
// OUT_DIR = target/<profile>/build/<package>-<hash>/out
|
||||
if let Some(profile) = out.ancestors().nth(3) { std::fs::copy(&library, profile.join(name)).expect("copy engine plugin"); }
|
||||
// OUT_DIR = target/<profile>/build/<package>-<hash>/out, or target/<profile>/build/<package>/<hash>/out with
|
||||
// the newer Cargo build-dir layout (Rust 1.100 CI): the profile dir is the parent of the `build` component.
|
||||
let profile = out.ancestors().find(|dir| dir.file_name().is_some_and(|n| n == "build")).and_then(|dir| dir.parent());
|
||||
match profile {
|
||||
Some(profile) => { std::fs::copy(&library, profile.join(name)).expect("copy engine plugin"); }
|
||||
None => println!("cargo:warning={name} built in {} but no target/<profile> dir found to copy it to", out.display()),
|
||||
}
|
||||
}
|
||||
@@ -67,6 +67,7 @@ static void selection_owner(GDBusConnection *bus,const gchar *sender,const gchar
|
||||
pthread_mutex_lock(&p->lock);
|
||||
g_free(p->clipboard_mime); p->clipboard_mime=selected;
|
||||
p->clipboard_changed=!owner && selected!=NULL; p->clipboard_revision++;
|
||||
p->clipboard_owns=owner?1:0;
|
||||
pthread_mutex_unlock(&p->lock);
|
||||
if (types) g_variant_unref(types);
|
||||
}
|
||||
@@ -100,16 +101,46 @@ int uu_portal_clipboard_set(struct uu_portal *p,const uint8_t *text,size_t lengt
|
||||
if (!uu_portal_clipboard_ready(p) || length>CLIP_LIMIT || !g_utf8_validate((const char *)text,(gssize)length,NULL)) return -1;
|
||||
char *copy=g_malloc(length+1); memcpy(copy,text,length); copy[length]=0;
|
||||
pthread_mutex_lock(&p->lock);
|
||||
g_free(p->clipboard_text); p->clipboard_text=copy; p->clipboard_length=length;
|
||||
p->clipboard_changed=0;
|
||||
/* Serve the new text while the portal announces it, and restore the old one on failure. */
|
||||
char *old_text=p->clipboard_text; size_t old_length=p->clipboard_length;
|
||||
uint64_t revision=p->clipboard_revision;
|
||||
p->clipboard_text=copy; p->clipboard_length=length; p->clipboard_changed=0;
|
||||
pthread_mutex_unlock(&p->lock);
|
||||
const char *types[]={"text/plain;charset=utf-8","text/plain",NULL};
|
||||
GVariantBuilder options; g_variant_builder_init(&options,G_VARIANT_TYPE_VARDICT);
|
||||
g_variant_builder_add(&options,"{sv}","mime_types",g_variant_new_strv(types,-1));
|
||||
GVariant *reply=g_dbus_connection_call_sync(p->bus,DEST,PATH,CLIPBOARD,"SetSelection",
|
||||
g_variant_new("(o@a{sv})",p->session,g_variant_builder_end(&options)),NULL,G_DBUS_CALL_FLAGS_NONE,2000,NULL,NULL);
|
||||
if (!reply) return -1;
|
||||
g_variant_unref(reply); return 0;
|
||||
if (!reply) {
|
||||
pthread_mutex_lock(&p->lock);
|
||||
g_free(p->clipboard_text);
|
||||
p->clipboard_text=old_text; p->clipboard_length=old_length;
|
||||
pthread_mutex_unlock(&p->lock);
|
||||
return -1;
|
||||
}
|
||||
g_variant_unref(reply);
|
||||
g_free(old_text);
|
||||
pthread_mutex_lock(&p->lock);
|
||||
/* Another owner may have been reported meanwhile; its newer state must win. */
|
||||
if (p->clipboard_revision==revision) p->clipboard_owns=1;
|
||||
pthread_mutex_unlock(&p->lock);
|
||||
return 0;
|
||||
}
|
||||
/* Hand the text this session is providing to a replacement session, so a session swap (cursor
|
||||
* mode, privacy screen, monitor switch) does not drop the viewer's clipboard. Transfers only
|
||||
* while this session still owns the selection. Returns 0 transferred, 1 nothing to transfer. */
|
||||
int uu_portal_clipboard_copy(struct uu_portal *from, struct uu_portal *to) {
|
||||
if (!from || !to) return -1;
|
||||
/* A session that ended cannot know whether a newer owner took the selection since. */
|
||||
if (!uu_portal_alive(from)) return 1;
|
||||
pthread_mutex_lock(&from->lock);
|
||||
char *copy=(from->clipboard_owns && from->clipboard_text)?g_memdup2(from->clipboard_text,from->clipboard_length+1):NULL;
|
||||
size_t length=from->clipboard_length;
|
||||
pthread_mutex_unlock(&from->lock);
|
||||
if (!copy) return 1;
|
||||
int result=uu_portal_clipboard_set(to,(const uint8_t *)copy,length);
|
||||
g_free(copy);
|
||||
return result==0?0:-1;
|
||||
}
|
||||
int uu_portal_clipboard_poll(struct uu_portal *p,uint8_t *out,size_t capacity) {
|
||||
if (!out || !uu_portal_clipboard_ready(p) || capacity<CLIP_LIMIT) return -1;
|
||||
|
||||
@@ -38,7 +38,8 @@ struct uu_portal {
|
||||
char *session;
|
||||
char *restore_token;
|
||||
guint closed_subscription, clipboard_owner_subscription, clipboard_transfer_subscription, display_subscription;
|
||||
int clipboard_enabled, clipboard_changed;
|
||||
int clipboard_enabled, clipboard_changed, clipboard_owns;
|
||||
int cursor_available, cursor_applied;
|
||||
char *clipboard_text, *clipboard_mime;
|
||||
size_t clipboard_length;
|
||||
uint64_t clipboard_revision;
|
||||
@@ -82,6 +83,13 @@ struct uu_portal {
|
||||
|
||||
static pthread_once_t pw_once = PTHREAD_ONCE_INIT;
|
||||
static atomic_uint token_sequence = 1;
|
||||
/* Cursor preference for sessions opened from now on; -1 defers to UU_PORTAL_CURSOR_MODE. */
|
||||
static atomic_int cursor_mode_override = -1;
|
||||
void uu_portal_set_cursor_mode(int mode) { atomic_store(&cursor_mode_override, mode); }
|
||||
/* Cursor mode the last session actually requested: 1 hidden, 2 embedded, 0 when unavailable. */
|
||||
int uu_portal_cursor_mode(struct uu_portal *p) { return p ? p->cursor_applied : 0; }
|
||||
/* Cursor modes the backend advertised for the last session; 0 when the property was unreadable. */
|
||||
int uu_portal_cursor_modes(struct uu_portal *p) { return p ? p->cursor_available : 0; }
|
||||
static void initialize_pipewire(void) { pw_init(NULL, NULL); }
|
||||
static GVariant *empty_options(void) { return g_variant_new_array(G_VARIANT_TYPE("{sv}"), NULL, 0); }
|
||||
static int open_cancelled(struct uu_portal *p) {
|
||||
@@ -89,10 +97,10 @@ static int open_cancelled(struct uu_portal *p) {
|
||||
}
|
||||
static int wait_for_first_frame(struct uu_portal *p);
|
||||
#include "portal_eis.inc"
|
||||
/* A uint32 RemoteDesktop property (version, AvailableDeviceTypes); 0 when unreadable. */
|
||||
static guint remote_property(struct uu_portal *p, const char *name) {
|
||||
/* A uint32 portal property; 0 when unreadable. */
|
||||
static guint interface_property(struct uu_portal *p, const char *interface, const char *name) {
|
||||
GVariant *reply = g_dbus_connection_call_sync(p->bus, DEST, PATH,
|
||||
"org.freedesktop.DBus.Properties", "Get", g_variant_new("(ss)", REMOTE, name),
|
||||
"org.freedesktop.DBus.Properties", "Get", g_variant_new("(ss)", interface, name),
|
||||
G_VARIANT_TYPE("(v)"), G_DBUS_CALL_FLAGS_NONE, 3000, NULL, NULL);
|
||||
guint result = 0;
|
||||
if (reply) {
|
||||
@@ -102,6 +110,10 @@ static guint remote_property(struct uu_portal *p, const char *name) {
|
||||
}
|
||||
return result;
|
||||
}
|
||||
/* A uint32 RemoteDesktop property (version, AvailableDeviceTypes). */
|
||||
static guint remote_property(struct uu_portal *p, const char *name) {
|
||||
return interface_property(p, REMOTE, name);
|
||||
}
|
||||
static void fail(struct uu_portal *p, int error) {
|
||||
pthread_mutex_lock(&p->lock);
|
||||
if (!p->error) p->error = error;
|
||||
@@ -179,6 +191,8 @@ static void session_closed(GDBusConnection *bus, const gchar *sender, const gcha
|
||||
const gchar *interface, const gchar *signal, GVariant *parameters, gpointer data) {
|
||||
(void)bus; (void)sender; (void)path; (void)interface; (void)signal; (void)parameters;
|
||||
struct uu_portal *p = data;
|
||||
/* A closed session no longer tracks owner changes, so its cached claim is stale. */
|
||||
pthread_mutex_lock(&p->lock); p->clipboard_owns=0; pthread_mutex_unlock(&p->lock);
|
||||
atomic_store(&p->closed, 1); fail(p, 9);
|
||||
}
|
||||
static void *run_dbus(void *data) {
|
||||
@@ -658,7 +672,23 @@ static struct uu_portal *open_persist(const char *restore, void (*save_token)(co
|
||||
/* 1 monitor; 4 virtual (KDE creates a KWin virtual output for the stream). */
|
||||
g_variant_builder_add(&options, "{sv}", "types", g_variant_new_uint32(source_types));
|
||||
g_variant_builder_add(&options, "{sv}", "multiple", g_variant_new_boolean(FALSE));
|
||||
/* Hidden cursor avoids duplicate pointer; supported since ScreenCast v1. */
|
||||
/* Hidden cursor avoids a duplicate pointer in absolute mode: the viewer draws its own where
|
||||
* it last sent motion. Relative mode has no such position, so the game's cursor has to come
|
||||
* from the compositor. The host flips this at runtime through uu_portal_set_cursor_mode();
|
||||
* UU_PORTAL_CURSOR_MODE=embedded is the startup default. Only sent when the backend
|
||||
* advertises embedded, since an unsupported value closes the session. */
|
||||
int cursor_mode = atomic_load(&cursor_mode_override);
|
||||
if (cursor_mode < 0) {
|
||||
const char *wanted = g_getenv("UU_PORTAL_CURSOR_MODE");
|
||||
cursor_mode = (wanted && !g_ascii_strcasecmp(wanted, "embedded")) ? 2 : 1;
|
||||
}
|
||||
/* The host reads these back so its belief matches what the session actually requested. */
|
||||
p->cursor_available = (int)interface_property(p, SCREEN, "AvailableCursorModes");
|
||||
p->cursor_applied = 1;
|
||||
if (cursor_mode == 2 && (p->cursor_available & 2)) {
|
||||
g_variant_builder_add(&options, "{sv}", "cursor_mode", g_variant_new_uint32(2));
|
||||
p->cursor_applied = 2;
|
||||
}
|
||||
results = request(p, SCREEN, "SelectSources", &options, 1, error);
|
||||
if (!results) goto done;
|
||||
g_variant_unref(results);
|
||||
@@ -1032,6 +1062,8 @@ int uu_portal_monitors(char *out, size_t length) {
|
||||
* captures then report a closed stream until the handle is replaced. */
|
||||
void uu_portal_end(struct uu_portal *p) {
|
||||
if (!p || atomic_exchange(&p->closed, 1)) return;
|
||||
/* A closed session no longer tracks owner changes, so its cached claim is stale. */
|
||||
pthread_mutex_lock(&p->lock); p->clipboard_owns=0; pthread_mutex_unlock(&p->lock);
|
||||
if (p->bus && p->session) {
|
||||
GVariant *reply = g_dbus_connection_call_sync(p->bus, DEST, p->session, SESSION, "Close",
|
||||
NULL, NULL, G_DBUS_CALL_FLAGS_NONE, 3000, NULL, NULL);
|
||||
|
||||
@@ -18,10 +18,19 @@ struct uu_portal *uu_portal_open_persist_cancellable(const char *restore, void (
|
||||
/* Select the capture transport before connecting, including on same-process recovery. */
|
||||
struct uu_portal *uu_portal_open_persist_capture(const char *restore, void (*save_token)(const char *, void *), void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data, int prefer_dmabuf, int *error, uint32_t *width, uint32_t *height);
|
||||
struct uu_portal *uu_portal_open_restore(const char *restore, int *error, uint32_t *width, uint32_t *height);
|
||||
/* Cursor mode for subsequent sessions: 1 hidden, 2 embedded (the compositor draws the pointer
|
||||
* into the stream). -1 restores the UU_PORTAL_CURSOR_MODE default. The host switches this at
|
||||
* runtime because the viewer cannot draw a pointer of its own during relative motion. */
|
||||
void uu_portal_set_cursor_mode(int mode);
|
||||
/* What the last session requested and what the backend offered, for host bookkeeping. */
|
||||
int uu_portal_cursor_mode(struct uu_portal *portal);
|
||||
int uu_portal_cursor_modes(struct uu_portal *portal);
|
||||
const char *uu_portal_restore_token(struct uu_portal *portal);
|
||||
void uu_portal_close(struct uu_portal *portal);
|
||||
int uu_portal_clipboard_ready(struct uu_portal *portal);
|
||||
int uu_portal_clipboard_set(struct uu_portal *portal, const uint8_t *text, size_t length);
|
||||
/* Offers the text `from` still owns to `to`; 0 transferred, 1 nothing to transfer. */
|
||||
int uu_portal_clipboard_copy(struct uu_portal *from, struct uu_portal *to);
|
||||
int uu_portal_clipboard_poll(struct uu_portal *portal, uint8_t *text, size_t capacity);
|
||||
int uu_portal_alive(struct uu_portal *portal);
|
||||
int uu_portal_capture_alive(struct uu_portal *portal);
|
||||
|
||||
Executable
+90
@@ -0,0 +1,90 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Run the opt-in microphone sink-loss regression on a private PulseAudio daemon.
|
||||
|
||||
No hardware modules or default configuration are loaded. The Rust test generates
|
||||
audio in memory and observes only its own null sinks. Requires pactl and parec.
|
||||
在独立 PulseAudio 服务中运行麦克风回归;仅使用空设备及内存生成音,需要 pactl、parec。
|
||||
"""
|
||||
import argparse
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import time
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("--daemon", default=shutil.which("pulseaudio"), help="PulseAudio 可执行文件 / PulseAudio executable")
|
||||
parser.add_argument("--module-dir", help="解压包的模块目录 / module directory for an unpacked package")
|
||||
parser.add_argument("--test-binary", help="已有 Cargo 测试程序;默认构建 / existing Cargo test executable; otherwise build")
|
||||
parser.add_argument("--smoke", action="store_true", help="验证生成音传输 / check generated audio delivery instead of target loss")
|
||||
args = parser.parse_args()
|
||||
if not args.daemon:
|
||||
parser.error("请用 --daemon 指定 PulseAudio,无需系统服务 / provide --daemon; no system service is needed")
|
||||
repo = Path(__file__).resolve().parent.parent
|
||||
with tempfile.TemporaryDirectory(prefix="uu-microphone-test-") as temp:
|
||||
private = Path(temp)
|
||||
for name in ["runtime", "state", "config", "cache"]:
|
||||
(private / name).mkdir(mode=0o700)
|
||||
cookie = private / "cookie"
|
||||
cookie.write_bytes(os.urandom(256))
|
||||
socket = private / "runtime/native"
|
||||
env = os.environ.copy()
|
||||
env.update(
|
||||
XDG_RUNTIME_DIR=str(private / "runtime"), XDG_CONFIG_HOME=str(private / "config"),
|
||||
XDG_STATE_HOME=str(private / "state"), XDG_CACHE_HOME=str(private / "cache"),
|
||||
PULSE_RUNTIME_PATH=str(private / "runtime"), PULSE_STATE_PATH=str(private / "state"),
|
||||
PULSE_COOKIE=str(cookie), PULSE_SERVER="unix:" + str(socket), UU_MICROPHONE_ISOLATED_TEST="1",
|
||||
UU_MICROPHONE="1",
|
||||
)
|
||||
command = [args.daemon, "-n", "--daemonize=no", "--use-pid-file=no", "--exit-idle-time=-1",
|
||||
"--disable-shm=yes", "--realtime=no", "--high-priority=no",
|
||||
"--load=module-native-protocol-unix socket=" + str(socket)
|
||||
+ " auth-anonymous=1 auth-cookie=" + str(cookie)]
|
||||
if args.module_dir:
|
||||
command.append("--dl-search-path=" + args.module_dir)
|
||||
with (private / "daemon.log").open("w") as log:
|
||||
daemon = subprocess.Popen(command, env=env, stdout=log, stderr=log)
|
||||
try:
|
||||
for _ in range(100):
|
||||
if daemon.poll() is not None:
|
||||
raise RuntimeError("独立服务启动失败 / isolated server failed:\n" + (private / "daemon.log").read_text()[-2000:])
|
||||
if socket.exists() and subprocess.run(
|
||||
["pactl", "--server=" + env["PULSE_SERVER"], "info"], env=env,
|
||||
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
|
||||
).returncode == 0:
|
||||
break
|
||||
time.sleep(0.03)
|
||||
else:
|
||||
raise RuntimeError("独立 PulseAudio 未就绪 / isolated PulseAudio did not become ready")
|
||||
test = "microphone::tests::pulse_target_loss_never_routes_to_default_output"
|
||||
if args.smoke:
|
||||
test = "microphone::tests::pipewire_virtual_microphone_receives_generated_tone"
|
||||
if args.test_binary:
|
||||
command = [str(Path(args.test_binary).resolve()), test, "--ignored", "--exact"]
|
||||
else:
|
||||
command = ["cargo", "test", "--locked", "--bin", "uuremote-server", test,
|
||||
"--", "--ignored", "--exact"]
|
||||
listing = subprocess.run(command + ["--list", "--color=never"], cwd=repo, env=env,
|
||||
capture_output=True, text=True)
|
||||
if listing.returncode:
|
||||
print(listing.stderr, file=sys.stderr)
|
||||
return listing.returncode
|
||||
if f"{test}: test" not in listing.stdout.splitlines():
|
||||
parser.error("目标测试不存在,拒绝零项成功 / requested test is absent; refusing a zero-test success")
|
||||
return subprocess.run(command, cwd=repo, env=env).returncode
|
||||
finally:
|
||||
if daemon.poll() is None:
|
||||
daemon.terminate()
|
||||
try:
|
||||
daemon.wait(timeout=3)
|
||||
except subprocess.TimeoutExpired:
|
||||
daemon.kill()
|
||||
daemon.wait()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -30,6 +30,13 @@ is aimed at the virtual output's region. Needs GTK3.
|
||||
`portal-permissions/kde-virtual`)。窗口会被 KWin 移到虚拟屏,恢复后位置可能变化。
|
||||
The virtual size is KDE's (1920x1080 by default; the first share may ask on the host, later ones
|
||||
reuse `portal-permissions/kde-virtual`). KWin moves windows to it; positions may change on restore.
|
||||
- 壁纸模式下新出现的窗口也会被送到虚拟输出:KWin 按它认为"当前活动"的屏幕放置新窗口,而那块
|
||||
屏幕可能是遮罩下的物理屏,远端就看不到。主机在防窥期间保持加载一个 KWin 脚本,新窗口和换了
|
||||
屏幕的窗口都会被送回虚拟输出,恢复时卸载。
|
||||
In wallpaper mode, windows that appear later are also sent to the virtual output: KWin places a
|
||||
new window on the screen it considers active, which may be one under the cover, where the viewer
|
||||
cannot see it. The host keeps a KWin script loaded for the privacy session that sends new windows
|
||||
and windows that changed screen back to the virtual output, and unloads it on restore.
|
||||
- KDE 不处理虚拟输出共享上的 portal 输入,防窥期间指针、按键和文字改走 uinput(需要 `/dev/uinput`
|
||||
权限,见 README);手机拖动手势在此期间按普通鼠标拖动处理。
|
||||
KDE ignores portal input on a virtual-output share, so pointer, keys and text use uinput while the
|
||||
@@ -81,6 +88,8 @@ is aimed at the virtual output's region. Needs GTK3.
|
||||
Success does not send ReportError; -9 in Mac 4.43.0 reports a system session change, not privacy success.
|
||||
- iOS 控制端选“关闭显示器”发 `enable=0, privacy_type=3`:iOS 的 `enable` 是图片模式开关,关屏意图由 `type=3` 表达;iOS“不启用”发 `enable=0, privacy_type=1`。主机只对 iOS 控制端把 `0/3` 归一化为开屏保关屏(日志 `iOS screen-off encoding normalized`),其他控制端(包括已验收的 Android 4.43.0)保持字段 1 的语义。
|
||||
The iOS viewer sends `enable=0, privacy_type=3` for "turn off the display": its `enable` is the picture-mode switch and `type=3` carries the intent; iOS "off" is `enable=0, privacy_type=1`. The host normalizes `0/3` to screen-off for iOS controllers only (log: `iOS screen-off encoding normalized`); other controllers, including the verified Android 4.43.0, keep the field-1 semantics.
|
||||
- Windows 控制端每个 RPC 7 都带 `enable=0`,意图全在 `type`:`0/0` 关闭、`0/2` 屏保、`0/3` 关屏。其中 `0/0` 和 `0/2` 已在 Windows 客户端上实测;主机只对 `controller_platform=1` 做这层归一化(日志 `Windows encoding normalized`),Android 和 macOS 保持字段 1 的语义。
|
||||
The Windows viewer sends every RPC 7 with `enable=0` and carries the intent in `type`: `0/0` off, `0/2` picture, `0/3` screen off. `0/0` and `0/2` were verified live on the Windows client. The host normalizes this for `controller_platform=1` only (log: `Windows encoding normalized`); Android and macOS keep the field-1 semantics.
|
||||
- RPC 25 `update_screen_saver_req` → RpcResponse 21:开启隐私模式前发送,主机回空成功应答,画面仍用本机壁纸。
|
||||
Sent before picture mode; answered empty (success), the host keeps its own wallpaper.
|
||||
- FeatureFlag 4 `ff_private_screen` = 2 (ENHANCED_PRIVACY);SettingMetric 4 `private_screen`、7 `private_screen_type`
|
||||
|
||||
@@ -0,0 +1,19 @@
|
||||
功能与修复版:防窥模式、嵌入式光标、NVENC 关键帧画质。/ Feature and fix release: privacy mode, embedded cursor, NVENC keyframe quality.
|
||||
|
||||
### 新增 / Added
|
||||
- **嵌入式光标跟随控制端鼠标模式(#203)**:Portal 采集在控制端使用相对移动("使用被控端鼠标"、Mac 触控板模式)时请求 `cursor_mode=embedded`,让游戏光标出现在画面中;绝对移动时保持隐藏,只显示一个指针。/ Portal capture asks for an embedded cursor while the viewer sends relative motion, so the game's cursor shows in the picture; absolute motion keeps it hidden.
|
||||
|
||||
### 修复 / Fixed
|
||||
- **Windows 控制端防窥请求(#202)**:Windows 控制端(平台 1)以 `enable=0` 加 `privacy_type` 表达意图,主机现在按类型(2 画面、3 熄屏)开启防窥,不再误判为关闭。/ The host now honours the Windows viewer's `enable=0` + `privacy_type` encoding instead of treating it as "off".
|
||||
- **防窥画面模式下的新窗口(#201)**:KWin 防窥模式中后出现的窗口和桌宠会被移到虚拟输出,不再落在被遮盖的物理屏上而看不见。/ Windows that appear later in KWin picture mode are moved to the virtual output instead of the covered physical screen.
|
||||
- **NVENC 关键帧模糊(#205,修 #103)**:NVENC 的 VBV 缓冲默认按 libx264 规则取码率并限制在 500–8000 kbit,关键帧不再糊;VAAPI 不变,`UU_NVENC_BUFFER_MS` 仍可覆盖。/ The NVENC VBV buffer now follows the libx264 rule (bitrate, clamped to 500–8000 kbit) so keyframes stop blurring; VAAPI is unchanged and `UU_NVENC_BUFFER_MS` still overrides.
|
||||
|
||||
感谢 @RiverOnVenus 与 @Chr0mium24 的贡献。/ Thanks to @RiverOnVenus and @Chr0mium24.
|
||||
|
||||
### 验证范围 / Validation
|
||||
单元测试与 CI;#201、#203 作者在 KDE Plasma 6 Wayland 上实测。维护方未做 Windows/Mac 客户端界面验收。
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux_0.2.56_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.56-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.56`(x86_64)。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -0,0 +1,17 @@
|
||||
功能与修复版:可选控制端麦克风输入、文件传输空路径防护。/ Feature and fix release: opt-in controller microphone, file-transfer empty-path guard.
|
||||
|
||||
### 新增 / Added
|
||||
- **控制端麦克风输入(实验性,默认关闭,#207)**:设置 `UU_MICROPHONE=1` 后,主机通过已认证的桌面 WebRTC 连接接收控制端 Opus 音轨,并提供独立虚拟麦克风 **UU-远程麦克风**(`uu-remote-microphone`),不修改系统默认输入输出。需要 PipeWire-pulse 或 PulseAudio 13+、`libopus.so.0`、`libpulse.so.0` 与 `pactl`;详见 `docs/remote-microphone.md`。/ With `UU_MICROPHONE=1` the host receives the viewer's Opus track over the authenticated desktop WebRTC connection and exposes a dedicated virtual microphone, leaving system defaults untouched. See `docs/remote-microphone.md`.
|
||||
|
||||
### 修复 / Fixed
|
||||
- **文件传输空路径(#208)**:不带路径的 `send_request` 现在返回协议错误,不再从根目录遍历。/ A `send_request` without a path now returns a protocol error instead of walking `/`.
|
||||
|
||||
感谢 @JuckZ 的贡献。/ Thanks to @JuckZ.
|
||||
|
||||
### 验证范围 / Validation
|
||||
单元测试与 CI;维护方未做麦克风实机验收。Windows 4.44.1 新下载流程与端口映射(#208)仍未支持。
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux_0.2.57_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.57-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.57`(x86_64)。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -0,0 +1,16 @@
|
||||
修复版:唤醒助手注册、锁屏监测改用 logind D-Bus、HUD 中文字体。/ Fix release: wake-helper registration, logind D-Bus lock monitoring, CJK HUD font.
|
||||
|
||||
### 修复 / Fixed
|
||||
- **网络唤醒助手注册(#209)**:注册唤醒助手时补发 `inner_ip`,云端不再以 422 拒绝,`UU_WOL_HELPER=1` 的主机可以接收唤醒推送并发送魔术包。/ The wake helper registration now sends `inner_ip`, so the cloud accepts it and forwards wake-on-LAN pushes.
|
||||
- **锁屏监测(#217、#218)**:改为通过 D-Bus 订阅 logind `LockedHint`,不再每秒启动 `loginctl`,减少进程轮询与审计日志噪声;无图形会话时保持订阅、不阻塞启动。/ Lock state is now watched via logind D-Bus `LockedHint` instead of spawning `loginctl` every second.
|
||||
- **HUD 中文显示(#219)**:HUD 字体选择优先含汉字的字体,修复部分系统(如 Omarchy)HUD 中文显示为方框。/ The HUD prefers a CJK-capable font, fixing tofu boxes on some systems.
|
||||
|
||||
感谢 @enrzh、@AYssu、@Onekki 的贡献。/ Thanks to @enrzh, @AYssu and @Onekki.
|
||||
|
||||
### 验证范围 / Validation
|
||||
单元测试与 CI;#209 由贡献者端到端实测(iOS 控制端唤醒 Windows PC)。维护方未做锁屏监测与 HUD 字体实机验收。
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux_0.2.58_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.58-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.58`(x86_64)。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -0,0 +1,15 @@
|
||||
修复版:KDE 锁屏冷连接显示真实锁屏界面、适配 Cargo 新 build-dir 布局。/ Fix release: real lock screen on KDE locked cold connections, Cargo build-dir layout fix.
|
||||
|
||||
### 修复 / Fixed
|
||||
- **KDE 锁屏冷连接(#227、#229)**:KDE Plasma(KWin)锁屏后 Portal 采集仍可用,主机默认在锁屏时也打开采集,冷连接直接看到真实锁屏界面并可用远程键盘输入密码,不再停在「正在传输画面」;`UU_LOCKED_CAPTURE=0` 关闭,`UU_LOCKED_CAPTURE=1` 在无法识别桌面时强制开启。GNOME 行为不变。/ On KDE Plasma the host now keeps Portal capture open while locked, so a cold connection shows the real lock screen; `UU_LOCKED_CAPTURE=0` disables it. GNOME is unchanged.
|
||||
- **源码构建(#226)**:适配 Cargo 新的 build-dir 布局,引擎插件复制到 profile 目录。/ Engine plugins are copied to the profile directory under Cargo's newer build-dir layout.
|
||||
|
||||
感谢 @RiverOnVenus 的贡献。/ Thanks to @RiverOnVenus.
|
||||
|
||||
### 验证范围 / Validation
|
||||
单元测试与 CI;#229 由贡献者在 Plasma 6.8.2 + 官方 Windows 控制端实测锁屏冷连接与远程键盘解锁。维护方未做 KDE 实机验收。
|
||||
|
||||
### 下载 / Download
|
||||
`uu-remote-linux_0.2.59_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.59-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.59`(x86_64)。
|
||||
|
||||
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
|
||||
@@ -0,0 +1,79 @@
|
||||
# Remote microphone / 控制端麦克风(实验性)
|
||||
|
||||
Opt-in controller-to-host Opus audio uses the existing authenticated desktop WebRTC connection and exposes a dedicated virtual microphone to Linux applications.
|
||||
|
||||
可选功能:通过原有、已认证的桌面 WebRTC 连接接收控制端 Opus 音轨,为 Linux 应用提供独立虚拟麦克风。
|
||||
|
||||
## Enable / 启用
|
||||
|
||||
Requires Linux, running PipeWire-pulse or PulseAudio 13+, the `libopus.so.0` / `libpulse.so.0` runtimes, and `pactl`. Debian/Ubuntu: install `libopus0 pulseaudio-utils`; Arch: install `opus libpulse`. No administrator privileges or additional network listener are needed at runtime. Both libraries are loaded only when requested; ordinary builds need no PulseAudio or Opus development package or extra link-time dependency.
|
||||
|
||||
需要 Linux、已运行的 PipeWire-pulse 或 PulseAudio 13+、`libopus.so.0` / `libpulse.so.0` 和 `pactl`。Debian/Ubuntu 对应 `libopus0 pulseaudio-utils`;Arch 对应 `opus libpulse`。运行时无需管理员权限,也不新增监听端口;普通构建无需安装 PulseAudio、Opus 开发包或增加链接依赖。
|
||||
|
||||
```ini
|
||||
# ~/.config/systemd/user/uuremote-native.service.d/microphone.conf
|
||||
[Service]
|
||||
Environment=UU_MICROPHONE=1
|
||||
```
|
||||
|
||||
```sh
|
||||
systemctl --user daemon-reload
|
||||
systemctl --user restart uuremote-native.service
|
||||
```
|
||||
|
||||
The host creates the input device **UU-Remote-Microphone** (`uu-remote-microphone`) and a private backing sink (`uu-remote-mic-input`). In the application that should receive your voice, select UU-Remote-Microphone as its input. This patch does not change the system default input or output device. The backing sink is an audio destination for the decoder; it is not the device to select as an application microphone.
|
||||
|
||||
被控端会出现 **UU-远程麦克风** 输入设备(英文界面显示 **UU-Remote-Microphone**)。在需要使用麦克风的应用中选择这个输入。设备与音频流的显示名称跟随被控端语言,技术名称 `uu-remote-microphone`、`uu-remote-mic-input` 不变。补丁不修改系统默认输入、输出;底层的 `uu-remote-mic-input` 是解码器内部输出目标,不是应用应选择的麦克风。
|
||||
|
||||
Device and stream display labels follow the host language; the technical sink/source identifiers stay unchanged.
|
||||
|
||||
Enable the controller's microphone in the official UU client. The host completes VirtualAudioDriverPolicyRequest (RpcRequest field 21) using RpcResponse field 17 with a correctly encoded two-byte tag. It commits the reception gate and queues its reply/notification as one ordered transition before any network send can block. CONTROL and TEXT callbacks share the same transition lock, so a stalled open reply cannot overwrite a later close. Reception starts closed; connecting alone does not request capture. Opus is decoded at 48 kHz stereo and written through libpulse with PA_STREAM_DONT_MOVE, preventing rescue to a physical output on either supported audio server. A disconnected or superseded desktop drops queued audio and closes playback. Tool-only peers cannot inject microphone audio. A new incoming track replaces the previous track of the same peer.
|
||||
|
||||
在官方控制端中开启麦克风。被控端通过正确编码的 RPC 响应确认虚拟声卡策略;接收开关和回复、通知的排队操作使用统一的状态锁,均在网络发送之前完成,避免拥塞时旧开麦请求覆盖后到的关麦。接收初始为关闭,单纯建立远控连接不会主动要求采集。Opus 解码为 48 kHz 双声道,通过 libpulse 的禁止迁移标志仅写入虚拟麦克风,两个支持的音频后端均不会在目标丢失后转向物理输出。断开或桌面会话被替换时清空待播放内容并停止播放;文件、终端等非桌面连接不接收麦克风。
|
||||
|
||||
If an external tool removes the virtual endpoints, or the audio server restarts, reception stops. Restart the host to recreate its endpoints.
|
||||
|
||||
如果外部工具删除了虚拟设备,或音频服务重启,接收会停止。重启被控端服务可重新创建设备。
|
||||
|
||||
No microphone audio is logged, saved or played through physical speakers by this receiver. Applications consuming the virtual input retain their own behavior. A 40 ms initial jitter window and a maximum 12-packet queue limit backlog. RTP timestamps determine missing audio duration for Opus loss concealment, including variable-duration packets and sequence/timestamp rollover. Each track claims a unique generation before its worker is spawned; a superseded worker checks that generation before processing audio.
|
||||
|
||||
接收器不记录、保存麦克风音频,也不将它播放到物理扬声器。读取虚拟输入的应用仍按各自设置工作。初始抖动缓冲为 40 毫秒,队列最多 12 包;根据 RTP 时间戳推导缺失音频时长后进行 Opus 补偿,支持可变包长与序号、时间戳回绕。新音轨在启动接收任务前取得唯一归属编号,旧任务处理音频前会核验该编号。
|
||||
|
||||
The endpoint lock lives in a private per-user directory under `/tmp`, independently of `UU_CONFIG`, `XDG_RUNTIME_DIR` and `TMPDIR`. Recovery requires an exact match of module kind and arguments, including the remap source's master. Cleanup checks the module id and arguments again before unloading, and the route is released on ordinary error returns as well as shutdown.
|
||||
|
||||
设备锁位于 `/tmp` 下的用户私有目录,不随配置目录、`XDG_RUNTIME_DIR` 或 `TMPDIR` 变化。恢复设备时严格匹配模块类型及全部参数,包括虚拟输入的 master;清理前再次核验模块编号及参数。常规错误返回与正常关闭都会释放设备。
|
||||
|
||||
Native PulseAudio uses its `norewinds` null-sink option to avoid the default two-second idle buffer on first playback. This Pulse-only option is not passed to PipeWire. Unsupported older PulseAudio servers leave the opt-in microphone disabled.
|
||||
|
||||
原生 PulseAudio 使用空设备的 `norewinds` 选项,避免首次播放时的默认两秒空闲缓冲;不向 PipeWire 传递这个专用参数。较旧、不受支持的 PulseAudio 不会启用麦克风。
|
||||
|
||||
## Validation / 验证
|
||||
|
||||
Opus-dependent unit tests print a skip diagnostic when `libopus.so.0` is unavailable, so default tests still pass without this optional runtime. CI's `inproc-av` jobs install libopus and exercise these tests. The explicitly requested audio-server smoke tests require the runtime and fail if it is missing.
|
||||
|
||||
缺少可选的 `libopus.so.0` 时,依赖 Opus 的单元测试会输出跳过说明,默认测试仍能通过。CI 的 `inproc-av` 任务安装 libopus 并实际运行这些测试;显式启用的音频服务真机测试需要该运行库,缺少时会失败。
|
||||
|
||||
```sh
|
||||
cargo test --locked --bin uuremote-server --features wayland,portal,engine-plugins microphone::tests
|
||||
# Real audio-server smoke test: independent test endpoints, generated audio only, in memory.
|
||||
UU_MICROPHONE=1 \
|
||||
cargo test --locked --bin uuremote-server --features wayland,portal,engine-plugins \
|
||||
microphone::tests::pipewire_virtual_microphone_receives_generated_tone -- --ignored --exact
|
||||
```
|
||||
|
||||
The smoke test creates process-specific sink/source names, plays and captures only through those endpoints, waits for its playback task to end before removing them, and never reuses the host's microphone. A separate config file alone does not isolate audio resources. Unit tests cover cross-process locking, module ownership, concurrent track claims, 10/20/40/60 ms loss, mixed-duration gaps, clock rollover, WebRTC track replacement, and CONTROL/TEXT ordering under send congestion. Earlier controller acceptance passed with Windows 4.44.0.3919 on CachyOS using the previous receiver backend. The native playback backend is checked separately with generated audio; Windows acceptance has not been repeated after that backend change.
|
||||
|
||||
真机测试使用进程专属的虚拟输入、输出名称,仅在测试设备之间播放和采集,等播放任务结束后再删除设备,不复用正式服务的麦克风。单独更换配置文件不能隔离音频资源。回归测试覆盖跨进程锁、模块归属、并发音轨、10/20/40/60 毫秒包的丢包、混合时长缺口、时钟回绕、WebRTC 音轨替换及拥塞时的 CONTROL/TEXT 顺序。之前的接收后端已用 Windows 4.44.0.3919 在 CachyOS 实机通过控制端验收;原生播放后端另用生成音验证,更换后尚未重复 Windows 实机验收。
|
||||
|
||||
An optional native PulseAudio check starts a private server with no hardware modules. It first confirms sustained generated audio, then verifies that removing its playback target closes the stream and leaves the default null sink silent. Use `--smoke` to check audio delivery alone. The wrapper verifies that the named test exists before running it, so an old `--test-binary` cannot silently pass with zero tests. It needs a PulseAudio executable; `--daemon` and `--module-dir` also support unpacked packages. It does not start or modify a system service.
|
||||
|
||||
可选的原生 PulseAudio 检查会启动不加载硬件模块的独立服务,先确认持续生成音正常,再验证播放目标消失后音频流关闭、默认空设备保持静音;`--smoke` 仅验证生成音传输。脚本会检查目标测试存在,旧 `--test-binary` 不会以零项测试误报成功。需要 PulseAudio 可执行文件,`--daemon`、`--module-dir` 也支持解压后的程序包,不启动或修改系统服务。
|
||||
|
||||
```sh
|
||||
python3 contrib/check-microphone-pulse.py
|
||||
python3 contrib/check-microphone-pulse.py --smoke
|
||||
```
|
||||
|
||||
To disable, remove `microphone.conf`, reload the user manager and restart the host. The virtual endpoints are removed on normal shutdown. After a crash, the next enabled run reuses only the exact tagged modules created by this receiver.
|
||||
|
||||
停用时删除 `microphone.conf`,重新加载并重启用户服务。正常退出会删除虚拟设备;异常退出后,下次启用仅复用本接收器创建并标记的同名模块。
|
||||
@@ -243,7 +243,16 @@ async fn locked_control_unlock_requests_and_tools_work_without_a_video_frame() {
|
||||
let frame = tokio::time::timeout(Duration::from_secs(5), async {
|
||||
loop {
|
||||
let (channel, message) = terminal_viewer.messages.recv().await.unwrap();
|
||||
if channel == "BINARY_DATA_CHANNEL" { break crate::terminal::decode(&message).unwrap(); }
|
||||
if channel != "BINARY_DATA_CHANNEL" {
|
||||
continue;
|
||||
}
|
||||
// The process-global terminal change watch also broadcasts the field-28
|
||||
// list-invalidated notification here, which is not a TERM frame.
|
||||
if let Some(frame) = crate::terminal::decode(&message) {
|
||||
if frame.kind == crate::terminal::LIST_RESP && frame.session == 71 {
|
||||
break frame;
|
||||
}
|
||||
}
|
||||
}
|
||||
}).await.unwrap();
|
||||
assert_eq!((frame.kind, frame.session), (crate::terminal::LIST_RESP, 71));
|
||||
@@ -299,7 +308,16 @@ async fn locked_control_unlock_requests_and_tools_work_without_a_video_frame() {
|
||||
let frame = tokio::time::timeout(Duration::from_secs(5), async {
|
||||
loop {
|
||||
let (channel, message) = terminal_viewer.messages.recv().await.unwrap();
|
||||
if channel == "BINARY_DATA_CHANNEL" { break crate::terminal::decode(&message).unwrap(); }
|
||||
if channel != "BINARY_DATA_CHANNEL" {
|
||||
continue;
|
||||
}
|
||||
// The process-global terminal change watch also broadcasts the field-28
|
||||
// list-invalidated notification here, which is not a TERM frame.
|
||||
if let Some(frame) = crate::terminal::decode(&message) {
|
||||
if frame.kind == crate::terminal::LIST_RESP && frame.session == 72 {
|
||||
break frame;
|
||||
}
|
||||
}
|
||||
}
|
||||
}).await.unwrap();
|
||||
assert_eq!((frame.kind, frame.session), (crate::terminal::LIST_RESP, 72));
|
||||
|
||||
+199
-25
@@ -1,6 +1,6 @@
|
||||
//! Portal availability is independent of the authenticated CONTROL transport.
|
||||
use std::future::Future;
|
||||
use std::sync::{Arc, atomic::{AtomicBool, Ordering}};
|
||||
use std::sync::{Arc, OnceLock, atomic::{AtomicBool, Ordering}};
|
||||
use std::time::Instant;
|
||||
use tokio::sync::{watch, Mutex};
|
||||
use crate::{capture::ScreenCapture, input::DesktopInputSession};
|
||||
@@ -29,6 +29,7 @@ pub struct PortalDesktop {
|
||||
state: watch::Sender<State>,
|
||||
opening: Arc<Mutex<()>>,
|
||||
locked: watch::Receiver<Option<bool>>,
|
||||
capture_while_locked: bool,
|
||||
}
|
||||
|
||||
struct CancelOnDrop(Arc<AtomicBool>);
|
||||
@@ -71,6 +72,7 @@ enum AttemptOutcome {
|
||||
Ready(Arc<ScreenCapture>),
|
||||
Retry(String),
|
||||
Terminal(String),
|
||||
Deferred,
|
||||
Cancelled,
|
||||
}
|
||||
|
||||
@@ -85,14 +87,52 @@ fn classify(result: Result<Arc<ScreenCapture>, PortalError>) -> AttemptOutcome {
|
||||
}
|
||||
}
|
||||
|
||||
/// A consent dialog opened behind the lock screen cannot be approved, so its denied/timed-out
|
||||
/// error must not end this connection's supervisor: ask again after the local unlock.
|
||||
fn defer_consent(error: &PortalError, state: Option<bool>) -> bool {
|
||||
state == Some(true) && matches!(error.code, 4 | 5)
|
||||
}
|
||||
|
||||
/// True when this iteration sees a lock state it has not attempted under yet. Waking and resetting
|
||||
/// the retry delay must happen once per transition, not once per 200 ms poll: a locked state would
|
||||
/// otherwise re-run wake, inhibitor and publish on every tick and defeat the 5 s retry backoff.
|
||||
fn fresh_state(previous: Option<Option<bool>>, state: Option<bool>) -> bool {
|
||||
previous != Some(state)
|
||||
}
|
||||
|
||||
fn should_prepare_power(healthy: bool, force_wake: bool) -> bool {
|
||||
!healthy || force_wake
|
||||
}
|
||||
|
||||
/// KWin keeps the Portal screencast, including the lock screen, alive while the session is
|
||||
/// locked, so a cold connection can show the real lock screen. Mutter closes the session on
|
||||
/// lock, so other desktops keep the existing black-frame path. `UU_LOCKED_CAPTURE=0` opts out.
|
||||
fn capture_while_locked() -> bool {
|
||||
static ENABLED: OnceLock<bool> = OnceLock::new();
|
||||
*ENABLED.get_or_init(|| {
|
||||
match std::env::var("UU_LOCKED_CAPTURE").ok().filter(|value| !value.is_empty()) {
|
||||
Some(value) => !matches!(value.to_ascii_lowercase().as_str(), "0" | "off" | "false" | "no"),
|
||||
None => ["XDG_CURRENT_DESKTOP", "XDG_SESSION_DESKTOP"].iter().any(|key|
|
||||
std::env::var(key).is_ok_and(|desktop| desktop.split(':')
|
||||
.any(|part| part.eq_ignore_ascii_case("KDE")))),
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// Capture may start and continue in this lock state. An unknown state keeps the old wait on
|
||||
/// desktops whose compositor closes the session on lock.
|
||||
fn attempt_allowed(state: Option<bool>, capture_while_locked: bool) -> bool {
|
||||
match state {
|
||||
Some(false) => true,
|
||||
Some(true) | None => capture_while_locked,
|
||||
}
|
||||
}
|
||||
|
||||
fn prepare_attempt<W, I>(
|
||||
cancelled: &AtomicBool,
|
||||
owner: &DesktopInputSession,
|
||||
locked: &watch::Receiver<Option<bool>>,
|
||||
allow_locked: bool,
|
||||
wake: W,
|
||||
inhibit: I,
|
||||
) -> Option<AttemptPrep>
|
||||
@@ -102,7 +142,7 @@ where
|
||||
{
|
||||
let current = || !cancelled.load(Ordering::Acquire)
|
||||
&& owner.is_current()
|
||||
&& *locked.borrow() == Some(false);
|
||||
&& attempt_allowed(*locked.borrow(), allow_locked);
|
||||
if !current() { return None; }
|
||||
let wake = wake();
|
||||
if !current() { return None; }
|
||||
@@ -114,7 +154,8 @@ where
|
||||
impl PortalDesktop {
|
||||
pub fn new(screen: Arc<ScreenCapture>) -> Self {
|
||||
Self { state: watch::channel(State { waiting: screen.init_error.is_some(), screen }).0,
|
||||
opening: Arc::new(Mutex::new(())), locked: crate::session_lock::watch_locked() }
|
||||
opening: Arc::new(Mutex::new(())), locked: crate::session_lock::watch_locked(),
|
||||
capture_while_locked: capture_while_locked() }
|
||||
}
|
||||
pub fn begin(&self) {
|
||||
// GNOME closes the Portal session on lock; a cached screen with a dead session
|
||||
@@ -133,10 +174,21 @@ impl PortalDesktop {
|
||||
}
|
||||
pub fn subscribe(&self) -> watch::Receiver<State> { self.state.subscribe() }
|
||||
pub fn lock_state(&self) -> watch::Receiver<Option<bool>> { self.locked.clone() }
|
||||
/// Whether capture may run in this lock state for this desktop. Shares the rule used by
|
||||
/// maintain(), so capture-setting requests do not stall behind a lock the compositor does
|
||||
/// not honor.
|
||||
pub fn capture_allowed(&self, locked: Option<bool>) -> bool {
|
||||
attempt_allowed(locked, self.capture_while_locked)
|
||||
}
|
||||
#[cfg(test)]
|
||||
pub fn with_lock_state(screen: Arc<ScreenCapture>, locked: watch::Receiver<Option<bool>>) -> Self {
|
||||
Self::with_lock_state_and_capture(screen, locked, false)
|
||||
}
|
||||
#[cfg(test)]
|
||||
pub fn with_lock_state_and_capture(screen: Arc<ScreenCapture>, locked: watch::Receiver<Option<bool>>,
|
||||
capture_while_locked: bool) -> Self {
|
||||
Self { state: watch::channel(State { waiting: screen.init_error.is_some(), screen }).0,
|
||||
opening: Arc::new(Mutex::new(())), locked }
|
||||
opening: Arc::new(Mutex::new(())), locked, capture_while_locked }
|
||||
}
|
||||
#[cfg(test)]
|
||||
pub fn publish_test_screen(&self, screen: Arc<ScreenCapture>) {
|
||||
@@ -204,22 +256,27 @@ impl PortalDesktop {
|
||||
let inhibit = Arc::new(inhibit);
|
||||
let open = Arc::new(open);
|
||||
let mut locked = self.locked.clone();
|
||||
let mut previous = None;
|
||||
let allow_locked = self.capture_while_locked;
|
||||
let mut previous: Option<Option<bool>> = None;
|
||||
let mut defer_until_unlock = false;
|
||||
let mut retry_at = Instant::now();
|
||||
loop {
|
||||
if !owner.is_current() { return Ok(()); }
|
||||
let state = *locked.borrow_and_update();
|
||||
if state != Some(false) {
|
||||
if previous == Some(false) { self.pause(&owner); }
|
||||
} else {
|
||||
// A fresh unlocked transition gets an immediate wake/recovery attempt.
|
||||
let force_wake = previous != Some(false);
|
||||
if state == Some(false) { defer_until_unlock = false; }
|
||||
if state != Some(false) && previous == Some(Some(false)) { self.pause(&owner); }
|
||||
if state == Some(true) && previous != Some(Some(true)) && allow_locked {
|
||||
log::info!("Desktop is locked; opening Portal capture for the lock screen");
|
||||
}
|
||||
if attempt_allowed(state, allow_locked) && !defer_until_unlock {
|
||||
// A fresh transition into an attempted state gets an immediate wake/recovery attempt.
|
||||
let force_wake = fresh_state(previous, state);
|
||||
if force_wake { retry_at = Instant::now(); }
|
||||
let mut attempt_locked = locked.clone();
|
||||
let outcome = tokio::select! {
|
||||
biased;
|
||||
_ = wait_for_lock(&mut locked) => AttemptOutcome::Cancelled,
|
||||
outcome = self.portal_attempt(&owner, &mut attempt_locked, retry_at, force_wake, wake.clone(), inhibit.clone(), open.clone()) => outcome,
|
||||
_ = wait_for_lock(&mut locked, allow_locked) => AttemptOutcome::Cancelled,
|
||||
outcome = self.portal_attempt(&owner, &mut attempt_locked, allow_locked, retry_at, force_wake, wake.clone(), inhibit.clone(), open.clone()) => outcome,
|
||||
};
|
||||
match outcome {
|
||||
AttemptOutcome::Ready(screen) => self.publish(&owner, screen),
|
||||
@@ -228,11 +285,12 @@ impl PortalDesktop {
|
||||
log::warn!("Portal desktop recovery deferred: {error}");
|
||||
retry_at = Instant::now() + std::time::Duration::from_secs(5);
|
||||
}
|
||||
AttemptOutcome::Deferred => { defer_until_unlock = true; }
|
||||
AttemptOutcome::Cancelled => {}
|
||||
}
|
||||
if *locked.borrow_and_update() != Some(false) { self.pause(&owner); }
|
||||
if !attempt_allowed(*locked.borrow_and_update(), allow_locked) { self.pause(&owner); }
|
||||
}
|
||||
previous = *locked.borrow_and_update();
|
||||
previous = Some(*locked.borrow_and_update());
|
||||
tokio::select! {
|
||||
_ = locked.changed() => {},
|
||||
_ = tokio::time::sleep(std::time::Duration::from_millis(200)) => {},
|
||||
@@ -241,20 +299,20 @@ impl PortalDesktop {
|
||||
}
|
||||
|
||||
async fn portal_attempt<W, I, O>(&self, owner: &Arc<DesktopInputSession>,
|
||||
locked: &mut watch::Receiver<Option<bool>>, retry_at: Instant, force_wake: bool,
|
||||
locked: &mut watch::Receiver<Option<bool>>, allow_locked: bool, retry_at: Instant, force_wake: bool,
|
||||
wake: Arc<W>, inhibit: Arc<I>, open: Arc<O>) -> AttemptOutcome
|
||||
where
|
||||
W: Fn() -> Result<(), String> + Send + Sync + 'static,
|
||||
I: Fn() -> IdleGuard + Send + Sync + 'static,
|
||||
O: Fn(Arc<ScreenCapture>, Arc<AtomicBool>) -> Result<Arc<ScreenCapture>, PortalError> + Send + Sync + 'static,
|
||||
{
|
||||
if !owner.is_current() || *locked.borrow() != Some(false) || Instant::now() < retry_at {
|
||||
if !owner.is_current() || !attempt_allowed(*locked.borrow(), allow_locked) || Instant::now() < retry_at {
|
||||
return AttemptOutcome::Cancelled;
|
||||
}
|
||||
let gate = self.opening.clone().lock_owned().await;
|
||||
// The state can change while this attempt waits for an earlier worker
|
||||
// to finish rotating the Portal permission token.
|
||||
if !owner.is_current() || *locked.borrow() != Some(false) {
|
||||
if !owner.is_current() || !attempt_allowed(*locked.borrow(), allow_locked) {
|
||||
return AttemptOutcome::Cancelled;
|
||||
}
|
||||
let screen = self.snapshot().screen;
|
||||
@@ -271,6 +329,7 @@ impl PortalDesktop {
|
||||
&prep_cancel,
|
||||
&prep_owner,
|
||||
&prep_locked,
|
||||
allow_locked,
|
||||
|| (*wake)(),
|
||||
|| (*inhibit)(),
|
||||
)).await {
|
||||
@@ -282,7 +341,7 @@ impl PortalDesktop {
|
||||
// Held by the cancellable async helper, not the blocking worker, so a
|
||||
// lock transition releases it while worker cleanup may still be running.
|
||||
let _inhibitor = prep.inhibitor;
|
||||
if !owner.is_current() || *locked.borrow() != Some(false) {
|
||||
if !owner.is_current() || !attempt_allowed(*locked.borrow(), allow_locked) {
|
||||
return AttemptOutcome::Cancelled;
|
||||
}
|
||||
// A new controller can arrive while the cached Portal handle is alive
|
||||
@@ -298,19 +357,25 @@ impl PortalDesktop {
|
||||
}
|
||||
open(screen, worker_cancel)
|
||||
}).await;
|
||||
if !owner.is_current() || *locked.borrow() != Some(false) {
|
||||
if !owner.is_current() || !attempt_allowed(*locked.borrow(), allow_locked) {
|
||||
return AttemptOutcome::Cancelled;
|
||||
}
|
||||
match result {
|
||||
Ok(Err(error)) if defer_consent(&error, *locked.borrow()) => {
|
||||
// The consent dialog opened behind the lock screen cannot be approved here.
|
||||
// Keep this connection alive and ask again after the local unlock.
|
||||
log::info!("Portal consent is behind the lock screen; waiting for the local unlock");
|
||||
AttemptOutcome::Deferred
|
||||
}
|
||||
Ok(result) => classify(result),
|
||||
Err(_) => AttemptOutcome::Terminal("Portal initialization worker failed".into()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn wait_for_lock(locked: &mut watch::Receiver<Option<bool>>) {
|
||||
async fn wait_for_lock(locked: &mut watch::Receiver<Option<bool>>, allow_locked: bool) {
|
||||
while locked.changed().await.is_ok() {
|
||||
if *locked.borrow_and_update() != Some(false) { return; }
|
||||
if !attempt_allowed(*locked.borrow_and_update(), allow_locked) { return; }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -441,19 +506,19 @@ mod tests {
|
||||
let wakes = AtomicUsize::new(0);
|
||||
let inhibitors = AtomicUsize::new(0);
|
||||
let cancelled = AtomicBool::new(true);
|
||||
assert!(prepare_attempt(&cancelled, &owner, &locked,
|
||||
assert!(prepare_attempt(&cancelled, &owner, &locked, false,
|
||||
|| { wakes.fetch_add(1, Ordering::Relaxed); Ok(()) },
|
||||
|| { inhibitors.fetch_add(1, Ordering::Relaxed); IdleGuard::default() }).is_none());
|
||||
assert_eq!(wakes.load(Ordering::Relaxed), 0);
|
||||
cancelled.store(false, Ordering::Release);
|
||||
lock.send(Some(true)).unwrap();
|
||||
assert!(prepare_attempt(&cancelled, &owner, &locked,
|
||||
assert!(prepare_attempt(&cancelled, &owner, &locked, false,
|
||||
|| { wakes.fetch_add(1, Ordering::Relaxed); Ok(()) },
|
||||
|| { inhibitors.fetch_add(1, Ordering::Relaxed); IdleGuard::default() }).is_none());
|
||||
assert_eq!(wakes.load(Ordering::Relaxed), 0);
|
||||
lock.send(Some(false)).unwrap();
|
||||
let locked_during_wake = lock.clone();
|
||||
assert!(prepare_attempt(&cancelled, &owner, &locked,
|
||||
assert!(prepare_attempt(&cancelled, &owner, &locked, false,
|
||||
|| {
|
||||
wakes.fetch_add(1, Ordering::Relaxed);
|
||||
locked_during_wake.send(Some(true)).unwrap();
|
||||
@@ -464,7 +529,7 @@ mod tests {
|
||||
assert_eq!(inhibitors.load(Ordering::Relaxed), 0);
|
||||
lock.send(Some(false)).unwrap();
|
||||
let replacement = input.desktop_session();
|
||||
assert!(prepare_attempt(&cancelled, &owner, &locked,
|
||||
assert!(prepare_attempt(&cancelled, &owner, &locked, false,
|
||||
|| { wakes.fetch_add(1, Ordering::Relaxed); Ok(()) },
|
||||
|| { inhibitors.fetch_add(1, Ordering::Relaxed); IdleGuard::default() }).is_none());
|
||||
assert_eq!(wakes.load(Ordering::Relaxed), 1);
|
||||
@@ -479,6 +544,115 @@ mod tests {
|
||||
drop(guard);
|
||||
assert!(flag.load(Ordering::Acquire));
|
||||
}
|
||||
#[test]
|
||||
fn locked_capture_gate_follows_the_compositor_rule() {
|
||||
assert!(attempt_allowed(Some(false), false));
|
||||
assert!(!attempt_allowed(Some(true), false));
|
||||
assert!(!attempt_allowed(None, false));
|
||||
assert!(attempt_allowed(Some(true), true));
|
||||
assert!(attempt_allowed(None, true));
|
||||
}
|
||||
#[test]
|
||||
fn wake_and_retry_reset_once_per_lock_transition() {
|
||||
assert!(fresh_state(None, Some(true)));
|
||||
assert!(!fresh_state(Some(Some(true)), Some(true)));
|
||||
assert!(fresh_state(Some(Some(true)), Some(false)));
|
||||
assert!(!fresh_state(Some(Some(false)), Some(false)));
|
||||
assert!(fresh_state(Some(Some(true)), None));
|
||||
assert!(!fresh_state(Some(None), None));
|
||||
}
|
||||
#[test]
|
||||
fn consent_failures_are_deferred_only_while_locked() {
|
||||
for code in [4, 5] {
|
||||
assert!(defer_consent(&PortalError { code }, Some(true)));
|
||||
assert!(!defer_consent(&PortalError { code }, Some(false)));
|
||||
assert!(!defer_consent(&PortalError { code }, None));
|
||||
}
|
||||
assert!(!defer_consent(&PortalError { code: 8 }, Some(true)));
|
||||
assert!(!defer_consent(&PortalError { code: 13 }, Some(true)));
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn wait_for_lock_ends_on_a_lock_the_compositor_does_not_honor() {
|
||||
use std::time::Duration;
|
||||
let (lock, mut locked) = watch::channel(Some(false));
|
||||
let mut task = tokio::spawn(async move { wait_for_lock(&mut locked, false).await; });
|
||||
lock.send(Some(true)).unwrap();
|
||||
tokio::time::timeout(Duration::from_secs(1), &mut task).await
|
||||
.expect("lock must end the wait").unwrap();
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn wait_for_lock_ignores_lock_changes_when_capture_is_allowed() {
|
||||
use std::time::Duration;
|
||||
let (lock, mut locked) = watch::channel(Some(false));
|
||||
let mut task = tokio::spawn(async move { wait_for_lock(&mut locked, true).await; });
|
||||
lock.send(Some(true)).unwrap();
|
||||
assert!(tokio::time::timeout(Duration::from_millis(100), &mut task).await.is_err(),
|
||||
"lock cancelled an allowed wait");
|
||||
lock.send(None).unwrap();
|
||||
assert!(tokio::time::timeout(Duration::from_millis(100), &mut task).await.is_err(),
|
||||
"unknown lock cancelled an allowed wait");
|
||||
task.abort();
|
||||
let _ = task.await;
|
||||
}
|
||||
#[test]
|
||||
fn locked_attempt_is_allowed_when_the_compositor_keeps_the_stream() {
|
||||
let input = Arc::new(crate::input::InputInjector::without_desktop());
|
||||
let owner = input.desktop_session();
|
||||
let (lock, locked) = watch::channel(Some(true));
|
||||
let cancelled = AtomicBool::new(false);
|
||||
let wakes = AtomicUsize::new(0);
|
||||
assert!(prepare_attempt(&cancelled, &owner, &locked, true,
|
||||
|| { wakes.fetch_add(1, Ordering::Relaxed); Ok(()) },
|
||||
|| IdleGuard::default()).is_some());
|
||||
lock.send(None).unwrap();
|
||||
assert!(prepare_attempt(&cancelled, &owner, &locked, true,
|
||||
|| { wakes.fetch_add(1, Ordering::Relaxed); Ok(()) },
|
||||
|| IdleGuard::default()).is_some());
|
||||
assert_eq!(wakes.load(Ordering::Relaxed), 2);
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn locked_capture_keeps_the_attempt_running() {
|
||||
use std::time::Duration;
|
||||
let (lock, locked) = watch::channel(Some(false));
|
||||
let host = Arc::new(PortalDesktop::with_lock_state_and_capture(
|
||||
Arc::new(ScreenCapture::unavailable("pending".into())), locked, true));
|
||||
let input = Arc::new(crate::input::InputInjector::without_desktop());
|
||||
let owner = input.desktop_session();
|
||||
let releases = Arc::new(AtomicUsize::new(0));
|
||||
let worker_release = Arc::new(AtomicBool::new(false));
|
||||
let (started, mut started_rx) = tokio::sync::mpsc::unbounded_channel();
|
||||
let task = tokio::spawn({
|
||||
let host = host.clone();
|
||||
let owner = owner.clone();
|
||||
let releases = releases.clone();
|
||||
let worker_release = worker_release.clone();
|
||||
async move {
|
||||
host.maintain_with(owner,
|
||||
|| Ok(()),
|
||||
move || IdleGuard(Some(Inhibitor::Fake(DropSignal(releases.clone())))),
|
||||
move |screen, cancel| {
|
||||
let _ = started.send(());
|
||||
while !worker_release.load(Ordering::Acquire) && !cancel.load(Ordering::Acquire) {
|
||||
std::thread::sleep(Duration::from_millis(1));
|
||||
}
|
||||
if cancel.load(Ordering::Acquire) { return Err(PortalError { code: 13 }); }
|
||||
Ok(screen)
|
||||
}).await
|
||||
}
|
||||
});
|
||||
started_rx.recv().await.unwrap();
|
||||
lock.send(Some(true)).unwrap();
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
assert_eq!(releases.load(Ordering::Relaxed), 0, "lock released a compositor-backed attempt");
|
||||
worker_release.store(true, Ordering::Release);
|
||||
let deadline = tokio::time::Instant::now() + Duration::from_secs(2);
|
||||
while host.snapshot().waiting {
|
||||
assert!(tokio::time::Instant::now() < deadline, "locked attempt did not publish");
|
||||
tokio::task::yield_now().await;
|
||||
}
|
||||
task.abort();
|
||||
let _ = task.await;
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn lock_transition_cancels_blocked_attempt_and_releases_inhibitor() {
|
||||
let (lock, locked) = watch::channel(Some(false));
|
||||
|
||||
@@ -127,6 +127,11 @@ pub async fn run() -> Result<(), String> {
|
||||
line("render node", writable(&std::env::var("UU_VAAPI_DEVICE").unwrap_or_else(|_| "/dev/dri/renderD128".into())));
|
||||
|
||||
println!("-- audio");
|
||||
line(crate::i18n::s("麦克风输入", "microphone input"),
|
||||
crate::i18n::s("控制端 Opus 到固定虚拟输入(可选)", "controller Opus to pinned virtual input (opt-in)"));
|
||||
line("UU_MICROPHONE", if crate::microphone::requested() { crate::i18n::s("已启用", "enabled") } else { crate::i18n::s("已禁用", "disabled") });
|
||||
line(crate::i18n::s("虚拟麦克风", "virtual microphone"), command_output("pactl", &["list", "short", "sources"]).await
|
||||
.is_some_and(|sources| sources.lines().any(|line| line.split('\t').nth(1) == Some(crate::microphone::SOURCE))));
|
||||
for tool in ["pactl", "pw-cli"] {
|
||||
line(tool, command_output("sh", &["-c", &format!("command -v {tool} >/dev/null && echo found || echo missing")]).await.unwrap_or_else(|| "unknown".into()));
|
||||
}
|
||||
|
||||
@@ -568,6 +568,13 @@ impl FileSession {
|
||||
fn send_request(self: &Arc<Self>, rid: u64, f: &[WireField]) {
|
||||
let id = TaskId::parse(f);
|
||||
let raw = get_text(f, 2);
|
||||
// Newer viewers (Windows 4.44.1, #208) send only the task id here; an empty path must not
|
||||
// become "/" and walk the whole filesystem into a misleading permission error.
|
||||
if raw.trim().is_empty() {
|
||||
log::info!("File transfer send_request without path: task={} fields={:?}", id.task, f.iter().map(|x| x.number).collect::<Vec<_>>());
|
||||
self.respond(rid, 2, Enc::default().msg(1, id.enc()).uint(2, FT_PROTOCOL));
|
||||
return;
|
||||
}
|
||||
let path = normalize(&raw);
|
||||
let collected = collect_download(&path).map_err(|e| io_error(&e));
|
||||
let mut body = Enc::default().msg(1, id.enc());
|
||||
|
||||
+84
-6
@@ -43,6 +43,28 @@ struct PendingPointer {
|
||||
unsafe fn x11_pointer_state(_: *mut libc::c_int,_:*mut libc::c_int,_:*mut libc::c_uint)->libc::c_int {-1}
|
||||
#[derive(Default)]
|
||||
struct HeldInput { buttons: std::collections::BTreeSet<i32>, keys: std::collections::BTreeSet<u64> }
|
||||
/// Inputs held through the portal session are dropped when that session is replaced; the
|
||||
/// cursor-mode rebuild waits until they are released. uinput devices survive the swap.
|
||||
static PORTAL_INPUT_HELD: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
|
||||
/// An active contact on the portal touchscreen is also lost when the session is replaced.
|
||||
static PORTAL_TOUCH_HELD: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
|
||||
pub fn portal_input_held() -> bool {
|
||||
PORTAL_INPUT_HELD.load(std::sync::atomic::Ordering::Relaxed) || PORTAL_TOUCH_HELD.load(std::sync::atomic::Ordering::Relaxed)
|
||||
}
|
||||
/// Inputs currently bound to the portal session; a replacement tears those devices down.
|
||||
static PORTAL_HELD: std::sync::Mutex<HeldInput> = std::sync::Mutex::new(HeldInput { buttons: std::collections::BTreeSet::new(), keys: std::collections::BTreeSet::new() });
|
||||
/// Serializes recording an input with retiring the records of a replaced handle.
|
||||
static PORTAL_HELD_SERIAL: std::sync::Mutex<()> = std::sync::Mutex::new(());
|
||||
pub fn lock_portal_held() -> std::sync::MutexGuard<'static, ()> {
|
||||
PORTAL_HELD_SERIAL.lock().unwrap_or_else(std::sync::PoisonError::into_inner)
|
||||
}
|
||||
/// The portal replaced its native devices: records of held portal inputs no longer apply.
|
||||
/// The caller holds `lock_portal_held()`, so an input recorded against the new handle stays.
|
||||
pub fn portal_session_replaced() {
|
||||
if let Ok(mut held)=PORTAL_HELD.lock() { *held=HeldInput::default(); }
|
||||
PORTAL_INPUT_HELD.store(false, std::sync::atomic::Ordering::Relaxed);
|
||||
PORTAL_TOUCH_HELD.store(false, std::sync::atomic::Ordering::Relaxed);
|
||||
}
|
||||
/// Held modifier VKs (bit 0 Ctrl, 1 Shift, 2 Alt, 3 Win) and keys that got a synthetic Shift.
|
||||
#[derive(Default)]
|
||||
struct Shortcuts { modifiers: u8, shifted: std::collections::BTreeSet<i32> }
|
||||
@@ -81,7 +103,7 @@ fn finger_held(finger: Finger, now: std::time::Instant) -> Option<(i32,i32)> {
|
||||
/// Viewer platform from the connect header `controller_platform` (website enum: 1 windows, 2 android,
|
||||
/// 3 ios, 4 macos, 5 tv).
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
|
||||
pub enum Controller { #[default] Other, Mac, Mobile, Ios }
|
||||
pub enum Controller { #[default] Other, Windows, Mac, Mobile, Ios }
|
||||
impl Controller {
|
||||
/// Touch semantics cover both mobile platforms; the iOS RPC 7 screen-off encoding is its own quirk.
|
||||
pub fn is_mobile(self) -> bool { matches!(self, Self::Mobile | Self::Ios) }
|
||||
@@ -92,9 +114,11 @@ impl Controller {
|
||||
Some(4) => Self::Mac,
|
||||
Some(3) => Self::Ios,
|
||||
Some(2) => Self::Mobile,
|
||||
Some(1) => Self::Windows,
|
||||
_ if text.as_deref().is_some_and(|s| s.contains("mac") || s.contains("darwin")) => Self::Mac,
|
||||
_ if text.as_deref().is_some_and(|s| s.contains("ios") || s.contains("iphone") || s.contains("ipad")) => Self::Ios,
|
||||
_ if text.as_deref().is_some_and(|s| s.contains("android")) => Self::Mobile,
|
||||
_ if text.as_deref().is_some_and(|s| s.contains("windows")) => Self::Windows,
|
||||
_ => Self::Other,
|
||||
}
|
||||
}
|
||||
@@ -386,8 +410,20 @@ impl InputInjector {
|
||||
});
|
||||
}
|
||||
fn inject_touch(&self, phase: i32, x: i32, y: i32) -> i32 {
|
||||
// Serialize the contact with handle replacement: a contact sent to the new devices
|
||||
let Some(portal) = self.portal.lock().unwrap().clone() else { return -1 };
|
||||
self.portal_result("touch", portal.touch(phase, f64::from(x), f64::from(y)))
|
||||
// Serialize with handle replacement while the contact is sent; portal then recording
|
||||
// lock, the same order the button and key recorders use.
|
||||
let _serial = lock_portal_held();
|
||||
let result = self.portal_result("touch", portal.touch(phase, f64::from(x), f64::from(y)));
|
||||
if result == 0 {
|
||||
match phase {
|
||||
0 => PORTAL_TOUCH_HELD.store(true, std::sync::atomic::Ordering::Relaxed),
|
||||
2 => PORTAL_TOUCH_HELD.store(false, std::sync::atomic::Ordering::Relaxed),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
fn terminal_focused(&self) -> bool {
|
||||
@@ -502,6 +538,16 @@ impl InputInjector {
|
||||
if !keys_ok {log::warn!("Desktop input reset incomplete: backend unavailable");}
|
||||
}
|
||||
*held=HeldInput::default();
|
||||
// Inputs bound to the portal session are not covered by the uinput release above.
|
||||
let (portal_buttons, portal_keys) = {
|
||||
let _serial=lock_portal_held();
|
||||
let mut pending=PORTAL_HELD.lock().unwrap();
|
||||
(std::mem::take(&mut pending.buttons), std::mem::take(&mut pending.keys))
|
||||
};
|
||||
// Stop on the first failure like the sweep above: each call can wait out the portal timeout.
|
||||
let buttons_ok = portal_buttons.into_iter().all(|button| self.inject_button(button,false)==0);
|
||||
if buttons_ok { for key in portal_keys { if self.inject_key(key,false)!=0 { break; } } }
|
||||
PORTAL_INPUT_HELD.store(false,std::sync::atomic::Ordering::Relaxed);
|
||||
*self.shortcuts.lock().unwrap()=Shortcuts::default();
|
||||
*self.cmd.lock().unwrap()=CmdState::default();
|
||||
}
|
||||
@@ -535,7 +581,22 @@ impl InputInjector {
|
||||
}
|
||||
}
|
||||
}
|
||||
/// Inputs bound to the portal session are dropped when that session is replaced.
|
||||
fn record_portal_button(&self, button: i32, pressed: bool) {
|
||||
// Callers hold the serial lock across the injection they are recording.
|
||||
let mut held = PORTAL_HELD.lock().unwrap();
|
||||
if pressed { held.buttons.insert(button); } else { held.buttons.remove(&button); }
|
||||
PORTAL_INPUT_HELD.store(!held.buttons.is_empty() || !held.keys.is_empty(), std::sync::atomic::Ordering::Relaxed);
|
||||
}
|
||||
fn record_portal_key(&self, symbol: u64, pressed: bool) {
|
||||
let mut held = PORTAL_HELD.lock().unwrap();
|
||||
if pressed { held.keys.insert(symbol); } else { held.keys.remove(&symbol); }
|
||||
PORTAL_INPUT_HELD.store(!held.buttons.is_empty() || !held.keys.is_empty(), std::sync::atomic::Ordering::Relaxed);
|
||||
}
|
||||
fn inject_move(&self,x:i32,y:i32,relative:bool)->i32 {
|
||||
// The viewer's mouse mode decides whether the stream must carry the pointer (see
|
||||
// portal::note_pointer_motion); only the portal backend can change that.
|
||||
if self.backend==crate::desktop_backend::DesktopBackend::Portal { crate::portal::note_pointer_motion(relative); }
|
||||
if self.uinput_pointer && self.backend != crate::desktop_backend::DesktopBackend::X11 {
|
||||
if let Some(uinput) = &self.uinput {
|
||||
if relative { return Self::uinput_result(uinput.move_relative(x,y)); }
|
||||
@@ -605,14 +666,25 @@ impl InputInjector {
|
||||
// Portal: clicks follow absolute motion on the same session, so a tap cannot land
|
||||
// before the compositor has moved the pointer there (uinput is a separate queue).
|
||||
if !self.uinput_pointer && self.backend==crate::desktop_backend::DesktopBackend::Portal && !self.virtual_uinput() {
|
||||
if let Some(portal)=self.portal.lock().unwrap().as_ref() { return self.portal_result("button", portal.button(button,pressed)); }
|
||||
if let Some(portal)=self.portal.lock().unwrap().as_ref() {
|
||||
// The injection and its record must both predate or both postdate a swap.
|
||||
let _serial=lock_portal_held();
|
||||
let result=self.portal_result("button", portal.button(button,pressed));
|
||||
if result==0 { self.record_portal_button(button,pressed); }
|
||||
return result;
|
||||
}
|
||||
}
|
||||
if let Some(uinput)=&self.uinput {
|
||||
if let Some((v,h))=crate::uinput::wheel_step(button) { return if pressed { Self::uinput_result(uinput.wheel(v,h)) } else { 0 }; }
|
||||
if let Some(code)=crate::uinput::button_code(button) { return Self::uinput_result(uinput.button(code,pressed)); }
|
||||
}
|
||||
if self.backend==crate::desktop_backend::DesktopBackend::Kms { return -1; }
|
||||
if let Some(portal)=self.portal.lock().unwrap().as_ref() { return self.portal_result("button", portal.button(button,pressed)); }
|
||||
if let Some(portal)=self.portal.lock().unwrap().as_ref() {
|
||||
let _serial=lock_portal_held();
|
||||
let result=self.portal_result("button", portal.button(button,pressed));
|
||||
if result==0 { self.record_portal_button(button,pressed); }
|
||||
return result;
|
||||
}
|
||||
if self.backend==crate::desktop_backend::DesktopBackend::Portal {return self.portal_result("button", Err("Portal input session is not bound".into()));}
|
||||
if self.backend==crate::desktop_backend::DesktopBackend::Wayland { crate::wayland::button(button,pressed) }
|
||||
else { unsafe { x11_mouse_button(button,i32::from(pressed)) } }
|
||||
@@ -622,7 +694,12 @@ impl InputInjector {
|
||||
if let Some(code)=crate::uinput::keysym_to_evdev(symbol) { return Self::uinput_result(uinput.key(code,pressed)); }
|
||||
}
|
||||
if self.backend==crate::desktop_backend::DesktopBackend::Kms { return -1; }
|
||||
if let Some(portal)=self.portal.lock().unwrap().as_ref() { return self.portal_result("keyboard", portal.key(symbol,pressed)); }
|
||||
if let Some(portal)=self.portal.lock().unwrap().as_ref() {
|
||||
let _serial=lock_portal_held();
|
||||
let result=self.portal_result("keyboard", portal.key(symbol,pressed));
|
||||
if result==0 { self.record_portal_key(symbol,pressed); }
|
||||
return result;
|
||||
}
|
||||
if self.backend==crate::desktop_backend::DesktopBackend::Portal {return self.portal_result("keyboard", Err("Portal input session is not bound".into()));}
|
||||
if self.backend==crate::desktop_backend::DesktopBackend::Wayland { crate::wayland::key(symbol,pressed) }
|
||||
else { unsafe { x11_key_symbol(symbol as libc::c_ulong,i32::from(pressed)) } }
|
||||
@@ -1310,7 +1387,8 @@ mod touch_tests {
|
||||
assert!(!Controller::Mac.is_mobile());
|
||||
assert_eq!(Controller::from_platform(Some(&json!(4))), Controller::Mac);
|
||||
assert_eq!(Controller::from_platform(Some(&json!("MacOS"))), Controller::Mac);
|
||||
assert_eq!(Controller::from_platform(Some(&json!(1))), Controller::Other);
|
||||
assert_eq!(Controller::from_platform(Some(&json!(1))), Controller::Windows);
|
||||
assert_eq!(Controller::from_platform(Some(&json!("Windows"))), Controller::Windows);
|
||||
assert_eq!(Controller::from_platform(None), Controller::Other);
|
||||
}
|
||||
#[test]
|
||||
|
||||
+5
-2
@@ -45,6 +45,7 @@ mod damage_capture;
|
||||
mod inproc_encoder;
|
||||
mod capture_setting;
|
||||
mod audio;
|
||||
mod microphone;
|
||||
mod virtual_audio;
|
||||
mod privacy_screen;
|
||||
mod system_actions;
|
||||
@@ -649,6 +650,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
privacy_screen::recover();
|
||||
virtual_audio::init();
|
||||
let _audio_cleanup=virtual_audio::Cleanup;
|
||||
microphone::init();
|
||||
let _microphone_cleanup = microphone::Cleanup;
|
||||
log::info!("Starting uu-remote-linux host v{}...", env!("CARGO_PKG_VERSION"));
|
||||
session_ice::configure_relay_transport();
|
||||
// Before host.pid, and before assist: a missing or failed assist session must still handle SIGUSR2.
|
||||
@@ -685,7 +688,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
}
|
||||
#[cfg(not(target_os="linux"))]
|
||||
let _ = tokio::signal::ctrl_c().await;
|
||||
if !assist_enabled { privacy_screen::shutdown(); shutdown_input.shutdown(); virtual_audio::disable(); terminal::shutdown_all(); std::process::exit(0); }
|
||||
if !assist_enabled { privacy_screen::shutdown(); shutdown_input.shutdown(); microphone::shutdown().await; virtual_audio::disable(); terminal::shutdown_all(); std::process::exit(0); }
|
||||
let _ = signal_tx.send(true);
|
||||
});
|
||||
let mut assist = if assist_enabled { Some(assist::Assist::start(&mut shutdown, unified).await?) } else { None };
|
||||
@@ -716,7 +719,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
// One exit path for commands, signals, transport failures and UI failures.
|
||||
if let Some(session) = assist.as_mut() { session.allowed = false; }
|
||||
for (_, old) in webrtc_sessions.lock().await.drain() { close_peer(&old.pc).await; }
|
||||
privacy_screen::shutdown(); virtual_audio::disable(); input.shutdown(); terminal::shutdown_all();
|
||||
privacy_screen::shutdown(); microphone::shutdown().await; virtual_audio::disable(); input.shutdown(); terminal::shutdown_all();
|
||||
// Switching identity (signed in / out) restarts at once and the new identity republishes the same
|
||||
// device share: logout already withdrew it, and after a QR login the cloud moved it to the account
|
||||
// (a guest cancel then fails). Only a real stop withdraws here.
|
||||
|
||||
@@ -0,0 +1,439 @@
|
||||
//! Controller Opus -> a dedicated virtual microphone. Never record or log audio payloads.
|
||||
//! Opt in with UU_MICROPHONE=1. The normal desktop-output/monitor route is not changed.
|
||||
use std::collections::HashMap;
|
||||
use std::os::fd::AsRawFd;
|
||||
use std::process::{Command, Stdio};
|
||||
use std::sync::{Arc, Mutex, OnceLock, atomic::{AtomicBool, Ordering}};
|
||||
use std::time::Duration;
|
||||
use tokio::io::{AsyncWrite, AsyncWriteExt};
|
||||
use tokio::sync::watch;
|
||||
use webrtc::{peer_connection::{RTCPeerConnection, peer_connection_state::RTCPeerConnectionState},
|
||||
rtp::packet::Packet, rtp_transceiver::rtp_codec::RTPCodecType, track::track_remote::TrackRemote};
|
||||
|
||||
mod pulse;
|
||||
|
||||
pub const SOURCE: &str = "uu-remote-microphone";
|
||||
const SINK: &str = "uu-remote-mic-input";
|
||||
const MAX_PACKETS: u16 = 12;
|
||||
static AVAILABLE: AtomicBool = AtomicBool::new(false);
|
||||
static ROUTE: OnceLock<Mutex<Option<Route>>> = OnceLock::new();
|
||||
struct Workers { stopped: watch::Sender<bool>, active: watch::Sender<usize> }
|
||||
fn workers() -> &'static Workers {
|
||||
static STATE: OnceLock<Workers> = OnceLock::new();
|
||||
STATE.get_or_init(|| Workers { stopped: watch::channel(false).0, active: watch::channel(0).0 })
|
||||
}
|
||||
struct Worker;
|
||||
impl Worker {
|
||||
fn new() -> Self { workers().active.send_modify(|count| *count += 1); Self }
|
||||
}
|
||||
impl Drop for Worker {
|
||||
fn drop(&mut self) { workers().active.send_modify(|count| *count -= 1); }
|
||||
}
|
||||
struct Module { id: u32, kind: &'static str, args: Vec<String> }
|
||||
struct Route { source: Module, sink: Module, _lock: std::fs::File }
|
||||
|
||||
pub fn requested() -> bool { std::env::var("UU_MICROPHONE").is_ok_and(|v| v == "1") }
|
||||
pub fn available() -> bool { AVAILABLE.load(Ordering::Acquire) }
|
||||
pub fn policy_request(rpc: &[crate::protocol::WireField]) -> Option<u64> {
|
||||
use crate::protocol::{decode_wire, WireValue};
|
||||
let body = rpc.iter().find_map(|f| match (f.number, &f.value) { (21, WireValue::Bytes(b)) => Some(*b), _ => None })?;
|
||||
let fields = decode_wire(body).ok()?;
|
||||
Some(fields.iter().find_map(|f| match (f.number, &f.value) { (1, WireValue::Varint(v)) => Some(*v), _ => None }).unwrap_or(0))
|
||||
}
|
||||
fn pactl(args: &[&str]) -> Result<String, String> {
|
||||
let out = Command::new("pactl").args(args).env("LC_ALL", "C")
|
||||
.stdin(Stdio::null()).stderr(Stdio::null()).output().map_err(|_| "pactl unavailable")?;
|
||||
if !out.status.success() { return Err("PulseAudio virtual microphone operation failed".into()); }
|
||||
Ok(String::from_utf8_lossy(&out.stdout).trim().to_owned())
|
||||
}
|
||||
impl Module {
|
||||
fn matching_id(line: &str, kind: &str, args: &[String]) -> Option<u32> {
|
||||
let mut fields = line.split('\t');
|
||||
let id = fields.next()?.parse().ok()?;
|
||||
if fields.next()? != kind { return None; }
|
||||
let actual: Vec<_> = fields.next()?.split_whitespace().collect();
|
||||
(actual.len() == args.len() && args.iter().all(|arg| actual.contains(&arg.as_str()))).then_some(id)
|
||||
}
|
||||
fn open(kind: &'static str, args: Vec<String>) -> Result<Self, String> {
|
||||
let modules = pactl(&["list", "short", "modules"])?;
|
||||
let key = &args[0];
|
||||
let named: Vec<_> = modules.lines().filter(|line| line.split('\t').nth(2)
|
||||
.is_some_and(|a| a.split_whitespace().any(|a| a == key))).collect();
|
||||
let id = if named.is_empty() {
|
||||
let mut command = vec!["load-module", kind];
|
||||
command.extend(args.iter().map(String::as_str));
|
||||
pactl(&command)?.parse().map_err(|_| "Virtual microphone module returned no id")?
|
||||
} else if named.len() == 1 {
|
||||
Self::matching_id(named[0], kind, &args).ok_or("Virtual microphone name already belongs to another module")?
|
||||
} else {
|
||||
return Err("Virtual microphone module ownership is ambiguous".into());
|
||||
};
|
||||
Ok(Self { id, kind, args })
|
||||
}
|
||||
fn unload(&self) {
|
||||
// Audio-server restarts may reuse numeric ids; never unload an unrelated replacement.
|
||||
if pactl(&["list", "short", "modules"]).is_ok_and(|list| list.lines()
|
||||
.any(|line| Self::matching_id(line, self.kind, &self.args) == Some(self.id))) {
|
||||
let _ = pactl(&["unload-module", &self.id.to_string()]);
|
||||
}
|
||||
}
|
||||
}
|
||||
fn route_lock_path(source: &str) -> Result<std::path::PathBuf, String> {
|
||||
use std::os::unix::fs::{DirBuilderExt, MetadataExt};
|
||||
// Fixed per-user endpoints need a lock shared even by launchers with different UU_CONFIG,
|
||||
// XDG_RUNTIME_DIR or TMPDIR. Only the lock inode persists; flock releases on process exit.
|
||||
let dir = std::path::PathBuf::from(format!("/tmp/uu-remote-linux-{}", unsafe { libc::geteuid() }));
|
||||
std::fs::DirBuilder::new().recursive(true).mode(0o700).create(&dir)
|
||||
.map_err(|_| "Microphone runtime directory unavailable")?;
|
||||
let metadata = std::fs::symlink_metadata(&dir).map_err(|_| "Microphone runtime directory unavailable")?;
|
||||
if !metadata.is_dir() || metadata.uid() != unsafe { libc::geteuid() } || metadata.mode() & 0o077 != 0 {
|
||||
return Err("Microphone runtime directory is not private".into());
|
||||
}
|
||||
Ok(dir.join(format!("{source}.lock")))
|
||||
}
|
||||
fn route_lock(source: &str) -> Result<std::fs::File, String> {
|
||||
use std::os::unix::fs::OpenOptionsExt;
|
||||
let lock = std::fs::OpenOptions::new().read(true).write(true).create(true).truncate(false).mode(0o600)
|
||||
.custom_flags(libc::O_NOFOLLOW | libc::O_CLOEXEC).open(route_lock_path(source)?)
|
||||
.map_err(|_| "Microphone ownership lock unavailable")?;
|
||||
if unsafe { libc::flock(lock.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) } != 0 {
|
||||
return Err("Another host owns the virtual microphone".into());
|
||||
}
|
||||
Ok(lock)
|
||||
}
|
||||
fn native_pulse(info: &str) -> Result<bool, String> {
|
||||
let field = |key: &str| info.lines().find_map(|line| line.strip_prefix(key).map(str::trim));
|
||||
let name = field("Server Name:").ok_or("Microphone audio server unavailable")?;
|
||||
if name.to_ascii_lowercase().contains("pipewire") { return Ok(false); }
|
||||
if !name.eq_ignore_ascii_case("pulseaudio") { return Err("Unsupported microphone audio server".into()); }
|
||||
let major = field("Server Version:").and_then(|v| v.split('.').next()).and_then(|v| v.parse::<u32>().ok());
|
||||
if !major.is_some_and(|v| v >= 13) { return Err("Remote microphone requires PulseAudio 13 or newer".into()); }
|
||||
Ok(true)
|
||||
}
|
||||
fn sink_args(name: &str) -> Result<Vec<String>, String> {
|
||||
let description = crate::i18n::s("UU-远程麦克风输入", "UU-Remote-Microphone-Input");
|
||||
let mut args = vec![format!("sink_name={name}"), format!("sink_properties=device.description={description}"),
|
||||
"rate=48000".into(), "channels=2".into()];
|
||||
// PulseAudio 13+: norewinds starts the null sink with a 50 ms block instead of 2 s of
|
||||
// idle silence. PipeWire's compatible module does not accept this Pulse-only argument.
|
||||
if native_pulse(&pactl(&["info"])?)? { args.push("norewinds=1".into()); }
|
||||
Ok(args)
|
||||
}
|
||||
impl Route {
|
||||
fn new(sink_name: &str, source_name: &str) -> Result<Self, String> {
|
||||
let lock = route_lock(source_name)?;
|
||||
let sink = Module::open("module-null-sink", sink_args(sink_name)?)?;
|
||||
let description = crate::i18n::s("UU-远程麦克风", "UU-Remote-Microphone");
|
||||
let source = Module::open("module-remap-source", vec![format!("source_name={source_name}"),
|
||||
format!("master={sink_name}.monitor"), format!("source_properties=device.description={description}"),
|
||||
"rate=48000".into(), "channels=2".into()]);
|
||||
match source {
|
||||
Ok(source) => Ok(Route { source, sink, _lock: lock }),
|
||||
Err(e) => { sink.unload(); Err(e) }
|
||||
}
|
||||
}
|
||||
}
|
||||
impl Drop for Route {
|
||||
fn drop(&mut self) { self.source.unload(); self.sink.unload(); }
|
||||
}
|
||||
pub struct Cleanup;
|
||||
impl Drop for Cleanup {
|
||||
fn drop(&mut self) {
|
||||
AVAILABLE.store(false, Ordering::Release);
|
||||
workers().stopped.send_replace(true);
|
||||
// On an unexpected unwind leave recovery to the next run rather than move a live stream
|
||||
// off its disappearing sink. Normal shutdown waits for every playback worker below.
|
||||
if *workers().active.borrow() == 0 { release_route(); }
|
||||
}
|
||||
}
|
||||
pub fn init() {
|
||||
if !requested() { return; }
|
||||
let mut state = ROUTE.get_or_init(|| Mutex::new(None)).lock().unwrap();
|
||||
if state.is_some() { return; }
|
||||
let result = (|| {
|
||||
let _ = Decoder::new()?;
|
||||
pulse::available()?;
|
||||
Route::new(SINK, SOURCE)
|
||||
})();
|
||||
match result {
|
||||
Ok(route) => {
|
||||
*state = Some(route);
|
||||
workers().stopped.send_replace(false);
|
||||
AVAILABLE.store(true, Ordering::Release);
|
||||
log::info!("Remote microphone virtual input ready (48 kHz stereo, pinned Pulse stream)");
|
||||
}
|
||||
Err(error) => log::warn!("Remote microphone unavailable: {error}"),
|
||||
}
|
||||
}
|
||||
pub async fn shutdown() {
|
||||
AVAILABLE.store(false, Ordering::Release);
|
||||
workers().stopped.send_replace(true);
|
||||
let mut active = workers().active.subscribe();
|
||||
let _ = active.wait_for(|count| *count == 0).await;
|
||||
release_route();
|
||||
}
|
||||
fn release_route() {
|
||||
if let Some(state) = ROUTE.get() {
|
||||
state.lock().unwrap().take();
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(target_os = "linux")]
|
||||
struct Opus {
|
||||
_handle: usize,
|
||||
create: unsafe extern "C" fn(i32, i32, *mut i32) -> *mut libc::c_void,
|
||||
destroy: unsafe extern "C" fn(*mut libc::c_void),
|
||||
decode: unsafe extern "C" fn(*mut libc::c_void, *const u8, i32, *mut i16, i32, i32) -> i32,
|
||||
samples: unsafe extern "C" fn(*const u8, i32, i32) -> i32,
|
||||
}
|
||||
#[cfg(target_os = "linux")]
|
||||
fn opus() -> Result<&'static Opus, String> {
|
||||
static LIB: OnceLock<Option<Opus>> = OnceLock::new();
|
||||
LIB.get_or_init(|| unsafe {
|
||||
let handle = libc::dlopen(c"libopus.so.0".as_ptr(), libc::RTLD_NOW | libc::RTLD_LOCAL);
|
||||
if handle.is_null() { return None; }
|
||||
let names = [c"opus_decoder_create", c"opus_decoder_destroy", c"opus_decode", c"opus_packet_get_nb_samples"];
|
||||
let functions: Vec<_> = names.iter().map(|name| libc::dlsym(handle, name.as_ptr())).collect();
|
||||
if functions.iter().any(|f| f.is_null()) { libc::dlclose(handle); return None; }
|
||||
// The library stays loaded for the process lifetime; signatures match the public Opus API.
|
||||
Some(Opus { _handle: handle as usize, create: std::mem::transmute(functions[0]),
|
||||
destroy: std::mem::transmute(functions[1]), decode: std::mem::transmute(functions[2]),
|
||||
samples: std::mem::transmute(functions[3]) })
|
||||
}).as_ref().ok_or_else(|| "libopus runtime unavailable".into())
|
||||
}
|
||||
struct Decoder(*mut libc::c_void);
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
enum Frame { Opus(Vec<u8>), Conceal(u32) }
|
||||
// One task owns the decoder and all calls; no decoder state is shared concurrently.
|
||||
unsafe impl Send for Decoder {}
|
||||
impl Decoder {
|
||||
fn new() -> Result<Self, String> {
|
||||
#[cfg(target_os = "linux")] {
|
||||
let mut error = 0;
|
||||
let decoder = unsafe { (opus()?.create)(48000, 2, &mut error) };
|
||||
if error == 0 && !decoder.is_null() { return Ok(Self(decoder)); }
|
||||
}
|
||||
Err("Opus microphone decoder unavailable".into())
|
||||
}
|
||||
fn decode(&mut self, frame: &Frame) -> Result<(Vec<u8>, u32), String> {
|
||||
#[cfg(target_os = "linux")] {
|
||||
let (packet, size) = match frame {
|
||||
Frame::Opus(data) if valid_packet(data) => (Some(data.as_slice()), 5760),
|
||||
Frame::Conceal(samples) if (120..=5760).contains(samples) && samples % 120 == 0 => (None, *samples as i32),
|
||||
_ => return Err("Invalid microphone Opus frame".into()),
|
||||
};
|
||||
let data = packet.unwrap_or(&[]);
|
||||
let mut pcm = vec![0i16; 5760 * 2];
|
||||
let samples = unsafe { (opus()?.decode)(self.0, if packet.is_some() { data.as_ptr() } else { std::ptr::null() },
|
||||
data.len() as i32, pcm.as_mut_ptr(), size, 0) };
|
||||
if samples <= 0 { return Err("Microphone Opus decode failed".into()); }
|
||||
let bytes = pcm[..samples as usize * 2].iter().flat_map(|s| s.to_le_bytes()).collect();
|
||||
return Ok((bytes, samples as u32));
|
||||
}
|
||||
#[allow(unreachable_code)] { let _ = frame; Err("Microphone decoding requires Linux".into()) }
|
||||
}
|
||||
}
|
||||
impl Drop for Decoder {
|
||||
fn drop(&mut self) { #[cfg(target_os = "linux")] if let Ok(lib) = opus() { unsafe { (lib.destroy)(self.0); } } }
|
||||
}
|
||||
fn packet_samples(data: &[u8]) -> Option<u32> {
|
||||
if data.is_empty() || data.len() > 8192 { return None; }
|
||||
#[cfg(target_os = "linux")] {
|
||||
let samples = unsafe { (opus().ok()?.samples)(data.as_ptr(), data.len() as i32, 48000) };
|
||||
return (120..=5760).contains(&samples).then_some(samples as u32);
|
||||
}
|
||||
#[allow(unreachable_code)] None
|
||||
}
|
||||
fn valid_packet(data: &[u8]) -> bool { packet_samples(data).is_some() }
|
||||
|
||||
/// Fixed memory and bounded reordering across sequence wrap; stale backlog is discarded.
|
||||
#[derive(Default)]
|
||||
struct Jitter { next: Option<u16>, timestamp: Option<u32>, last_samples: Option<u32>, packets: HashMap<u16, QueuedPacket> }
|
||||
struct QueuedPacket { timestamp: u32, samples: u32, payload: Vec<u8> }
|
||||
impl Jitter {
|
||||
fn push(&mut self, packet: Packet) {
|
||||
let Some(samples) = packet_samples(&packet.payload) else { return; };
|
||||
let seq = packet.header.sequence_number;
|
||||
let next = *self.next.get_or_insert(seq);
|
||||
let ahead = seq.wrapping_sub(next);
|
||||
if ahead >= 0x8000 { return; }
|
||||
if ahead >= MAX_PACKETS { self.packets.clear(); self.next = Some(seq); self.timestamp = None; }
|
||||
self.packets.entry(seq).or_insert_with(|| QueuedPacket {
|
||||
timestamp: packet.header.timestamp, samples, payload: packet.payload.to_vec(),
|
||||
});
|
||||
}
|
||||
/// A future packet's RTP clock bounds the missing audio, including variable packet durations.
|
||||
fn pop(&mut self) -> Option<Frame> {
|
||||
if self.packets.is_empty() { return None; }
|
||||
let seq = self.next?;
|
||||
self.next = Some(seq.wrapping_add(1));
|
||||
if let Some(packet) = self.packets.remove(&seq) {
|
||||
self.timestamp = Some(packet.timestamp.wrapping_add(packet.samples));
|
||||
self.last_samples = Some(packet.samples);
|
||||
return Some(Frame::Opus(packet.payload));
|
||||
}
|
||||
let inferred = self.timestamp.and_then(|timestamp| {
|
||||
let (&future, packet) = self.packets.iter().min_by_key(|(n, _)| n.wrapping_sub(seq))?;
|
||||
let missing = u32::from(future.wrapping_sub(seq));
|
||||
let gap = packet.timestamp.wrapping_sub(timestamp);
|
||||
// Ignore timestamp discontinuities/DTX; do not manufacture seconds of concealment.
|
||||
(missing > 0 && (missing * 120..=missing * 5760).contains(&gap) && gap % 120 == 0)
|
||||
.then(|| gap / missing / 120 * 120)
|
||||
});
|
||||
let samples = inferred.or(self.last_samples).unwrap_or(960);
|
||||
self.timestamp = self.timestamp.map(|timestamp| timestamp.wrapping_add(samples));
|
||||
Some(Frame::Conceal(samples))
|
||||
}
|
||||
}
|
||||
|
||||
type Writer = std::pin::Pin<Box<dyn AsyncWrite + Send>>;
|
||||
struct Playback { decoder: Decoder, writer: Writer, output: Option<pulse::Output> }
|
||||
impl Playback {
|
||||
fn new() -> Result<Self, String> {
|
||||
Self::at(SINK)
|
||||
}
|
||||
fn at(sink: &str) -> Result<Self, String> {
|
||||
let decoder = Decoder::new()?;
|
||||
let (writer, output) = pulse::start(sink)?;
|
||||
Ok(Self { decoder, writer: Box::pin(writer), output: Some(output) })
|
||||
}
|
||||
async fn write(&mut self, frame: &Frame) -> Result<u32, String> {
|
||||
let (bytes, samples) = self.decoder.decode(frame)?;
|
||||
match tokio::time::timeout(Duration::from_millis(200), self.writer.write_all(&bytes)).await {
|
||||
Ok(Ok(())) => {},
|
||||
Ok(Err(_)) => {
|
||||
if let Some(output) = self.output.as_mut() {
|
||||
if let Err(error) = output.stop().await { return Err(error); }
|
||||
}
|
||||
return Err("Microphone playback ended".into());
|
||||
},
|
||||
Err(_) => return Err("Microphone playback stalled".into()),
|
||||
}
|
||||
Ok(samples)
|
||||
}
|
||||
async fn stop(&mut self) {
|
||||
if let Some(output) = self.output.as_mut() { let _ = output.stop().await; }
|
||||
}
|
||||
}
|
||||
|
||||
type Factory = Arc<dyn Fn() -> Result<Playback, String> + Send + Sync>;
|
||||
#[derive(Clone)]
|
||||
pub struct Session { open: watch::Sender<bool>, owner: watch::Sender<u64>, serial: Arc<Mutex<()>>, factory: Factory }
|
||||
impl Session {
|
||||
pub fn new() -> Self {
|
||||
// Do not request or accept capture until the controller explicitly enables it.
|
||||
Self { open: watch::channel(false).0, owner: watch::channel(0).0, serial: Arc::new(Mutex::new(())), factory: Arc::new(Playback::new) }
|
||||
}
|
||||
/// Official SimpleAction map: 23 microphone_opened, 24 microphone_closed.
|
||||
pub fn action(&self, action: u64) -> bool {
|
||||
self.action_with(action, || {})
|
||||
}
|
||||
/// Commit the gate and enqueue its notifications as one ordered transition across channels.
|
||||
/// The callback only queues messages; actual network sends must happen outside this lock.
|
||||
pub fn action_with(&self, action: u64, enqueue: impl FnOnce()) -> bool {
|
||||
match action {
|
||||
23 | 24 => {
|
||||
let _serial = self.serial.lock().unwrap();
|
||||
self.open.send_replace(action == 23);
|
||||
enqueue();
|
||||
log::info!("Remote microphone switch: open={}", action == 23);
|
||||
true
|
||||
},
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
fn claim_track(&self) -> (u64, watch::Receiver<u64>) {
|
||||
let owner = self.owner.subscribe();
|
||||
let mut generation = 0;
|
||||
self.owner.send_modify(|id| { *id = id.wrapping_add(1); generation = *id; });
|
||||
(generation, owner)
|
||||
}
|
||||
pub fn attach(&self, pc: &Arc<RTCPeerConnection>, active: watch::Receiver<bool>) {
|
||||
let weak = Arc::downgrade(pc);
|
||||
let session = self.clone();
|
||||
pc.on_track(Box::new(move |track, _, _| {
|
||||
let (session, active, weak) = (session.clone(), active.clone(), weak.clone());
|
||||
Box::pin(async move {
|
||||
if track.kind() != RTPCodecType::Audio { return; }
|
||||
if !track.codec().capability.mime_type.eq_ignore_ascii_case("audio/opus") {
|
||||
log::warn!("Incoming microphone track uses an unsupported codec"); return;
|
||||
}
|
||||
log::info!("Incoming microphone Opus track received");
|
||||
if let Some(pc) = weak.upgrade() {
|
||||
let (generation, owner) = session.claim_track();
|
||||
let worker = Worker::new();
|
||||
tokio::spawn(session.receive(track, pc, active, generation, owner, worker));
|
||||
}
|
||||
})
|
||||
}));
|
||||
}
|
||||
async fn receive(self, track: Arc<TrackRemote>, pc: Arc<RTCPeerConnection>, mut active: watch::Receiver<bool>,
|
||||
generation: u64, mut owner: watch::Receiver<u64>, _worker: Worker) {
|
||||
let mut stopped = workers().stopped.subscribe();
|
||||
let mut open = self.open.subscribe();
|
||||
let mut jitter = Jitter::default();
|
||||
let mut player: Option<Playback> = None;
|
||||
let mut next = tokio::time::Instant::now();
|
||||
let mut health = tokio::time::interval(Duration::from_millis(100));
|
||||
let mut played = 0u64;
|
||||
let mut lost = 0u64;
|
||||
// TrackRemote reads are not cancel safe. Keep the same future across timer and gate ticks.
|
||||
let mut pending = Box::pin(track.read_rtp());
|
||||
loop {
|
||||
// A worker can first run after its replacement has already subscribed. Check the id,
|
||||
// not only changed(): both receivers may otherwise have marked the latest id as seen.
|
||||
if *stopped.borrow() || *owner.borrow_and_update() != generation { break; }
|
||||
let allowed = *open.borrow() && *active.borrow() && pc.connection_state() == RTCPeerConnectionState::Connected;
|
||||
if !allowed {
|
||||
jitter = Jitter::default();
|
||||
if let Some(mut output) = player.take() { output.stop().await; log::info!("Remote microphone playback paused"); }
|
||||
}
|
||||
tokio::select! {
|
||||
biased;
|
||||
_ = stopped.changed() => break,
|
||||
_ = owner.changed() => break,
|
||||
change = open.changed() => {
|
||||
if change.is_err() { break; }
|
||||
jitter = Jitter::default();
|
||||
if let Some(mut output) = player.take() { output.stop().await; }
|
||||
},
|
||||
change = active.changed() => if change.is_err() { break; },
|
||||
_ = health.tick() => {
|
||||
if matches!(pc.connection_state(), RTCPeerConnectionState::Closed | RTCPeerConnectionState::Failed) { break; }
|
||||
},
|
||||
_ = tokio::time::sleep_until(next), if player.is_some() && allowed => {
|
||||
if let Some(packet) = jitter.pop() {
|
||||
if matches!(packet, Frame::Conceal(_)) { lost += 1; }
|
||||
match player.as_mut().unwrap().write(&packet).await {
|
||||
Ok(samples) => {
|
||||
played += 1;
|
||||
next = (next + Duration::from_secs_f64(f64::from(samples) / 48000.)).max(tokio::time::Instant::now());
|
||||
if played == 1 || played % 250 == 0 { log::info!("Remote microphone playback: frames={played} concealed={lost}"); }
|
||||
},
|
||||
Err(error) => { log::warn!("{error}"); break; }
|
||||
}
|
||||
} else {
|
||||
next = tokio::time::Instant::now() + Duration::from_millis(10);
|
||||
}
|
||||
},
|
||||
received = &mut pending => {
|
||||
let Ok((packet, _)) = received else { break; };
|
||||
pending.set(track.read_rtp());
|
||||
if !allowed || !valid_packet(&packet.payload) { continue; }
|
||||
if player.is_none() {
|
||||
match (self.factory)() {
|
||||
Ok(output) => { player = Some(output); next = tokio::time::Instant::now() + Duration::from_millis(40); },
|
||||
Err(error) => { log::warn!("{error}"); break; }
|
||||
}
|
||||
}
|
||||
jitter.push(packet);
|
||||
},
|
||||
}
|
||||
}
|
||||
if let Some(mut output) = player { output.stop().await; }
|
||||
log::info!("Remote microphone track ended: frames={played} concealed={lost}");
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
@@ -0,0 +1,187 @@
|
||||
//! Pulse playback pinned with PA_STREAM_DONT_MOVE, supported by PulseAudio and PipeWire-pulse.
|
||||
//! Load the stable public C API at runtime so opt-out builds need no Pulse development package.
|
||||
use std::ffi::{CStr, CString};
|
||||
use std::sync::OnceLock;
|
||||
use std::time::{Duration, Instant};
|
||||
use tokio::io::{AsyncReadExt, DuplexStream};
|
||||
use tokio::sync::watch;
|
||||
|
||||
type Handle = *mut libc::c_void;
|
||||
type Free = Option<unsafe extern "C" fn(Handle)>;
|
||||
#[repr(C)]
|
||||
struct SampleSpec { format: i32, rate: u32, channels: u8 }
|
||||
#[repr(C)]
|
||||
struct BufferAttr { maxlength: u32, tlength: u32, prebuf: u32, minreq: u32, fragsize: u32 }
|
||||
|
||||
struct Api {
|
||||
_library: usize,
|
||||
mainloop_new: unsafe extern "C" fn() -> Handle,
|
||||
mainloop_free: unsafe extern "C" fn(Handle),
|
||||
mainloop_get_api: unsafe extern "C" fn(Handle) -> Handle,
|
||||
mainloop_iterate: unsafe extern "C" fn(Handle, i32, *mut i32) -> i32,
|
||||
context_new: unsafe extern "C" fn(Handle, *const libc::c_char) -> Handle,
|
||||
context_connect: unsafe extern "C" fn(Handle, *const libc::c_char, u32, Handle) -> i32,
|
||||
context_get_state: unsafe extern "C" fn(Handle) -> i32,
|
||||
context_disconnect: unsafe extern "C" fn(Handle),
|
||||
context_unref: unsafe extern "C" fn(Handle),
|
||||
stream_new: unsafe extern "C" fn(Handle, *const libc::c_char, *const SampleSpec, Handle) -> Handle,
|
||||
stream_connect_playback: unsafe extern "C" fn(Handle, *const libc::c_char, *const BufferAttr, u32, Handle, Handle) -> i32,
|
||||
stream_get_state: unsafe extern "C" fn(Handle) -> i32,
|
||||
stream_get_device_name: unsafe extern "C" fn(Handle) -> *const libc::c_char,
|
||||
stream_writable_size: unsafe extern "C" fn(Handle) -> usize,
|
||||
stream_write: unsafe extern "C" fn(Handle, *const libc::c_void, usize, Free, i64, i32) -> i32,
|
||||
stream_disconnect: unsafe extern "C" fn(Handle) -> i32,
|
||||
stream_unref: unsafe extern "C" fn(Handle),
|
||||
}
|
||||
fn api() -> Result<&'static Api, String> {
|
||||
static API: OnceLock<Option<Api>> = OnceLock::new();
|
||||
API.get_or_init(|| unsafe {
|
||||
let library = libc::dlopen(c"libpulse.so.0".as_ptr(), libc::RTLD_NOW | libc::RTLD_LOCAL);
|
||||
if library.is_null() { return None; }
|
||||
macro_rules! load {
|
||||
($name:expr, $signature:ty) => {{
|
||||
let function = libc::dlsym(library, $name.as_ptr());
|
||||
if function.is_null() { return None; }
|
||||
std::mem::transmute::<Handle, $signature>(function)
|
||||
}};
|
||||
}
|
||||
let result = (|| Some(Api {
|
||||
_library: library as usize,
|
||||
mainloop_new: load!(c"pa_mainloop_new", unsafe extern "C" fn() -> Handle),
|
||||
mainloop_free: load!(c"pa_mainloop_free", unsafe extern "C" fn(Handle)),
|
||||
mainloop_get_api: load!(c"pa_mainloop_get_api", unsafe extern "C" fn(Handle) -> Handle),
|
||||
mainloop_iterate: load!(c"pa_mainloop_iterate", unsafe extern "C" fn(Handle, i32, *mut i32) -> i32),
|
||||
context_new: load!(c"pa_context_new", unsafe extern "C" fn(Handle, *const libc::c_char) -> Handle),
|
||||
context_connect: load!(c"pa_context_connect", unsafe extern "C" fn(Handle, *const libc::c_char, u32, Handle) -> i32),
|
||||
context_get_state: load!(c"pa_context_get_state", unsafe extern "C" fn(Handle) -> i32),
|
||||
context_disconnect: load!(c"pa_context_disconnect", unsafe extern "C" fn(Handle)),
|
||||
context_unref: load!(c"pa_context_unref", unsafe extern "C" fn(Handle)),
|
||||
stream_new: load!(c"pa_stream_new", unsafe extern "C" fn(Handle, *const libc::c_char, *const SampleSpec, Handle) -> Handle),
|
||||
stream_connect_playback: load!(c"pa_stream_connect_playback", unsafe extern "C" fn(Handle, *const libc::c_char, *const BufferAttr, u32, Handle, Handle) -> i32),
|
||||
stream_get_state: load!(c"pa_stream_get_state", unsafe extern "C" fn(Handle) -> i32),
|
||||
stream_get_device_name: load!(c"pa_stream_get_device_name", unsafe extern "C" fn(Handle) -> *const libc::c_char),
|
||||
stream_writable_size: load!(c"pa_stream_writable_size", unsafe extern "C" fn(Handle) -> usize),
|
||||
stream_write: load!(c"pa_stream_write", unsafe extern "C" fn(Handle, *const libc::c_void, usize, Free, i64, i32) -> i32),
|
||||
stream_disconnect: load!(c"pa_stream_disconnect", unsafe extern "C" fn(Handle) -> i32),
|
||||
stream_unref: load!(c"pa_stream_unref", unsafe extern "C" fn(Handle)),
|
||||
}))();
|
||||
if result.is_none() { libc::dlclose(library); }
|
||||
result
|
||||
}).as_ref().ok_or_else(|| "libpulse runtime unavailable".into())
|
||||
}
|
||||
pub(super) fn available() -> Result<(), String> { api().map(|_| ()) }
|
||||
|
||||
struct Stream { api: &'static Api, mainloop: Handle, context: Handle, stream: Handle }
|
||||
impl Drop for Stream {
|
||||
fn drop(&mut self) { unsafe {
|
||||
if !self.stream.is_null() { (self.api.stream_disconnect)(self.stream); (self.api.stream_unref)(self.stream); }
|
||||
if !self.context.is_null() { (self.api.context_disconnect)(self.context); (self.api.context_unref)(self.context); }
|
||||
if !self.mainloop.is_null() { (self.api.mainloop_free)(self.mainloop); }
|
||||
} }
|
||||
}
|
||||
impl Stream {
|
||||
fn connect(api: &'static Api, sink: &CStr, stopped: &watch::Receiver<bool>) -> Result<Self, String> { unsafe {
|
||||
let mut output = Self { api, mainloop: (api.mainloop_new)(), context: std::ptr::null_mut(), stream: std::ptr::null_mut() };
|
||||
if output.mainloop.is_null() { return Err("Microphone audio loop unavailable".into()); }
|
||||
let client = CString::new(crate::i18n::s("UU 远程麦克风", "UU Remote microphone")).unwrap();
|
||||
output.context = (api.context_new)((api.mainloop_get_api)(output.mainloop), client.as_ptr());
|
||||
// PA_CONTEXT_NOAUTOSPAWN: connecting to the configured server must not start another one.
|
||||
if output.context.is_null() || (api.context_connect)(output.context, std::ptr::null(), 1, std::ptr::null_mut()) < 0 {
|
||||
return Err("Microphone audio server unavailable".into());
|
||||
}
|
||||
let context = output.context;
|
||||
output.wait(stopped, || (api.context_get_state)(context) == 4)?; // PA_CONTEXT_READY
|
||||
let spec = SampleSpec { format: 3, rate: 48000, channels: 2 }; // PA_SAMPLE_S16LE
|
||||
let name = CString::new(crate::i18n::s("远程麦克风", "Remote-Microphone")).unwrap();
|
||||
output.stream = (api.stream_new)(context, name.as_ptr(), &spec, std::ptr::null_mut());
|
||||
let attr = BufferAttr { maxlength: u32::MAX, tlength: 5760, prebuf: u32::MAX, minreq: 1920, fragsize: u32::MAX };
|
||||
// pulse/def.h: PA_STREAM_DONT_MOVE | PA_STREAM_ADJUST_LATENCY. A disappearing target
|
||||
// must fail closed; PipeWire-only node properties cannot enforce this on PulseAudio.
|
||||
if output.stream.is_null() || (api.stream_connect_playback)(output.stream, sink.as_ptr(), &attr,
|
||||
0x0200 | 0x2000, std::ptr::null_mut(), std::ptr::null_mut()) < 0 {
|
||||
return Err("Microphone audio target unavailable".into());
|
||||
}
|
||||
let stream = output.stream;
|
||||
output.wait(stopped, || (api.stream_get_state)(stream) == 2)?; // PA_STREAM_READY
|
||||
let actual = (api.stream_get_device_name)(stream);
|
||||
if actual.is_null() || CStr::from_ptr(actual) != sink { return Err("Microphone audio target changed".into()); }
|
||||
Ok(output)
|
||||
} }
|
||||
fn pump(&mut self) -> Result<(), String> { unsafe {
|
||||
if (self.api.mainloop_iterate)(self.mainloop, 0, std::ptr::null_mut()) < 0
|
||||
|| (self.api.context_get_state)(self.context) >= 5
|
||||
|| (!self.stream.is_null() && (self.api.stream_get_state)(self.stream) >= 3) {
|
||||
return Err("Microphone audio connection ended".into());
|
||||
}
|
||||
Ok(())
|
||||
} }
|
||||
fn wait(&mut self, stopped: &watch::Receiver<bool>, ready: impl Fn() -> bool) -> Result<(), String> {
|
||||
let deadline = Instant::now() + Duration::from_secs(3);
|
||||
loop {
|
||||
if *stopped.borrow() { return Err("Microphone playback stopped".into()); }
|
||||
self.pump()?;
|
||||
if ready() { return Ok(()); }
|
||||
if Instant::now() >= deadline { return Err("Microphone audio connection timed out".into()); }
|
||||
std::thread::sleep(Duration::from_millis(2));
|
||||
}
|
||||
}
|
||||
fn write(&mut self, pcm: &[u8], stopped: &watch::Receiver<bool>) -> Result<(), String> {
|
||||
if pcm.len() % 4 != 0 { return Err("Invalid microphone PCM frame".into()); }
|
||||
let deadline = Instant::now() + Duration::from_millis(200);
|
||||
let mut offset = 0;
|
||||
while offset < pcm.len() {
|
||||
if *stopped.borrow() { return Err("Microphone playback stopped".into()); }
|
||||
self.pump()?;
|
||||
let available = unsafe { (self.api.stream_writable_size)(self.stream) };
|
||||
if available == usize::MAX { return Err("Microphone audio stream ended".into()); }
|
||||
let count = available.min(pcm.len() - offset) & !3;
|
||||
if count > 0 {
|
||||
// With no free callback libpulse copies these bytes before returning.
|
||||
if unsafe { (self.api.stream_write)(self.stream, pcm[offset..].as_ptr().cast(), count, None, 0, 0) } < 0 {
|
||||
return Err("Microphone audio write failed".into());
|
||||
}
|
||||
offset += count;
|
||||
} else {
|
||||
if Instant::now() >= deadline {
|
||||
return Err(format!("Microphone playback stalled: remaining={} writable={available}", pcm.len() - offset));
|
||||
}
|
||||
std::thread::sleep(Duration::from_millis(2));
|
||||
}
|
||||
}
|
||||
self.pump()
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) struct Output { stopped: watch::Sender<bool>, task: Option<tokio::task::JoinHandle<Result<(), String>>> }
|
||||
impl Output {
|
||||
pub(super) async fn stop(&mut self) -> Result<(), String> {
|
||||
self.stopped.send_replace(true);
|
||||
if let Some(task) = self.task.take() {
|
||||
return task.await.map_err(|_| "Microphone audio worker aborted")?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
impl Drop for Output { fn drop(&mut self) { self.stopped.send_replace(true); } }
|
||||
pub(super) fn start(sink: &str) -> Result<(DuplexStream, Output), String> {
|
||||
let api = api()?;
|
||||
let sink = CString::new(sink).map_err(|_| "Invalid microphone audio target")?;
|
||||
let (writer, mut reader) = tokio::io::duplex(65536);
|
||||
let (stop, mut stopped) = watch::channel(false);
|
||||
let runtime = tokio::runtime::Handle::current();
|
||||
let task = tokio::task::spawn_blocking(move || {
|
||||
let mut output = Stream::connect(api, &sink, &stopped)?;
|
||||
let mut buffer = [0; 23040]; // maximum 120 ms stereo PCM
|
||||
loop {
|
||||
if *stopped.borrow() { return Ok(()); }
|
||||
let count = runtime.block_on(async { tokio::select! {
|
||||
biased;
|
||||
_ = stopped.changed() => Ok(0),
|
||||
result = reader.read(&mut buffer) => result,
|
||||
} }).map_err(|_| "Microphone PCM input ended")?;
|
||||
if count == 0 { return Ok(()); }
|
||||
output.write(&buffer[..count], &stopped)?;
|
||||
}
|
||||
});
|
||||
Ok((writer, Output { stopped: stop, task: Some(task) }))
|
||||
}
|
||||
@@ -0,0 +1,533 @@
|
||||
#![cfg(target_os = "linux")]
|
||||
use super::*;
|
||||
use tokio::io::AsyncReadExt;
|
||||
use webrtc::track::track_local::{track_local_static_rtp::TrackLocalStaticRTP, TrackLocalWriter};
|
||||
use webrtc::rtp_transceiver::rtp_codec::RTCRtpCodecCapability;
|
||||
use webrtc::interceptor::{mock::{mock_builder::MockBuilder, mock_interceptor::MockInterceptor},
|
||||
registry::Registry, Attributes, RTPReader};
|
||||
|
||||
fn have_opus() -> bool {
|
||||
match opus() {
|
||||
Ok(_) => true,
|
||||
Err(error) => { eprintln!("Skipping Opus-dependent microphone test: {error}"); false }
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct ReadPause {
|
||||
requested: AtomicBool, entered: tokio::sync::Notify,
|
||||
resume: tokio::sync::Notify, completed: tokio::sync::Notify,
|
||||
}
|
||||
struct PausedReader { reader: Arc<dyn RTPReader + Send + Sync>, pause: Arc<ReadPause> }
|
||||
#[async_trait::async_trait]
|
||||
impl RTPReader for PausedReader {
|
||||
async fn read(&self, buffer: &mut [u8], attributes: &Attributes) -> Result<(Packet, Attributes), webrtc::interceptor::Error> {
|
||||
let result = self.reader.read(buffer, attributes).await?;
|
||||
if self.pause.requested.swap(false, Ordering::AcqRel) {
|
||||
// The packet has already been consumed; cancelling here would lose it.
|
||||
self.pause.entered.notify_one();
|
||||
self.pause.resume.notified().await;
|
||||
self.pause.completed.notify_one();
|
||||
}
|
||||
Ok(result)
|
||||
}
|
||||
}
|
||||
fn pause_registry(pause: Arc<ReadPause>) -> Registry {
|
||||
let mut registry = Registry::new();
|
||||
registry.add(Box::new(MockBuilder::new(move |_| {
|
||||
let pause = pause.clone();
|
||||
Ok(Arc::new(MockInterceptor { bind_remote_stream_fn: Some(Box::new(move |_, reader| {
|
||||
let pause = pause.clone();
|
||||
Box::pin(async move {
|
||||
Arc::new(PausedReader { reader, pause }) as Arc<dyn RTPReader + Send + Sync>
|
||||
})
|
||||
})), ..Default::default() }))
|
||||
})));
|
||||
registry
|
||||
}
|
||||
|
||||
fn tone() -> Vec<u8> {
|
||||
tone_samples(960)
|
||||
}
|
||||
fn tone_samples(samples: usize) -> Vec<u8> {
|
||||
let handle = opus().unwrap()._handle as *mut libc::c_void;
|
||||
let create: unsafe extern "C" fn(i32, i32, i32, *mut i32) -> *mut libc::c_void = unsafe {
|
||||
std::mem::transmute(libc::dlsym(handle, c"opus_encoder_create".as_ptr()))
|
||||
};
|
||||
let encode: unsafe extern "C" fn(*mut libc::c_void, *const i16, i32, *mut u8, i32) -> i32 = unsafe {
|
||||
std::mem::transmute(libc::dlsym(handle, c"opus_encode".as_ptr()))
|
||||
};
|
||||
let destroy: unsafe extern "C" fn(*mut libc::c_void) = unsafe {
|
||||
std::mem::transmute(libc::dlsym(handle, c"opus_encoder_destroy".as_ptr()))
|
||||
};
|
||||
let pcm: Vec<i16> = (0..samples).flat_map(|i| {
|
||||
let s = ((i as f64 * std::f64::consts::TAU * 1000. / 48000.).sin() * 6000.) as i16;
|
||||
[s, s]
|
||||
}).collect();
|
||||
let mut error = 0;
|
||||
let enc = unsafe { create(48000, 2, 2048, &mut error) };
|
||||
assert_eq!(error, 0);
|
||||
assert!(!enc.is_null());
|
||||
let mut out = vec![0; 4000];
|
||||
let n = unsafe { encode(enc, pcm.as_ptr(), samples as i32, out.as_mut_ptr(), out.len() as i32) };
|
||||
unsafe { destroy(enc); }
|
||||
assert!(n > 0);
|
||||
out.truncate(n as usize);
|
||||
out
|
||||
}
|
||||
fn packet(seq: u16, data: &[u8]) -> Packet {
|
||||
packet_at(seq, u32::from(seq) * 960, data)
|
||||
}
|
||||
fn packet_at(seq: u16, timestamp: u32, data: &[u8]) -> Packet {
|
||||
Packet { header: webrtc::rtp::header::Header { version: 2, sequence_number: seq,
|
||||
timestamp, marker: true, ..Default::default() },
|
||||
payload: bytes::Bytes::copy_from_slice(data) }
|
||||
}
|
||||
fn rms(bytes: &[u8]) -> f64 {
|
||||
let sum: f64 = bytes.chunks_exact(2).map(|s| f64::from(i16::from_le_bytes([s[0], s[1]])).powi(2)).sum();
|
||||
(sum / (bytes.len() / 2).max(1) as f64).sqrt()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn opus_decodes_generated_tone_and_conceals_loss() {
|
||||
if !have_opus() { return; }
|
||||
assert!(!valid_packet(&[]));
|
||||
assert!(!valid_packet(&vec![0; 8193]));
|
||||
let data = tone();
|
||||
let mut decoder = Decoder::new().unwrap();
|
||||
let (pcm, frames) = decoder.decode(&Frame::Opus(data)).unwrap();
|
||||
assert_eq!(frames, 960);
|
||||
assert_eq!(pcm.len(), 3840);
|
||||
assert!(rms(&pcm) > 1000.);
|
||||
assert_eq!(decoder.decode(&Frame::Conceal(960)).unwrap().0.len(), 3840);
|
||||
assert!(decoder.decode(&Frame::Opus(vec![])).is_err());
|
||||
assert!(decoder.decode(&Frame::Conceal(0)).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reorder_handles_wrap_loss_duplicates_and_bounded_backlog() {
|
||||
if !have_opus() { return; }
|
||||
let data = tone();
|
||||
let mut jitter = Jitter::default();
|
||||
for seq in [65535, 1, 0, 0] { jitter.push(packet(seq, &data)); }
|
||||
for _ in 0..3 { assert_eq!(jitter.pop(), Some(Frame::Opus(data.clone()))); }
|
||||
assert!(jitter.pop().is_none());
|
||||
jitter.push(packet(3, &data));
|
||||
assert_eq!(jitter.pop(), Some(Frame::Conceal(960))); // sequence 2 was lost
|
||||
assert_eq!(jitter.pop(), Some(Frame::Opus(data.clone())));
|
||||
jitter.push(packet(0, &data)); // late retransmission
|
||||
assert!(jitter.pop().is_none());
|
||||
for seq in 4..1000 { jitter.push(packet(seq, &data)); assert!(jitter.packets.len() <= MAX_PACKETS as usize); }
|
||||
assert!(jitter.next.unwrap() >= 988);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn loss_duration_follows_rtp_clock_across_wrap_and_packet_sizes() {
|
||||
if !have_opus() { return; }
|
||||
for samples in [480, 960, 1920, 2880] {
|
||||
let data = tone_samples(samples);
|
||||
let mut decoder = Decoder::new().unwrap();
|
||||
let mut jitter = Jitter::default();
|
||||
let timestamp = u32::MAX - 239;
|
||||
jitter.push(packet_at(65535, timestamp, &data));
|
||||
assert_eq!(decoder.decode(&jitter.pop().unwrap()).unwrap().1, samples as u32);
|
||||
jitter.push(packet_at(1, timestamp.wrapping_add(samples as u32 * 2), &data));
|
||||
let loss = jitter.pop().unwrap();
|
||||
assert_eq!(loss, Frame::Conceal(samples as u32));
|
||||
assert_eq!(decoder.decode(&loss).unwrap().1, samples as u32);
|
||||
assert_eq!(decoder.decode(&jitter.pop().unwrap()).unwrap().1, samples as u32);
|
||||
assert!(jitter.pop().is_none());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn variable_losses_preserve_total_time_and_bound_discontinuities() {
|
||||
if !have_opus() { return; }
|
||||
let data = tone();
|
||||
let mut jitter = Jitter::default();
|
||||
let mut decoder = Decoder::new().unwrap();
|
||||
jitter.push(packet_at(0, 0, &data));
|
||||
decoder.decode(&jitter.pop().unwrap()).unwrap();
|
||||
// Two missing packets total 50 ms; their individual durations cannot be inferred.
|
||||
jitter.push(packet_at(3, 960 + 2400, &data));
|
||||
let mut concealed = 0;
|
||||
for _ in 0..2 { concealed += decoder.decode(&jitter.pop().unwrap()).unwrap().1; }
|
||||
assert_eq!(concealed, 2400);
|
||||
decoder.decode(&jitter.pop().unwrap()).unwrap();
|
||||
jitter.push(packet_at(5, 48_000_000, &data));
|
||||
assert_eq!(jitter.pop(), Some(Frame::Conceal(960))); // discontinuity is not a huge loss
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ownership_lock_is_shared_across_config_directories() {
|
||||
const CHILD: &str = "UU_MICROPHONE_TEST_LOCK";
|
||||
if let Ok(source) = std::env::var(CHILD) {
|
||||
assert!(route_lock(&source).is_err(), "a different UU_CONFIG bypassed the endpoint lock");
|
||||
return;
|
||||
}
|
||||
let source = format!("uu-microphone-test-{}", std::process::id());
|
||||
let lock = route_lock(&source).unwrap();
|
||||
for config in ["first/config.json", "second/config.json"] {
|
||||
let result = Command::new(std::env::current_exe().unwrap())
|
||||
.args(["microphone::tests::ownership_lock_is_shared_across_config_directories", "--exact"])
|
||||
.env(CHILD, &source).env("UU_CONFIG", std::env::temp_dir().join(config))
|
||||
.env("XDG_RUNTIME_DIR", std::env::temp_dir().join(config).with_extension("runtime"))
|
||||
.env("TMPDIR", std::env::temp_dir().join(config).with_extension("temporary"))
|
||||
.output().unwrap();
|
||||
assert!(result.status.success(), "{}", String::from_utf8_lossy(&result.stdout));
|
||||
}
|
||||
drop(lock);
|
||||
drop(route_lock(&source).expect("the lock must be released on drop"));
|
||||
std::fs::remove_file(route_lock_path(&source).unwrap()).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn recovery_requires_exact_module_arguments_and_master() {
|
||||
let args = vec!["source_name=uu-remote-microphone".into(), "master=uu-remote-mic-input.monitor".into(),
|
||||
"source_properties=device.description=UU-Remote-Microphone".into(), "rate=48000".into(), "channels=2".into()];
|
||||
let line = format!("42\tmodule-remap-source\t{}", args.join(" "));
|
||||
assert_eq!(Module::matching_id(&line, "module-remap-source", &args), Some(42));
|
||||
for foreign in [line.replace("master=uu-remote-mic-input.monitor", "master=physical-microphone"),
|
||||
line.replace("description=UU-Remote-Microphone", "description=UU-Remote-Microphone-Foreign"),
|
||||
format!("{line} remix=no")] {
|
||||
assert_eq!(Module::matching_id(&foreign, "module-remap-source", &args), None);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn native_sink_options_are_not_applied_to_pipewire_or_unsupported_servers() {
|
||||
assert_eq!(native_pulse("Server Name: pulseaudio\nServer Version: 13.0"), Ok(true));
|
||||
assert_eq!(native_pulse("Server Name: PulseAudio (on PipeWire 1.6.9)\nServer Version: 15.0.0"), Ok(false));
|
||||
assert!(native_pulse("Server Name: pulseaudio\nServer Version: 12.2").is_err());
|
||||
assert!(native_pulse("Server Name: unsupported\nServer Version: 99.0").is_err());
|
||||
assert!(native_pulse("").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn concurrent_track_claims_have_only_one_current_owner() {
|
||||
let session = Session::new();
|
||||
let claimed = Arc::new(std::sync::Barrier::new(2));
|
||||
let workers: Vec<_> = (0..2).map(|_| {
|
||||
let (session, claimed) = (session.clone(), claimed.clone());
|
||||
std::thread::spawn(move || {
|
||||
let (generation, mut owner) = session.claim_track();
|
||||
claimed.wait(); // both workers start receiving only after both tracks have claimed
|
||||
let current = *owner.borrow_and_update() == generation;
|
||||
(generation, current)
|
||||
})
|
||||
}).collect();
|
||||
let owners: Vec<_> = workers.into_iter().map(|w| w.join().unwrap()).collect();
|
||||
assert_eq!(owners.iter().filter(|(_, current)| *current).count(), 1);
|
||||
assert!(owners.contains(&(2, true)));
|
||||
assert!(owners.contains(&(1, false)));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn congested_reply_cannot_overwrite_a_later_close() {
|
||||
let session = Session::new();
|
||||
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
|
||||
let (pending, wait_pending) = tokio::sync::oneshot::channel();
|
||||
let (resume, wait_resume) = tokio::sync::oneshot::channel();
|
||||
let sending = tokio::spawn(async move {
|
||||
let notice = rx.recv().await.unwrap();
|
||||
pending.send(()).unwrap();
|
||||
wait_resume.await.unwrap(); // the ordered outbox is blocked in its network send
|
||||
notice
|
||||
});
|
||||
session.action_with(23, || { tx.send(23).unwrap(); });
|
||||
wait_pending.await.unwrap();
|
||||
assert!(*session.open.borrow());
|
||||
session.action(24); // independent TEXT callback closes while the CONTROL reply is pending
|
||||
assert!(!*session.open.borrow());
|
||||
resume.send(()).unwrap();
|
||||
assert_eq!(sending.await.unwrap(), 23);
|
||||
assert!(!*session.open.borrow(), "completing an old send must not apply an old policy");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn state_and_notice_enqueue_are_serialized_across_channels() {
|
||||
let session = Session::new();
|
||||
let notices = Arc::new(Mutex::new(Vec::new()));
|
||||
let (inside, entered) = std::sync::mpsc::channel();
|
||||
let release = Arc::new(std::sync::Barrier::new(2));
|
||||
let open = {
|
||||
let (session, notices, release) = (session.clone(), notices.clone(), release.clone());
|
||||
std::thread::spawn(move || { session.action_with(23, || {
|
||||
inside.send(()).unwrap();
|
||||
release.wait();
|
||||
notices.lock().unwrap().push(23);
|
||||
}); })
|
||||
};
|
||||
entered.recv().unwrap();
|
||||
let close = {
|
||||
let (session, notices) = (session.clone(), notices.clone());
|
||||
std::thread::spawn(move || { session.action_with(24, || { notices.lock().unwrap().push(24); }); })
|
||||
};
|
||||
release.wait();
|
||||
open.join().unwrap(); close.join().unwrap();
|
||||
assert_eq!(*notices.lock().unwrap(), [23, 24]);
|
||||
assert!(!*session.open.borrow());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn shutdown_waits_for_receivers_before_removing_endpoints() {
|
||||
const CHILD: &str = "UU_MICROPHONE_TEST_SHUTDOWN";
|
||||
if std::env::var_os(CHILD).is_none() {
|
||||
let result = Command::new(std::env::current_exe().unwrap())
|
||||
.args(["microphone::tests::shutdown_waits_for_receivers_before_removing_endpoints", "--exact"])
|
||||
.env(CHILD, "1").output().unwrap();
|
||||
assert!(result.status.success(), "{}", String::from_utf8_lossy(&result.stdout));
|
||||
return;
|
||||
}
|
||||
let worker = Worker::new();
|
||||
let stopped = Arc::new(AtomicBool::new(false));
|
||||
let finished = stopped.clone();
|
||||
let task = tokio::spawn(async move {
|
||||
let mut stopping = workers().stopped.subscribe();
|
||||
stopping.wait_for(|stopped| *stopped).await.unwrap();
|
||||
tokio::time::sleep(Duration::from_millis(20)).await;
|
||||
finished.store(true, Ordering::Release);
|
||||
drop(worker);
|
||||
});
|
||||
tokio::time::timeout(Duration::from_secs(1), shutdown()).await.unwrap();
|
||||
assert!(stopped.load(Ordering::Acquire));
|
||||
task.await.unwrap();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn webrtc_microphone_obeys_mute_desktop_role_and_disconnect() {
|
||||
if !have_opus() { return; }
|
||||
tokio::time::timeout(Duration::from_secs(15), async {
|
||||
let (left, right, router) = crate::test_network::virtual_network().await;
|
||||
async fn peer(settings: webrtc::api::setting_engine::SettingEngine, registry: Registry) -> Arc<RTCPeerConnection> {
|
||||
let mut m = webrtc::api::media_engine::MediaEngine::default();
|
||||
m.register_default_codecs().unwrap();
|
||||
Arc::new(webrtc::api::APIBuilder::new().with_media_engine(m).with_setting_engine(settings).with_interceptor_registry(registry)
|
||||
.build().new_peer_connection(Default::default()).await.unwrap())
|
||||
}
|
||||
let pause = Arc::new(ReadPause::default());
|
||||
let sender = peer(left, Registry::new()).await;
|
||||
let host = peer(right, pause_registry(pause.clone())).await;
|
||||
// Match the real host: its existing desktop sound track negotiates a bidirectional m-line.
|
||||
host.add_track(Arc::new(TrackLocalStaticRTP::new(RTCRtpCodecCapability {
|
||||
mime_type: "audio/opus".into(), clock_rate: 48000, channels: 2, ..Default::default()
|
||||
}, "desktop-sound".into(), "host".into()))).await.unwrap();
|
||||
let track = Arc::new(TrackLocalStaticRTP::new(RTCRtpCodecCapability {
|
||||
mime_type: "audio/opus".into(), clock_rate: 48000, channels: 2, ..Default::default()
|
||||
}, "mic".into(), "generated-tone".into()));
|
||||
sender.add_track(track.clone()).await.unwrap();
|
||||
let replacement = Arc::new(TrackLocalStaticRTP::new(RTCRtpCodecCapability {
|
||||
mime_type: "audio/opus".into(), clock_rate: 48000, channels: 2, ..Default::default()
|
||||
}, "replacement-mic".into(), "generated-tone".into()));
|
||||
sender.add_track(replacement.clone()).await.unwrap();
|
||||
let (created, mut outputs) = tokio::sync::mpsc::unbounded_channel();
|
||||
let session = Session { factory: Arc::new(move || {
|
||||
let (writer, reader) = tokio::io::duplex(65536);
|
||||
created.send(reader).unwrap();
|
||||
Ok(Playback { decoder: Decoder::new()?, writer: Box::pin(writer), output: None })
|
||||
}), ..Session::new() };
|
||||
assert!(!session.action(2));
|
||||
assert!(session.action(24));
|
||||
let (desktop, active) = watch::channel(true);
|
||||
session.attach(&host, active);
|
||||
let mut gathered = sender.gathering_complete_promise().await;
|
||||
let offer = sender.create_offer(None).await.unwrap();
|
||||
sender.set_local_description(offer).await.unwrap(); gathered.recv().await;
|
||||
host.set_remote_description(sender.local_description().await.unwrap()).await.unwrap();
|
||||
let mut gathered = host.gathering_complete_promise().await;
|
||||
let answer = host.create_answer(None).await.unwrap();
|
||||
host.set_local_description(answer).await.unwrap(); gathered.recv().await;
|
||||
sender.set_remote_description(host.local_description().await.unwrap()).await.unwrap();
|
||||
while sender.connection_state() != RTCPeerConnectionState::Connected { tokio::time::sleep(Duration::from_millis(10)).await; }
|
||||
let data = tone();
|
||||
let sending = tokio::spawn(async move {
|
||||
for seq in 0..500 { let _ = track.write_rtp(&packet(seq, &data)).await; tokio::time::sleep(Duration::from_millis(20)).await; }
|
||||
});
|
||||
tokio::time::sleep(Duration::from_millis(200)).await;
|
||||
assert!(outputs.try_recv().is_err()); // muted before the first packet
|
||||
session.action(23);
|
||||
let mut pcm = outputs.recv().await.unwrap();
|
||||
let mut frame = vec![0; 3840];
|
||||
pcm.read_exact(&mut frame).await.unwrap();
|
||||
assert!(rms(&frame) > 1000.);
|
||||
// Playback must keep pace with a continuous 20 ms source, not add a polling delay
|
||||
// to every frame (which eventually overflows the jitter buffer and skips speech).
|
||||
let mut played_frames = 0;
|
||||
let _ = tokio::time::timeout(Duration::from_millis(600), async {
|
||||
loop { pcm.read_exact(&mut frame).await.unwrap(); played_frames += 1; }
|
||||
}).await;
|
||||
assert!((25..=35).contains(&played_frames), "wrong real-time playout rate: {played_frames} frames / 600 ms");
|
||||
pause.requested.store(true, Ordering::Release);
|
||||
pause.entered.notified().await;
|
||||
// Span several playout ticks and at least two health ticks with a consumed RTP packet.
|
||||
tokio::time::sleep(Duration::from_millis(250)).await;
|
||||
pause.resume.notify_one();
|
||||
tokio::time::timeout(Duration::from_secs(1), pause.completed.notified()).await
|
||||
.expect("timer ticks cancelled a pending RTP read and lost its packet");
|
||||
let data = tone();
|
||||
let replacing = tokio::spawn(async move {
|
||||
for seq in 0..500 { let _ = replacement.write_rtp(&packet(seq, &data)).await; tokio::time::sleep(Duration::from_millis(20)).await; }
|
||||
});
|
||||
let mut replacement_pcm = outputs.recv().await.unwrap();
|
||||
replacement_pcm.read_exact(&mut frame).await.unwrap();
|
||||
assert!(rms(&frame) > 1000.);
|
||||
tokio::time::timeout(Duration::from_secs(1), pcm.read_to_end(&mut Vec::new())).await.unwrap().unwrap();
|
||||
let mut pcm = replacement_pcm;
|
||||
session.action(24);
|
||||
let mut remainder = Vec::new();
|
||||
tokio::time::timeout(Duration::from_secs(1), pcm.read_to_end(&mut remainder)).await.unwrap().unwrap();
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
assert!(outputs.try_recv().is_err());
|
||||
desktop.send_replace(false);
|
||||
session.action(23);
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
assert!(outputs.try_recv().is_err()); // a demoted desktop cannot inject audio
|
||||
desktop.send_replace(true);
|
||||
let mut resumed = outputs.recv().await.unwrap();
|
||||
resumed.read_exact(&mut frame).await.unwrap();
|
||||
assert!(rms(&frame) > 1000.);
|
||||
host.close().await.unwrap(); sender.close().await.unwrap();
|
||||
tokio::time::timeout(Duration::from_secs(1), resumed.read_to_end(&mut Vec::new())).await.unwrap().unwrap();
|
||||
sending.abort(); replacing.abort(); router.lock().await.stop().await.unwrap();
|
||||
}).await.expect("microphone WebRTC integration timed out");
|
||||
}
|
||||
|
||||
/// Explicit opt-in only; records the generated tone from our isolated virtual source in memory.
|
||||
#[tokio::test]
|
||||
#[ignore]
|
||||
async fn pipewire_virtual_microphone_receives_generated_tone() {
|
||||
assert!(requested(), "run with UU_MICROPHONE=1; the test creates independent audio endpoints");
|
||||
let sink = format!("uu-mic-test-input-{}", std::process::id());
|
||||
let source = format!("uu-mic-test-source-{}", std::process::id());
|
||||
let route = Route::new(&sink, &source).unwrap();
|
||||
let mut recorder = tokio::process::Command::new("parec").args(["--raw", "--format=s16le", "--rate=48000", "--channels=2",
|
||||
&format!("--device={source}"), "--latency-msec=20"])
|
||||
.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null()).kill_on_drop(true).spawn().unwrap();
|
||||
let mut capture = recorder.stdout.take().unwrap();
|
||||
let mut player = Playback::at(&sink).unwrap();
|
||||
let (stop, mut stopped) = watch::channel(false);
|
||||
let generating = tokio::spawn(async move {
|
||||
let data = tone();
|
||||
for _ in 0..100 {
|
||||
if *stopped.borrow() { break; }
|
||||
player.write(&Frame::Opus(data.clone())).await.unwrap();
|
||||
tokio::select! { _ = stopped.changed() => break, _ = tokio::time::sleep(Duration::from_millis(20)) => {} }
|
||||
}
|
||||
player.stop().await;
|
||||
});
|
||||
let received = tokio::time::timeout(Duration::from_secs(4), async {
|
||||
let mut frame = vec![0; 3840];
|
||||
loop { capture.read_exact(&mut frame).await?; if rms(&frame) > 1000. { return Ok::<_, std::io::Error>(()); } }
|
||||
}).await;
|
||||
let inputs = pactl(&["--format=json", "list", "sink-inputs"]);
|
||||
let devices = [pactl(&["--format=json", "list", "sinks"]), pactl(&["--format=json", "list", "sources"])];
|
||||
let stopped = recorder.kill().await;
|
||||
stop.send_replace(true);
|
||||
let generated = generating.await;
|
||||
drop(route);
|
||||
let sources = pactl(&["list", "short", "sources"]).unwrap();
|
||||
assert!(!sources.lines().any(|line| line.split('\t').nth(1) == Some(source.as_str())));
|
||||
std::fs::remove_file(route_lock_path(&source).unwrap()).unwrap();
|
||||
stopped.unwrap();
|
||||
assert!(!generated.is_err_and(|e| e.is_panic()), "tone generator panicked");
|
||||
received.expect("generated tone did not reach the virtual microphone").unwrap();
|
||||
let inputs: serde_json::Value = serde_json::from_str(&inputs.unwrap()).unwrap();
|
||||
let pid = std::process::id().to_string();
|
||||
let properties = inputs.as_array().unwrap().iter().find_map(|input| {
|
||||
let properties = input.get("properties")?;
|
||||
(properties.get("application.process.id")?.as_str()? == pid
|
||||
&& properties.get("media.name")?.as_str()? == crate::i18n::s("远程麦克风", "Remote-Microphone")).then_some(properties)
|
||||
}).expect("localized microphone stream missing");
|
||||
assert_eq!(properties["application.name"], crate::i18n::s("UU 远程麦克风", "UU Remote microphone"));
|
||||
for (data, name, description) in [
|
||||
(&devices[0], &sink, crate::i18n::s("UU-远程麦克风输入", "UU-Remote-Microphone-Input")),
|
||||
(&devices[1], &source, crate::i18n::s("UU-远程麦克风", "UU-Remote-Microphone")),
|
||||
] {
|
||||
let devices: serde_json::Value = serde_json::from_str(data.as_ref().unwrap()).unwrap();
|
||||
let device = devices.as_array().unwrap().iter().find(|device| device["name"] == name.as_str()).unwrap();
|
||||
assert_eq!(device["description"], description);
|
||||
}
|
||||
}
|
||||
|
||||
/// Run through contrib/check-microphone-pulse.py, never against the desktop's audio server.
|
||||
#[tokio::test]
|
||||
#[ignore]
|
||||
async fn pulse_target_loss_never_routes_to_default_output() {
|
||||
assert_eq!(std::env::var("UU_MICROPHONE_ISOLATED_TEST").as_deref(), Ok("1"));
|
||||
assert!(std::env::var("PULSE_SERVER").is_ok_and(|s| s.starts_with("unix:")));
|
||||
assert!(pactl(&["list", "short", "sinks"]).unwrap().is_empty(), "requires an empty isolated server");
|
||||
assert!(pactl(&["list", "short", "sources"]).unwrap().is_empty(), "requires an empty isolated server");
|
||||
let fallback_name = format!("uu-mic-test-default-{}", std::process::id());
|
||||
let fallback = Module::open("module-null-sink", sink_args(&fallback_name).unwrap()).unwrap();
|
||||
struct Fallback(Module);
|
||||
impl Drop for Fallback { fn drop(&mut self) { self.0.unload(); } }
|
||||
let _fallback = Fallback(fallback);
|
||||
pactl(&["set-default-sink", &fallback_name]).unwrap();
|
||||
let sink = format!("uu-mic-test-pinned-{}", std::process::id());
|
||||
let source = format!("uu-mic-test-pinned-source-{}", std::process::id());
|
||||
let route = Route::new(&sink, &source).unwrap();
|
||||
let mut player = Playback::at(&sink).unwrap();
|
||||
let generating = tokio::spawn(async move {
|
||||
let frame = Frame::Opus(tone());
|
||||
let mut failed_closed = false;
|
||||
for _ in 0..150 {
|
||||
if player.write(&frame).await.is_err() { failed_closed = true; break; }
|
||||
tokio::time::sleep(Duration::from_millis(20)).await;
|
||||
}
|
||||
player.stop().await;
|
||||
failed_closed
|
||||
});
|
||||
tokio::time::timeout(Duration::from_secs(3), async {
|
||||
while pactl(&["list", "short", "sink-inputs"]).unwrap().is_empty() {
|
||||
tokio::time::sleep(Duration::from_millis(10)).await;
|
||||
}
|
||||
}).await.unwrap();
|
||||
let mut probe = tokio::process::Command::new("parec").args(["--raw", "--format=s16le", "--rate=48000", "--channels=2",
|
||||
&format!("--device={source}"), "--latency-msec=20"])
|
||||
.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null()).kill_on_drop(true).spawn().unwrap();
|
||||
let mut baseline = probe.stdout.take().unwrap();
|
||||
let flowing = tokio::time::timeout(Duration::from_secs(3), async {
|
||||
let mut frame = vec![0; 3840];
|
||||
let mut audible = 0;
|
||||
loop {
|
||||
baseline.read_exact(&mut frame).await?;
|
||||
audible = if rms(&frame) > 1000. { audible + 1 } else { 0 };
|
||||
if audible >= 15 { return Ok::<_, std::io::Error>(()); } // 300 ms of healthy playback
|
||||
}
|
||||
}).await;
|
||||
let probe_stopped = probe.kill().await;
|
||||
if !matches!(&flowing, Ok(Ok(()))) {
|
||||
generating.abort(); let _ = generating.await;
|
||||
panic!("no sustained generated tone before removing the target: {flowing:?}");
|
||||
}
|
||||
probe_stopped.unwrap();
|
||||
flowing.expect("no sustained generated tone before removing the target").unwrap();
|
||||
let mut recorder = tokio::process::Command::new("parec").args(["--raw", "--format=s16le", "--rate=48000", "--channels=2",
|
||||
&format!("--device={fallback_name}.monitor"), "--latency-msec=20"])
|
||||
.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null()).kill_on_drop(true).spawn().unwrap();
|
||||
let mut capture = recorder.stdout.take().unwrap();
|
||||
tokio::time::sleep(Duration::from_millis(200)).await;
|
||||
assert!(!generating.is_finished(), "playback failed before the target was removed");
|
||||
route.source.unload(); route.sink.unload(); // remove the target while audio is still flowing
|
||||
let mut generating = generating;
|
||||
let ended = tokio::time::timeout(Duration::from_secs(2), &mut generating).await;
|
||||
if ended.is_err() { generating.abort(); let _ = generating.await; }
|
||||
let mut peak = 0.0_f64;
|
||||
let observed = async {
|
||||
let deadline = tokio::time::sleep(Duration::from_millis(350));
|
||||
tokio::pin!(deadline);
|
||||
let mut frame = vec![0; 3840];
|
||||
loop { tokio::select! {
|
||||
_ = &mut deadline => break,
|
||||
read = capture.read_exact(&mut frame) => { read?; peak = peak.max(rms(&frame)); },
|
||||
} }
|
||||
Ok::<_, std::io::Error>(())
|
||||
}.await;
|
||||
recorder.kill().await.unwrap();
|
||||
observed.unwrap();
|
||||
assert!(ended.expect("playback did not stop after its target disappeared").unwrap());
|
||||
assert!(pactl(&["list", "short", "sink-inputs"]).unwrap().is_empty());
|
||||
assert_eq!(peak, 0.0, "microphone audio reached the default output");
|
||||
drop(route);
|
||||
std::fs::remove_file(route_lock_path(&source).unwrap()).unwrap();
|
||||
}
|
||||
+406
-25
@@ -42,9 +42,13 @@ mod native {
|
||||
fn uu_portal_open_persist_cancellable(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), save_data: *mut c_void, cancelled: extern "C" fn(*mut c_void) -> i32, cancel_data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
|
||||
fn uu_portal_open_persist_capture(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), save_data: *mut c_void, cancelled: Option<extern "C" fn(*mut c_void) -> i32>, cancel_data: *mut c_void, prefer_dmabuf: i32, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
|
||||
fn uu_portal_open_detailed(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void, i32, i32, i32), save_data: *mut c_void, cancelled: Option<extern "C" fn(*mut c_void) -> i32>, cancel_data: *mut c_void, prefer_dmabuf: i32, source_types: u32, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
|
||||
fn uu_portal_set_cursor_mode(mode: i32);
|
||||
fn uu_portal_cursor_mode(portal: *mut c_void) -> i32;
|
||||
fn uu_portal_cursor_modes(portal: *mut c_void) -> i32;
|
||||
fn uu_portal_clipboard_supported(portal: *mut c_void) -> i32;
|
||||
fn uu_portal_clipboard_ready(portal: *mut c_void) -> i32;
|
||||
fn uu_portal_clipboard_set(portal: *mut c_void, text: *const u8, length: usize) -> i32;
|
||||
fn uu_portal_clipboard_copy(from: *mut c_void, to: *mut c_void) -> i32;
|
||||
fn uu_portal_clipboard_poll(portal: *mut c_void, text: *mut u8, capacity: usize) -> i32;
|
||||
fn uu_portal_close(portal: *mut c_void);
|
||||
fn uu_portal_alive(portal: *mut c_void) -> i32;
|
||||
@@ -83,6 +87,8 @@ mod native {
|
||||
}
|
||||
// Portal preparation and native teardown can wait for consent or D-Bus.
|
||||
// Only the swap may hold the mutex shared with input and clipboard.
|
||||
// Only the unit tests swap a test handle now; production swaps carry the clipboard.
|
||||
#[cfg(test)]
|
||||
fn replace_handle<T>(current: &Mutex<T>, locked: MutexGuard<'_, T>, prepare: impl FnOnce() -> Result<Option<T>, String>) -> Result<bool, String> {
|
||||
drop(locked);
|
||||
let Some(replacement) = prepare()? else { return Ok(false); };
|
||||
@@ -93,6 +99,24 @@ mod native {
|
||||
drop(old);
|
||||
Ok(true)
|
||||
}
|
||||
/// Like `replace_handle`, but carries the viewer's clipboard text before the old session
|
||||
/// closes. Clipboard writers wait from before the swap until the carry-over finishes.
|
||||
fn replace_handle_carrying(current: &Mutex<Arc<Handle>>, clipboard_write: &Mutex<()>, locked: MutexGuard<'_, Arc<Handle>>, prepare: impl FnOnce() -> Result<Option<Arc<Handle>>, String>) -> Result<bool, String> {
|
||||
drop(locked);
|
||||
let Some(replacement) = prepare()? else { return Ok(false); };
|
||||
let _clipboard = clipboard_write.lock().map_err(|_| "Portal clipboard lock poisoned")?;
|
||||
let _serial = crate::input::lock_portal_held();
|
||||
let (old, installed) = {
|
||||
let mut handle = current.lock().map_err(|_| "Portal session lock poisoned")?;
|
||||
let old = std::mem::replace(&mut *handle, replacement);
|
||||
(old, Arc::clone(&*handle))
|
||||
};
|
||||
unsafe { uu_portal_clipboard_copy(old.0.as_ptr(), installed.0.as_ptr()) };
|
||||
drop(old);
|
||||
// The replaced devices took any held portal input with them.
|
||||
crate::input::portal_session_replaced();
|
||||
Ok(true)
|
||||
}
|
||||
#[derive(Default)]
|
||||
struct Recovery { retry_at: Option<std::time::Instant>, failed_until: Option<std::time::Instant>, denied: bool }
|
||||
impl Recovery {
|
||||
@@ -118,7 +142,7 @@ mod native {
|
||||
was_locked.store(false, std::sync::atomic::Ordering::Release);
|
||||
}
|
||||
}
|
||||
pub struct Session { handle: Mutex<Arc<Handle>>, locked: tokio::sync::watch::Receiver<Option<bool>>, was_locked: std::sync::atomic::AtomicBool, recovery: Mutex<Recovery>, size: std::sync::atomic::AtomicU64, monitor: Mutex<Option<String>>, virtual_output: std::sync::atomic::AtomicBool }
|
||||
pub struct Session { handle: Mutex<Arc<Handle>>, locked: tokio::sync::watch::Receiver<Option<bool>>, was_locked: std::sync::atomic::AtomicBool, recovery: Mutex<Recovery>, size: std::sync::atomic::AtomicU64, monitor: Mutex<Option<String>>, virtual_output: std::sync::atomic::AtomicBool, clipboard_write: Mutex<()>, end_generation: Arc<std::sync::atomic::AtomicU64> }
|
||||
impl Session {
|
||||
fn take_lock_observation(&self) -> Result<bool, String> {
|
||||
// A recovery in progress must see the lock even if another capture
|
||||
@@ -139,6 +163,44 @@ mod native {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
/// Swap `replacement` in, carrying the viewer's clipboard text before the old session
|
||||
/// closes. `expected` rejects a desktop end that raced the open.
|
||||
fn install_replacement(&self, replacement: Self, expected: Option<u64>, defer_held: bool, refresh_privacy: bool) -> Result<(u32, u32), String> {
|
||||
let size = replacement.size();
|
||||
let next = replacement.handle.into_inner().map_err(|_| "Portal session lock poisoned".to_string())?;
|
||||
let clipboard = self.clipboard_write.lock().map_err(|_| "Portal clipboard lock poisoned".to_string())?;
|
||||
// Records made against the new handle must postdate the reset below.
|
||||
let serial = crate::input::lock_portal_held();
|
||||
// Checked under the serial lock: an input recorded after an earlier check would
|
||||
// otherwise be destroyed with the session it was sent to.
|
||||
if defer_held && crate::input::portal_input_held() { return Err("input held during the swap".into()); }
|
||||
let mut handle = self.handle.lock().map_err(|_| "Portal session lock poisoned".to_string())?;
|
||||
if expected.is_some_and(|generation| self.end_generation.load(std::sync::atomic::Ordering::Acquire) != generation) {
|
||||
return Err("desktop session ended during the rebuild".into());
|
||||
}
|
||||
self.size.store(pack(size.0, size.1), std::sync::atomic::Ordering::Release);
|
||||
let previous_handle = std::mem::replace(&mut *handle, next);
|
||||
let installed = Arc::clone(&*handle);
|
||||
drop(handle);
|
||||
if unsafe { uu_portal_clipboard_copy(previous_handle.0.as_ptr(), installed.0.as_ptr()) } < 0 {
|
||||
log::warn!("Portal clipboard ownership could not be carried over");
|
||||
}
|
||||
drop(clipboard);
|
||||
drop(previous_handle);
|
||||
// The replaced devices took any held portal input with them.
|
||||
crate::input::portal_session_replaced();
|
||||
drop(serial);
|
||||
// A replaced virtual output can move in the layout; absolute input needs its new share.
|
||||
if refresh_privacy { crate::privacy_screen::refresh_pointer_region(); }
|
||||
Ok(size)
|
||||
}
|
||||
/// Point the host and the engine at the cursor mode the installed session really has.
|
||||
fn restore_installed_cursor_mode(&self, fallback: bool) {
|
||||
let installed = self.handle.lock().ok().map(|handle| unsafe { uu_portal_cursor_mode(handle.0.as_ptr()) }).unwrap_or(0);
|
||||
let embedded = if installed > 0 { installed == 2 } else { fallback };
|
||||
unsafe { uu_portal_set_cursor_mode(if embedded { 2 } else { 1 }); }
|
||||
super::CURSOR_MODE.store(if embedded { 2 } else { 1 }, std::sync::atomic::Ordering::Release);
|
||||
}
|
||||
pub fn is_alive(&self) -> bool {
|
||||
self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_alive(handle.0.as_ptr()) != 0 })
|
||||
}
|
||||
@@ -218,7 +280,8 @@ mod native {
|
||||
prefer_dmabuf = true;
|
||||
}
|
||||
let pointer = if detailed {
|
||||
let cancel = cancelled.filter(|_| !virtual_output);
|
||||
// Virtual shares can wait for consent too; cancel them like monitor opens.
|
||||
let cancel = cancelled;
|
||||
let callback = cancel.map(|_| is_cancelled as extern "C" fn(*mut c_void) -> i32);
|
||||
let cancel_data = cancel.map_or(std::ptr::null_mut(), |value| value as *const _ as *mut c_void);
|
||||
unsafe { uu_portal_open_detailed(
|
||||
@@ -266,7 +329,14 @@ mod native {
|
||||
if wanted.is_some() && granted != wanted { log::warn!("Portal granted a different monitor than requested"); }
|
||||
// Keep a freshly granted compositor frame regardless of lock state. Discarding it
|
||||
// before new damage can leave a static desktop permanently blank (#2).
|
||||
Ok(Self { handle: Mutex::new(Arc::new(Handle(handle))), locked: crate::session_lock::watch_locked(), was_locked: std::sync::atomic::AtomicBool::new(false), recovery: Mutex::new(Recovery::default()), size: pack(width, height).into(), monitor: Mutex::new(granted), virtual_output: virtual_output.into() })
|
||||
let handle = Arc::new(Handle(handle));
|
||||
// The engine records what it actually requested; a backend can refuse the mode the
|
||||
// environment or a runtime switch asked for.
|
||||
let available = unsafe { uu_portal_cursor_modes(handle.0.as_ptr()) };
|
||||
let applied = unsafe { uu_portal_cursor_mode(handle.0.as_ptr()) };
|
||||
if applied > 0 { super::CURSOR_MODE.store(if applied == 2 { 2 } else { 1 }, std::sync::atomic::Ordering::Release); }
|
||||
if available > 0 { super::CURSOR_EMBED.store(if available & 2 != 0 { 2 } else { 1 }, std::sync::atomic::Ordering::Release); }
|
||||
Ok(Self { handle: Mutex::new(handle), locked: crate::session_lock::watch_locked(), was_locked: std::sync::atomic::AtomicBool::new(false), recovery: Mutex::new(Recovery::default()), size: pack(width, height).into(), monitor: Mutex::new(granted), virtual_output: virtual_output.into(), clipboard_write: Mutex::new(()), end_generation: Arc::new(std::sync::atomic::AtomicU64::new(0)) })
|
||||
}
|
||||
/// Frame pixels of the monitor the stream currently follows.
|
||||
pub fn size(&self) -> (u32, u32) {
|
||||
@@ -276,7 +346,13 @@ mod native {
|
||||
/// End the compositor session (screen-share indicator off); the next desktop
|
||||
/// connection reopens it with the saved consent.
|
||||
pub fn end(&self) {
|
||||
// Invalidate an open that is still waiting for consent: it must not install a share
|
||||
// after the desktop was ended (viewer disconnect, idle shutdown, capture teardown).
|
||||
self.end_generation.fetch_add(1, std::sync::atomic::Ordering::AcqRel);
|
||||
if let Ok(handle) = self.handle.lock() { unsafe { uu_portal_end(handle.0.as_ptr()) }; }
|
||||
// The ended session's native devices are gone; forget the inputs bound to them.
|
||||
let _serial = crate::input::lock_portal_held();
|
||||
crate::input::portal_session_replaced();
|
||||
}
|
||||
/// Mutter connector of the monitor this session captures, when several are advertised.
|
||||
pub fn monitor(&self) -> Option<String> { self.monitor.lock().ok().and_then(|m| m.clone()) }
|
||||
@@ -284,19 +360,15 @@ mod native {
|
||||
/// time GNOME asks on the host) and swap it in, so every holder of this Arc follows.
|
||||
pub fn switch_to(&self, connector: &str) -> Result<(), String> {
|
||||
if self.monitor().as_deref() == Some(connector) { return Ok(()); }
|
||||
// Both this and the cursor-mode rebuild replace the handle: serialize them so the
|
||||
// later open cannot install a stale source over the other.
|
||||
let _recovery = self.recovery.lock().map_err(|_| "Portal recovery lock poisoned")?;
|
||||
let replacement = Self::open_inner(None, Some(connector), false, false).map_err(|error| error.to_string())?;
|
||||
if replacement.monitor().as_deref() != Some(connector) {
|
||||
return Err("Another monitor was shared; choose this monitor in the host dialog".into());
|
||||
}
|
||||
let size = replacement.size();
|
||||
let next = replacement.handle.into_inner().map_err(|_| "Portal session lock poisoned")?;
|
||||
let previous = {
|
||||
let mut handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
|
||||
self.size.store(pack(size.0, size.1), std::sync::atomic::Ordering::Release);
|
||||
std::mem::replace(&mut *handle, next)
|
||||
};
|
||||
self.install_replacement(replacement, None, false, false)?;
|
||||
if let Ok(mut monitor) = self.monitor.lock() { *monitor = Some(connector.to_owned()); }
|
||||
drop(previous);
|
||||
Ok(())
|
||||
}
|
||||
pub fn is_virtual(&self) -> bool { self.virtual_output.load(std::sync::atomic::Ordering::Acquire) }
|
||||
@@ -311,18 +383,116 @@ mod native {
|
||||
// exists (seen live: 3968x1280 = panel + virtual), so end the virtual share first.
|
||||
if !on { self.end(); }
|
||||
let replacement = Self::open_inner(None, monitor.as_deref(), false, on).map_err(|error| error.to_string())?;
|
||||
let size = replacement.size();
|
||||
let next = replacement.handle.into_inner().map_err(|_| "Portal session lock poisoned")?;
|
||||
let previous = {
|
||||
let mut handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
|
||||
self.size.store(pack(size.0, size.1), std::sync::atomic::Ordering::Release);
|
||||
self.virtual_output.store(on, std::sync::atomic::Ordering::Release);
|
||||
std::mem::replace(&mut *handle, next)
|
||||
};
|
||||
drop(previous);
|
||||
let size = self.install_replacement(replacement, None, false, false)?;
|
||||
self.virtual_output.store(on, std::sync::atomic::Ordering::Release);
|
||||
log::info!("Portal capture source: virtual={on} size={}x{}", size.0, size.1);
|
||||
Ok(())
|
||||
}
|
||||
/// Ask the compositor to draw the pointer into the stream (embedded) or keep it out
|
||||
/// (hidden). The portal only reads this when the session is created, so swap in a fresh
|
||||
/// session with the saved consent; every holder of this Arc follows the new handle.
|
||||
/// Ok(true): the mode changed. Ok(false): nothing to do, or the desktop is locked and the
|
||||
/// next unlocked motion retries.
|
||||
pub fn set_cursor_embedded(&self, embedded: bool) -> Result<bool, String> {
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
if super::cursor_embedded() == embedded { return Ok(false); }
|
||||
// Sample before waiting for `recovery`: an end that happens while this worker is
|
||||
// queued must invalidate the rebuild below.
|
||||
let generation = self.end_generation.load(Ordering::Acquire);
|
||||
if *self.locked.borrow() != Some(false) { return Ok(false); }
|
||||
// A backend without the embedded cursor mode never applies the request; remember it
|
||||
// so motion does not spawn a rebuild every few events.
|
||||
let modes = self.handle.lock().map(|handle| unsafe { uu_portal_cursor_modes(handle.0.as_ptr()) }).unwrap_or(0);
|
||||
if modes > 0 && modes & 2 == 0 { super::CURSOR_EMBED.store(1, Ordering::Release); return Ok(false); }
|
||||
if modes & 2 != 0 { super::CURSOR_EMBED.store(2, Ordering::Release); }
|
||||
let _recovery = self.recovery.lock().map_err(|_| "Portal recovery lock poisoned")?;
|
||||
if super::cursor_embedded() == embedded { return Ok(false); }
|
||||
if *self.locked.borrow() != Some(false) { return Ok(false); }
|
||||
// The session this rebuild replaces must still be running: a viewer that left or an
|
||||
// idle shutdown ends it, and a replacement opened afterwards would share with nobody.
|
||||
if !self.is_alive() { return Ok(false); }
|
||||
if crate::input::portal_input_held() { return Ok(false); }
|
||||
let previous = super::cursor_embedded();
|
||||
let virtual_output = self.is_virtual();
|
||||
let monitor = self.monitor();
|
||||
// A lock or desktop end during the open must cancel the consent request, not wait
|
||||
// out its timeout.
|
||||
let cancel = Arc::new(AtomicBool::new(false));
|
||||
let stop = Arc::new(AtomicBool::new(false));
|
||||
let watcher = {
|
||||
let locked = self.locked.clone();
|
||||
let end_generation = self.end_generation.clone();
|
||||
let cancel = cancel.clone();
|
||||
let stop = stop.clone();
|
||||
std::thread::Builder::new().name("portal-cursor-lock".into()).spawn(move || {
|
||||
while !stop.load(Ordering::Acquire) {
|
||||
if *locked.borrow() != Some(false) || end_generation.load(Ordering::Acquire) != generation {
|
||||
cancel.store(true, Ordering::Release);
|
||||
return;
|
||||
}
|
||||
std::thread::sleep(std::time::Duration::from_millis(50));
|
||||
}
|
||||
}).ok()
|
||||
};
|
||||
unsafe { uu_portal_set_cursor_mode(if embedded { 2 } else { 1 }); }
|
||||
let result = (|| -> Result<Option<((u32, u32), i32)>, String> {
|
||||
let replacement = Self::open_inner(Some(&cancel), monitor.as_deref(), false, virtual_output)
|
||||
.map_err(|error| error.to_string())?;
|
||||
if *self.locked.borrow() != Some(false) { return Err("desktop locked during the rebuild".into()); }
|
||||
if self.end_generation.load(Ordering::Acquire) != generation {
|
||||
return Err("desktop session ended during the rebuild".into());
|
||||
}
|
||||
// A source change that finished meanwhile must not be undone by this swap.
|
||||
if self.is_virtual() != virtual_output || (!virtual_output && self.monitor() != monitor) {
|
||||
return Err("capture source changed during the rebuild".into());
|
||||
}
|
||||
// A restored consent must not silently move the share to another monitor.
|
||||
if !virtual_output && monitor.is_some() && replacement.monitor() != monitor {
|
||||
return Err("another monitor was shared; choose this monitor in the host dialog".into());
|
||||
}
|
||||
// KDE does not report the connector, so a size change is the signal that the
|
||||
// replacement follows another output.
|
||||
self.check_geometry(&replacement).map_err(|error| error.to_string())?;
|
||||
// A key or button can go down while the open waits for consent.
|
||||
if crate::input::portal_input_held() { return Ok(None); }
|
||||
let size = match self.install_replacement(replacement, Some(generation), true, virtual_output) {
|
||||
Ok(size) => size,
|
||||
Err(error) if error == "input held during the swap" => return Ok(None),
|
||||
Err(error) => return Err(error),
|
||||
};
|
||||
let applied = self.handle.lock().ok().map(|handle| unsafe { uu_portal_cursor_mode(handle.0.as_ptr()) }).unwrap_or(0);
|
||||
Ok(Some((size, applied)))
|
||||
})();
|
||||
stop.store(true, Ordering::Release);
|
||||
drop(watcher);
|
||||
match result {
|
||||
Ok(Some(((width, height), applied))) => {
|
||||
let applied_embedded = applied == 2;
|
||||
super::CURSOR_MODE.store(if applied_embedded { 2 } else { 1 }, Ordering::Release);
|
||||
if applied_embedded != embedded {
|
||||
// The backend refused the mode (or cannot report support); retrying would
|
||||
// rebuild the session every motion run without changing anything.
|
||||
super::CURSOR_EMBED.store(1, Ordering::Release);
|
||||
unsafe { uu_portal_set_cursor_mode(applied) };
|
||||
log::info!("Portal backend did not apply the embedded cursor");
|
||||
return Ok(false);
|
||||
}
|
||||
log::info!("Portal cursor mode: embedded={embedded} size={width}x{height}");
|
||||
Ok(true)
|
||||
}
|
||||
Ok(None) => {
|
||||
// Deferred (input went down during the open): open_inner published the
|
||||
// replacement's mode, but that session is never installed.
|
||||
self.restore_installed_cursor_mode(previous);
|
||||
Ok(false)
|
||||
}
|
||||
Err(error) => {
|
||||
// Leave the engine on the mode the installed session actually has.
|
||||
self.restore_installed_cursor_mode(previous);
|
||||
Err(error)
|
||||
}
|
||||
}
|
||||
}
|
||||
pub fn open() -> Result<Self, String> {
|
||||
Self::open_inner(None, None, false, false).map_err(|error| error.to_string())
|
||||
}
|
||||
@@ -337,6 +507,8 @@ mod native {
|
||||
pub fn upgrade_touch(&self) -> Result<bool, String> {
|
||||
let available = self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_touch_available(handle.0.as_ptr()) } != 0);
|
||||
if !available || self.touch_supported() { return Ok(false); }
|
||||
// Serialize with recovery and the cursor-mode rebuild: all replace the handle.
|
||||
let _recovery = self.recovery.lock().map_err(|_| "Portal recovery lock poisoned")?;
|
||||
log::info!("Portal touch consent: asking the host again for the touchscreen");
|
||||
let monitor = self.monitor();
|
||||
let replacement = Self::open_inner(None, monitor.as_deref(), true, self.is_virtual()).map_err(|error| error.to_string())?;
|
||||
@@ -344,9 +516,7 @@ mod native {
|
||||
if replacement.monitor() != monitor { return Err("another monitor was shared".into()); }
|
||||
if !replacement.touch_supported() { return Err("the touchscreen was not granted".into()); }
|
||||
self.check_geometry(&replacement).map_err(|error| error.to_string())?;
|
||||
let next = replacement.handle.into_inner().map_err(|_| "Portal session lock poisoned")?;
|
||||
let previous = std::mem::replace(&mut *self.handle.lock().map_err(|_| "Portal session lock poisoned")?, next);
|
||||
drop(previous);
|
||||
self.install_replacement(replacement, None, false, self.is_virtual())?;
|
||||
Ok(true)
|
||||
}
|
||||
pub fn open_cancellable(cancelled: &std::sync::atomic::AtomicBool) -> Result<Self, super::PortalError> {
|
||||
@@ -381,9 +551,19 @@ mod native {
|
||||
let result = super::open_then_install(cancelled, || Self::open_inner(Some(cancelled), monitor.as_deref(), false, virtual_output), |replacement| {
|
||||
self.check_geometry(&replacement)?;
|
||||
let replacement_handle = replacement.handle.into_inner().map_err(|_| super::PortalError { code: 3 })?;
|
||||
let clipboard = self.clipboard_write.lock().map_err(|_| super::PortalError { code: 3 })?;
|
||||
let serial = crate::input::lock_portal_held();
|
||||
let mut handle = self.handle.lock().map_err(|_| super::PortalError { code: 3 })?;
|
||||
if cancelled.load(Ordering::Acquire) { return Err(super::PortalError { code: 13 }); }
|
||||
*handle = replacement_handle;
|
||||
let previous_handle = std::mem::replace(&mut *handle, replacement_handle);
|
||||
let installed = Arc::clone(&*handle);
|
||||
drop(handle);
|
||||
unsafe { uu_portal_clipboard_copy(previous_handle.0.as_ptr(), installed.0.as_ptr()) };
|
||||
drop(clipboard);
|
||||
drop(previous_handle);
|
||||
// The replaced devices took any held portal input with them.
|
||||
crate::input::portal_session_replaced();
|
||||
drop(serial);
|
||||
clear_pause_for_unlocked_replacement(&self.was_locked, *self.locked.borrow());
|
||||
log::info!("Portal capture session restored after closure");
|
||||
Ok(())
|
||||
@@ -474,7 +654,7 @@ mod native {
|
||||
Err(TryLockError::WouldBlock) => return Ok(blank_changed(frame, version)),
|
||||
Err(TryLockError::Poisoned(_)) => return Err("Portal recovery lock poisoned".into()),
|
||||
};
|
||||
if replace_handle(&self.handle, handle, || {
|
||||
if replace_handle_carrying(&self.handle, &self.clipboard_write, handle, || {
|
||||
{
|
||||
let handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
|
||||
if unsafe { uu_portal_capture_alive(handle.0.as_ptr()) } != 0 {
|
||||
@@ -546,6 +726,9 @@ mod native {
|
||||
}
|
||||
pub fn clipboard_set(&self, text: &str) -> Result<(), String> {
|
||||
if text.len()>crate::clipboard::MAX_TEXT || *self.locked.borrow()!=Some(false) { return Err("Portal clipboard unavailable".into()); }
|
||||
// Serialize with the cursor-session swap: it carries the old text over before
|
||||
// releasing this lock, so a update that arrives during the swap wins afterwards.
|
||||
let _write=self.clipboard_write.lock().map_err(|_| "Portal clipboard lock poisoned")?;
|
||||
let handle=self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
|
||||
if unsafe { uu_portal_clipboard_set(handle.0.as_ptr(),text.as_ptr(),text.len()) }==0 {Ok(())} else {Err("Portal clipboard ownership failed".into())}
|
||||
}
|
||||
@@ -624,6 +807,8 @@ mod native {
|
||||
recovery: Mutex::new(Recovery::default()),
|
||||
size: pack(physical.0, physical.1).into(),
|
||||
monitor: Mutex::new(None), virtual_output: false.into(),
|
||||
clipboard_write: Mutex::new(()),
|
||||
end_generation: Arc::new(std::sync::atomic::AtomicU64::new(0)),
|
||||
}))
|
||||
}
|
||||
|
||||
@@ -920,6 +1105,7 @@ impl PortalSession {
|
||||
pub fn end(&self) {}
|
||||
pub fn switch_to(&self, _: &str) -> Result<(), String> { Err(error(15)) }
|
||||
pub fn set_virtual(&self, _: bool) -> Result<(), String> { Err(error(15)) }
|
||||
pub fn set_cursor_embedded(&self, _: bool) -> Result<bool, String> { Err(error(15)) }
|
||||
pub fn is_virtual(&self) -> bool { false }
|
||||
}
|
||||
#[cfg(not(all(target_os = "linux", feature = "portal")))]
|
||||
@@ -980,6 +1166,128 @@ pub fn switch_active(connector: &str) -> Result<(), String> {
|
||||
.ok_or("Portal desktop unavailable")?;
|
||||
session.switch_to(connector)
|
||||
}
|
||||
/// Whether the capture stream carries the compositor's pointer. 0 is "not asked yet"; the
|
||||
/// startup answer has to match what the engine reads from UU_PORTAL_CURSOR_MODE.
|
||||
static CURSOR_MODE: std::sync::atomic::AtomicU8 = std::sync::atomic::AtomicU8::new(0);
|
||||
/// Embedded cursor support reported by a session: 0 unknown, 1 unavailable, 2 available.
|
||||
static CURSOR_EMBED: std::sync::atomic::AtomicU8 = std::sync::atomic::AtomicU8::new(0);
|
||||
fn cursor_embedded() -> bool {
|
||||
use std::sync::atomic::Ordering;
|
||||
match CURSOR_MODE.load(Ordering::Acquire) {
|
||||
0 => {
|
||||
let embedded = std::env::var("UU_PORTAL_CURSOR_MODE").is_ok_and(|value| value.eq_ignore_ascii_case("embedded"));
|
||||
CURSOR_MODE.store(if embedded { 2 } else { 1 }, Ordering::Release);
|
||||
embedded
|
||||
}
|
||||
mode => mode == 2,
|
||||
}
|
||||
}
|
||||
/// Ask the running session for a stream with (or without) the compositor cursor.
|
||||
pub fn set_cursor_embedded(embedded: bool) -> Result<bool, String> {
|
||||
let session = ACTIVE.lock().unwrap_or_else(std::sync::PoisonError::into_inner).as_ref().and_then(std::sync::Weak::upgrade)
|
||||
.ok_or("Portal desktop unavailable")?;
|
||||
session.set_cursor_embedded(embedded)
|
||||
}
|
||||
/// A release package can carry an older libuu-portal.so without the runtime cursor switch;
|
||||
/// rebuilding the session would be wasted work there.
|
||||
fn cursor_switch_available() -> bool {
|
||||
#[cfg(all(target_os = "linux", feature = "portal", feature = "engine-plugins"))]
|
||||
{
|
||||
static AVAILABLE: std::sync::OnceLock<bool> = std::sync::OnceLock::new();
|
||||
*AVAILABLE.get_or_init(|| crate::engine_plugin::symbol(crate::engine_plugin::Engine::Portal, "uu_portal_set_cursor_mode\0") != 0)
|
||||
}
|
||||
#[cfg(not(all(target_os = "linux", feature = "portal", feature = "engine-plugins")))]
|
||||
{ cfg!(all(target_os = "linux", feature = "portal")) }
|
||||
}
|
||||
/// Relative motion has no position the viewer could draw a cursor at, so the stream has to carry
|
||||
/// one. Absolute motion means the viewer draws its own and an embedded copy would trail it. Both
|
||||
/// need a fresh portal session, so wait for a run of the same kind before rebuilding it.
|
||||
struct PointerMode {
|
||||
candidate: Option<bool>,
|
||||
streak: u32,
|
||||
first: Option<std::time::Instant>,
|
||||
switching: bool,
|
||||
blocked_until: Option<std::time::Instant>,
|
||||
}
|
||||
static POINTER_MODE: std::sync::Mutex<PointerMode> = std::sync::Mutex::new(PointerMode {
|
||||
candidate: None, streak: 0, first: None, switching: false, blocked_until: None,
|
||||
});
|
||||
const POINTER_STREAK: u32 = 5;
|
||||
/// A burst at connect must not rebuild the session, so the run has to span time as well.
|
||||
const POINTER_WINDOW: std::time::Duration = std::time::Duration::from_millis(200);
|
||||
/// After a failed rebuild the consent may be gone; do not retry on the next few events.
|
||||
const POINTER_COOLDOWN: std::time::Duration = std::time::Duration::from_secs(5);
|
||||
fn pointer_decision(state: &mut PointerMode, current: bool, relative: bool, now: std::time::Instant) -> Option<bool> {
|
||||
if current == relative {
|
||||
state.candidate = None;
|
||||
state.streak = 0;
|
||||
state.first = None;
|
||||
return None;
|
||||
}
|
||||
if state.switching || state.blocked_until.is_some_and(|until| now < until) { return None; }
|
||||
match state.candidate {
|
||||
Some(candidate) if candidate == relative => {
|
||||
state.streak += 1;
|
||||
if state.streak >= POINTER_STREAK
|
||||
&& state.first.is_some_and(|first| now.duration_since(first) >= POINTER_WINDOW) {
|
||||
return Some(relative);
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
state.candidate = Some(relative);
|
||||
state.streak = 1;
|
||||
state.first = Some(now);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
pub fn note_pointer_motion(relative: bool) {
|
||||
if !cursor_switch_available() { return; }
|
||||
// The backend does not advertise an embedded cursor: nothing to switch to.
|
||||
if CURSOR_EMBED.load(std::sync::atomic::Ordering::Acquire) == 1 { return; }
|
||||
// A swap closes the portal input devices; do not drop keys or buttons the viewer holds.
|
||||
if crate::input::portal_input_held() { return; }
|
||||
let decision = {
|
||||
let Ok(mut state) = POINTER_MODE.lock() else { return; };
|
||||
let decision = pointer_decision(&mut state, cursor_embedded(), relative, std::time::Instant::now());
|
||||
if decision.is_some() {
|
||||
state.switching = true;
|
||||
state.candidate = None;
|
||||
state.streak = 0;
|
||||
state.first = None;
|
||||
}
|
||||
decision
|
||||
};
|
||||
let Some(target) = decision else { return; };
|
||||
let spawned = std::thread::Builder::new().name("portal-cursor".into()).spawn(move || {
|
||||
let result = set_cursor_embedded(target);
|
||||
let mut state = POINTER_MODE.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
|
||||
state.switching = false;
|
||||
state.candidate = None;
|
||||
state.streak = 0;
|
||||
state.first = None;
|
||||
match result {
|
||||
Ok(true) => {
|
||||
state.blocked_until = None;
|
||||
drop(state);
|
||||
log::info!("Cursor mode follows the pointer: embedded={target}");
|
||||
}
|
||||
Ok(false) => {
|
||||
// Locked, or something else changed the mode first; the next motion retries.
|
||||
state.blocked_until = None;
|
||||
drop(state);
|
||||
}
|
||||
Err(error) => {
|
||||
state.blocked_until = Some(std::time::Instant::now() + POINTER_COOLDOWN);
|
||||
drop(state);
|
||||
log::warn!("Portal cursor switch failed: {error}");
|
||||
}
|
||||
}
|
||||
});
|
||||
if spawned.is_err() {
|
||||
if let Ok(mut state) = POINTER_MODE.lock() { state.switching = false; }
|
||||
}
|
||||
}
|
||||
pub struct Monitor { pub connector: String, pub width: u32, pub height: u32, pub x: i32, pub y: i32, pub primary: bool }
|
||||
#[cfg(all(target_os = "linux", feature = "portal"))]
|
||||
pub use native::monitors;
|
||||
@@ -1065,3 +1373,76 @@ mod tests {
|
||||
assert_eq!(*handle.lock().unwrap(), 11);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod pointer_mode_tests {
|
||||
use super::{pointer_decision, PointerMode, POINTER_COOLDOWN, POINTER_WINDOW};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
fn state() -> PointerMode {
|
||||
PointerMode { candidate: None, streak: 0, first: None, switching: false, blocked_until: None }
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_connect_burst_does_not_rebuild_the_session() {
|
||||
let mut state = state();
|
||||
let start = Instant::now();
|
||||
for step in 0..20 {
|
||||
assert_eq!(pointer_decision(&mut state, true, false, start + Duration::from_millis(step)), None);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_sustained_change_decides_once_the_run_spans_the_window() {
|
||||
let mut state = state();
|
||||
let start = Instant::now();
|
||||
let mut decided = None;
|
||||
for step in 0..40 {
|
||||
let now = start + Duration::from_millis(step * 10);
|
||||
if let Some(value) = pointer_decision(&mut state, true, false, now) {
|
||||
assert!(now.duration_since(start) >= POINTER_WINDOW);
|
||||
decided = Some(value);
|
||||
break;
|
||||
}
|
||||
}
|
||||
assert_eq!(decided, Some(false));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_opposite_event_restarts_the_run() {
|
||||
let mut state = state();
|
||||
let start = Instant::now();
|
||||
for step in 0..10 { pointer_decision(&mut state, true, false, start + Duration::from_millis(step)); }
|
||||
pointer_decision(&mut state, true, true, start + Duration::from_millis(10));
|
||||
for step in 11..19 {
|
||||
assert_eq!(pointer_decision(&mut state, true, false, start + Duration::from_millis(step)), None);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_failed_switch_waits_out_the_cooldown() {
|
||||
let mut state = state();
|
||||
let start = Instant::now();
|
||||
state.blocked_until = Some(start + POINTER_COOLDOWN);
|
||||
for step in 0..40 {
|
||||
assert_eq!(pointer_decision(&mut state, true, false, start + Duration::from_millis(step * 10)), None);
|
||||
}
|
||||
let after = start + POINTER_COOLDOWN + Duration::from_millis(1);
|
||||
let mut decided = None;
|
||||
for step in 0..30 {
|
||||
let now = after + Duration::from_millis(step * 10);
|
||||
if let Some(value) = pointer_decision(&mut state, true, false, now) { decided = Some(value); break; }
|
||||
}
|
||||
assert_eq!(decided, Some(false));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_switch_in_flight_ignores_more_events() {
|
||||
let mut state = state();
|
||||
let start = Instant::now();
|
||||
state.switching = true;
|
||||
for step in 0..40 {
|
||||
assert_eq!(pointer_decision(&mut state, true, false, start + Duration::from_millis(step * 10)), None);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -20,6 +20,9 @@ pub trait Backend: Send + Sync {
|
||||
fn enter(&self, mode: Mode, journal: &mut Journal) -> Result<Entered, String>;
|
||||
/// Undo `data` from `enter`. Also used for crash recovery, where no desktop stream exists.
|
||||
fn leave(&self, data: &serde_json::Value) -> Result<(), String>;
|
||||
/// Recompute `Entered::pointer_region` after the virtual output was recreated. None keeps
|
||||
/// the stored region (backends without a virtual output, or a layout not settled yet).
|
||||
fn refresh_pointer_region(&self) -> Option<[f64; 4]> { None }
|
||||
}
|
||||
|
||||
/// The backend for this session, if the desktop has one.
|
||||
|
||||
@@ -1,12 +1,28 @@
|
||||
//! One-shot KWin scripts (org.kde.kwin.Scripting).
|
||||
//! KWin scripts (org.kde.kwin.Scripting): one-shot ones, plus the new-window keeper that picture
|
||||
//! mode leaves loaded for the whole privacy session.
|
||||
use super::super::tool::gdbus;
|
||||
|
||||
const ONE_SHOT: &str = "uu-privacy";
|
||||
const KEEP_WINDOWS: &str = "uu-privacy-windows";
|
||||
|
||||
fn call(object: &str, method: &str, args: &[&str]) -> Result<String, String> { gdbus("org.kde.KWin", object, method, args) }
|
||||
fn script(js: &str) -> Result<(), String> {
|
||||
/// Output names go into a JS string literal.
|
||||
fn escape(output: &str) -> String { output.replace('\\', "\\\\").replace('"', "\\\"") }
|
||||
/// Windows that belong on the captured output. Desktop pets and tool palettes use toolbar/utility
|
||||
/// windows, which `normalWindow` misses; panels, the desktop and transient popups stay where they
|
||||
/// are, so the layout of the physical outputs is unchanged.
|
||||
const MOVABLE: &str = r#"function movable(w) {
|
||||
if (!w || w.desktopWindow || w.dock) return false;
|
||||
if (w.tooltip || w.popupMenu || w.dropdownMenu || w.comboBox || w.dndIcon) return false;
|
||||
return w.normalWindow || w.dialog || w.toolbar || w.utility || w.splash;
|
||||
}"#;
|
||||
/// Loads `js` under `name` and runs it. `keep` leaves it loaded with its signal connections alive;
|
||||
/// otherwise it is unloaded after the run, as the one-shot scripts expect.
|
||||
fn script(js: &str, name: &str, keep: bool) -> Result<(), String> {
|
||||
let dir = std::env::var_os("XDG_RUNTIME_DIR").map(std::path::PathBuf::from).ok_or("missing runtime directory")?;
|
||||
let file = dir.join(format!("uu-privacy-{}.js", std::process::id()));
|
||||
let file = dir.join(format!("uu-privacy-{name}-{}.js", std::process::id()));
|
||||
std::fs::write(&file, js).map_err(|e| e.kind().to_string())?;
|
||||
let name = "uu-privacy";
|
||||
// A script left loaded by a host that died would keep running with a stale target.
|
||||
let _ = call("/Scripting", "org.kde.kwin.Scripting.unloadScript", &[name]);
|
||||
let result = call("/Scripting", "org.kde.kwin.Scripting.loadScript", &[&file.to_string_lossy(), name]).and_then(|out| {
|
||||
let id: String = out.chars().filter(char::is_ascii_digit).collect();
|
||||
@@ -14,14 +30,52 @@ fn script(js: &str) -> Result<(), String> {
|
||||
call(&format!("/Scripting/Script{id}"), "org.kde.kwin.Script.run", &[])
|
||||
});
|
||||
std::thread::sleep(std::time::Duration::from_millis(300));
|
||||
let _ = call("/Scripting", "org.kde.kwin.Scripting.unloadScript", &[name]);
|
||||
// A failed run must not leave a half-started keeper behind.
|
||||
if !keep || result.is_err() { let _ = call("/Scripting", "org.kde.kwin.Scripting.unloadScript", &[name]); }
|
||||
let _ = std::fs::remove_file(file);
|
||||
result.map(|_| ())
|
||||
}
|
||||
/// Sends every normal window and dialog to `output` (a name from kscreen-doctor, file-name safe).
|
||||
/// Sends every movable window to `output` (a name from kscreen-doctor).
|
||||
pub fn move_windows_to(output: &str) -> Result<(), String> {
|
||||
script(&format!(r#"const v = workspace.screens.find(o => o.name == "{output}");
|
||||
if (v) for (const w of workspace.windowList()) if (w.normalWindow || w.dialog) workspace.sendClientToScreen(w, v);"#))
|
||||
let output = escape(output);
|
||||
script(&format!(r#"{movable}
|
||||
const v = workspace.screens.find(o => o.name == "{output}");
|
||||
if (v) for (const w of workspace.windowList()) if (movable(w)) workspace.sendClientToScreen(w, v);"#, movable = MOVABLE), ONE_SHOT, false)
|
||||
}
|
||||
/// Keeps windows on `output`. Picture mode turns the physical outputs back on as secondaries, and
|
||||
/// KWin then places a new window on the screen it considers active, which can be one hidden under
|
||||
/// the cover: the viewer would never see it. Every window is checked when it appears and whenever
|
||||
/// its geometry changes, so an application that places itself on a physical output is sent back.
|
||||
/// `frameGeometryChanged` is the trigger because KWin 6.8 does not emit `outputChanged` for
|
||||
/// `sendClientToScreen` moves (verified live). Unloaded by `unload_keep_windows` on restore.
|
||||
pub fn keep_windows_on(output: &str) -> Result<(), String> {
|
||||
let output = escape(output);
|
||||
script(&format!(r#"{movable}
|
||||
function keep(w) {{
|
||||
if (!movable(w)) return;
|
||||
// The cover windows belong on the physical outputs.
|
||||
if (w.resourceClass === "uuremote-server" || (w.caption || "").indexOf("uu-remote-linux privacy") === 0) return;
|
||||
const screen = workspace.screens.find(o => o.name === "{output}");
|
||||
if (!screen || (w.output && w.output.name === "{output}")) return;
|
||||
workspace.sendClientToScreen(w, screen);
|
||||
}}
|
||||
function watch(w) {{
|
||||
if (!w) return;
|
||||
// One window that cannot be moved or observed must not stop the others.
|
||||
try {{
|
||||
keep(w);
|
||||
w.frameGeometryChanged.connect(function () {{ keep(w); }});
|
||||
}} catch (e) {{}}
|
||||
}}
|
||||
// New windows first: a throwing sweep must not leave them unhandled.
|
||||
workspace.windowAdded.connect(watch);
|
||||
workspace.windowList().forEach(watch);
|
||||
"#, movable = MOVABLE), KEEP_WINDOWS, true)
|
||||
}
|
||||
/// Stops following new windows. A name that is not loaded (screen-off mode, a restarted KWin
|
||||
/// session) reports false without an error.
|
||||
pub fn unload_keep_windows() -> Result<(), String> {
|
||||
call("/Scripting", "org.kde.kwin.Scripting.unloadScript", &[KEEP_WINDOWS]).map(|_| ())
|
||||
}
|
||||
/// Hides the cover window from the task manager. GTK's skip-taskbar hint is an X11 hint and KWin
|
||||
/// ignores it on Wayland, so the cover showed up as an unidentified window with the theme's
|
||||
@@ -30,5 +84,14 @@ if (v) for (const w of workspace.windowList()) if (w.normalWindow || w.dialog) w
|
||||
/// duplicate captions, so match the title as a prefix.
|
||||
pub fn hide_cover_from_taskbar() -> Result<(), String> {
|
||||
script(r#"for (const w of workspace.windowList())
|
||||
if (w.resourceClass === "uuremote-server" && w.caption.indexOf("uu-remote-linux privacy") === 0) w.skipTaskbar = true;"#)
|
||||
if (w.resourceClass === "uuremote-server" && w.caption.indexOf("uu-remote-linux privacy") === 0) w.skipTaskbar = true;"#, ONE_SHOT, false)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#[test]
|
||||
fn escapes_output_names_for_the_script() {
|
||||
assert_eq!(super::escape("DP-3"), "DP-3");
|
||||
assert_eq!(super::escape(r#"a"b\c"#), r#"a\"b\\c"#);
|
||||
}
|
||||
}
|
||||
@@ -5,7 +5,8 @@
|
||||
//! physical outputs before the virtual one exists (KWin applies stored configs on creation),
|
||||
//! re-enable them before the virtual output goes away, and never disable the virtual output
|
||||
//! itself (KWin bug 527747 persists that and breaks later virtual shares).
|
||||
//! Picture mode then turns the physical outputs back on as secondary ones and covers them.
|
||||
//! Picture mode then turns the physical outputs back on as secondary ones and covers them, and a
|
||||
//! second KWin script keeps windows that appear later on the virtual output too.
|
||||
mod input;
|
||||
mod kwin;
|
||||
mod outputs;
|
||||
@@ -39,6 +40,12 @@ fn wallpaper() -> Option<std::path::PathBuf> {
|
||||
/// secondary outputs, keep the windows on the virtual one, and cover the physical ones.
|
||||
fn cover(data: &Data) -> Result<[f64; 4], String> {
|
||||
let virtual_name = outputs::layout()?.into_iter().map(|o| o.name).find(|n| !data.outputs.contains(n)).ok_or("virtual output not found")?;
|
||||
// Loaded before the physical outputs come back: from then on KWin places a new window on the
|
||||
// screen it considers active, which may be one that is about to be covered.
|
||||
match kwin::keep_windows_on(&virtual_name) {
|
||||
Ok(()) => log::info!("Privacy new-window keeper: loaded"),
|
||||
Err(e) => log::warn!("Privacy new-window keeper: {e}"),
|
||||
}
|
||||
outputs::set(&data.outputs, true).map_err(|e| format!("enable outputs: {e}"))?;
|
||||
if let Err(e) = outputs::set_primary(&virtual_name) { log::warn!("Privacy virtual output priority: {e}"); }
|
||||
kwin::move_windows_to(&virtual_name).map_err(|e| format!("move windows: {e}"))?;
|
||||
@@ -81,12 +88,22 @@ impl Backend for Kde {
|
||||
log::info!("Privacy KDE: outputs={} input_devices={}", data.outputs.len(), data.devices.len());
|
||||
Ok(entered)
|
||||
}
|
||||
fn refresh_pointer_region(&self) -> Option<[f64; 4]> {
|
||||
// The old virtual output disappears with the replaced session; wait for the layout to
|
||||
// settle on the new one before taking its share of the bounding box.
|
||||
let layout = outputs::layout().ok()?;
|
||||
let virtuals: Vec<_> = layout.iter().filter(|o| o.name.starts_with("Virtual")).collect();
|
||||
let target = match virtuals.as_slice() { [only] => *only, _ => return None };
|
||||
outputs::region(&layout, &target.name)
|
||||
}
|
||||
fn leave(&self, data: &serde_json::Value) -> Result<(), String> {
|
||||
let data: Data = serde_json::from_value(data.clone()).map_err(|_| "invalid KDE recovery data")?;
|
||||
// KWin persists the device flag: a failure is returned (after restoring the outputs) so the
|
||||
// controller keeps the recovery record and the guard for the next attempt. A device that
|
||||
// no longer exists is skipped, so a record replayed after a reboot cannot wedge recovery.
|
||||
let devices = input::restore(&data.devices).map_err(|e| format!("enable input devices: {e}"));
|
||||
// Stop following new windows before the virtual output goes away.
|
||||
if let Err(e) = kwin::unload_keep_windows() { log::warn!("Privacy new-window keeper: {e}"); }
|
||||
// Physical outputs first: switching back opens a monitor share, which needs them enabled.
|
||||
// The wait also matters: a share opened before KWin applies the mode got the virtual
|
||||
// output's geometry (seen live: 1920x1080 instead of the panel's 3072x1920).
|
||||
|
||||
@@ -12,7 +12,7 @@ mod record;
|
||||
mod tool;
|
||||
|
||||
pub use mode::Mode;
|
||||
use std::sync::{atomic::{AtomicBool, Ordering}, Mutex};
|
||||
use std::sync::{atomic::{AtomicBool, AtomicU64, Ordering}, Mutex};
|
||||
|
||||
struct Active { mode: Mode, record: Option<record::Record> }
|
||||
struct State { sessions: usize, active: Option<Active> }
|
||||
@@ -25,14 +25,20 @@ static POINTER: Mutex<Option<[f64; 4]>> = Mutex::new(None);
|
||||
/// ends. An auto-enable never overrides it, including an RPC that arrives after the connection
|
||||
/// opens but before `session_started` bumps the counter.
|
||||
static VIEWER_OVERRIDE: AtomicBool = AtomicBool::new(false);
|
||||
/// iOS viewers encode "screen off" as `enable=0, type=3`; see
|
||||
/// `protocol::Request::normalize_ios_screen_off`.
|
||||
/// Bumped when a new first desktop session spawns its auto-enable thread. A reconnect that beats
|
||||
/// the 500 ms poll would otherwise leave the old waiter running for up to five minutes.
|
||||
static AUTO_GENERATION: AtomicU64 = AtomicU64::new(0);
|
||||
/// iOS viewers encode "screen off" as `enable=0, type=3`, and Windows viewers carry every request
|
||||
/// in `type` with `enable=0`; see `protocol::Request::normalize_ios_screen_off` and
|
||||
/// `protocol::Request::normalize_windows`.
|
||||
static VIEWER_IOS: AtomicBool = AtomicBool::new(false);
|
||||
static VIEWER_WINDOWS: AtomicBool = AtomicBool::new(false);
|
||||
|
||||
pub fn supported() -> bool { backend::detect().is_some() }
|
||||
/// Record the desktop controller's platform for the iOS RPC 7 encoder quirk.
|
||||
/// Record the desktop controller's platform for the RPC 7 encoder quirks.
|
||||
pub fn set_viewer_controller(controller: crate::input::Controller) {
|
||||
VIEWER_IOS.store(controller == crate::input::Controller::Ios, Ordering::Relaxed);
|
||||
VIEWER_WINDOWS.store(controller == crate::input::Controller::Windows, Ordering::Relaxed);
|
||||
}
|
||||
pub fn active() -> bool { ACTIVE.load(Ordering::Relaxed) }
|
||||
/// The viewer's privacy_type now in effect.
|
||||
@@ -45,6 +51,18 @@ pub fn state_message(seq: u64, timestamp: u64) -> Vec<u8> {
|
||||
}
|
||||
/// See `backend::Entered::pointer_region`.
|
||||
pub fn pointer_region() -> Option<[f64; 4]> { *POINTER.lock().ok()? }
|
||||
/// A session rebuild replaced the virtual output: refresh the region absolute input maps into.
|
||||
pub fn refresh_pointer_region() {
|
||||
if !active() { return; }
|
||||
for _ in 0..10 {
|
||||
if let Some(region) = backend::detect().and_then(backend::Backend::refresh_pointer_region) {
|
||||
if let Ok(mut pointer) = POINTER.lock() { *pointer = Some(region); }
|
||||
return;
|
||||
}
|
||||
std::thread::sleep(std::time::Duration::from_millis(50));
|
||||
}
|
||||
log::warn!("Privacy pointer region not refreshed: virtual output layout did not settle");
|
||||
}
|
||||
|
||||
fn publish(active: Option<&Active>) {
|
||||
ACTIVE.store(active.is_some(), Ordering::Relaxed);
|
||||
@@ -125,6 +143,9 @@ pub fn rpc_accept(rpc: &[crate::protocol::WireField]) -> Option<(Vec<u8>, Option
|
||||
// as an accepted request would.
|
||||
VIEWER_OVERRIDE.store(true, Ordering::Relaxed);
|
||||
log::info!("Privacy request: iOS screen-off encoding normalized (enable=0 type=3)");
|
||||
} else if request.normalize_windows(VIEWER_WINDOWS.load(Ordering::Relaxed)) {
|
||||
VIEWER_OVERRIDE.store(true, Ordering::Relaxed);
|
||||
log::info!("Privacy request: Windows encoding normalized (enable=0 mode={:?})", request.mode);
|
||||
}
|
||||
if let Some(e) = refuse(request.enable, request.mode) {
|
||||
log::warn!("Privacy request refused: enable={} mode={:?}: {e}", request.enable, request.mode);
|
||||
@@ -164,10 +185,42 @@ fn auto_set(mode: Mode) -> Result<bool, String> {
|
||||
if result.is_err() { if let Err(e) = leave(&mut state) { log::warn!("Privacy rollback failed: {e}"); } }
|
||||
result.map(|_| true)
|
||||
}
|
||||
/// The watch is authoritative while it has a value. A None (the logind monitor lost the session)
|
||||
/// must not fail open: ask logind directly before covering a possibly locked desktop.
|
||||
fn currently_locked() -> bool {
|
||||
let locked = crate::session_lock::watch_locked();
|
||||
let state = *locked.borrow();
|
||||
match state {
|
||||
Some(state) => state,
|
||||
None => crate::session_lock::locked_now() == Some(true),
|
||||
}
|
||||
}
|
||||
/// The capture session and the viewer's CONTROL state need a moment after the peer connects;
|
||||
/// retry while the portal session is still missing, and let the viewer's RPC 7 win if it arrives.
|
||||
fn auto_enable(mode: Mode) {
|
||||
fn auto_enable(mode: Mode, generation: u64) {
|
||||
// A locked desktop is already covered. Switching the share to the virtual output would hide
|
||||
// the lock screen the viewer needs to unlock, so wait for the local unlock first. Bounded:
|
||||
// a viewer that never unlocks, or leaves, must not hold this thread forever.
|
||||
let current = || AUTO_GENERATION.load(Ordering::Acquire) == generation;
|
||||
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(300);
|
||||
while currently_locked() {
|
||||
if !current() { return; }
|
||||
if VIEWER_OVERRIDE.load(Ordering::Relaxed) {
|
||||
log::info!("Privacy auto: skipped, the viewer already chose a mode");
|
||||
return;
|
||||
}
|
||||
if STATE.try_lock().is_ok_and(|state| state.sessions == 0) {
|
||||
log::info!("Privacy auto: skipped, the desktop session ended");
|
||||
return;
|
||||
}
|
||||
if std::time::Instant::now() >= deadline {
|
||||
log::info!("Privacy auto: desktop stayed locked; not covering it");
|
||||
return;
|
||||
}
|
||||
std::thread::sleep(std::time::Duration::from_millis(500));
|
||||
}
|
||||
for attempt in 1..=5 {
|
||||
if !current() { return; }
|
||||
if VIEWER_OVERRIDE.load(Ordering::Relaxed) {
|
||||
log::info!("Privacy auto: skipped, the viewer already chose a mode");
|
||||
return;
|
||||
@@ -197,9 +250,10 @@ pub fn session_started() {
|
||||
let first = STATE.lock().ok().is_some_and(|mut s| { s.sessions += 1; s.sessions == 1 });
|
||||
let Some(mode) = auto else { return };
|
||||
if !first { return; }
|
||||
let generation = AUTO_GENERATION.fetch_add(1, Ordering::AcqRel) + 1;
|
||||
std::thread::spawn(move || {
|
||||
std::thread::sleep(std::time::Duration::from_millis(1500));
|
||||
auto_enable(mode);
|
||||
auto_enable(mode, generation);
|
||||
});
|
||||
}
|
||||
pub fn session_ended() {
|
||||
|
||||
@@ -17,6 +17,16 @@ impl Request {
|
||||
}
|
||||
false
|
||||
}
|
||||
/// Windows viewers send every privacy request with `enable=0` and carry the intent in
|
||||
/// `privacy_type`: `0/0` is off, `0/2` picture and `0/3` screen-off (verified live on the
|
||||
/// Windows client). Android 4.43.0 and macOS keep field 1 as the master switch.
|
||||
pub fn normalize_windows(&mut self, windows: bool) -> bool {
|
||||
if windows && !self.enable && self.mode.is_some() {
|
||||
self.enable = true;
|
||||
return true;
|
||||
}
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
pub fn parse(rpc: &[crate::protocol::WireField]) -> Option<(Vec<u8>, Request)> {
|
||||
@@ -106,4 +116,31 @@ mod tests {
|
||||
assert!(!request.normalize_ios_screen_off(true));
|
||||
assert!(request.enable);
|
||||
}
|
||||
#[test]
|
||||
fn normalizes_windows_encoding_only() {
|
||||
// Windows: enable is always 0, the type carries the intent.
|
||||
for (wire, mode) in [(2u8, Mode::Picture), (3u8, Mode::ScreenOff)] {
|
||||
let bytes = [10, 2, 8, 42, 58, 4, 8, 0, 16, wire];
|
||||
let (_, mut request) = parse(&crate::protocol::decode_wire(&bytes).unwrap()).unwrap();
|
||||
assert!(request.normalize_windows(true));
|
||||
assert!(request.enable);
|
||||
assert_eq!(request.mode, Some(mode));
|
||||
}
|
||||
// Off stays off: type 0 (seen when the Windows switch is turned off) and type 1.
|
||||
for wire in [0u8, 1] {
|
||||
let bytes = [10, 2, 8, 42, 58, 4, 8, 0, 16, wire];
|
||||
let (_, mut request) = parse(&crate::protocol::decode_wire(&bytes).unwrap()).unwrap();
|
||||
assert!(!request.normalize_windows(true));
|
||||
assert!(!request.enable);
|
||||
}
|
||||
// Other platforms and explicit enables are untouched.
|
||||
let picture = crate::protocol::decode_wire(&[10, 2, 8, 42, 58, 4, 8, 0, 16, 2]).unwrap();
|
||||
let (_, mut request) = parse(&picture).unwrap();
|
||||
assert!(!request.normalize_windows(false));
|
||||
assert!(!request.enable);
|
||||
let explicit = crate::protocol::decode_wire(&[10, 2, 8, 42, 58, 4, 8, 1, 16, 2]).unwrap();
|
||||
let (_, mut request) = parse(&explicit).unwrap();
|
||||
assert!(!request.normalize_windows(true));
|
||||
assert!(request.enable);
|
||||
}
|
||||
}
|
||||
+74
-19
@@ -11,11 +11,15 @@
|
||||
//! (`loginctl unlock-session`, allowed for the session owner), which avoids remote keystrokes
|
||||
//! and gives an exact wrong-password result. The password is never logged or stored.
|
||||
|
||||
use std::process::Command;
|
||||
use std::process::{Command, Stdio};
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use std::sync::OnceLock;
|
||||
use std::time::Duration;
|
||||
use tokio::sync::watch;
|
||||
|
||||
mod logind;
|
||||
|
||||
/// Official UnlockResult cases (LockScreenManager).
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum UnlockResult { Success, WrongPassword, NoLoggedInUser, NoPermission, Failed }
|
||||
@@ -29,10 +33,44 @@ extern "C" {
|
||||
fn uu_pam_check(service: *const libc::c_char, user: *const libc::c_char, password: *const libc::c_char) -> libc::c_int;
|
||||
}
|
||||
|
||||
// Resolve once: execvp's unsuccessful PATH candidates are also recorded by auditd.
|
||||
fn loginctl_path() -> Option<&'static Path> {
|
||||
static PATH: OnceLock<Option<PathBuf>> = OnceLock::new();
|
||||
PATH.get_or_init(|| {
|
||||
std::env::var_os("PATH").into_iter().flat_map(|p| std::env::split_paths(&p).collect::<Vec<_>>())
|
||||
.map(|dir| dir.join("loginctl"))
|
||||
.find(|path| path.is_file() && std::ffi::CString::new(path.as_os_str().as_encoded_bytes())
|
||||
.map(|p| unsafe { libc::access(p.as_ptr(), libc::X_OK) == 0 }).unwrap_or(false))
|
||||
.and_then(|path| std::fs::canonicalize(path).ok())
|
||||
}).as_deref()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
static COMMAND_STARTS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
|
||||
|
||||
fn bounded_command(path: &Path, args: &[&str], timeout: Duration) -> Option<String> {
|
||||
use std::io::Read;
|
||||
#[cfg(test)]
|
||||
COMMAND_STARTS.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
|
||||
let mut child = Command::new(path).args(args).stdin(Stdio::null()).stdout(Stdio::piped())
|
||||
.stderr(Stdio::null()).spawn().ok()?;
|
||||
let deadline = std::time::Instant::now() + timeout;
|
||||
loop {
|
||||
match child.try_wait() {
|
||||
Ok(Some(status)) => {
|
||||
if !status.success() { return None; }
|
||||
let mut text = String::new();
|
||||
child.stdout.take()?.take(4096).read_to_string(&mut text).ok()?;
|
||||
return Some(text.trim().to_owned());
|
||||
}
|
||||
Ok(None) if std::time::Instant::now() < deadline => std::thread::sleep(Duration::from_millis(10)),
|
||||
_ => { let _ = child.kill(); let _ = child.wait(); return None; }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn loginctl(args: &[&str]) -> Option<String> {
|
||||
let out = Command::new("loginctl").args(args).output().ok()?;
|
||||
if !out.status.success() { return None; }
|
||||
Some(String::from_utf8_lossy(&out.stdout).trim().to_string()).filter(|s| !s.is_empty())
|
||||
bounded_command(loginctl_path()?, args, Duration::from_secs(3)).filter(|s| !s.is_empty())
|
||||
}
|
||||
|
||||
/// The logind session that owns this user's graphical display.
|
||||
@@ -44,7 +82,7 @@ fn display_session() -> Option<String> {
|
||||
pub fn locked_now() -> Option<bool> { display_session().as_deref().and_then(session_locked) }
|
||||
|
||||
fn session_locked(session: &str) -> Option<bool> {
|
||||
loginctl(&["show-session", session, "-p", "LockedHint", "--value"]).map(|v| v == "yes")
|
||||
loginctl(&["show-session", session, "-p", "LockedHint", "--value"]).and_then(|v| match v.as_str() { "yes" => Some(true), "no" => Some(false), _ => None })
|
||||
}
|
||||
|
||||
fn user_name() -> Option<String> {
|
||||
@@ -78,30 +116,28 @@ pub fn supported() -> bool {
|
||||
*SUPPORTED.get_or_init(|| pam_available() && display_session().is_some())
|
||||
}
|
||||
|
||||
/// Current lock state (None = unknown), refreshed every second by one background thread.
|
||||
/// Current lock state (None = unknown), shared by all desktop connections.
|
||||
pub fn watch_locked() -> watch::Receiver<Option<bool>> {
|
||||
static STATE: OnceLock<watch::Sender<Option<bool>>> = OnceLock::new();
|
||||
STATE.get_or_init(|| {
|
||||
let (tx, _) = watch::channel(None);
|
||||
let sender = tx.clone();
|
||||
std::thread::Builder::new().name("uu-lock-state".into()).spawn(move || {
|
||||
let mut session = None;
|
||||
loop {
|
||||
if session.is_none() { session = display_session(); }
|
||||
let locked = session.as_deref().and_then(session_locked);
|
||||
if locked.is_none() { session = None; } // session ended or changed: look it up again
|
||||
sender.send_if_modified(|current| if *current != locked {
|
||||
log::info!("Desktop lock state: {}", match locked { Some(true) => "locked", Some(false) => "unlocked", None => "unknown" });
|
||||
if locked == Some(true) { log::info!("Desktop is locked; capture continues while the compositor supplies frames"); }
|
||||
*current = locked; true
|
||||
} else { false });
|
||||
std::thread::sleep(Duration::from_secs(1));
|
||||
}
|
||||
tokio::runtime::Builder::new_current_thread().enable_all().build()
|
||||
.expect("lock monitor runtime").block_on(logind::monitor(sender));
|
||||
}).expect("spawn lock state thread");
|
||||
tx
|
||||
}).subscribe()
|
||||
}
|
||||
|
||||
fn publish_lock_state(sender: &watch::Sender<Option<bool>>, locked: Option<bool>) {
|
||||
sender.send_if_modified(|current| if *current != locked {
|
||||
log::info!("Desktop lock state: {}", match locked { Some(true) => "locked", Some(false) => "unlocked", None => "unknown" });
|
||||
if locked == Some(true) { log::info!("Desktop is locked; capture continues while the compositor supplies frames"); }
|
||||
*current = locked; true
|
||||
} else { false });
|
||||
}
|
||||
|
||||
/// Verifies the session user's password and unlocks the display session. Blocking (PAM may
|
||||
/// delay a failure by seconds); call from spawn_blocking. Consumes and wipes the password.
|
||||
pub fn unlock(password: String) -> UnlockResult {
|
||||
@@ -117,7 +153,7 @@ fn unlock_with(password: &str) -> UnlockResult {
|
||||
let Some(user) = user_name() else { return UnlockResult::NoLoggedInUser };
|
||||
if password.is_empty() || password.contains('\0') { return UnlockResult::WrongPassword; }
|
||||
match pam_check(&user, password) { 0 => {}, 1 => return UnlockResult::WrongPassword, _ => return UnlockResult::Failed }
|
||||
if Command::new("loginctl").args(["unlock-session", &session]).status().map(|s| !s.success()).unwrap_or(true) {
|
||||
if loginctl_path().and_then(|path| bounded_command(path, &["unlock-session", &session], Duration::from_secs(3))).is_none() {
|
||||
return UnlockResult::NoPermission;
|
||||
}
|
||||
if let Err(error) = crate::capture::keep_display_awake() {
|
||||
@@ -204,6 +240,25 @@ pub fn password_from_args(args: &[u8]) -> Option<String> {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn unknown_state_is_preserved_and_repeated_states_do_not_notify() {
|
||||
let (tx, mut rx) = watch::channel(Some(true));
|
||||
publish_lock_state(&tx, None);
|
||||
assert_eq!(*rx.borrow_and_update(), None);
|
||||
publish_lock_state(&tx, None);
|
||||
assert!(!rx.has_changed().unwrap());
|
||||
publish_lock_state(&tx, Some(false));
|
||||
assert!(rx.has_changed().unwrap());
|
||||
assert_eq!(*rx.borrow_and_update(), Some(false));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hung_fallback_is_killed_and_reaped() {
|
||||
let start = std::time::Instant::now();
|
||||
assert_eq!(bounded_command(Path::new("/bin/sleep"), &["10"], Duration::from_millis(30)), None);
|
||||
assert!(start.elapsed() < Duration::from_secs(2));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn password_comes_from_the_official_key_field() {
|
||||
assert_eq!(password_from_args(br#"{"key":"p@ss word"}"#).as_deref(), Some("p@ss word"));
|
||||
|
||||
@@ -0,0 +1,208 @@
|
||||
//! logind signals replace per-second process spawning; loginctl is a bounded fallback.
|
||||
use super::{publish_lock_state, Duration};
|
||||
use futures_util::StreamExt;
|
||||
use tokio::sync::watch;
|
||||
use zbus::{Connection, MatchRule, MessageStream, Proxy, proxy::CacheProperties};
|
||||
|
||||
const SERVICE: &str = "org.freedesktop.login1";
|
||||
const ROOT: &str = "/org/freedesktop/login1";
|
||||
const CALL_TIMEOUT: Duration = Duration::from_secs(5);
|
||||
const RETRY: Duration = Duration::from_secs(30);
|
||||
|
||||
async fn locked(connection: &Connection) -> zbus::Result<Option<bool>> {
|
||||
let path = format!("{ROOT}/user/_{}", unsafe { libc::getuid() });
|
||||
let user = zbus::proxy::Builder::<Proxy<'_>>::new(connection).destination(SERVICE)?
|
||||
.path(path)?.interface("org.freedesktop.login1.User")?
|
||||
.cache_properties(CacheProperties::No).build().await?;
|
||||
// No cached property reads: signals, including invalidations, trigger a fresh snapshot.
|
||||
let display: (String, zbus::zvariant::OwnedObjectPath) = user.get_property("Display").await?;
|
||||
if display.0.is_empty() { return Ok(None); }
|
||||
let session = zbus::proxy::Builder::<Proxy<'_>>::new(connection).destination(SERVICE)?
|
||||
.path(display.1)?.interface("org.freedesktop.login1.Session")?
|
||||
.cache_properties(CacheProperties::No).build().await?;
|
||||
session.get_property("LockedHint").await.map(Some)
|
||||
}
|
||||
|
||||
async fn snapshot(connection: &Connection) -> zbus::Result<Option<bool>> {
|
||||
tokio::time::timeout(CALL_TIMEOUT, locked(connection)).await
|
||||
.map_err(|_| zbus::Error::Failure("lock query timed out".into()))?
|
||||
}
|
||||
|
||||
async fn monitor_connection(connection: &Connection, sender: &watch::Sender<Option<bool>>) -> zbus::Result<()> {
|
||||
// Subscribe before reading: any change during the first snapshot stays queued.
|
||||
// Watch all logind signals so User.Display, SessionNew/Removed and invalidated
|
||||
// properties also re-resolve the graphical session instead of trusting a stale path.
|
||||
let rule = MatchRule::builder().msg_type(zbus::message::Type::Signal)
|
||||
.sender(SERVICE)?.path_namespace(ROOT)?.build();
|
||||
let mut signals = tokio::time::timeout(CALL_TIMEOUT, MessageStream::for_match_rule(rule, connection, Some(64))).await
|
||||
.map_err(|_| zbus::Error::Failure("lock subscription timed out".into()))??;
|
||||
publish_lock_state(sender, snapshot(connection).await?);
|
||||
let mut reconcile = tokio::time::interval(RETRY);
|
||||
reconcile.tick().await;
|
||||
loop {
|
||||
tokio::select! {
|
||||
event = signals.next() => { event.ok_or_else(|| zbus::Error::Failure("system bus closed".into()))??; },
|
||||
_ = reconcile.tick() => {},
|
||||
}
|
||||
publish_lock_state(sender, snapshot(connection).await?);
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) async fn monitor(sender: watch::Sender<Option<bool>>) {
|
||||
let mut degraded = false;
|
||||
loop {
|
||||
let result = tokio::time::timeout(CALL_TIMEOUT, async { zbus::connection::Builder::system()?.method_timeout(CALL_TIMEOUT).build().await }).await;
|
||||
if let Ok(Ok(connection)) = result {
|
||||
if !degraded { log::debug!("Desktop lock monitor: logind D-Bus"); }
|
||||
// Recovery is announced only after a valid snapshot, via the state channel.
|
||||
let _ = monitor_connection(&connection, &sender).await;
|
||||
}
|
||||
publish_lock_state(&sender, None);
|
||||
if !degraded { log::warn!("Desktop lock monitor unavailable; retrying D-Bus with bounded loginctl fallback every 30s"); }
|
||||
degraded = true;
|
||||
let fallback = tokio::task::spawn_blocking(super::locked_now).await.ok().flatten();
|
||||
publish_lock_state(&sender, fallback);
|
||||
tokio::time::sleep(RETRY).await;
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::sync::{Arc, Mutex, atomic::{AtomicBool, Ordering}};
|
||||
use zbus::zvariant::{OwnedObjectPath, Value};
|
||||
|
||||
struct User(Arc<Mutex<String>>);
|
||||
#[zbus::interface(name = "org.freedesktop.login1.User")]
|
||||
impl User {
|
||||
#[zbus(property)]
|
||||
fn display(&self) -> (String, OwnedObjectPath) {
|
||||
let id = self.0.lock().unwrap().clone();
|
||||
let path = if id.is_empty() { "/".into() } else { format!("{ROOT}/session/{id}") };
|
||||
(id, OwnedObjectPath::try_from(path).unwrap())
|
||||
}
|
||||
}
|
||||
struct Session { locked: Arc<AtomicBool>, valid: Arc<AtomicBool> }
|
||||
#[zbus::interface(name = "org.freedesktop.login1.Session")]
|
||||
impl Session {
|
||||
#[zbus(property)]
|
||||
fn locked_hint(&self) -> zbus::fdo::Result<bool> {
|
||||
if !self.valid.load(Ordering::SeqCst) { return Err(zbus::fdo::Error::Failed("unavailable".into())); }
|
||||
Ok(self.locked.load(Ordering::SeqCst))
|
||||
}
|
||||
}
|
||||
|
||||
async fn expect(rx: &mut watch::Receiver<Option<bool>>, value: Option<bool>) {
|
||||
tokio::time::timeout(Duration::from_secs(3), async {
|
||||
loop {
|
||||
let current = *rx.borrow_and_update();
|
||||
if current == value { return; }
|
||||
rx.changed().await.unwrap();
|
||||
}
|
||||
}).await.expect("lock state update");
|
||||
}
|
||||
|
||||
async fn invalidated(server: &Connection, path: &str, interface: &str, property: &str) {
|
||||
// An invalidation has no replacement value: the client must re-read it.
|
||||
let changed = std::collections::HashMap::<&str, Value<'_>>::new();
|
||||
server.emit_signal(None::<&str>, path, "org.freedesktop.DBus.Properties", "PropertiesChanged",
|
||||
&(interface, changed, vec![property])).await.unwrap();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[ignore = "isolated D-Bus integration; requires dbus-daemon, never changes the real desktop"]
|
||||
async fn private_bus_tracks_initial_state_invalidation_session_change_and_failure() {
|
||||
use tokio::io::{AsyncBufReadExt, BufReader};
|
||||
let mut daemon = tokio::process::Command::new("dbus-daemon")
|
||||
.args(["--session", "--nofork", "--print-address=1"])
|
||||
.stdout(std::process::Stdio::piped()).stderr(std::process::Stdio::null())
|
||||
.kill_on_drop(true).spawn().unwrap();
|
||||
let mut address = String::new();
|
||||
tokio::time::timeout(Duration::from_secs(3), BufReader::new(daemon.stdout.take().unwrap()).read_line(&mut address)).await.unwrap().unwrap();
|
||||
let address = address.trim();
|
||||
let display = Arc::new(Mutex::new(String::new()));
|
||||
let locked = Arc::new(AtomicBool::new(true));
|
||||
let valid = Arc::new(AtomicBool::new(true));
|
||||
let user_path = format!("{ROOT}/user/_{}", unsafe { libc::getuid() });
|
||||
let server = zbus::connection::Builder::address(address).unwrap().name(SERVICE).unwrap()
|
||||
.serve_at(user_path.clone(), User(display.clone())).unwrap()
|
||||
.serve_at(format!("{ROOT}/session/a"), Session { locked: locked.clone(), valid: valid.clone() }).unwrap()
|
||||
.serve_at(format!("{ROOT}/session/b"), Session { locked: Arc::new(AtomicBool::new(true)), valid: valid.clone() }).unwrap()
|
||||
.build().await.unwrap();
|
||||
let client = zbus::connection::Builder::address(address).unwrap().build().await.unwrap();
|
||||
let (tx, mut rx) = watch::channel(Some(false));
|
||||
let monitor = tokio::spawn(async move {
|
||||
let result = monitor_connection(&client, &tx).await;
|
||||
publish_lock_state(&tx, None);
|
||||
result
|
||||
});
|
||||
expect(&mut rx, None).await;
|
||||
assert!(!monitor.is_finished(), "no graphical session must keep the D-Bus subscription alive");
|
||||
*display.lock().unwrap() = "a".into();
|
||||
invalidated(&server, &user_path, "org.freedesktop.login1.User", "Display").await;
|
||||
expect(&mut rx, Some(true)).await; // login is observed without waiting for the retry timer
|
||||
locked.store(false, Ordering::SeqCst);
|
||||
invalidated(&server, &format!("{ROOT}/session/a"), "org.freedesktop.login1.Session", "LockedHint").await;
|
||||
expect(&mut rx, Some(false)).await;
|
||||
*display.lock().unwrap() = "b".into();
|
||||
invalidated(&server, &user_path, "org.freedesktop.login1.User", "Display").await;
|
||||
expect(&mut rx, Some(true)).await;
|
||||
display.lock().unwrap().clear();
|
||||
invalidated(&server, &user_path, "org.freedesktop.login1.User", "Display").await;
|
||||
expect(&mut rx, None).await;
|
||||
assert!(!monitor.is_finished(), "logout must keep the D-Bus subscription alive");
|
||||
*display.lock().unwrap() = "b".into();
|
||||
invalidated(&server, &user_path, "org.freedesktop.login1.User", "Display").await;
|
||||
expect(&mut rx, Some(true)).await;
|
||||
valid.store(false, Ordering::SeqCst);
|
||||
invalidated(&server, &format!("{ROOT}/session/b"), "org.freedesktop.login1.Session", "LockedHint").await;
|
||||
expect(&mut rx, None).await; // failure must not become unlocked
|
||||
assert!(monitor.await.unwrap().is_err());
|
||||
// A fresh connection must recover after a service/property failure.
|
||||
valid.store(true, Ordering::SeqCst);
|
||||
let client = zbus::connection::Builder::address(address).unwrap().build().await.unwrap();
|
||||
let close = client.clone();
|
||||
let (tx, mut rx) = watch::channel(None);
|
||||
let monitor = tokio::spawn(async move {
|
||||
let result = monitor_connection(&client, &tx).await;
|
||||
publish_lock_state(&tx, None);
|
||||
result
|
||||
});
|
||||
expect(&mut rx, Some(true)).await;
|
||||
close.close().await.unwrap();
|
||||
expect(&mut rx, None).await;
|
||||
assert!(monitor.await.unwrap().is_err());
|
||||
daemon.kill().await.unwrap();
|
||||
daemon.wait().await.unwrap();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[ignore = "manual acceptance: observes a real lock/unlock for up to three minutes"]
|
||||
async fn live_lock_unlock_signals() {
|
||||
let before = super::super::COMMAND_STARTS.load(Ordering::SeqCst);
|
||||
let mut rx = super::super::watch_locked();
|
||||
let start = std::time::Instant::now();
|
||||
tokio::time::timeout(Duration::from_secs(180), async {
|
||||
let mut saw_lock = false;
|
||||
loop {
|
||||
let state = *rx.borrow_and_update();
|
||||
println!("live lock state: {state:?}; elapsed_ms={}", start.elapsed().as_millis());
|
||||
if state == Some(true) { saw_lock = true; }
|
||||
if saw_lock && state == Some(false) { break; }
|
||||
rx.changed().await.unwrap();
|
||||
}
|
||||
}).await.expect("please lock and unlock the desktop during this probe");
|
||||
let started = super::super::COMMAND_STARTS.load(Ordering::SeqCst) - before;
|
||||
println!("lock monitor command starts: {started}");
|
||||
assert_eq!(started, 0, "healthy D-Bus monitoring should not spawn loginctl");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[ignore = "read-only live logind probe; requires an active graphical logind session"]
|
||||
async fn live_logind_snapshot_matches_loginctl_without_changing_lock_state() {
|
||||
let connection = Connection::system().await.unwrap();
|
||||
let dbus = snapshot(&connection).await.unwrap();
|
||||
let command = tokio::task::spawn_blocking(super::super::locked_now).await.unwrap();
|
||||
assert_eq!(dbus, command);
|
||||
}
|
||||
}
|
||||
+27
-2
@@ -300,15 +300,26 @@ impl PeerActions {
|
||||
/// 0 is always sent), 21 virtual_audio_driver_policy_req -> 17 (no virtual driver needed: the
|
||||
/// sink monitor is captured directly). Responses carry error_code 0 (default).
|
||||
pub fn session_rpc_response(rpc: &[crate::protocol::WireField]) -> Option<Vec<u8>> {
|
||||
session_rpc_response_with_error(rpc, 0)
|
||||
}
|
||||
pub fn session_rpc_response_with_error(rpc: &[crate::protocol::WireField], error: u8) -> Option<Vec<u8>> {
|
||||
use crate::protocol::{decode_wire, WireValue};
|
||||
let body = |n: u32| rpc.iter().find_map(|f| match (f.number, &f.value) { (x, WireValue::Bytes(b)) if x == n => Some(*b), _ => None });
|
||||
let (request, response_field) = [(15u32, 11u8), (21, 17)].into_iter().find_map(|(req, resp)| body(req).map(|b| (b, resp)))?;
|
||||
let value = decode_wire(request).ok().and_then(|f| f.iter().find_map(|f| match (f.number, &f.value) { (1, WireValue::Varint(v)) => Some(*v), _ => None }));
|
||||
log::info!("Session RPC answered: response_field={} value={:?}", response_field, value);
|
||||
let header = body(1).unwrap_or(&[]);
|
||||
let mut out = vec![10, header.len() as u8];
|
||||
fn varint(mut value: usize, out: &mut Vec<u8>) {
|
||||
while value >= 128 { out.push((value as u8 & 127) | 128); value >>= 7; }
|
||||
out.push(value as u8);
|
||||
}
|
||||
let mut out = vec![10];
|
||||
varint(header.len(), &mut out);
|
||||
out.extend_from_slice(header);
|
||||
out.extend_from_slice(&[response_field << 3 | 2, 0]);
|
||||
// Field 17 has a two-byte tag (0x8a 0x01). A truncated tag prevents the client's
|
||||
// microphone request from completing even though the data channel delivers it.
|
||||
varint(usize::from(response_field) << 3 | 2, &mut out);
|
||||
if error == 0 { out.push(0); } else { out.extend([2, 8, error]); }
|
||||
Some(out)
|
||||
}
|
||||
|
||||
@@ -337,6 +348,20 @@ pub fn plugin_response(rpc: &[crate::protocol::WireField]) -> Option<Vec<u8>> {
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn virtual_audio_policy_reply_completes_field_17_and_preserves_request_id() {
|
||||
use crate::protocol::{decode_wire, WireValue};
|
||||
let request = [10, 2, 8, 9, 170, 1, 2, 8, 1];
|
||||
let rpc = decode_wire(&request).unwrap();
|
||||
let response = session_rpc_response(&rpc).unwrap();
|
||||
let fields = decode_wire(&response).expect("valid protobuf reply, including the field 17 tag");
|
||||
assert_eq!(fields[0].value, WireValue::Bytes(&[8, 9]));
|
||||
assert_eq!(fields[1].number, 17);
|
||||
assert_eq!(fields[1].value, WireValue::Bytes(&[]));
|
||||
let denied = session_rpc_response_with_error(&rpc, 1).unwrap();
|
||||
let fields = decode_wire(&denied).unwrap();
|
||||
assert_eq!(fields[1].value, WireValue::Bytes(&[8, 1]));
|
||||
}
|
||||
#[test]
|
||||
fn toggle_values_from_value_field_json_and_text() {
|
||||
assert!(!toggle_value(Some(0), b"1"));
|
||||
assert!(toggle_value(Some(1), b""));
|
||||
|
||||
+17
-11
@@ -795,11 +795,11 @@ async fn read_inprocess(
|
||||
job.await.map_err(|e| format!("Encoder task: {e}"))?
|
||||
}
|
||||
|
||||
/// Rate-control arguments: constant quality capped at 30M (自动), or capped at the viewer's
|
||||
/// chosen bitrate. The VBV buffer stays at most 500k so a cap never adds queueing latency.
|
||||
/// VBV buffer in kbit. NVENC ull and VAAPI keep the small low-latency buffer; libx264 needs room for a
|
||||
/// whole IDR frame, otherwise large desktops get near-grey keyframes that sharpen over the GOP (#8).
|
||||
/// Half a second of bitrate still starved repeated 0.5 s-GOP keyframes at 3296x2036/2M; one second did not.
|
||||
/// VBV buffer in kbit. libx264 and NVENC need room for a whole IDR frame, otherwise large desktops get
|
||||
/// keyframes quantized into a blur that sharpens over the GOP (#8 libx264, #103 NVENC). Half a second of
|
||||
/// bitrate still starved repeated 0.5 s-GOP keyframes at 3296x2036/2M; one second did not. The 8000 kbit
|
||||
/// cap bounds the keyframe burst: 4K hevc_nvenc CQ18 IDRs measured 0.45 MB (desktop) to 0.76 MB (photo).
|
||||
/// VAAPI keeps the small low-latency buffer unless UU_VAAPI_BUFFER_MS asks for more.
|
||||
fn buffer_kbits(max_kbps: u32, encoder: Encoder) -> u32 {
|
||||
let env = match encoder {
|
||||
Encoder::Cpu => return max_kbps.clamp(500, 8000),
|
||||
@@ -807,13 +807,14 @@ fn buffer_kbits(max_kbps: u32, encoder: Encoder) -> u32 {
|
||||
Encoder::Nvenc => "UU_NVENC_BUFFER_MS",
|
||||
};
|
||||
let requested = std::env::var(env).ok();
|
||||
buffer_ms_kbits(max_kbps, requested.as_deref()).unwrap_or((max_kbps / 8).clamp(100, 500))
|
||||
let default = if encoder == Encoder::Nvenc { max_kbps.clamp(500, 8000) } else { (max_kbps / 8).clamp(100, 500) };
|
||||
buffer_ms_kbits(max_kbps, requested.as_deref()).unwrap_or(default)
|
||||
}
|
||||
|
||||
/// Opt-in hardware VBV buffer: `码率上限 × 毫秒 / 1000` for `UU_VAAPI_BUFFER_MS` /
|
||||
/// `UU_NVENC_BUFFER_MS` in 10-1000 ms. With the 100-500 kbit default the encoder quantizes a
|
||||
/// whole desktop keyframe, which reads as a blur that sharpens over each GOP (#42 VAAPI, #103 NVENC).
|
||||
/// Unset, out of range or unparsable values keep the default buffer.
|
||||
/// Hardware VBV buffer override: `码率上限 × 毫秒 / 1000` for `UU_VAAPI_BUFFER_MS` /
|
||||
/// `UU_NVENC_BUFFER_MS` in 10-1000 ms. With VAAPI's 100-500 kbit default the encoder quantizes a
|
||||
/// whole desktop keyframe, which reads as a blur that sharpens over each GOP (#42); a small NVENC value
|
||||
/// brings back the old low-latency buffer. Unset, out of range or unparsable values keep the default buffer.
|
||||
fn buffer_ms_kbits(max_kbps: u32, value: Option<&str>) -> Option<u32> {
|
||||
let ms = value?.trim().parse::<u32>().ok().filter(|ms| (10..=1000).contains(ms))?;
|
||||
Some((max_kbps.saturating_mul(ms) / 1000).max(1))
|
||||
@@ -825,6 +826,8 @@ fn buffer_for(settings: &VideoSettings, encoder: Encoder) -> u32 {
|
||||
} else { buffer_kbits(settings.max_kbps().unwrap_or(30_000), encoder) }
|
||||
}
|
||||
|
||||
/// Rate-control arguments: constant quality capped at 30M (自动), or capped at the viewer's
|
||||
/// chosen bitrate.
|
||||
fn rate_args(settings: &VideoSettings, encoder: Encoder) -> (String, String) {
|
||||
let max_kbps = settings.max_kbps().unwrap_or(30_000);
|
||||
(format!("{max_kbps}k"), format!("{}k", buffer_for(settings, encoder)))
|
||||
@@ -1613,7 +1616,10 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn x264_buffer_fits_keyframes() {
|
||||
assert_eq!(buffer_kbits(2000, Encoder::Nvenc), 250);
|
||||
// NVENC follows libx264 (#103): one second of the cap within 500-8000 kbit.
|
||||
assert_eq!(buffer_kbits(2000, Encoder::Nvenc), 2000);
|
||||
assert_eq!(buffer_kbits(300, Encoder::Nvenc), 500);
|
||||
assert_eq!(buffer_kbits(30_000, Encoder::Nvenc), 8000);
|
||||
assert_eq!(buffer_kbits(2000, Encoder::Vaapi), 250);
|
||||
assert_eq!(buffer_kbits(2000, Encoder::Cpu), 2000);
|
||||
assert_eq!(buffer_kbits(300, Encoder::Cpu), 500);
|
||||
|
||||
+3
-1
@@ -67,7 +67,9 @@ pub fn load_font() -> Option<FontVec> {
|
||||
let (path, index) = match std::env::var("UU_VIEWER_FONT") {
|
||||
Ok(p) if !p.is_empty() => (p, 0),
|
||||
_ => {
|
||||
let out = std::process::Command::new("fc-match").args(["-f", "%{file}\t%{index}", "sans-serif:lang=zh-cn"]).output().ok()?;
|
||||
// Request U+63A7 (控, from 控制中心) to prefer a CJK-capable font;
|
||||
// the HUD uses a single font without per-glyph fallback.
|
||||
let out = std::process::Command::new("fc-match").args(["-f", "%{file}\t%{index}", "sans-serif:lang=zh-cn:charset=63a7"]).output().ok()?;
|
||||
let line = String::from_utf8(out.stdout).ok()?;
|
||||
let (file, index) = line.split_once('\t').unwrap_or((line.as_str(), "0"));
|
||||
// fontconfig puts the variable-font named instance in the upper 16 bits; the face is below.
|
||||
|
||||
+32
-1
@@ -274,6 +274,8 @@ impl WebRtcSession {
|
||||
|
||||
let role = Arc::new(DesktopRole::new(desktop));
|
||||
if desktop { *role.input.lock().unwrap() = Some(input.desktop_session()); }
|
||||
let microphone = crate::microphone::Session::new();
|
||||
if crate::microphone::available() { microphone.attach(&pc, role.active.subscribe()); }
|
||||
let context = Arc::new(Mutex::new(SessionContext::default()));
|
||||
crate::network_diagnostics::start(Arc::downgrade(&pc));
|
||||
|
||||
@@ -530,6 +532,7 @@ impl WebRtcSession {
|
||||
// Settings arrive on CONTROL or TEXT; serialize both queues for this peer.
|
||||
let settings_serial=Arc::new(Mutex::new(()));
|
||||
let data_role = role.clone();
|
||||
let data_microphone = microphone.clone();
|
||||
// 监听 DataChannel
|
||||
pc.on_data_channel(Box::new(move |d: Arc<RTCDataChannel>| {
|
||||
let label = d.label().to_string();
|
||||
@@ -538,6 +541,7 @@ impl WebRtcSession {
|
||||
let peer_settings_serial=settings_serial.clone();
|
||||
let input_inst = input_clone.clone();
|
||||
let channel_role=data_role.clone();
|
||||
let channel_microphone = data_microphone.clone();
|
||||
let screen = control_capture.clone();
|
||||
let portal_desktop = portal_desktop.clone();
|
||||
let desktop_pc = desktop_pc.clone();
|
||||
@@ -708,7 +712,7 @@ impl WebRtcSession {
|
||||
}
|
||||
let live = state.screen.init_error.is_none()
|
||||
&& (cfg!(test) || state.screen.portal.as_ref().is_some_and(|portal| portal.is_alive()))
|
||||
&& *manager.lock_state().borrow() == Some(false);
|
||||
&& manager.capture_allowed(*manager.lock_state().borrow());
|
||||
if live { break Some(state.screen); }
|
||||
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
|
||||
if channel.upgrade().is_none_or(|channel| channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open) { return; }
|
||||
@@ -1169,6 +1173,7 @@ impl WebRtcSession {
|
||||
let input_worker = inp.clone();
|
||||
let message_input_session=channel_role.input();
|
||||
let message_role=channel_role.clone();
|
||||
let message_microphone = channel_microphone.clone();
|
||||
let terminal_worker = terminal_conn.clone();
|
||||
let rpc_out = outbound.clone();
|
||||
let text_out = text_out.clone();
|
||||
@@ -1244,6 +1249,30 @@ impl WebRtcSession {
|
||||
let _ = text_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
|
||||
return;
|
||||
}
|
||||
if let Some(policy) = rpc_fields.as_deref().and_then(crate::microphone::policy_request) {
|
||||
let supported = policy <= 1 && crate::microphone::available() && message_role.is_desktop();
|
||||
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
|
||||
let next = || out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
|
||||
let response = crate::system_actions::session_rpc_response_with_error(rpc_fields.as_deref().unwrap(), u8::from(!supported)).unwrap();
|
||||
let response = crate::initialization::envelope(next(), ts, 22, &response);
|
||||
// Windows NevaudioHelper completes the request on TEXT; mirror CONTROL
|
||||
// for viewers that dispatch responses there, as for privacy RPCs.
|
||||
let enqueue = |message: Vec<u8>| {
|
||||
let _ = text_out.send(message.clone());
|
||||
if channel_name != "TEXT_DATA_CHANNEL" { let _ = rpc_out.send(message); }
|
||||
};
|
||||
if supported {
|
||||
let action = if policy == 1 { 23 } else { 24 };
|
||||
// Use the channel's ordered outbox: a stalled SCTP send must
|
||||
// never delay this state transition past a later close on TEXT.
|
||||
message_microphone.action_with(action, || {
|
||||
enqueue(response);
|
||||
enqueue(crate::initialization::envelope(next(), ts, 3, &[8, action as u8]));
|
||||
});
|
||||
} else { enqueue(response); }
|
||||
log::info!("Remote microphone policy: value={policy} supported={supported}");
|
||||
return;
|
||||
}
|
||||
if let Some(response) = rpc_fields.as_deref().and_then(|r| crate::system_actions::plugin_response(r).or_else(|| crate::system_actions::session_rpc_response(r))) {
|
||||
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
|
||||
let _ = rpc_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
|
||||
@@ -1452,6 +1481,8 @@ impl WebRtcSession {
|
||||
} else {
|
||||
log::info!("SimpleAction 4 (capture_desktop) not handled: tool connection without a desktop route");
|
||||
}
|
||||
} else if matches!(action, 23 | 24) && crate::microphone::available() && message_role.is_desktop() {
|
||||
message_microphone.action(action);
|
||||
} else if action > 1 && action != 15 {
|
||||
let args = action_fields.iter().find_map(|f| match (&f.value, f.number) { (WireValue::Bytes(v), 2) => Some(*v), _ => None }).unwrap_or(&[]);
|
||||
log::info!("SimpleAction {} ({}) not handled: args={}", action, crate::control_protocol::simple_action_name(action).unwrap_or("?"), sa::args_shape(args));
|
||||
|
||||
+18
-1
@@ -83,10 +83,18 @@ pub fn lan_info() -> Option<(String, String, String)> {
|
||||
#[cfg(not(target_os = "linux"))]
|
||||
pub fn lan_info() -> Option<(String, String, String)> { None }
|
||||
|
||||
/// Body of the helper registration request (same address as `inner_ip` and `ip`: this host has one LAN address).
|
||||
fn report_body(mac: &str, ip: &str, subnet_mask: &str) -> serde_json::Value {
|
||||
serde_json::json!({ "mac": mac, "inner_ip": ip, "ip": ip, "subnet_mask": subnet_mask })
|
||||
}
|
||||
|
||||
/// Report this host's LAN identity like the official host after sign-in.
|
||||
/// The server rejects the report (HTTP 422, code 1001) unless `inner_ip` is present; the official macOS
|
||||
/// client sends `inner_ip`, `ip`, `mac` and `subnet_mask`. Verified live: with `inner_ip` the helper is
|
||||
/// accepted (HTTP 200) and the cloud forwards `wake_on_lan` pushes to this host.
|
||||
pub async fn report(auth: &crate::auth::UUAuthClient) {
|
||||
let Some((mac, ip, subnet_mask)) = lan_info() else { log::warn!("WOL helper: no IPv4 default-route interface"); return; };
|
||||
let body = serde_json::json!({ "mac": mac, "ip": ip, "subnet_mask": subnet_mask });
|
||||
let body = report_body(&mac, &ip, &subnet_mask);
|
||||
match auth.post_json_url("https://api-ipv4.nrd.nie.163.com", "/api/v1/device/wake_on_lan/info", &body).await {
|
||||
Ok((status, value)) => log::info!("WOL helper: LAN info reported: status={status} code={:?} turn_on_wol={:?}",
|
||||
value.get("code").and_then(serde_json::Value::as_i64),
|
||||
@@ -108,6 +116,15 @@ mod tests {
|
||||
assert_eq!(&packet[..6], &[0xff; 6]);
|
||||
assert_eq!(&packet[96..], &[1, 2, 3, 4, 5, 6]);
|
||||
}
|
||||
#[test]
|
||||
fn report_body_has_inner_ip() {
|
||||
let body = report_body("aa:bb:cc:dd:ee:01", "192.168.2.29", "255.255.255.0");
|
||||
assert_eq!(body["inner_ip"], "192.168.2.29");
|
||||
assert_eq!(body["ip"], "192.168.2.29");
|
||||
assert_eq!(body["mac"], "aa:bb:cc:dd:ee:01");
|
||||
assert_eq!(body["subnet_mask"], "255.255.255.0");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn directed_broadcast() {
|
||||
assert_eq!(subnet_broadcast("192.168.2.29", "255.255.255.0"), Some(Ipv4Addr::new(192, 168, 2, 255)));
|
||||
|
||||
Reference in new issue
Block a user