Compare commits

..
Author SHA1 Message Date
VallierDevandClaude Opus 5.5 af74af0f83 release: v0.2.53
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-06 11:42:15 +08:00
Jeff Zhang 2dd3280b7e perf(inproc): replace portal pseudo-polling with event-driven frame wait (#193)
* perf(portal): wait for frames without polling

* fix(portal): use monotonic clock for condition variable wait deadline

* fix(portal): compute wait_for_first_frame deadline with monotonic clock
2026-11-06 10:41:21 +08:00
VallierDevandClaude Opus 5.5 13c92d8f68 release: v0.2.52
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-06 07:39:51 +08:00
Jeff Zhang b0015a6c48 perf(input): offload text_input to spawn_blocking preserving order and rebase on main (#189) 2026-11-06 05:39:20 +08:00
Jeff Zhang c60d9f1bfa perf: HEVC RTP 分包零拷贝子切片与 X11 终端检测 100ms 缓存 (#182)
* perf: HEVC RTP 分包零拷贝子切片与 X11 终端检测 100ms 缓存

* fix(x11): 绑定焦点窗口缓存并支持焦点切换即时失效
2026-11-06 04:38:00 +08:00
Jeff Zhang 6032129228 perf: 优化 H.265 IRAP 单趟流式扫描与 CONTROL 通道 JSON 单次解析 (#180) 2026-11-06 03:38:47 +08:00
Jeff Zhang 7ba71a5540 webrtc: single-pass decode_wire for data channel packets and merge loop passes (#191) 2026-11-06 03:38:37 +08:00
Jeff Zhang b774bf6b16 perf: CompleteFrame 使用 bytes::Bytes 消除每帧码流克隆深拷贝 (#184) 2026-11-06 03:38:26 +08:00
VallierDevandClaude Opus 5.5 a22f576005 release: v0.2.51
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-05 20:32:15 +08:00
Onekki 212e4943f9 Hyprland 手机输入法文字:统一走独立文字键盘并每批重新 attach (#176)
所有 wlroots 合成器使用独立文字键盘、每批重新 attach 下发 keymap;ASCII 也以 Unicode keysym 发送,Wayland 下 text_input 先走 keysym;切换前同步原设备修饰键。
2026-11-05 19:30:25 +08:00
VallierDevandClaude Opus 5.5 0b3ac4c78e release: v0.2.50
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-05 06:24:03 +08:00
jinpeng2700-techandjinpeng2700-tech 8b6de40605 portal: persist rotated consent before video starts (#175)
Co-authored-by: jinpeng2700-tech <[email protected]>
2026-11-05 05:22:22 +08:00
CrandClaude Opus 5.5 7a0c40af73 annotation: answer viewer draw RPCs and draw strokes on an X11 overlay (#174)
* annotation: answer viewer draw RPCs and draw strokes on an X11 overlay

The official viewer's watch-mode annotation (批注) sends RpcRequest 27
draw_req, which this host never answered, so the viewer reported
批注开启失败 (9998). The schema is taken from the Mac 4.42.0
UURemoteService SwiftProtobuf metadata. Replies go on TEXT because a
reply on CONTROL times out.

Strokes are drawn on a click-through override-redirect ARGB window,
which needs a compositing manager. The window exists only while
annotation is on and is removed when the desktop session ends.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

* annotation: follow root resizes and scope resets to the owning peer

Addresses the Codex review on #174.

- A RandR resize (on X11 the viewer's resolution choice does this) left
  the overlay at its old size. The overlay now watches root
  ConfigureNotify and is rebuilt at the new geometry. Strokes keep the
  viewer's points and are laid out again.
- A delayed reset from a replaced desktop peer could remove the
  annotation of the viewer that took over. Requests and resets now carry
  the peer (its PeerActions address), and only the owner's reset,
  toggle-off or clear applies.

The ignored overlay smoke test covers both cases. It always checks the
owner takeover, and checks the resize when UU_ANNOTATION_SMOKE_RESIZE is
set on a disposable display.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

---------

Co-authored-by: Claude Opus 5.5 <[email protected]>
2026-11-05 05:22:14 +08:00
Mr. Error f67de7cc7d Privacy: recover the input devices after a reboot renumbers them (#173)
* fix(privacy): match recorded input devices after a reboot

The recovery record stores KWin's `eventN` sysNames, but udev renumbers
them between boots. A record replayed after a reboot (privacy was on at
shutdown) then set `enabled` on a device path that no longer exists; the
restore failed, kept the record, and every later switch failed at the
same step. The device that had been blocked could also stay disabled.

Records now keep name/product/vendor next to the sysName, and a restore
matches the current device by that identity, falling back to the exact
sysName for older string-only records. A device that no longer exists is
skipped with a log line instead of failing the restore, so the record,
the guard and the outputs are cleaned up; a device that exists but cannot
be enabled still fails and keeps the record for the next attempt.

Verified by replaying records with the release build on KDE Plasma 6.8: a
stale `event14` for a mouse now on `event12` is re-enabled and the record
removed; a record for a missing device logs the skip and restores
normally. `cargo test --features wayland,portal`: 330 passed, 10 ignored.

* fix(privacy): restore every device sharing an identity

- enable every current device whose identity matches a record entry,
  deduplicated by sysName: two record entries can describe one device, and
  one identity can cover several (identical keyboards, or a receiver
  exposing several event nodes under the same name)
- a failed property read during restore is an error instead of a missing
  device, so the record and the guard stay for the next attempt; blocking
  keeps the lenient read
- the gone-device warning logs a count only, matching the log-privacy rule

* fix(privacy): re-enable readable devices before reporting incomplete enumeration

A failed property read during restore no longer aborts enumeration before
set_sys runs: the readable matching devices are re-enabled first, then the
incomplete read is returned as an error so the record and the guard stay
for another attempt. Blocking still skips unreadable devices.
2026-11-05 03:22:02 +08:00
Jeff Zhangandferstar b9586f226d input: park the pointer worker until pointer or gesture work exists (#172)
* input: park the pointer worker until pointer or gesture work exists

A fixed 4 ms tick kept ~250 wakeups/s (clock_gettime storms, worker
steal spins, pow-heavy flush math) burning ~3% CPU on an idle host with
no viewer connected. The worker now parks on a Notify permit until a
pointer/scroll/button event or a live touch gesture needs the 4 ms
cadence; notify_one permit semantics make the park check race-free.
Sub-notch scroll residue cannot inject alone, so it parks too.

* fix(input): preserve pointer wake ordering and motion cadence

Hold the serial lock before notifying button transitions so a parked worker cannot miss a newly pending gesture. Keep the 4 ms coalescing cadence until an empty tick and reset the interval after each parked phase.

Add regression coverage for button wake ordering, 1 ms motion streams, and idle cadence reset using Tokio test-only clock control.

---------

Co-authored-by: ferstar <[email protected]>
2026-11-04 23:18:19 +08:00
VallierDevandClaude Opus 5.5 7b8980771d release: v0.2.49
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-03 23:40:44 +08:00
Mr. Error 50ff42e8d7 Privacy: keep the cover window out of the task manager (#169)
* fix(privacy): keep the cover window out of the task manager

The cover is a plain Wayland toplevel and GTK's skip-taskbar hint is X11
only, so KWin listed it: the task manager showed an unidentified window
(class uuremote-server, caption "uu-remote-linux privacy") with the icon
theme's generic "wayland" icon, a yellow W in Papirus.

Mark the window through KWin scripting after the cover reports ready. The
same one-shot script mechanism already moves windows to the virtual output.
Failure only logs; the cover itself is unaffected.

Verified on KDE Plasma 6.8 Wayland: setting skipTaskbar on the running
cover removes the task manager entry immediately, and the entry returns
when a new cover window is created without the fix. `cargo test --features
wayland,portal`: 320 passed, 10 ignored.

* fix(privacy): match every cover window, not just the first caption

Picture mode creates one cover per physical monitor with the same title,
and KWin appends " <2>" and similar suffixes to duplicate captions, so the
exact match skipped every cover after the first on a multi-monitor host.
Match the title as a prefix instead.

* fix(privacy): report the cover ready only after its windows are mapped

The child wrote "ready" before gtk_main(), so the host marked skip-taskbar
while KWin may not have listed the cover yet; a cover that mapped later
kept the task manager entry. Pump the pending GTK events to map the windows
before the handshake, and run the mark script a second time to catch a
compositor-side delay.
2026-11-03 22:39:08 +08:00
Zhenqiang Weng ba8f8ada20 viewer: mirror remote cursor shapes and hotspots in SDL (#168) 2026-11-03 19:35:53 +08:00
VallierDevandClaude Opus 5.5 c461db10a4 release: v0.2.48
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-03 16:34:29 +08:00
Mr. Error 4c86c7f782 Privacy: auto-enable on desktop connect (UU_PRIVACY_AUTO) (#161)
* feat(privacy): auto-enable the privacy screen on desktop connect

`UU_PRIVACY_AUTO=picture` / `screen-off` (or 2 / 3) enables the privacy
screen when the first desktop controller connects. Off by default. The
switch waits for the portal capture session and retries while it is
missing; the viewer's own RPC 7 cancels a pending auto-enable for that
session.

The privacy state poller that pushes SystemMetrics and SystemStateChange
now starts for desktop peers too (it only ran for a tool peer promoted to
desktop), and it pushes once on its first tick. A mode the viewer did not
request, such as an auto-enable, therefore reaches its menu, and the
state message also goes to TEXT, which viewers read for privacy replies.

Verified on KDE Plasma Wayland with an iOS viewer: auto picture and auto
screen-off both engage, the menu reflects the mode after the push, and a
disconnect restores the physical outputs. `cargo test --features
wayland,portal`: 320 passed, 10 ignored.

* fix(privacy): let a viewer request win against auto-enable races

Two paths could still override an explicit choice:

- the override was checked before acquiring STATE, so an RPC 7 applied in
  that window could disable privacy and the auto thread could turn it back
  on; the check now happens inside the same lock that enters the mode
- `session_started` captured the override counter as its baseline, so a
  request that arrived after CONTROL opened but before the session counter
  started was treated as unrelated and auto-enable ran anyway; the counter
  is now a flag set by any RPC 7 and cleared only when the last desktop
  session ends

docs/privacy-screen.md now says remote-assistance (guest) sessions are
covered too, and that supported hosts push the current privacy state once
on every desktop connect.
2026-11-03 16:33:41 +08:00
VallierDevandClaude Opus 5.5 81e9ccfa05 fix(signaling): log the sanitized reason when signaling fails to connect
The WebSocket transport already reduces errors to a category or HTTP status
without the token or endpoint, so log it instead of 'details omitted' to tell
a refused upgrade from a network failure (#166).

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-03 15:34:34 +08:00
Zhenqiang Weng c0abdeae72 fix(viewer): restore held modifier combinations after focus changes (#165) 2026-11-03 15:33:13 +08:00
Zhenqiang Weng 1dad755823 fix(viewer): use theme icons in the launcher (#158) 2026-11-03 14:01:02 +08:00
Jeff Zhang fcfd2b6717 feat(wallpaper): discover Omarchy backgrounds automatically (#157)
Read Omarchy's current/background link (XDG_STATE_HOME, falling back to XDG_CONFIG_HOME) on Hyprland; explicit UU_WALLPAPER keeps precedence.
2026-11-03 12:31:33 +08:00
VallierDevandClaude Opus 5.5 73c503a244 release: v0.2.47
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-03 01:26:54 +08:00
Jeff ZhangandJeff Zhang 3bce605eaa feat(host): 上报系统壁纸,补齐设备卡片缩略图 (#153)
* feat(host): report system wallpaper for device cards

* fix(host): handle quoted wallpaper paths and KDE defaults

* docs: align wallpaper guidance and disclose default uploads

* fix(host): validate active KDE plugin for stored wallpapers

* fix(host): support Plasma 5 wallpaper config queries

* fix(host): exclude Plasma panels from wallpaper reporting

* fix(host): follow image symlinks in KDE wallpaper packages

---------

Co-authored-by: Jeff Zhang <[email protected]>
2026-11-03 01:25:57 +08:00
VallierDevandClaude Opus 5.5 ebdd362452 release: v0.2.46
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-02 18:23:23 +08:00
VallierDevandClaude Opus 5.5 26811018e0 fix(clipboard): name the Unicode text offer predefined_13 for Windows viewers
A CF_UNICODETEXT name made the Windows viewer register a custom
clipboard format instead of using id 13, so Linux text never reached
the standard Unicode format. Fixes #151.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-02 18:23:23 +08:00
VallierDevandClaude Opus 5.5 c3959c01e9 release: v0.2.45
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-02 13:20:08 +08:00
m ef14f76422 fix(viewer): disable local IME text input in remote desktop window (#150) 2026-11-02 13:18:55 +08:00
VallierDevandClaude Opus 5.5 480819e369 release: v0.2.44
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-02 11:18:42 +08:00
Jeff Zhang f4f16aafe4 fix(privacy): synchronize Mac viewer privacy status over TEXT (#148)
* fix(privacy): synchronize Mac viewer privacy status over TEXT

* fix(webrtc): bound pending TEXT replies and coalesce metrics
2026-11-02 11:17:55 +08:00
VallierDevandClaude Opus 5.5 cb6f5b6617 release: v0.2.43
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-02 02:14:37 +08:00
Jeff Zhang 8e30371317 feat(host): KDE Wayland privacy screen (RPC 7) (#146)
* feat(host): KDE Wayland 被控端防窥模式(隐私 / 关屏)

viewer RPC 7 打开防窥时,采集和输入切到 KWin 虚拟输出(portal ScreenCast VIRTUAL),
再用 kscreen-doctor 禁用物理屏;隐私模式随后重新启用物理屏并全屏覆盖桌面壁纸。
防窥期间通过 KWin InputDevice 禁用本地键鼠,指针/按键/文字改走 uinput
(KDE 不处理虚拟输出共享上的 portal 输入)。

- privacy_type 实测:1 关闭、2 隐私(壁纸)、3 关屏;SettingMetric 4/7 上报真实状态
- 恢复记录 + privacy-guard 子进程:主机以任何方式结束(含 SIGKILL)都恢复屏幕和输入
- src/privacy_screen/ 分层:控制器/协议/记录/守护/遮挡窗口共享,桌面实现走 Backend trait(kde/)
- portal:Session::set_virtual,闭包恢复按当前源重开;编码器随 portal 尺寸变化重建

Refs #140

* fix(privacy): 按 Mac 客户端协议应答防窥请求,修复授权竞态

- FeatureFlag ff_private_screen=2(ENHANCED_PRIVACY),声明支持关屏
- 先回 RPC 7 应答再切换,避免客户端超时报 9998;切换失败发 ReportError -7
- 应答 RPC 25 update_screen_saver_req(RpcResponse 21),隐私模式不再被中止
- SettingMetric 4/7 上报开关与最近一次模式(host_settings.json privacy_type),状态变化推送 SystemStateChange 5
- portal 会话串行打开,打开失败回填一次性授权:快速重连时防窥切换与闭包恢复并发曾清空保存的授权

字段号与枚举取自官方 Mac 客户端的 SwiftProtobuf name map。
已知限制:Mac 客户端防窥菜单切换后仍显示"不启用",实际模式正确。

Refs #140

* fix(privacy): 处理 #146 评审意见

- 预检 uinput:injector 未打开 uinput(/dev/uinput 不可用或 UU_INPUT_BACKEND=native)时,
  在改动输出和设备之前拒绝防窥(虚拟输出共享上 KDE 忽略 portal 输入)
- leave() 中输入设备恢复失败在恢复输出后向上返回,保留 privacy-power.json 与 guard
- record::ownership() 只缓存成功持锁,guard 轮询和 recover() 可重试
- 遮挡窗口就绪握手:privacy-wallpaper 建好窗口后输出 ready,5 秒内未就绪则报错并回滚
- rebase 到 main(#145):DMA-BUF 打开路径跳过虚拟输出、失败同样回填授权;
  #145 的 uinput 指针路径也按隐私模式的虚拟输出区域换算坐标
- README 表格压缩为一句,细节在 docs/privacy-screen.md

Refs #140

* docs(privacy): 注明 ff_system_metrics=3 对应的枚举

Refs #140

* fix(privacy): resolve lifecycle and restoration review findings
2026-11-02 01:14:10 +08:00
VallierDevandClaude Opus 5.5 0ea37758fb release: v0.2.42
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-01 23:13:50 +08:00
Jeff Zhang 73293318b4 feat(portal): VAAPI DMA-BUF zero-copy, in-process Opus audio and lock-screen uinput control (#145)
* feat(audio): capture and encode Opus in process

* feat(portal): encode VAAPI from leased DMA-BUF frames

* fix(input): route Portal controls and committed ASCII through uinput

* docs(portal): shorten setup notes and colocate hardware acceptance guidance

* fix(input): preserve GNOME IME guard for committed uinput text

* build: link pulse/opus after the static C archive (--as-needed)
2026-11-01 22:12:04 +08:00
AZsaber 1bdc0eb910 fix(viewer): prevent compressed-frame queue overflow at high input rates (#143) 2026-11-01 21:11:07 +08:00
Jeff Zhangandferstar 33861082dc build: link inproc-av dependencies after the static engine archive (#105)
GNU ld with --as-needed (Ubuntu default) drops shared libraries listed before
libx11_engine.a, so --features inproc-av failed to link with undefined gbm_*,
xcb_dri3_* and xcb_damage_* on Ubuntu (found on aarch64; Arch is unaffected).

Co-authored-by: ferstar <[email protected]>
2026-11-01 20:11:39 +08:00
m 2422fce673 feat(ui): modernize GTK styling and add appearance settings (#144)
* feat(ui): modernize GTK styling and add appearance settings

* fix(ui): address review and avoid cached Cairo surface in smoke tests
2026-11-01 19:09:39 +08:00
AZsaber 1ff3383de7 feat(viewer): opt-in native gamepad and rumble for Windows hosts (#142)
SDL viewer forwards one mapped controller (gpd_connect/gpd_update/gpd_disconnect) and receives two-motor gpd_vibration over the existing CONTROL channel. Default off (UU_VIEWER_NATIVE_GAMEPAD=1).
2026-11-01 01:04:21 +08:00
97 changed files with 6987 additions and 719 deletions

No files matched your search

+21 -3
View File
@@ -25,10 +25,19 @@ jobs:
sudo apt-get update
sudo apt-get install -y build-essential pkg-config \
libx11-dev libxext-dev libxtst-dev libxfixes-dev libgtk-3-dev \
libwayland-dev libwayland-bin libxkbcommon-dev
libwayland-dev libwayland-bin libxkbcommon-dev xvfb xauth fonts-noto-cjk
- uses: dtolnay/rust-toolchain@stable
- uses: Swatinem/rust-cache@v2
- run: cargo test --locked
- name: GTK appearance and settings smoke tests
run: xvfb-run -a -s '-screen 0 1600x1200x24' sh tests/gtk-ui-smoke.sh "$RUNNER_TEMP/gtk-ui-previews"
- name: Synthetic GTK previews
if: always()
uses: actions/upload-artifact@v4
with:
name: gtk-ui-previews
path: ${{ runner.temp }}/gtk-ui-previews
if-no-files-found: ignore
# Same as the release job: the wayland plugin is built on 22.04; libei is unavailable here, so
# the portal plugin is skipped with a warning (release builds it on 24.04).
- name: Release feature set
@@ -97,7 +106,7 @@ jobs:
ASAN_OPTIONS: detect_leaks=1
UBSAN_OPTIONS: halt_on_error=1
run: |
for source in tests/portal_engine.c tests/portal_input.c tests/portal_eis.c tests/desktop_power.c tests/wayland_transform.c; do
for source in tests/portal_engine.c tests/portal_dmabuf.c tests/portal_input.c tests/portal_eis.c tests/desktop_power.c tests/wayland_transform.c; do
target="/tmp/$(basename "$source" .c)"
cc -O1 -g -fsanitize=address,undefined -fno-omit-frame-pointer \
-Wall -Wextra -Wno-unused-parameter "$source" -o "$target" \
@@ -114,10 +123,19 @@ jobs:
sudo apt-get update
sudo apt-get install -y build-essential pkg-config \
libx11-dev libxext-dev libxtst-dev libxfixes-dev libgtk-3-dev \
libva-dev libgbm-dev libx11-xcb-dev libxcb-dri3-dev libxcb-damage0-dev
libva-dev libgbm-dev libx11-xcb-dev libxcb-dri3-dev libxcb-damage0-dev \
libpulse-dev libopus-dev xvfb xauth \
libwayland-dev libxkbcommon-dev libglib2.0-dev libpipewire-0.3-dev libei-dev
- uses: dtolnay/rust-toolchain@stable
- uses: Swatinem/rust-cache@v2
- name: Read-only uinput text keymap regression
run: |
cc -O1 -g -fsanitize=address,undefined -fno-omit-frame-pointer \
-Wall -Wextra tests/uinput_keymap.c -o /tmp/uu-uinput-keymap-test -lX11
ASAN_OPTIONS=detect_leaks=1 UBSAN_OPTIONS=halt_on_error=1 \
xvfb-run -a /tmp/uu-uinput-keymap-test
- run: cargo test --locked --features inproc-av
- run: cargo test --locked --features inproc-av,wayland,portal
test-linux-arm64:
# aarch64 hosts (Ampere A1, arm64 VMs, Apple-silicon VMs) build from source, so keep that
+3 -6
View File
@@ -160,8 +160,10 @@ for a new QR login.
| `src/clipboard*.rs` | text clipboard bridge and protocol |
| `src/file_trans.rs` | FileTransferFtp RPC |
| `src/terminal.rs` | TERM frames + PTY sessions |
| `src/privacy_screen/`, `c_engine/privacy_wallpaper.c` | host privacy screen (RPC 7): desktop-independent controller, recovery record, guard and cover processes; `Backend` per desktop (`kde/`: KWin virtual output, kscreen-doctor, KWin input devices). See docs/privacy-screen.md |
| `src/session_lock.rs`, `c_engine/pam_check.c` | lock state reporting, auto unlock via PAM + logind |
| `src/system_actions.rs`, `src/system_metrics.rs` | SimpleAction system commands, mute, auto-lock, SystemMetrics |
| `src/annotation.rs`, `c_engine/annotation_overlay.c` | viewer annotation (RPC 27 `draw_req` → RpcResponse 23): click-through X11 ARGB overlay, needs a compositing manager |
| `src/initialization.rs`, `src/control_protocol.rs`, `src/protocol.rs` | protobuf encoders/decoders for CONTROL |
| `src/session_ice.rs`, `src/network_diagnostics.rs` | cloud ICE servers, address-free path diagnostics |
| `src/desktop_backend.rs`, `src/wayland.rs`, `src/portal*.rs` | backend selection, Hyprland, GNOME/KDE portal |
@@ -193,7 +195,7 @@ started a second full host server instead, so check that a subcommand exists in
- RPC = Message 21 `RpcRequest {1 header{1 request_id}, <case>}`, answered with Message 22
`RpcResponse {1 header (same id), <case>}`. Cases used: 2 capture_setting, 3 fps, 4 video_quality,
6 resolution, 8 file transfer, 9 clipboard, 15 send_video_track, 16–20 plugins, 21 virtual audio policy,
28/29 terminal.
27 draw (annotation; answered on TEXT, a CONTROL reply times out with 9998), 28/29 terminal.
- CaptureSettingRequest: field 1 is an **fps option index** (1=30, 2=60, 3=90); the real frame rate is
field 18 `fpsCount`. Field 2 quality: 1 Fast, 2 General (高清 2M), 3 HD (超清 8M), 4 Bluray (原画 20M),
5 Auto, 6 Custom. Resolution: 16/17 pixel size or 5/6, 10 resolution_type (3 = follow remote).
@@ -211,11 +213,6 @@ started a second full host server instead, so check that a subcommand exists in
- SystemMetrics (Message 13): GeneralMetric `2 system_sound_support` is an enum, **2 = supported** (1 = not
supported); SettingMetric 1 keep_mute, 2 mute_permanent, 3 auto_lock, 5 file_transfer_save_location,
8/9/10 permission states (2 = allow).
- 防窥 (privacy screen): RpcRequest 7 `PrivateScreenSettingRequest {1 enable, 2 privacy_type, 3 setting_source}` →
RpcResponse 3 `{1 error_code, 2 req_privacy_type, 3 cur_privacy_type}`; PrivateScreenType 1 NOT_SET, 2 NORMAL,
3 ENHANCED (wallpaper). Declared on X11 only: FeatureFlag `4 ff_private_screen=1`, `3 ff_system_metrics=3`;
SettingMetric 4 private_screen, 7 private_screen_type (`src/privacy_screen.rs`, xrandr brightness 0, saved
gamma restored on session end / SIGTERM / next start). Not yet accepted with an official viewer.
- Security menu: 静音运行 on → SimpleAction 14 + 18, off → 16. 远程结束后自动锁屏 → SimpleAction 19 with
`value` (field 5) **2 = on, 1 = off**. The viewer sends these only when toggled, so the host persists them.
- Auto unlock: host reports `SystemStateChange{1 SecureDesktopState{1 is_locked, 5 is_support_auto_logon}}`;
Generated
+35 -2
View File
@@ -673,6 +673,15 @@ dependencies = [
"windows-sys 0.61.2",
]
[[package]]
name = "fdeflate"
version = "0.3.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
dependencies = [
"simd-adler32",
]
[[package]]
name = "ff"
version = "0.13.1"
@@ -727,7 +736,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb"
dependencies = [
"crc32fast",
"miniz_oxide",
"miniz_oxide 0.9.1",
"zlib-rs",
]
@@ -1323,6 +1332,16 @@ version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
[[package]]
name = "miniz_oxide"
version = "0.8.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
dependencies = [
"adler2",
"simd-adler32",
]
[[package]]
name = "miniz_oxide"
version = "0.9.1"
@@ -1571,6 +1590,19 @@ version = "0.3.34"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548"
[[package]]
name = "png"
version = "0.18.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61"
dependencies = [
"bitflags 2.13.2",
"crc32fast",
"fdeflate",
"flate2",
"miniz_oxide 0.8.9",
]
[[package]]
name = "polyval"
version = "0.6.2"
@@ -2772,7 +2804,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
[[package]]
name = "uu-remote-linux"
version = "0.2.41"
version = "0.2.53"
dependencies = [
"ab_glyph",
"async-trait",
@@ -2788,6 +2820,7 @@ dependencies = [
"libc",
"log",
"nix 0.29.0",
"png",
"qrcode",
"rand 0.8.8",
"rcgen",
+4 -2
View File
@@ -1,6 +1,6 @@
[package]
name = "uu-remote-linux"
version = "0.2.41"
version = "0.2.53"
edition = "2021"
default-run = "uuremote-server"
authors = ["uu-remote-linux contributors"]
@@ -23,7 +23,7 @@ required-features = ["native-viewer"]
default = []
native-viewer = []
viewer-ffmpeg = ["native-viewer", "dep:ffmpeg-next"]
viewer-sdl = ["native-viewer", "dep:sdl2", "dep:ab_glyph"]
viewer-sdl = ["native-viewer", "dep:sdl2", "dep:ab_glyph", "dep:png"]
wayland = []
# Experimental direct linear framebuffer capture; never enabled in release builds.
kms = []
@@ -60,8 +60,10 @@ x11rb = { version = "0.13", features = ["damage", "shm", "allow-unsafe-code"], o
sdl2 = { version = "0.37", optional = true, features = ["use-pkgconfig"] }
ab_glyph = { version = "0.2", optional = true }
png = { version = "0.18", optional = true }
[dev-dependencies]
tokio = { version = "1", features = ["test-util"] }
# Synthetic loopback WSS certificates only; both crates already occur in Cargo.lock.
rcgen = "0.11.3"
tokio-rustls = { version = "0.26.6", default-features = false, features = ["ring", "tls12"] }
+41 -1
View File
@@ -23,6 +23,21 @@
<p align="center"><img src="docs/images/main-window.png" width="620" alt="Host main window: remote assistance and account"></p>
<p align="center"><sub>Linux host main window: remote assistance and account (device ID, code and account redacted). The UI is available in Chinese and English (see [Language](#language--语言)).</sub></p>
## Appearance / 外观
Launcher icons use the system icon theme instead of emoji glyphs, so they do not depend on emoji font coverage.
Signed-in graphical hosts report the system wallpaper for disconnected device cards in official clients
(no desktop-window screenshot). GNOME/Cinnamon, KDE, Xfce and Omarchy on Hyprland are supported (following the current wallpaper); checks run every 60 seconds
and unchanged content is not uploaded again. Other desktops can set `UU_WALLPAPER=/absolute/path/image.png`
(PNG/JPEG/WebP). Set `UU_WALLPAPER_UPLOAD=0` to disable; guest and headless hosts skip reporting.
See [protocol evidence and limitations](docs/wallpaper-protocol.md).
Choose **System / Light / Dark** (default: System) in the viewer's **Settings → General → Appearance**, or via the gear settings button in host / tool windows.
The choice is saved to `$XDG_CONFIG_HOME/uuremote/theme` (default `~/.config/uuremote/theme`).
<p align="center"><img src="docs/images/appearance-light.png" width="360" alt="Light appearance (synthetic devices)"> <img src="docs/images/appearance-dark.png" width="360" alt="Dark appearance (synthetic devices)"></p>
## Language / 语言
The language is picked once at start, in this order:
@@ -62,6 +77,7 @@ Protocol strings and messages that come from the UU servers are shown as the ser
| Mac shortcuts | **Recommended**: turn off 「使用 macOS 快捷键」 (use macOS shortcuts) in the Mac viewer's remote-window menu; then Cmd+C/V/A/F/X/Z work as on a Mac (Cmd+C/V become Ctrl+Shift+C/V in terminals) and Ctrl+C always interrupts. With the option on, the viewer sends Cmd as Ctrl: in a terminal Ctrl+V / Cmd+V paste, Ctrl+C interrupts, copy is Cmd+Shift+C (X11) |
| Pointer shape | Remote cursor shape is mirrored to the viewer (X11) |
| Clipboard | Two-way text sync; Wayland mobile IME text inputs use clipboard paste fallback (see below) |
| Viewer annotation | Strokes drawn with 「批注」 (annotate) in the viewer's watch mode appear on the Linux screen and stream back to the viewer (X11, needs a compositing manager; the overlay lets clicks through); cleared when annotation is turned off or the viewer disconnects. Verified with the Mac viewer 4.42.0; mobile viewers untested |
| Quality / frame rate / resolution | Auto, Original 20M, Ultra 8M, HD 2M, custom; 30/60/90/144 fps; on X11 a resolution choice changes the desktop resolution itself like the official Windows host (xrandr, adding the mode when missing; restored for "original" or on disconnect), `UU_DESKTOP_RESIZE=0` scales in the encoder instead; Wayland scales in the encoder |
| Sound | System audio captured from PulseAudio / PipeWire and sent as Opus |
| File transfer | Upload, download (including folders), create folder, rename, delete |
@@ -144,7 +160,7 @@ On niri, `niri msg --json outputs` enumerates enabled monitors. Normal and 90/18
| True color (4:4:4) | Supported (v0.1.15): the default FFmpeg pipeline with NVENC / libx264 encodes H.264 High 4:4:4; `inproc-av` native NVENC encodes H.264 High 4:4:4 / HEVC FRExt; VAAPI stays 4:2:0 and reports that to the client |
| HDR | Not implemented |
| Super screen / virtual display | Not implemented |
| Privacy screen on the host | 🧪 Experimental, X11 only: output brightness (gamma) is set to 0 so the physical monitors go black while the remote picture stays normal; normal privacy (black) only, no wallpaper mode; not on Wayland. Restored when the session ends or the service stops/restarts. Overrides custom gamma such as night light; local mouse/keyboard stay active |
| 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) |
| 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 |
@@ -203,6 +219,8 @@ sudo apt install libwayland-dev libxkbcommon-dev wl-clipboard
sudo apt install libglib2.0-dev libpipewire-0.3-dev libei-dev
# optional: headers for the inproc-av VAAPI/DRI3 engines (libva itself is loaded at runtime)
sudo apt install libva-dev libgbm-dev libx11-xcb-dev libxcb-dri3-dev libxcb-damage0-dev
# In-process audio capture and Opus encoding for inproc-av
sudo apt install libpulse-dev libopus-dev
```
- A Rust toolchain is required (<https://rustup.rs>).
@@ -221,6 +239,9 @@ cargo build --release --features wayland,portal # + GNOME/KDE on Wayland
The viewer's `viewer-ffmpeg` feature supports **FFmpeg 6.x only** (`pkg-config --modversion libavcodec` = 60.x); FFmpeg 7+ fails inside `ffmpeg-sys-next` with `avfft.h file not found` (#63).
The host's optional `--features inproc-av` encodes with hardware inside the process on X11. It does not link FFmpeg development libraries; it loads the NVIDIA driver libraries (`libcuda.so.1`, `libnvidia-encode.so.1`) at runtime for NVENC (needs a driver with NVENC API 12.1, 530 or newer) and `libva.so.2`/`libva-drm.so.2` for VAAPI. When the capture and encoder sizes match, NVENC reads the XShm buffer directly, saving one host-to-device copy; VAAPI runs in process under the same feature (DRI3 DMA-BUF zero copy, or XShm upload without DRI3, then VPP to NV12 and VCN; H.264/HEVC). CPU encoding and `UU_CAPTURE=grab` keep the FFmpeg process; if the in-process hardware session fails it falls back to the matching FFmpeg process pipeline, then to the CPU. The default build and the release packages need neither feature.
On GNOME/KDE Wayland, enable in-process encoding with `cargo build --release --features wayland,portal,inproc-av` and `set-encoder vaapi`; support is limited to Portal + VAAPI.
`UU_PORTAL_DMABUF=0` disables DMA-BUF in favor of in-process host upload; `UU_VIDEO_PIPELINE=process` restores external FFmpeg pipelines.
### 3. Log in
Run inside your graphical session:
@@ -285,6 +306,8 @@ sudo udevadm control --reload && sudo udevadm trigger --name-match=uinput
`uaccess` grants access only to the user sitting at the machine. `UU_INPUT_BACKEND=uinput|native` forces a backend.
X11 keeps XTest by default because it handles held keys correctly on high-latency links.
ASCII text mapping through uinput requires X11/XWayland XKB; unmappable text keeps the existing text/clipboard path.
## Remote assistance and the main window (experimental)
As in the official client, this host shows a **device ID** and a **verification code**; whoever you give them to can
@@ -444,6 +467,7 @@ flowchart LR
## Security and privacy
- By default, signed-in graphical hosts upload the current wallpaper image to UU's file service for device-card backgrounds. Set `UU_WALLPAPER_UPLOAD=0` to disable this upload.
- Logs never contain keystrokes, terminal text, clipboard contents, file contents, passwords or tokens.
- For auto unlock the password is stored in the **viewer** (the official client). The host only checks it
once with PAM; it is never written to disk or logs.
@@ -579,6 +603,8 @@ No official "no desktop" error code was found for headless desktop offers, so th
## Experimental native viewer (uuremote-viewer)
See [SDL viewer video scheduling](docs/viewer-video-scheduling.md).
`uuremote-viewer` is a Linux **viewer/controller**: it connects to and controls other devices on your UU account (official Windows / Mac
hosts or this project's Linux host), and can start remote assistance with someone's device ID and code. It is experimental and
separate from the host `uuremote-server`; the default host build and behaviour are unchanged.
@@ -588,6 +614,10 @@ separate from the host `uuremote-server`; the default host build and behaviour a
terminal emulator (`TERMINAL` selects one). From source: `sudo apt install libsdl2-dev`, then
`cargo build --release --locked --features native-viewer,viewer-sdl --bin uuremote-viewer`.
Key combinations use the left/right modifier state attached to each SDL key event. Focus loss releases remote keys; after focus returns, the next non-modifier key restores any still-held Shift/Ctrl/Alt/Win (Command on Mac). This is built in, with no adapter or setting required.
The viewer mirrors remote PNG pointer shapes (including text and window-resize cursors) with their hotspots. Leaving the remote picture or opening local controls restores the local arrow.
SDL clipboard access reuses the desktop window to avoid temporary-window Dock churn on GNOME Wayland (#37).
On niri, data-control-capable `wl-clipboard` is used instead, so synchronization does not require window focus.
Other SDL backends synchronize only while that window is focused. The 30 KiB text limit applies. Selections without a supported
@@ -624,6 +654,8 @@ GNOME-to-official-Mac bidirectional clipboard synchronization is still unverifie
- Frames are decoded at the host's native resolution and scaled to the window with linear filtering; a host resolution
change restarts the decoder. `UU_VIEWER_SIZE=WxH` forces a fixed letterboxed canvas instead.
The SDL remote desktop window disables local IME text composition and forwards physical keys; use the remote host’s input method and its language toggle (for example, Shift) to enter Chinese.
Mac targets use native macOS keycodes; Windows / Linux targets retain Windows VK. Keys follow physical positions, without
automatically translating Ctrl to Command; on a Mac target the PC Super / Windows key acts as Command. Only verified target
platform values 1 (Windows / this project's Linux host) and 4 (Mac) are accepted; unknown values fail explicitly. Account
@@ -648,3 +680,11 @@ assistance and ISO / JIS keyboards have not been tested live.
"—" = not tested yet. Only use reboot/shutdown on machines you can restart. **Not tested live**: H.265 / 4:4:4 with official hosts, multiple monitors. Logs carry field
numbers, sizes and states only, never keystrokes, clipboard or file contents, codes or credentials.
### Native gamepad and rumble (experimental)
The SDL viewer forwards one mapped controller and ordinary two-motor rumble through the existing desktop CONTROL channel to a Windows host.
Default OFF: set `UU_VIEWER_NATIVE_GAMEPAD=1` to enable input; `UU_VIEWER_NATIVE_RUMBLE=0` disables feedback independently.
Guide forwarding, multiple controllers and adaptive triggers are unsupported; suspend, forced exit and network recovery are not comprehensively verified.
One reporting user tested input, phone-hotspot WAN, reconnect and rumble on one Windows/Steam Deck pair.
See [protocol evidence, design and limits](docs/deckpad-native-gamepad.md).
+37 -1
View File
@@ -19,6 +19,17 @@
<p align="center"><img src="docs/images/main-window.png" width="620" alt="Linux 主机主窗口:远程协助与账号"></p>
<p align="center"><sub>Linux 被控端主窗口:远程协助与账号(设备 ID、验证码和账号已打码)</sub></p>
## 外观 / Appearance
启动器图标使用系统主题的符号图标,避免缺少 emoji 字体时显示方框。
已登录的图形主机会上报系统壁纸,供官方客户端的设备卡片在未连接时显示背景图(不是桌面窗口截图)。支持 GNOME/Cinnamon、KDE、Xfce 和 Hyprland 下的 Omarchy(自动跟随当前壁纸);每 60 秒检查一次,内容不变则不重复上传。其他桌面可用 `UU_WALLPAPER=/绝对路径/图片.png` 指定 PNG/JPEG/WebP;`UU_WALLPAPER_UPLOAD=0` 关闭。访客和无桌面模式跳过上报。协议依据与限制见 [设备壁纸上报](docs/wallpaper-protocol.md)。
在控制端的 **设置 → 常规 → 外观**,或主机 / 工具窗口的齿轮设置按钮中选择 **跟随系统 / 浅色 / 深色**(默认跟随系统)。
选择保存在 `$XDG_CONFIG_HOME/uuremote/theme`(默认 `~/.config/uuremote/theme`)。
<p align="center"><img src="docs/images/appearance-light.png" width="360" alt="浅色界面(虚构设备)"> <img src="docs/images/appearance-dark.png" width="360" alt="深色界面(虚构设备)"></p>
## 语言 / Language
启动时按以下顺序确定界面语言:
@@ -55,6 +66,7 @@ UU_LANG=en uuremote-server
| Mac 快捷键 | **推荐**:在 Mac 远控窗口菜单里关闭「使用 macOS 快捷键」,之后和在 Mac 上一样:Cmd+C/V/A/F/X/Z 是复制、粘贴、全选、查找、剪切、撤销(终端里 Cmd+C/V 自动变成 Ctrl+Shift+C/V),Ctrl+C 在终端里始终是中断。保持开启时,客户端会把 Cmd 和 Ctrl 都当成 Ctrl 发送:终端里 Ctrl+V / Cmd+V 自动转成粘贴,Ctrl+C 是中断,复制用 Cmd+Shift+C(X11) |
| 鼠标指针样式 | 远端指针形状实时同步(X11) |
| 剪贴板 | 双向文本同步;Wayland 手机输入法输入通过剪贴板兜底粘贴,见下文 |
| 观看模式批注 | 控制端观看模式下开启「批注」后画的笔迹显示在 Linux 屏幕上,并随画面传回控制端(X11,需要合成器;覆盖层不拦截鼠标);关闭批注或断开连接时清除。已用 Mac 控制端 4.42.0 实测,手机控制端未测 |
| 画质 / 帧率 / 分辨率 | 自动、原画 20M、超清 8M、高清 2M、自定义;30/60/90/144 帧;X11 下切换分辨率会像官方 Windows 被控端一样真正修改桌面分辨率(xrandr,缺少该模式时自动添加;选「原始」或断开后恢复),`UU_DESKTOP_RESIZE=0` 改为仅由编码器缩放;Wayland 仍由编码器缩放 |
| 声音 | 采集系统声音(PulseAudio / PipeWire),Opus 编码传到控制端 |
| 文件传输 | 上传、下载(含文件夹)、新建文件夹、重命名、删除 |
@@ -129,7 +141,7 @@ niri 会话通过 `niri msg --json outputs` 枚举已启用的显示器。普通
| 真彩(4:4:4) | 支持(v0.1.15):NVENC / libx264 的默认 FFmpeg 管线输出 H.264 High 4:4:4;`inproc-av` 原生 NVENC 输出 H.264 High 4:4:4 / HEVC FRExt;VAAPI 管线仍为 4:2:0,并如实回报给客户端 |
| HDR | 未实现 |
| 超级屏 / 虚拟显示器 | 未实现 |
| 被控端防窥模式 | 🧪 实验性,仅 X11:把显示器输出的亮度(gamma)调为 0,物理屏幕变黑,远程画面照常;只支持「普通防窥」(黑屏),不支持壁纸防窥;Wayland 未实现。连接断开、服务退出或重启时恢复屏幕。会改写夜间模式等自定义 gamma,本地鼠标键盘不会被禁用 |
| 被控端防窥模式 | 实验性,仅 KDE Plasma Wayland(portal);Mac 4.43.0 已验证不启用、隐私屏保、关闭显示屏三种状态回显;`UU_PRIVACY_AUTO=picture` / `screen-off` 可在桌面连接时自动开启,见 [docs/privacy-screen.md](docs/privacy-screen.md) |
| 麦克风(控制端声音传到被控端) | 未实现(需要虚拟声卡) |
| 魔兽世界排队提醒等插件 | 不支持,会明确告诉客户端「无插件」 |
| Linux 系统登录界面 | 还不支持控制开机后的系统登录界面(还没有人登录 Linux 桌面时);这种情况可以用无头模式或虚拟桌面(见下文)。注意:这里说的是 Linux 系统登录,**不登录 UU 账号**现在可以通过「远程协助」使用 |
@@ -186,6 +198,8 @@ sudo apt install libwayland-dev libxkbcommon-dev wl-clipboard
sudo apt install libglib2.0-dev libpipewire-0.3-dev libei-dev
# 可选:inproc-av 的 VAAPI/DRI3 引擎编译所需(libva 本体运行时加载)
sudo apt install libva-dev libgbm-dev libx11-xcb-dev libxcb-dri3-dev libxcb-damage0-dev
# inproc-av 的进程内音频采集与 Opus 编码
sudo apt install libpulse-dev libopus-dev
```
- 需要 Rust 工具链(<https://rustup.rs>)。
@@ -203,6 +217,9 @@ cargo build --release --features wayland,portal # + GNOME/KDE Wayland
控制端的 `viewer-ffmpeg` 只支持 **FFmpeg 6.x**(`pkg-config --modversion libavcodec` 为 60.x);FFmpeg 7 及以上会在依赖 `ffmpeg-sys-next` 里报 `avfft.h file not found`(#63)。
服务端可选的 `--features inproc-av` 是 X11 下的进程内硬件编码:不链接 FFmpeg 开发库,NVENC 运行时加载 NVIDIA 驱动库(`libcuda.so.1`、`libnvidia-encode.so.1`,需要支持 NVENC API 12.1 的驱动,530 及以上),VAAPI 运行时加载 `libva.so.2`/`libva-drm.so.2`。截屏与编码尺寸一致时 NVENC 直接读取 XShm 缓冲,省去一次主机到显存的拷贝;VAAPI 在同一特性下也进程内运行(DRI3 DMA-BUF 零拷贝,无 DRI3 时 XShm 上传,VPP 转 NV12 后送 VCN,支持 H.264/H.265)。CPU 编码或 `UU_CAPTURE=grab` 仍走外部 FFmpeg 进程;进程内硬件编码启动失败时先回退到对应的 FFmpeg 进程管线,再回退到 CPU。默认构建和预编译包都不需要该特性。
GNOME/KDE Wayland 的进程内编码用 `cargo build --release --features wayland,portal,inproc-av` 配合 `set-encoder vaapi` 启用,目前仅支持 Portal + VAAPI。
`UU_PORTAL_DMABUF=0` 禁用 DMA-BUF、改用进程内上传;`UU_VIDEO_PIPELINE=process` 恢复外部 FFmpeg 管线。
### 3. 登录
在图形桌面里运行:
@@ -265,6 +282,8 @@ sudo udevadm control --reload && sudo udevadm trigger --name-match=uinput
`uaccess` 只把权限给当前坐在这台机器前的登录用户。`UU_INPUT_BACKEND=uinput|native` 可以强制指定后端。
X11 默认继续用 XTest,因为它能正确处理网络延迟下按住不放的按键。
uinput 的 ASCII 文本映射依赖 X11/XWayland XKB;不可映射的文字保留原有文字输入/剪贴板路径。
## 远程协助与主窗口(实验性)
和官方客户端的「远程协助」一样:本机显示**设备 ID** 和**验证码**,把它们发给信任的人,对方在 UU 远程的「开始协助」里输入即可控制本机。
@@ -388,6 +407,7 @@ flowchart LR
## 安全与隐私
- 已登录的图形主机默认会将当前壁纸图片上传到 UU 的文件服务,供设备卡片显示背景;可用 `UU_WALLPAPER_UPLOAD=0` 关闭上传。
- 日志不记录键盘输入、终端内容、剪贴板内容、文件内容、密码和令牌。
- 自动解锁的密码保存在**控制端**(官方客户端)里,被控端只拿来做一次 PAM 校验,不落盘、不写日志。
- 能连上这台机器的,只有登录了同一个 UU 账号的设备。请保管好你的 UU 账号。
@@ -507,6 +527,8 @@ xfce4-session xfce4-panel xfdesktop xfwm4 gnome-terminal`。
## 实验性原生控制端(uuremote-viewer)
[SDL 控制端视频调度说明](docs/viewer-video-scheduling.md)。
`uuremote-viewer` 是 Linux 上的**控制端**:用你的 UU 账号连接并控制其他设备(官方 Windows / Mac 被控端,或本项目的 Linux 主机),
也可以凭对方的设备 ID 和验证码发起远程协助。它是实验性功能,与主机 `uuremote-server` 相互独立,默认主机构建和行为不变。
@@ -514,6 +536,10 @@ xfce4-session xfce4-panel xfdesktop xfwm4 gnome-terminal`。
`ffmpeg` 命令;SDL 桌面窗口直接同步文本剪贴板(Wayland/X11),无需额外剪贴板工具;终端功能需要本机终端程序(可用 `TERMINAL` 指定)。
从源码构建:`sudo apt install libsdl2-dev`,然后 `cargo build --release --locked --features native-viewer,viewer-sdl --bin uuremote-viewer`。
组合键使用 SDL 按键事件携带的左右修饰键状态;窗口失焦时释放远端按键,重新聚焦后的下一次普通按键会恢复仍按住的 Shift/Ctrl/Alt/Win(Mac 为 Command)。此行为内置,无需适配库或开关。
控制端会同步远端以 PNG 发送的指针形状(如文本光标和窗口缩放箭头),并保留正确热点。离开远控画面或打开本地菜单时恢复本机箭头。
SDL 剪贴板复用桌面窗口,避免 GNOME Wayland 上临时窗口引起的 Dock 跳动(#37)。niri 改用支持 data-control 的
`wl-clipboard`,不需要桌面窗口保持焦点;其他 SDL 后端仅在桌面窗口获得焦点时同步。
保留 30 KiB 文本上限;跳过不含支持的文本格式的本地选择,空文本的识别取决于 SDL2 后端。不带 SDL 的构建保留命令后端。
@@ -547,6 +573,8 @@ GNOME 与官方 Mac 被控端的双向剪贴板尚未验证通过;此修改不
以 CaptureSettingSync 回报为准。两种色度均由 FFmpeg 转为 RGB24 显示。
- 按被控端原始分辨率解码,窗口缩放使用线性过滤;被控端分辨率变化时自动重启解码器。`UU_VIEWER_SIZE=WxH` 可改为固定的留黑边画布。
SDL 远程画面窗口关闭本地输入法的文本组合,按物理键转发;输入中文时请使用被控端的输入法及其中英切换键(例如 Shift)。
Mac 目标使用 macOS 原生键码,Windows / Linux 目标保留 Windows VK。键盘按物理键位置转发,不自动把 Ctrl 改成 Command;
控制 Mac 时,PC 键盘的 Super / Win 键对应 Command。仅接受已验证的目标平台值 1(Windows / 本项目 Linux 主机)和 4(Mac),
未知值会报错,不猜测键码。账号连接缺少平台字段时查询目标设备;远程协助必须由连接响应提供平台。只看模式不需要此识别。
@@ -568,3 +596,11 @@ Mac 目标使用 macOS 原生键码,Windows / Linux 目标保留 Windows VK。
| Wayland 下的桌面窗口与剪贴板 | — | — | ✅ Hyprland、KDE;GNOME 窗口正常,剪贴板已于 v0.2.3 改为 SDL 直连(#37,最终版本未重新实机验收) |
「—」表示尚未测试。重启/关机只应在可以重启的机器上使用。**未实测**:官方被控端的 H.265 / 4:4:4、多显示器。日志只记录字段号、大小和状态,不记录键盘、剪贴板、文件内容、验证码或凭据。
### 原生手柄与震动(实验性)
SDL 控制端可通过现有桌面 CONTROL 通道向 Windows 被控端转发一个映射手柄,并接收普通双路震动。
默认关闭:`UU_VIEWER_NATIVE_GAMEPAD=1` 启用手柄,`UU_VIEWER_NATIVE_RUMBLE=0` 可独立关闭震动。
不支持 Guide 键、多手柄和自适应扳机;休眠、强制退出及断网恢复尚未全面验证。
一名报告用户在一组 Windows + Steam Deck 上测试了输入、手机热点、重连与震动。
详见[协议证据、设计与限制](docs/deckpad-native-gamepad.md)。
+26 -4
View File
@@ -1,15 +1,22 @@
fn main() {
println!("cargo:rerun-if-changed=c_engine/dmabuf_frame.h");
println!("cargo:rerun-if-changed=c_engine/wayland_transform.h");
println!("cargo:rerun-if-changed=c_engine/portal_clipboard.inc");
println!("cargo:rerun-if-changed=c_engine/x11_engine.c");
println!("cargo:rerun-if-changed=c_engine/annotation_overlay.c");
println!("cargo:rerun-if-changed=c_engine/uinput_keymap.c");
println!("cargo:rerun-if-changed=c_engine/uinput_keymap.h");
println!("cargo:rerun-if-changed=c_engine/nvenc_engine.c");
println!("cargo:rerun-if-changed=c_engine/nvenc_engine.h");
println!("cargo:rerun-if-changed=vendor/ffnvcodec/ffnvcodec/dynlink_cuda.h");
println!("cargo:rerun-if-changed=vendor/ffnvcodec/ffnvcodec/nvEncodeAPI.h");
println!("cargo:rerun-if-changed=c_engine/clipboard.c");
println!("cargo:rerun-if-changed=c_engine/assist_window.c");
println!("cargo:rerun-if-changed=c_engine/privacy_wallpaper.c");
println!("cargo:rerun-if-changed=c_engine/viewer_window.c");
println!("cargo:rerun-if-changed=c_engine/viewer_tools.c");
println!("cargo:rerun-if-changed=c_engine/ui_theme.c");
println!("cargo:rerun-if-changed=c_engine/ui_theme.h");
println!("cargo:rerun-if-changed=c_engine/pam_check.c");
println!("cargo:rerun-if-env-changed=UU_NO_GTK");
println!("cargo:rustc-check-cfg=cfg(uu_gtk)");
@@ -28,9 +35,17 @@ fn main() {
}
let mut x11_build = cc::Build::new();
x11_build.file("c_engine/x11_engine.c")
.file("c_engine/annotation_overlay.c")
.file("c_engine/uinput_keymap.c")
.file("c_engine/clipboard.c")
.file("c_engine/pam_check.c");
if std::env::var_os("CARGO_FEATURE_INPROC_AV").is_some() {
println!("cargo:rerun-if-changed=c_engine/audio_engine.c");
x11_build.file("c_engine/audio_engine.c");
let audio_flags = std::process::Command::new("pkg-config").args(["--cflags", "libpulse", "opus"])
.output().expect("inproc-av requires libpulse and opus development libraries");
assert!(audio_flags.status.success(), "inproc-av requires libpulse-dev and libopus-dev");
for flag in String::from_utf8_lossy(&audio_flags.stdout).split_whitespace() { x11_build.flag(flag); }
x11_build.file("c_engine/nvenc_engine.c");
x11_build.file("c_engine/vaapi_engine.c");
x11_build.file("c_engine/dri3_capture.c");
@@ -38,15 +53,22 @@ fn main() {
println!("cargo:rerun-if-changed={f}");
}
x11_build.include("vendor/ffnvcodec");
// libva/libva-drm are dlopen'ed at runtime (like NVENC's libcuda); these are
// link-time-only deps of the DRI3/VAAPI engines and must stay out of default builds.
}
x11_build.compile("x11_engine");
// libva/libva-drm are dlopen'ed at runtime (like NVENC's libcuda); these are
// link-time-only deps of the DRI3/VAAPI engines and must stay out of default builds.
if std::env::var_os("CARGO_FEATURE_INPROC_AV").is_some() {
// Emit them after the static C archive: GNU ld --as-needed would otherwise
// discard the shared libraries before libx11_engine.a references their symbols.
println!("cargo:rustc-link-lib=pulse");
println!("cargo:rustc-link-lib=opus");
println!("cargo:rustc-link-lib=gbm");
println!("cargo:rustc-link-lib=X11-xcb");
println!("cargo:rustc-link-lib=xcb");
println!("cargo:rustc-link-lib=xcb-dri3");
println!("cargo:rustc-link-lib=xcb-damage");
}
x11_build.compile("x11_engine");
println!("cargo:rustc-link-lib=X11");
println!("cargo:rustc-link-lib=Xext");
@@ -59,7 +81,7 @@ fn main() {
match (std::env::var_os("UU_NO_GTK").is_none()).then(|| gtk("--cflags").zip(gtk("--libs"))).flatten() {
Some((cflags, libs)) => {
let mut build = cc::Build::new();
build.file("c_engine/assist_window.c").file("c_engine/viewer_window.c").file("c_engine/viewer_tools.c").flag_if_supported("-Wno-deprecated-declarations");
build.file("c_engine/assist_window.c").file("c_engine/privacy_wallpaper.c").file("c_engine/viewer_window.c").file("c_engine/viewer_tools.c").file("c_engine/ui_theme.c").flag_if_supported("-Wno-deprecated-declarations");
for flag in cflags.split_whitespace() { build.flag(flag); }
build.compile("uu_login_window");
for flag in libs.split_whitespace() {
+137
View File
@@ -0,0 +1,137 @@
// Viewer annotation (观看模式「批注」) overlay for X11 desktops.
//
// A full-screen, override-redirect ARGB window with an empty input shape: strokes from the
// viewer are drawn on it, the compositor blends it over the desktop (so the capture shows the
// strokes), and every pointer event passes through to the windows below. The window only
// exists while the viewer keeps annotation enabled. One thread owns each handle (Xlib is not
// initialized for threads here).
#include <X11/Xlib.h>
#include <X11/Xatom.h>
#include <X11/Xutil.h>
#include <X11/extensions/shape.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
Display *dpy;
Window win, root;
Colormap cmap;
GC gc;
int x, y, width, height;
int root_width, root_height;
} uu_annotation;
static int has_compositor(Display *dpy, int screen) {
char name[32];
snprintf(name, sizeof name, "_NET_WM_CM_S%d", screen);
Atom selection = XInternAtom(dpy, name, False);
return XGetSelectionOwner(dpy, selection) != None;
}
// Opens the overlay over the root region (x, y, width, height); width/height <= 0 = whole root.
// error: 1 display, 2 no compositing manager (an ARGB window would be opaque), 3 no 32-bit visual.
void *uu_annotation_open(const char *display, int x, int y, int width, int height, int *error) {
*error = 0;
Display *dpy = XOpenDisplay(display && *display ? display : NULL);
if (!dpy) { *error = 1; return NULL; }
int screen = DefaultScreen(dpy);
Window root = RootWindow(dpy, screen);
if (!has_compositor(dpy, screen)) { XCloseDisplay(dpy); *error = 2; return NULL; }
XVisualInfo info;
if (!XMatchVisualInfo(dpy, screen, 32, TrueColor, &info)) { XCloseDisplay(dpy); *error = 3; return NULL; }
if (width <= 0 || height <= 0) {
x = 0; y = 0;
width = DisplayWidth(dpy, screen);
height = DisplayHeight(dpy, screen);
}
Colormap cmap = XCreateColormap(dpy, root, info.visual, AllocNone);
XSetWindowAttributes attrs;
memset(&attrs, 0, sizeof attrs);
attrs.override_redirect = True;
attrs.background_pixel = 0;
attrs.border_pixel = 0;
attrs.colormap = cmap;
attrs.event_mask = ExposureMask | StructureNotifyMask;
Window win = XCreateWindow(dpy, root, x, y, (unsigned)width, (unsigned)height, 0, 32, InputOutput, info.visual,
CWOverrideRedirect | CWBackPixel | CWBorderPixel | CWColormap | CWEventMask, &attrs);
// Empty input region: clicks, scrolls and hovers reach the windows below.
XShapeCombineRectangles(dpy, win, ShapeInput, 0, 0, NULL, 0, ShapeSet, Unsorted);
XStoreName(dpy, win, "uu-remote-linux annotation");
XClassHint hint = { "uu-remote-annotation", "uu-remote-linux" };
XSetClassHint(dpy, win, &hint);
// Keep the overlay composited (2 = never unredirect).
long bypass = 2;
XChangeProperty(dpy, win, XInternAtom(dpy, "_NET_WM_BYPASS_COMPOSITOR", False), XA_CARDINAL, 32,
PropModeReplace, (unsigned char *)&bypass, 1);
XMapRaised(dpy, win);
// Root ConfigureNotify reports RandR resizes, so the caller can rebuild at the new geometry.
XSelectInput(dpy, root, StructureNotifyMask);
GC gc = XCreateGC(dpy, win, 0, NULL);
XFlush(dpy);
uu_annotation *a = calloc(1, sizeof *a);
if (!a) { XFreeGC(dpy, gc); XDestroyWindow(dpy, win); XFreeColormap(dpy, cmap); XCloseDisplay(dpy); *error = 1; return NULL; }
a->dpy = dpy; a->win = win; a->root = root; a->cmap = cmap; a->gc = gc;
a->x = x; a->y = y; a->width = width; a->height = height;
a->root_width = DisplayWidth(dpy, screen); a->root_height = DisplayHeight(dpy, screen);
return a;
}
void uu_annotation_size(void *handle, int *width, int *height) {
uu_annotation *a = handle;
*width = a->width; *height = a->height;
}
// argb: premultiplied 0xAARRGGBB for the 32-bit visual. points: x0,y0,x1,y1,... in window pixels.
void uu_annotation_polyline(void *handle, const short *points, int count, unsigned int argb, int line_width) {
uu_annotation *a = handle;
if (count <= 0) return;
XSetForeground(a->dpy, a->gc, argb);
XSetLineAttributes(a->dpy, a->gc, line_width < 1 ? 1 : (unsigned)line_width, LineSolid, CapRound, JoinRound);
if (count == 1) {
int r = line_width / 2;
XFillArc(a->dpy, a->win, a->gc, points[0] - r, points[1] - r, (unsigned)line_width, (unsigned)line_width, 0, 360 * 64);
} else {
XDrawLines(a->dpy, a->win, a->gc, (XPoint *)points, count, CoordModeOrigin);
}
}
void uu_annotation_clear(void *handle) {
uu_annotation *a = handle;
XClearWindow(a->dpy, a->win);
}
void uu_annotation_flush(void *handle) {
uu_annotation *a = handle;
XRaiseWindow(a->dpy, a->win);
XFlush(a->dpy);
}
// Drains pending events: 2 when the root was resized (reopen the overlay), 1 when the window needs
// a full repaint (exposed or remapped), else 0.
int uu_annotation_poll(void *handle) {
uu_annotation *a = handle;
int result = 0;
while (XPending(a->dpy)) {
XEvent event;
XNextEvent(a->dpy, &event);
if (event.type == ConfigureNotify && event.xconfigure.window == a->root
&& (event.xconfigure.width != a->root_width || event.xconfigure.height != a->root_height)) {
a->root_width = event.xconfigure.width; a->root_height = event.xconfigure.height;
result = 2;
} else if (result == 0 && ((event.type == Expose && event.xexpose.count == 0) || event.type == MapNotify)) {
result = 1;
}
}
return result;
}
void uu_annotation_close(void *handle) {
uu_annotation *a = handle;
if (!a) return;
XFreeGC(a->dpy, a->gc);
XDestroyWindow(a->dpy, a->win);
XFreeColormap(a->dpy, a->cmap);
XCloseDisplay(a->dpy);
free(a);
}
+3 -26
View File
@@ -9,27 +9,9 @@
#include <string.h>
#include <dlfcn.h>
#include "i18n.h"
#include "ui_theme.h"
static void on_language(GtkComboBox *c, gpointer note);
static const char *CSS =
"window { background-color: #f5f6f8; }\n"
"* { font-family: 'Noto Sans CJK SC', 'Noto Sans SC', sans-serif; }\n"
".card { background-color: #ffffff; border-radius: 10px; border: 1px solid #e5e7eb; }\n"
".heading { font-size: 20px; font-weight: 700; color: #1d1d1f; }\n"
".key { font-size: 14px; color: #4b5563; }\n"
".big { font-size: 32px; font-weight: 800; color: #111111; }\n"
".note { font-size: 13px; color: #9ca3af; }\n"
".hint { font-size: 13px; color: #6b7280; }\n"
".footer { font-size: 12px; color: #9ca3af; }\n"
"button.flat { padding: 4px 8px; }\n"
"button.share { background-image: none; background-color: #ffffff; border: 1px solid #d1d5db;"
" border-radius: 6px; padding: 6px 14px; font-size: 14px; }\n"
"separator { background-color: #e5e7eb; min-height: 1px; }\n"
".user { font-size: 22px; font-weight: 700; color: #111111; }\n"
".status { font-size: 13px; color: #2f6bff; }\n"
".status.ok { color: #16a34a; }\n"
".status.error { color: #dc2626; }\n";
enum { CMD_NONE = 0, CMD_ALLOW = 1, CMD_DENY = 2, CMD_RESET = 3, CMD_STOP = 4, CMD_VERIFY = 5, CMD_REFRESH = 6, CMD_CUSTOM = 7, CMD_LOGOUT = 8, CMD_QUIT = 9 };
enum { VERIFY_TEMPORARY = 0, VERIFY_CUSTOM = 1, VERIFY_BOTH = 2 };
@@ -387,11 +369,7 @@ static void build_tray(void) {
}
static void build_window(void) {
GtkCssProvider *css = gtk_css_provider_new();
gtk_css_provider_load_from_data(css, CSS, -1, NULL);
gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), GTK_STYLE_PROVIDER(css),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref(css);
uu_theme_init();
gtk_window_set_default_icon_name("uu-remote-linux"); // contrib/desktop icon, when installed
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
@@ -522,6 +500,7 @@ static void build_window(void) {
gtk_box_pack_start(GTK_BOX(lang_row), lang, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(lang_row), lang_note, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(root), lang_row, FALSE, FALSE, 6);
gtk_box_pack_end(GTK_BOX(lang_row), uu_theme_settings_button(GTK_WINDOW(window)), FALSE, FALSE, 0);
if (close_hides) gtk_label_set_text(GTK_LABEL(footer_label), L("开源 Linux 被控端 · 非网易官方客户端 · 关闭窗口后远程协助仍在后台运行", "Open-source Linux host · not an official NetEase client · remote assistance keeps running after the window closes"));
render_code();
if (close_hides) build_tray();
@@ -544,8 +523,6 @@ static void on_language(GtkComboBox *c, gpointer note) {
static void *ui_main(void *arg) {
(void)arg;
int ok = gtk_init_check(NULL, NULL);
// The CSS hard-codes a light palette; a dark system theme would turn unstyled text white on white (#43).
if (ok) g_object_set(gtk_settings_get_default(), "gtk-theme-name", "Adwaita", "gtk-application-prefer-dark-theme", FALSE, NULL);
if (ok) build_window();
pthread_mutex_lock(&init_lock);
init_state = ok ? 1 : -1;
+124
View File
@@ -0,0 +1,124 @@
#include <pulse/pulseaudio.h>
#include <opus/opus.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include "i18n.h"
typedef struct {
pa_mainloop *loop;
pa_context *context;
pa_stream *stream;
OpusEncoder *encoder;
char *source;
int failed, connecting;
int16_t pcm[960 * 2];
size_t filled, offset;
} UuAudio;
void uu_audio_close(UuAudio *audio) {
if (!audio) return;
if (audio->stream) {
pa_stream_disconnect(audio->stream);
pa_stream_unref(audio->stream);
}
if (audio->context) {
pa_context_disconnect(audio->context);
pa_context_unref(audio->context);
}
if (audio->loop) pa_mainloop_free(audio->loop);
if (audio->encoder) opus_encoder_destroy(audio->encoder);
free(audio->source);
free(audio);
}
static void connect_source(UuAudio *audio, const char *source) {
if (!source || !*source) { audio->failed = 1; return; }
pa_sample_spec spec = { PA_SAMPLE_S16NE, 48000, 2 };
audio->stream = pa_stream_new(audio->context, L("UU 远程音频", "UU Remote audio"), &spec, NULL);
pa_buffer_attr attr = { (uint32_t)-1, (uint32_t)-1, (uint32_t)-1, (uint32_t)-1, sizeof(audio->pcm) };
if (!audio->stream || pa_stream_connect_record(audio->stream, source, &attr,
PA_STREAM_ADJUST_LATENCY | PA_STREAM_DONT_MOVE) < 0) audio->failed = 1;
}
static void source_info(pa_context *context, const pa_source_info *info, int end, void *data) {
(void)context;
UuAudio *audio = data;
if (info && !audio->stream) connect_source(audio, info->name);
if (end && !audio->stream) audio->failed = 1;
}
static void sink_info(pa_context *context, const pa_sink_info *info, int end, void *data) {
(void)context;
UuAudio *audio = data;
if (info && !audio->stream) connect_source(audio, info->monitor_source_name);
if (end && !audio->stream) audio->failed = 1;
}
static void server_info(pa_context *context, const pa_server_info *info, void *data) {
UuAudio *audio = data;
if (!info || !info->default_sink_name) { audio->failed = 1; return; }
pa_operation *op = pa_context_get_sink_info_by_name(context, info->default_sink_name, sink_info, audio);
if (op) pa_operation_unref(op);
else audio->failed = 1;
}
UuAudio *uu_audio_open(const char *source) {
UuAudio *audio = calloc(1, sizeof(*audio));
if (!audio) return NULL;
int error;
audio->source = strdup(source);
audio->encoder = opus_encoder_create(48000, 2, OPUS_APPLICATION_RESTRICTED_LOWDELAY, &error);
audio->loop = pa_mainloop_new();
if (!audio->source || !audio->encoder || !audio->loop) goto fail;
if (opus_encoder_ctl(audio->encoder, OPUS_SET_BITRATE(128000)) != OPUS_OK) goto fail;
audio->context = pa_context_new(pa_mainloop_get_api(audio->loop), "UU Remote");
if (!audio->context || pa_context_connect(audio->context, NULL, PA_CONTEXT_NOAUTOSPAWN, NULL) < 0) goto fail;
return audio;
fail:
uu_audio_close(audio);
return NULL;
}
/* Nonblocking: the Rust worker checks cancellation between calls, including on a suspended sink. */
int uu_audio_packet(UuAudio *audio, uint8_t *packet, int capacity) {
int result;
if (pa_mainloop_iterate(audio->loop, 0, &result) < 0) return -1;
pa_context_state_t state = pa_context_get_state(audio->context);
if (!PA_CONTEXT_IS_GOOD(state) || audio->failed) return -2;
if (state != PA_CONTEXT_READY) return 0;
if (!audio->connecting) {
audio->connecting = 1;
if (strcmp(audio->source, "@DEFAULT_MONITOR@") == 0) {
pa_operation *op = pa_context_get_server_info(audio->context, server_info, audio);
if (op) pa_operation_unref(op);
else return -3;
} else {
pa_operation *op = pa_context_get_source_info_by_name(audio->context, audio->source, source_info, audio);
if (op) pa_operation_unref(op);
else return -3;
}
}
if (!audio->stream) return 0;
pa_stream_state_t stream_state = pa_stream_get_state(audio->stream);
if (!PA_STREAM_IS_GOOD(stream_state)) return -4;
if (stream_state != PA_STREAM_READY) return 0;
const void *buffer;
size_t length;
if (pa_stream_peek(audio->stream, &buffer, &length) < 0) return -5;
if (!length) return 0;
if (audio->offset > length) return -6;
size_t copy = sizeof(audio->pcm) - audio->filled;
if (copy > length - audio->offset) copy = length - audio->offset;
if (buffer) memcpy((uint8_t *)audio->pcm + audio->filled, (const uint8_t *)buffer + audio->offset, copy);
else memset((uint8_t *)audio->pcm + audio->filled, 0, copy);
audio->filled += copy;
audio->offset += copy;
if (audio->offset == length) {
if (pa_stream_drop(audio->stream) < 0) return -7;
audio->offset = 0;
}
if (audio->filled < sizeof(audio->pcm)) return 0;
audio->filled = 0;
return opus_encode(audio->encoder, audio->pcm, 960, packet, capacity);
}
+10
View File
@@ -0,0 +1,10 @@
#ifndef UU_DMABUF_FRAME_H
#define UU_DMABUF_FRAME_H
#include <stdint.h>
/* Borrowed single-plane RGB buffer. The producer retains ownership until the lease ends. */
typedef struct {
int32_t fd;
uint32_t fourcc, width, height, stride, offset, size;
uint64_t modifier;
} UuDmaFrame;
#endif
+289 -24
View File
@@ -16,6 +16,7 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <limits.h>
#define DEST "org.freedesktop.portal.Desktop"
#define PATH "/org/freedesktop/portal/desktop"
@@ -71,6 +72,11 @@ struct uu_portal {
size_t frame_length;
uint64_t sequence;
uint64_t revision;
uint32_t buffers_seen, last_buffer_type;
int dma_requested, dma_negotiated, dma_format, dma_bad, dma_blocked, dma_neutral, dma_seen;
uint64_t modifier;
gint64 dma_requested_at;
struct pw_buffer *dma_pending, *dma_current;
};
#include "portal_clipboard.inc"
@@ -223,11 +229,17 @@ static void stream_state(void *data, enum pw_stream_state old, enum pw_stream_st
pthread_mutex_unlock(&p->lock);
if (state == PW_STREAM_STATE_ERROR || state == PW_STREAM_STATE_UNCONNECTED) fail(data, 9);
}
static void return_dma_buffer(struct uu_portal *p, struct pw_buffer **buffer);
static void stream_format(void *data, uint32_t id, const struct spa_pod *param) {
struct uu_portal *p = data;
if (id != SPA_PARAM_Format) return;
if (!param) {
pthread_mutex_lock(&p->lock);
if (p->dma_format) {
return_dma_buffer(p, &p->dma_pending);
return_dma_buffer(p, &p->dma_current);
p->sequence = 0;
}
p->format_valid = 0;
update_interruption(p);
pthread_mutex_unlock(&p->lock);
@@ -239,6 +251,11 @@ static void stream_format(void *data, uint32_t id, const struct spa_pod *param)
(info.format != SPA_VIDEO_FORMAT_BGRA && info.format != SPA_VIDEO_FORMAT_BGRx &&
info.format != SPA_VIDEO_FORMAT_RGBA && info.format != SPA_VIDEO_FORMAT_RGBx)) { fail(p, 8); return; }
pthread_mutex_lock(&p->lock);
if (p->dma_format) {
return_dma_buffer(p, &p->dma_pending);
return_dma_buffer(p, &p->dma_current);
p->sequence = 0;
}
if (p->width && (p->width != info.size.width || p->height != info.size.height)) {
p->error = 8; pthread_cond_broadcast(&p->changed); pthread_mutex_unlock(&p->lock); return;
}
@@ -246,12 +263,70 @@ static void stream_format(void *data, uint32_t id, const struct spa_pod *param)
if (!p->frame) p->frame = malloc(length);
if (!p->frame) { p->error = 8; pthread_mutex_unlock(&p->lock); return; }
p->width = info.size.width; p->height = info.size.height; p->format = info.format;
p->dma_format = spa_pod_find_prop(param, NULL, SPA_FORMAT_VIDEO_modifier) != NULL;
p->modifier = info.modifier;
p->dma_negotiated = p->dma_requested;
p->buffers_seen = 0;
p->frame_length = length;
p->format_valid = 1;
p->display_changed_at = 0;
update_interruption(p);
pthread_cond_broadcast(&p->changed);
pthread_mutex_unlock(&p->lock);
fprintf(stderr, "Portal capture format: format=%u size=%ux%u dma_buf=%d dma_requested=%d modifier=%llu\n",
info.format, info.size.width, info.size.height, p->dma_format, p->dma_requested, (unsigned long long)info.modifier);
/* PipeWire DMA-BUF sharing: modifier formats require DMA buffers exclusively.
* Keep a current and a pending frame; at least four buffers prevent producer starvation. */
if (p->stream) {
uint8_t storage[256];
struct spa_pod_builder builder = SPA_POD_BUILDER_INIT(storage, sizeof(storage));
const struct spa_pod *buffers = spa_pod_builder_add_object(&builder, SPA_TYPE_OBJECT_ParamBuffers, SPA_PARAM_Buffers,
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(4, 4, 8),
SPA_PARAM_BUFFERS_dataType, SPA_POD_CHOICE_FLAGS_Int(p->dma_format ?
(1 << SPA_DATA_DmaBuf) : ((1 << SPA_DATA_MemPtr) | (1 << SPA_DATA_MemFd))));
pw_stream_update_params(p->stream, &buffers, 1);
}
}
/* All pending/current buffer changes run under the PipeWire loop lock, then p->lock. */
static void return_dma_buffer(struct uu_portal *p, struct pw_buffer **buffer) {
if (*buffer && p->stream) pw_stream_queue_buffer(p->stream, *buffer);
*buffer = NULL;
}
static int describe_dma_buffer(struct uu_portal *p, struct spa_buffer *spa, UuDmaFrame *frame) {
if (p->error || atomic_load(&p->closed)) return 10;
if (p->modifier != 0) return 19;
if (!p->format_valid || !p->width || !p->height || spa->n_datas != 1) return 14;
struct spa_data *d = &spa->datas[0];
struct spa_meta_header *header = spa_buffer_find_meta_data(spa, SPA_META_Header, sizeof(*header));
if (!d->chunk || (d->chunk->flags & SPA_CHUNK_FLAG_CORRUPTED) ||
(header && (header->flags & SPA_META_HEADER_FLAG_CORRUPTED))) return 10;
if (d->chunk->flags & SPA_CHUNK_FLAG_EMPTY) return 15;
struct spa_meta_region *crop = spa_buffer_find_meta_data(spa, SPA_META_VideoCrop, sizeof(*crop));
if (crop && spa_meta_region_is_valid(crop) && (crop->region.position.x || crop->region.position.y ||
crop->region.size.width != p->width || crop->region.size.height != p->height)) return 14;
/* Explicit sync is not advertised; require implicit DMA-BUF fences understood by VAAPI. */
#if PW_CHECK_VERSION(1, 2, 0)
if (spa_buffer_find_meta(spa, SPA_META_SyncTimeline)) return 18;
#endif
if (d->type != SPA_DATA_DmaBuf || d->fd < 0 || d->fd > INT_MAX || d->chunk->stride < (int64_t)p->width * 4)
return 14;
uint64_t offset = (uint64_t)d->mapoffset + d->chunk->offset;
uint64_t size = (uint64_t)d->mapoffset + d->maxsize;
uint64_t required = offset + (uint64_t)(p->height - 1) * d->chunk->stride + (uint64_t)p->width * 4;
if (required > size || size > UINT32_MAX) return 14;
if (required - offset > d->chunk->size) return 10;
uint32_t fourcc;
switch (p->format) {
case SPA_VIDEO_FORMAT_BGRx: fourcc=0x34325258; break;
case SPA_VIDEO_FORMAT_BGRA: fourcc=0x34325241; break;
case SPA_VIDEO_FORMAT_RGBx: fourcc=0x34324258; break;
case SPA_VIDEO_FORMAT_RGBA: fourcc=0x34324241; break;
default: return 14;
}
*frame = (UuDmaFrame){ .fd=d->fd, .fourcc=fourcc, .width=p->width, .height=p->height,
.stride=d->chunk->stride, .offset=offset, .size=size, .modifier=p->modifier };
return 0;
}
/* Called with the frame mutex held. Invalid transient chunks are discarded;
* allocation capacity is not evidence that valid pixels have been supplied. */
@@ -301,14 +376,131 @@ static void stream_process(void *data) {
}
if (!newest) return;
pthread_mutex_lock(&p->lock);
copy_video_buffer(p, newest->buffer);
p->buffers_seen++;
p->last_buffer_type = newest->buffer->n_datas ? newest->buffer->datas[0].type : 0;
if (p->dma_format) {
UuDmaFrame frame;
int result = describe_dma_buffer(p, newest->buffer, &frame);
if (result == 0 && p->dma_requested && !p->dma_blocked) {
return_dma_buffer(p, &p->dma_pending);
p->dma_pending = newest;
newest = NULL;
p->dma_seen = 1;
p->sequence++; p->revision++; p->dma_neutral = 0;
} else if (result == 15) {
return_dma_buffer(p, &p->dma_pending);
return_dma_buffer(p, &p->dma_current);
p->dma_neutral = 1; p->sequence++; p->revision++;
} else if (result != 10) p->dma_bad = result;
} else copy_video_buffer(p, newest->buffer);
pthread_cond_broadcast(&p->changed);
pthread_mutex_unlock(&p->lock);
pw_stream_queue_buffer(p->stream, newest);
if (newest) pw_stream_queue_buffer(p->stream, newest);
}
static void stream_remove_buffer(void *data, struct pw_buffer *buffer) {
struct uu_portal *p = data;
pthread_mutex_lock(&p->lock);
if (p->dma_pending == buffer) p->dma_pending = NULL;
if (p->dma_current == buffer) p->dma_current = NULL;
pthread_mutex_unlock(&p->lock);
}
static const struct pw_stream_events stream_events = {
PW_VERSION_STREAM_EVENTS, .state_changed = stream_state, .param_changed = stream_format, .process = stream_process
PW_VERSION_STREAM_EVENTS, .state_changed = stream_state, .param_changed = stream_format, .process = stream_process,
.remove_buffer = stream_remove_buffer
};
static unsigned capture_formats(struct uu_portal *p, struct spa_pod_builder *b, const struct spa_pod **params, int dma) {
unsigned count = 0;
/* Only advertise linear RGB: arbitrary tiling/compression cannot be inferred from an FD.
* PipeWire page_dma_buf: put the modifier format before the shared-memory fallback. */
for (int with_modifier = dma; with_modifier >= 0; with_modifier--) {
struct spa_pod_frame frame;
spa_pod_builder_push_object(b, &frame, SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat);
spa_pod_builder_add(b,
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_video),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_VIDEO_format, SPA_POD_CHOICE_ENUM_Id(4, SPA_VIDEO_FORMAT_BGRA, SPA_VIDEO_FORMAT_BGRx, SPA_VIDEO_FORMAT_RGBA, SPA_VIDEO_FORMAT_RGBx),
0);
if (p->width && p->height) spa_pod_builder_add(b,
SPA_FORMAT_VIDEO_size, SPA_POD_Rectangle(&SPA_RECTANGLE(p->width,p->height)), 0);
else spa_pod_builder_add(b, SPA_FORMAT_VIDEO_size,
SPA_POD_CHOICE_RANGE_Rectangle(&SPA_RECTANGLE(1920,1080), &SPA_RECTANGLE(1,1), &SPA_RECTANGLE(8192,8192)), 0);
spa_pod_builder_add(b,
SPA_FORMAT_VIDEO_framerate, SPA_POD_CHOICE_RANGE_Fraction(&SPA_FRACTION(60,1), &SPA_FRACTION(0,1), &SPA_FRACTION(60,1)), 0);
if (with_modifier) {
spa_pod_builder_prop(b, SPA_FORMAT_VIDEO_modifier, SPA_POD_PROP_FLAG_MANDATORY);
spa_pod_builder_long(b, 0); /* DRM_FORMAT_MOD_LINEAR */
}
params[count++] = spa_pod_builder_pop(b, &frame);
}
params[count++] = spa_pod_builder_add_object(b, SPA_TYPE_OBJECT_ParamBuffers, SPA_PARAM_Buffers,
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(4, 4, 8),
SPA_PARAM_BUFFERS_dataType, SPA_POD_CHOICE_FLAGS_Int((1 << SPA_DATA_MemPtr) | (1 << SPA_DATA_MemFd) |
(dma ? (1 << SPA_DATA_DmaBuf) : 0)));
return count;
}
static int request_capture_formats(struct uu_portal *p, int dma) {
uint8_t storage[2048];
struct spa_pod_builder b = SPA_POD_BUILDER_INIT(storage, sizeof(storage));
const struct spa_pod *params[3];
unsigned count = capture_formats(p, &b, params, dma);
return pw_stream_update_params(p->stream, params, count);
}
int uu_portal_dmabuf_acquire(struct uu_portal *p, UuDmaFrame *frame, uint64_t *revision) {
if (!p || !p->pw_loop || !p->stream || !frame || !revision) return 14;
pw_thread_loop_lock(p->pw_loop);
pthread_mutex_lock(&p->lock);
int result = 10;
if (atomic_load(&p->closed) || p->error || p->dma_blocked) result = 14;
else if (p->dma_bad) result = p->dma_bad;
else if (!p->dma_requested) {
p->dma_requested = 1; p->dma_negotiated = 0; p->dma_seen = 0;
p->dma_requested_at = g_get_monotonic_time();
pthread_mutex_unlock(&p->lock);
int status = request_capture_formats(p, 1);
pw_thread_loop_unlock(p->pw_loop);
return status < 0 ? 14 : 10;
} else if (p->dma_negotiated && !p->dma_format) result = 16;
else if (!p->dma_seen && !p->dma_neutral &&
g_get_monotonic_time() - p->dma_requested_at > 2 * G_TIME_SPAN_SECOND) result = 17;
else if (p->dma_neutral) result = 15;
else if (p->dma_format && p->format_valid) {
if (p->dma_pending) {
return_dma_buffer(p, &p->dma_current);
p->dma_current = p->dma_pending; p->dma_pending = NULL;
}
if (p->dma_current) {
result = describe_dma_buffer(p, p->dma_current->buffer, frame);
if (!result) {
result = *revision == p->revision ? 12 : 0;
*revision = p->revision;
}
}
}
pthread_mutex_unlock(&p->lock);
/* A lease pins both the pw_buffer and its format across VAAPI's completion fence.
* No producer buffer may be returned, removed or renegotiated while the GPU reads it. */
if (result != 0 && result != 12) pw_thread_loop_unlock(p->pw_loop);
return result;
}
void uu_portal_dmabuf_release(struct uu_portal *p) {
pw_thread_loop_unlock(p->pw_loop);
}
void uu_portal_dmabuf_disable(struct uu_portal *p) {
if (!p || !p->pw_loop || !p->stream) return;
pw_thread_loop_lock(p->pw_loop);
pthread_mutex_lock(&p->lock);
int requested = p->dma_requested;
if (requested) {
p->dma_requested = 0; p->dma_blocked = 1; p->dma_neutral = 0;
return_dma_buffer(p, &p->dma_pending); return_dma_buffer(p, &p->dma_current);
if (p->dma_format) { p->sequence = 0; p->revision++; }
}
pthread_mutex_unlock(&p->lock);
if (requested) request_capture_formats(p, 0);
pw_thread_loop_unlock(p->pw_loop);
}
static int connect_pipewire(struct uu_portal *p) {
if (open_cancelled(p)) return 13;
GUnixFDList *fds = NULL;
@@ -337,36 +529,45 @@ static int connect_pipewire(struct uu_portal *p) {
PW_KEY_MEDIA_TYPE, "Video", PW_KEY_MEDIA_CATEGORY, "Capture", PW_KEY_MEDIA_ROLE, "Screen", NULL));
if (!p->stream) return 7;
pw_stream_add_listener(p->stream, &p->stream_listener, &stream_events, p);
uint8_t storage[1024]; struct spa_pod_builder builder = SPA_POD_BUILDER_INIT(storage, sizeof(storage));
const struct spa_pod *params[2];
params[0] = spa_pod_builder_add_object(&builder, SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_video), SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_VIDEO_format, SPA_POD_CHOICE_ENUM_Id(4, SPA_VIDEO_FORMAT_BGRA, SPA_VIDEO_FORMAT_BGRx, SPA_VIDEO_FORMAT_RGBA, SPA_VIDEO_FORMAT_RGBx),
SPA_FORMAT_VIDEO_size, SPA_POD_CHOICE_RANGE_Rectangle(&SPA_RECTANGLE(1920,1080), &SPA_RECTANGLE(1,1), &SPA_RECTANGLE(8192,8192)),
SPA_FORMAT_VIDEO_framerate, SPA_POD_CHOICE_RANGE_Fraction(&SPA_FRACTION(60,1), &SPA_FRACTION(0,1), &SPA_FRACTION(60,1)));
params[1] = spa_pod_builder_add_object(&builder, SPA_TYPE_OBJECT_ParamBuffers, SPA_PARAM_Buffers,
SPA_PARAM_BUFFERS_dataType, SPA_POD_CHOICE_FLAGS_Int((1 << SPA_DATA_MemPtr) | (1 << SPA_DATA_MemFd)));
uint8_t storage[2048]; struct spa_pod_builder builder = SPA_POD_BUILDER_INIT(storage, sizeof(storage));
const struct spa_pod *params[3];
unsigned param_count = capture_formats(p, &builder, params, p->dma_requested);
p->dma_requested_at = g_get_monotonic_time();
/* Node ID belongs to this portal's restricted remote. Do not put it into
* target.object, whose numeric value means object.serial on modern PW. */
if (pw_stream_connect(p->stream, PW_DIRECTION_INPUT, p->node,
PW_STREAM_FLAG_AUTOCONNECT | PW_STREAM_FLAG_MAP_BUFFERS, params, 2) < 0) return 7;
PW_STREAM_FLAG_AUTOCONNECT | PW_STREAM_FLAG_MAP_BUFFERS, params, param_count) < 0) return 7;
if (pw_thread_loop_start(p->pw_loop) < 0) return 7;
return wait_for_first_frame(p);
int result = wait_for_first_frame(p);
pthread_mutex_lock(&p->lock);
int fallback = (result == 10 || result == 14) && p->dma_requested && !p->error &&
!atomic_load(&p->closed) && !open_cancelled(p);
int dma_status = p->dma_bad;
pthread_mutex_unlock(&p->lock);
if (fallback) {
fprintf(stderr, "Portal initial DMA-BUF unavailable: status=%d; falling back to shared-memory capture\n", dma_status);
uu_portal_dmabuf_disable(p);
result = wait_for_first_frame(p);
}
return result;
}
static int wait_for_first_frame(struct uu_portal *p) {
struct timespec until;
gint64 deadline = g_get_monotonic_time() + 10 * G_TIME_SPAN_SECOND;
pthread_mutex_lock(&p->lock);
while (!p->sequence && !p->error && !open_cancelled(p)) {
while (!p->sequence && !p->error && !open_cancelled(p) && !(p->dma_requested && p->dma_bad)) {
gint64 remaining = deadline - g_get_monotonic_time();
if (remaining <= 0) break;
clock_gettime(CLOCK_REALTIME, &until);
clock_gettime(CLOCK_MONOTONIC, &until);
gint64 wait_us = MIN(100000, remaining);
until.tv_nsec += wait_us * 1000;
if (until.tv_nsec >= 1000000000) { until.tv_sec++; until.tv_nsec -= 1000000000; }
pthread_cond_timedwait(&p->changed, &p->lock, &until);
}
int result = p->error ? p->error : open_cancelled(p) ? 13 : p->sequence ? 0 : 10;
int result = p->error ? p->error : open_cancelled(p) ? 13 : p->sequence ? 0 :
p->dma_requested && p->dma_bad ? 14 : 10;
if (result == 10) fprintf(stderr, "Portal first-frame timeout: format_valid=%d dma_buf=%d dma_requested=%d buffers=%u last_type=%u dma_status=%d\n",
p->format_valid, p->dma_format, p->dma_requested, p->buffers_seen, p->last_buffer_type, p->dma_bad);
pthread_mutex_unlock(&p->lock);
return result;
}
@@ -393,14 +594,21 @@ static int read_stream_result(struct uu_portal *p, GVariant *results) {
if (streams) g_variant_unref(streams);
return error;
}
static void save_restore_token(struct uu_portal *p, void (*save_token)(const char *, void *),
uu_portal_save_detailed_fn save_detailed, void *save_data) {
if (!p->restore_token) return;
if (save_token) save_token(p->restore_token, save_data);
if (save_detailed) save_detailed(p->restore_token, save_data, p->has_position, p->position_x, p->position_y);
}
static struct uu_portal *open_persist(const char *restore, void (*save_token)(const char *, void *),
void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data,
int *error, uint32_t *width, uint32_t *height) {
uu_portal_save_detailed_fn save_detailed, void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data,
int prefer_dmabuf, int *error, uint32_t *width, uint32_t *height, uint32_t source_types) {
*error = 0; *width = *height = 0;
struct uu_portal *p = calloc(1, sizeof(*p));
if (!p) { *error = 8; return NULL; }
p->cancelled = cancelled;
p->cancel_data = cancel_data;
p->dma_requested = !!prefer_dmabuf;
/* GNOME forwards NotifyPointerMotionAbsolute into Mutter's stream-to-stage
* transform. It expects stream pixels, unlike the compositor-sized KDE path.
* Do not apply the compositor scale twice on fractional-scale displays. */
@@ -408,7 +616,12 @@ static struct uu_portal *open_persist(const char *restore, void (*save_token)(co
for (gchar **desktop = desktops; *desktop; desktop++)
if (!g_ascii_strcasecmp(*desktop, "GNOME")) p->absolute_stream_pixels = 1;
g_strfreev(desktops);
pthread_mutex_init(&p->lock, NULL); pthread_cond_init(&p->changed, NULL);
pthread_mutex_init(&p->lock, NULL);
pthread_condattr_t cond_attr;
pthread_condattr_init(&cond_attr);
pthread_condattr_setclock(&cond_attr, CLOCK_MONOTONIC);
pthread_cond_init(&p->changed, &cond_attr);
pthread_condattr_destroy(&cond_attr);
p->context = g_main_context_new(); g_main_context_push_thread_default(p->context);
p->bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
if (!p->bus) { *error = 1; goto done; }
@@ -442,7 +655,8 @@ static struct uu_portal *open_persist(const char *restore, void (*save_token)(co
if (!results) goto done;
g_variant_unref(results);
g_variant_builder_init(&options, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add(&options, "{sv}", "types", g_variant_new_uint32(1));
/* 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. */
results = request(p, SCREEN, "SelectSources", &options, 1, error);
@@ -472,7 +686,7 @@ static struct uu_portal *open_persist(const char *restore, void (*save_token)(co
fprintf(stderr, "Portal persistence: requested=%d restore_attempted=%d token_returned=%d\n",
version >= 2, restore && *restore, p->restore_token && *p->restore_token);
}
if (!*error && p->restore_token && save_token) save_token(p->restore_token, save_data);
if (!*error) save_restore_token(p, save_token, save_detailed, save_data);
g_variant_unref(results);
if (*error) goto done;
p->main_loop = g_main_loop_new(p->context, FALSE);
@@ -505,11 +719,27 @@ struct uu_portal *uu_portal_open_persist_cancellable(const char *restore,
void (*save_token)(const char *, void *), void *save_data,
uu_portal_cancelled_fn cancelled, void *cancel_data,
int *error, uint32_t *width, uint32_t *height) {
return open_persist(restore, save_token, save_data, cancelled, cancel_data, error, width, height);
return open_persist(restore, save_token, NULL, save_data, cancelled, cancel_data, 0, error, width, height, 1);
}
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) {
return open_persist(restore, save_token, NULL, save_data, cancelled, cancel_data, prefer_dmabuf, error, width, height, 1);
}
struct uu_portal *uu_portal_open_persist(const char *restore, void (*save_token)(const char *, void *),
void *data, int *error, uint32_t *width, uint32_t *height) {
return open_persist(restore, save_token, data, NULL, NULL, error, width, height);
return open_persist(restore, save_token, NULL, data, NULL, NULL, 0, error, width, height, 1);
}
struct uu_portal *uu_portal_open_virtual(const char *restore, void (*save_token)(const char *, void *),
void *data, int *error, uint32_t *width, uint32_t *height) {
return open_persist(restore, save_token, NULL, data, NULL, NULL, 0, error, width, height, 4);
}
struct uu_portal *uu_portal_open_detailed(const char *restore, uu_portal_save_detailed_fn save_token,
void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data, int prefer_dmabuf,
uint32_t source_types, int *error, uint32_t *width, uint32_t *height) {
if (source_types != 1 && source_types != 4) { *error = 3; *width = *height = 0; return NULL; }
return open_persist(restore, NULL, save_token, save_data, cancelled, cancel_data, prefer_dmabuf, error, width, height, source_types);
}
struct uu_portal *uu_portal_open_restore(const char *restore, int *error, uint32_t *width, uint32_t *height) {
return uu_portal_open_persist(restore, NULL, NULL, error, width, height);
@@ -556,11 +786,15 @@ void uu_portal_close(struct uu_portal *p) {
}
void uu_portal_reset_frame(struct uu_portal *p) {
if (!p) return;
if (p->pw_loop) pw_thread_loop_lock(p->pw_loop);
pthread_mutex_lock(&p->lock);
return_dma_buffer(p, &p->dma_pending); return_dma_buffer(p, &p->dma_current);
p->dma_neutral = 0;
p->sequence = 0;
p->revision++;
if (p->frame) memset(p->frame, 0, p->frame_length);
pthread_mutex_unlock(&p->lock);
if (p->pw_loop) pw_thread_loop_unlock(p->pw_loop);
}
int uu_portal_capture(struct uu_portal *p, uint8_t *frame, size_t length) {
return uu_portal_capture_since(p, frame, length, NULL);
@@ -577,6 +811,7 @@ static int stream_stalled(struct uu_portal *p) {
}
int uu_portal_capture_since(struct uu_portal *p, uint8_t *frame, size_t length, uint64_t *revision) {
if (!p || !frame) return 11;
uu_portal_dmabuf_disable(p);
pthread_mutex_lock(&p->lock);
int result = atomic_load(&p->closed) ? 9 : p->error ? p->error : stream_stalled(p) ? 9 :
!p->sequence ? 10 : length != p->frame_length ? 11 : 0;
@@ -602,6 +837,36 @@ int uu_portal_capture_alive(struct uu_portal *p) {
pthread_mutex_unlock(&p->lock);
return alive;
}
int uu_portal_wait_frame(struct uu_portal *p, int64_t timeout_us) {
if (!p || atomic_load(&p->closed)) return -1;
pthread_mutex_lock(&p->lock);
if (p->error || atomic_load(&p->closed) || stream_stalled(p)) {
pthread_mutex_unlock(&p->lock);
return -1;
}
uint64_t prev_seq = p->sequence;
if (timeout_us <= 0) {
int ready = (p->sequence != prev_seq);
pthread_mutex_unlock(&p->lock);
return ready;
}
struct timespec until;
clock_gettime(CLOCK_MONOTONIC, &until);
until.tv_sec += timeout_us / 1000000LL;
until.tv_nsec += (long)(timeout_us % 1000000LL) * 1000L;
if (until.tv_nsec >= 1000000000L) {
until.tv_sec += 1;
until.tv_nsec -= 1000000000L;
}
while (p->sequence == prev_seq && !p->error && !atomic_load(&p->closed) && !stream_stalled(p)) {
int rc = pthread_cond_timedwait(&p->changed, &p->lock, &until);
if (rc != 0) break; // timeout or error
}
int res = (p->error || atomic_load(&p->closed) || stream_stalled(p)) ? -1 :
(p->sequence != prev_seq) ? 1 : 0;
pthread_mutex_unlock(&p->lock);
return res;
}
void uu_portal_input_dispatch(struct uu_portal *p) {
if (p->ei) portal_eis_dispatch(p);
}
+16
View File
@@ -2,14 +2,21 @@
#define UU_PORTAL_ENGINE_H
#include <stddef.h>
#include <stdint.h>
#include "dmabuf_frame.h"
struct uu_portal;
typedef int (*uu_portal_cancelled_fn)(void *data);
typedef void (*uu_portal_save_detailed_fn)(const char *token, void *data, int has_position, int32_t x, int32_t y);
/* Reports the granted position alongside the rotated token before video initialization. */
struct uu_portal *uu_portal_open_detailed(const char *restore, uu_portal_save_detailed_fn save_token, void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data, int prefer_dmabuf, uint32_t source_types, int *error, uint32_t *width, uint32_t *height);
/* One object owns one consent/session and one PipeWire stream. */
struct uu_portal *uu_portal_open(int *error, uint32_t *width, uint32_t *height);
/* Saves the rotated token immediately after Start, before video initialization. */
struct uu_portal *uu_portal_open_virtual(const char *restore, void (*save_token)(const char *, void *), void *data, int *error, uint32_t *width, uint32_t *height);
struct uu_portal *uu_portal_open_persist(const char *restore, void (*save_token)(const char *, void *), void *data, int *error, uint32_t *width, uint32_t *height);
/* The cancellation callback and data are used only until this call returns. */
struct uu_portal *uu_portal_open_persist_cancellable(const char *restore, void (*save_token)(const char *, void *), void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data, int *error, uint32_t *width, uint32_t *height);
/* 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);
const char *uu_portal_restore_token(struct uu_portal *portal);
void uu_portal_close(struct uu_portal *portal);
@@ -18,11 +25,20 @@ int uu_portal_clipboard_set(struct uu_portal *portal, const uint8_t *text, size_
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);
/* Wait for a new frame or status change with a timeout in microseconds.
* Returns 1 if a new frame or status change occurred, 0 on timeout, <0 on closed/error. */
int uu_portal_wait_frame(struct uu_portal *portal, int64_t timeout_us);
void uu_portal_input_dispatch(struct uu_portal *portal);
void uu_portal_logical_size(struct uu_portal *portal, uint32_t *width, uint32_t *height);
void uu_portal_reset_frame(struct uu_portal *portal);
int uu_portal_capture(struct uu_portal *portal, uint8_t *bgra, size_t length);
int uu_portal_capture_since(struct uu_portal *portal, uint8_t *bgra, size_t length, uint64_t *revision);
/* acquire holds the PipeWire loop until release, including GPU completion.
* 0/12 = leased new/unchanged frame, 10 = pending, 15 = neutral black.
* CPU fallback: 14 layout/disabled, 16 shared memory, 17 timeout, 18 explicit sync, 19 modifier. */
int uu_portal_dmabuf_acquire(struct uu_portal *portal, UuDmaFrame *frame, uint64_t *revision);
void uu_portal_dmabuf_release(struct uu_portal *portal);
void uu_portal_dmabuf_disable(struct uu_portal *portal);
int uu_portal_move(struct uu_portal *portal, double x, double y, int relative);
int uu_portal_button(struct uu_portal *portal, int button, int pressed);
int uu_portal_scroll(struct uu_portal *portal, double dx, double dy, int finish);
+88
View File
@@ -0,0 +1,88 @@
// Privacy screen, wallpaper mode: a fullscreen keep-above window on each physical monitor showing
// a picture and a notice, while the remote session works on a KWin virtual output. Runs in its own
// process (`uuremote-server privacy-wallpaper`), which the host kills on restore.
#include <gtk/gtk.h>
#include <stdio.h>
#include <stdlib.h>
#include "i18n.h"
typedef struct { int x, y, w, h; } Rect;
static GdkPixbuf *picture;
static gboolean host_closed(GIOChannel *channel, GIOCondition condition, gpointer data) {
(void)channel; (void)condition; (void)data;
gtk_main_quit();
return G_SOURCE_REMOVE;
}
static gboolean draw(GtkWidget *widget, cairo_t *cr, gpointer data) {
(void)data;
int w = gtk_widget_get_allocated_width(widget), h = gtk_widget_get_allocated_height(widget);
cairo_set_source_rgb(cr, 0, 0, 0); cairo_paint(cr);
if (picture) {
// Cover: scale to fill, crop the overflow, keep the aspect ratio.
double pw = gdk_pixbuf_get_width(picture), ph = gdk_pixbuf_get_height(picture);
double s = w / pw > h / ph ? w / pw : h / ph;
cairo_save(cr);
cairo_translate(cr, (w - pw * s) / 2, (h - ph * s) / 2);
cairo_scale(cr, s, s);
gdk_cairo_set_source_pixbuf(cr, picture, 0, 0);
cairo_paint(cr);
cairo_restore(cr);
}
PangoLayout *layout = gtk_widget_create_pango_layout(widget, L("此设备正在被远程控制", "This device is being remotely controlled"));
PangoFontDescription *font = pango_font_description_from_string("Sans 20");
pango_layout_set_font_description(layout, font);
int tw, th; pango_layout_get_pixel_size(layout, &tw, &th);
cairo_set_source_rgba(cr, 0, 0, 0, 0.45);
cairo_rectangle(cr, (w - tw) / 2.0 - 24, h - th - 96, tw + 48, th + 32); cairo_fill(cr);
cairo_set_source_rgb(cr, 1, 1, 1);
cairo_move_to(cr, (w - tw) / 2.0, h - th - 80);
pango_cairo_show_layout(cr, layout);
pango_font_description_free(font); g_object_unref(layout);
return TRUE;
}
/* `rects` are the physical outputs in logical coordinates; monitors elsewhere (the virtual output)
* stay uncovered. Returns when every window is closed or the process is killed. */
int uu_privacy_wallpaper_run(const char *image, const int *rects, int count) {
if (!gtk_init_check(NULL, NULL)) return 1;
if (image && *image) picture = gdk_pixbuf_new_from_file(image, NULL);
GdkDisplay *display = gdk_display_get_default();
int shown = 0;
for (int i = 0; i < gdk_display_get_n_monitors(display); i++) {
GdkMonitor *monitor = gdk_display_get_monitor(display, i);
GdkRectangle g; gdk_monitor_get_geometry(monitor, &g);
int physical = 0;
for (int r = 0; r < count; r++) {
const int *c = rects + r * 4;
if (c[0] == g.x && c[1] == g.y && c[2] == g.width && c[3] == g.height) physical = 1;
}
if (!physical) continue;
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "uu-remote-linux privacy");
gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
gtk_window_set_keep_above(GTK_WINDOW(window), TRUE);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(window), TRUE);
gtk_window_set_skip_pager_hint(GTK_WINDOW(window), TRUE);
gtk_window_set_default_size(GTK_WINDOW(window), g.width, g.height);
g_signal_connect(window, "draw", G_CALLBACK(draw), NULL);
g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
gtk_window_fullscreen_on_monitor(GTK_WINDOW(window), gtk_widget_get_screen(window), i);
gtk_widget_show_all(window);
shown++;
}
if (!shown) return 2;
/* Map the covers before reporting ready: the host marks them skip-taskbar through KWin right
after this line, and KWin can only list windows whose surfaces already exist. */
while (gtk_events_pending()) gtk_main_iteration_do(FALSE);
/* EOF follows the host process, including crashes, rather than its spawning worker thread. */
GIOChannel *host = g_io_channel_unix_new(0);
guint watch = g_io_add_watch(host, G_IO_HUP | G_IO_ERR | G_IO_NVAL, host_closed, NULL);
/* Readiness handshake: the host treats picture mode as on only after this line. */
fputs("ready\n", stdout); fflush(stdout);
gtk_main();
if (g_main_context_find_source_by_id(NULL, watch)) g_source_remove(watch);
g_io_channel_unref(host);
return 0;
}
+141
View File
@@ -0,0 +1,141 @@
// One palette for all GTK windows. Named GTK colors also follow live system theme changes.
#include "ui_theme.h"
#include "i18n.h"
#include <glib/gstdio.h>
#include <string.h>
static int initialized, mode;
static const char *modes[] = {"system", "light", "dark"};
static const char *CSS =
"* { font-family: 'Noto Sans CJK SC', 'Noto Sans SC', sans-serif; }\n"
"@define-color uu_bg mix(@theme_bg_color, @theme_base_color, 0.5);\n"
"@define-color uu_surface @theme_base_color;\n"
"@define-color uu_fg @theme_fg_color;\n"
"@define-color uu_muted mix(@theme_fg_color, @theme_bg_color, 0.25);\n"
"@define-color uu_border mix(@theme_bg_color, @theme_fg_color, 0.18);\n"
"@define-color uu_accent @theme_selected_bg_color;\n"
"@define-color uu_accent_fg @theme_selected_fg_color;\n"
"@define-color uu_tint mix(@theme_base_color, @theme_selected_bg_color, 0.12);\n"
"@define-color uu_success mix(@theme_fg_color, #16a34a, 0.55);\n"
"@define-color uu_error mix(@theme_fg_color, #dc2626, 0.65);\n"
"window { background-color: @uu_bg; color: @uu_fg; }\n"
"headerbar { background-image: none; background-color: @uu_bg; box-shadow: none; border-bottom: 1px solid @uu_border; }\n"
"button { background-image: none; background-color: @uu_surface; color: @uu_fg; border: 1px solid @uu_border; border-radius: 8px; box-shadow: none; text-shadow: none; padding: 7px 12px; }\n"
"button:hover { background-color: @uu_tint; border-color: @uu_accent; }\n"
"button:active, button:checked { background-color: @uu_tint; border-color: @uu_accent; }\n"
"button:disabled { color: mix(@uu_fg, @uu_surface, 0.55); background-color: @uu_bg; border-color: @uu_border; }\n"
"button:focus, entry:focus { border-color: @uu_accent; outline-color: @uu_accent; outline-style: solid; outline-width: 2px; outline-offset: 2px; }\n"
"entry { background-image: none; background-color: @uu_surface; color: @uu_fg; border: 1px solid @uu_border; border-radius: 8px; box-shadow: none; padding: 7px 10px; }\n"
"entry:disabled { color: @uu_muted; background-color: @uu_bg; }\n"
"separator { background-color: @uu_border; min-height: 1px; min-width: 1px; }\n"
".card, .cardbtn, .banner { background-color: @uu_surface; border: 1px solid @uu_border; border-radius: 12px; }\n"
".heading, .title, .h2, .user { font-size: 22px; font-weight: 700; color: @uu_fg; }\n"
".section, .group { font-size: 16px; font-weight: 600; color: @uu_fg; }\n"
".big { font-size: 32px; font-weight: 700; color: @uu_fg; }\n"
".key, .hint, .empty { font-size: 14px; color: @uu_muted; }\n"
".note, .footer { font-size: 13px; color: @uu_muted; }\n"
".status { font-size: 13px; color: @uu_muted; }\n"
".status.ok, .online, .dot { color: @uu_success; }\n"
".status.error { color: @uu_error; }\n"
".tag { background-color: @uu_tint; color: @uu_fg; border-radius: 6px; padding: 3px 8px; font-size: 12px; }\n"
".tag.remote { color: @uu_success; }\n"
"button.primary, button.enter { background-color: @uu_accent; color: @uu_accent_fg; border-color: transparent; font-weight: 600; padding: 9px 24px; }\n"
"button.primary:hover, button.enter:hover { background-color: shade(@uu_accent, 0.9); }\n"
"button.primary:active, button.enter:active { background-color: shade(@uu_accent, 0.8); }\n"
"button.primary:disabled, button.enter:disabled { background-color: @uu_bg; color: @uu_muted; border-color: @uu_border; }\n"
"button.flat, button.hbtn, button.tool { background-color: transparent; border-color: transparent; }\n"
"button.flat:hover, button.hbtn:hover, button.tool:hover, button.cardbtn:hover { background-color: @uu_tint; border-color: @uu_border; }\n"
".toast { background-color: @uu_fg; color: @uu_surface; border-radius: 10px; padding: 12px 18px; font-size: 14px; }\n"
".qrbox { background-color: white; border: 1px solid @uu_border; border-radius: 12px; padding: 14px; }\n";
void uu_theme_load_css(const char *css) {
GtkCssProvider *provider = gtk_css_provider_new();
GError *error = NULL;
if (gtk_css_provider_load_from_data(provider, css, -1, &error))
gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
else { g_warning("Could not load UI stylesheet"); g_clear_error(&error); }
g_object_unref(provider);
}
static char *theme_path(void) {
return g_build_filename(g_get_user_config_dir(), "uuremote", "theme", NULL);
}
static void apply_mode(void) {
GtkSettings *settings = gtk_settings_get_default();
if (!mode) {
// Reset the application override, so subsequent desktop changes still propagate.
gtk_settings_reset_property(settings, "gtk-theme-name");
gtk_settings_reset_property(settings, "gtk-application-prefer-dark-theme");
} else {
g_object_set(settings, "gtk-theme-name", "Adwaita", "gtk-application-prefer-dark-theme", mode == 2, NULL);
}
}
void uu_theme_init(void) {
if (initialized) return;
initialized = 1;
char *path = theme_path(), *value = NULL;
if (g_file_get_contents(path, &value, NULL, NULL)) {
g_strstrip(value);
for (int i = 0; i < 3; i++) if (!strcmp(value, modes[i])) mode = i;
}
g_free(value); g_free(path);
apply_mode();
uu_theme_load_css(CSS);
}
static void on_theme(GtkComboBox *combo, gpointer note) {
int selected = gtk_combo_box_get_active(combo);
if (selected < 0 || selected > 2) return;
mode = selected;
apply_mode();
char *path = theme_path(), *dir = g_path_get_dirname(path);
gboolean saved = g_mkdir_with_parents(dir, 0700) == 0 && g_file_set_contents(path, modes[mode], -1, NULL);
gtk_label_set_text(GTK_LABEL(note), saved ? "" : L("无法保存外观设置", "Could not save appearance"));
gtk_widget_set_visible(GTK_WIDGET(note), !saved);
g_free(dir); g_free(path);
}
GtkWidget *uu_theme_selector(void) {
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6), *row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
GtkWidget *label = gtk_label_new(L("外观", "Appearance")), *combo = gtk_combo_box_text_new(), *note = gtk_label_new("");
gtk_style_context_add_class(gtk_widget_get_style_context(label), "key");
gtk_style_context_add_class(gtk_widget_get_style_context(note), "status");
gtk_style_context_add_class(gtk_widget_get_style_context(note), "error");
gtk_label_set_line_wrap(GTK_LABEL(note), TRUE);
gtk_widget_set_no_show_all(note, TRUE);
gtk_widget_set_halign(note, GTK_ALIGN_START);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), L("跟随系统", "System"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), L("浅色", "Light"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), L("深色", "Dark"));
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), mode);
atk_object_set_name(gtk_widget_get_accessible(combo), L("外观", "Appearance"));
g_signal_connect(combo, "changed", G_CALLBACK(on_theme), note);
gtk_box_pack_start(GTK_BOX(row), label, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(row), combo, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(box), row, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(box), note, FALSE, FALSE, 0);
return box;
}
static void open_settings(GtkButton *button, gpointer parent) {
(void)button;
GtkWidget *dialog = gtk_dialog_new_with_buttons(L("设置", "Settings"), GTK_WINDOW(parent),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, L("关闭", "Close"), GTK_RESPONSE_CLOSE, NULL);
GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
gtk_window_set_default_size(GTK_WINDOW(dialog), 360, -1);
gtk_container_set_border_width(GTK_CONTAINER(area), 24);
gtk_box_pack_start(GTK_BOX(area), uu_theme_selector(), FALSE, FALSE, 0);
g_signal_connect_swapped(dialog, "response", G_CALLBACK(gtk_widget_destroy), dialog);
gtk_widget_show_all(dialog);
}
GtkWidget *uu_theme_settings_button(GtkWindow *parent) {
GtkWidget *button = gtk_button_new_from_icon_name("preferences-system-symbolic", GTK_ICON_SIZE_BUTTON);
gtk_style_context_add_class(gtk_widget_get_style_context(button), "flat");
gtk_widget_set_tooltip_text(button, L("设置", "Settings"));
atk_object_set_name(gtk_widget_get_accessible(button), L("设置", "Settings"));
g_signal_connect(button, "clicked", G_CALLBACK(open_settings), parent);
return button;
}
+10
View File
@@ -0,0 +1,10 @@
#ifndef UU_UI_THEME_H
#define UU_UI_THEME_H
#include <gtk/gtk.h>
// Call on the GTK thread, after gtk_init_check. Shared by the host and viewer tools.
void uu_theme_init(void);
GtkWidget *uu_theme_selector(void);
GtkWidget *uu_theme_settings_button(GtkWindow *parent);
void uu_theme_load_css(const char *css);
#endif
+58
View File
@@ -0,0 +1,58 @@
#include "uinput_keymap.h"
#include <X11/Xlib.h>
#include <X11/XKBlib.h>
#include <X11/keysym.h>
#include <string.h>
static size_t text_plan(XkbDescPtr map, const XkbStateRec *state,
const uint8_t *text, size_t length, UuTextKey *plan, size_t capacity) {
if (!map || !map->map || !map->map->modmap || !state || state->base_mods || state->latched_mods) return 0;
/* Prove the XKB -> evdev offset from physical key names rather than assuming a US layout. */
if (!map->names || !map->names->keys || map->min_key_code > 10 || map->max_key_code < 50 ||
memcmp(map->names->keys[10].name,"AE01",4) ||
memcmp(map->names->keys[38].name,"AC01",4) ||
memcmp(map->names->keys[50].name,"LFSH",4)) return 0;
uint16_t shift_code=0;
for (unsigned code=9; code<=map->max_key_code; code++) {
if (code>=map->min_key_code && code-8<=248 && (map->map->modmap[code] & ShiftMask)) {
shift_code=code-8; break;
}
}
UuTextKey lookup[128]={0};
for (unsigned shift=0; shift<2; shift++) {
if (shift && !shift_code) continue;
for (unsigned code=9; code<=map->max_key_code; code++) {
if (code<map->min_key_code || code-8>248) continue;
KeySym symbol=NoSymbol;
unsigned consumed=0;
unsigned modifiers=XkbBuildCoreState(state->locked_mods | (shift ? ShiftMask : 0),state->group);
if (!XkbTranslateKeyCode(map,code,modifiers,&consumed,&symbol)) continue;
UuTextKey key={.code=code-8,.shift=shift ? shift_code : 0};
if (symbol>=0x20 && symbol<=0x7e && !lookup[symbol].code) lookup[symbol]=key;
else if (symbol==XK_Return && !lookup['\n'].code) lookup['\n']=lookup['\r']=key;
else if (symbol==XK_Tab && !lookup['\t'].code) lookup['\t']=key;
}
}
size_t count=0;
while (count<length && count<capacity && text[count]<128 && lookup[text[count]].code) {
plan[count]=lookup[text[count]];
count++;
}
return count;
}
size_t uu_uinput_text_plan(const uint8_t *text, size_t length, UuTextKey *plan, size_t capacity) {
if (!text || !length || !plan || !capacity || text[0]>=128) return 0;
XInitThreads();
Display *display=XOpenDisplay(NULL);
if (!display) return 0;
XkbDescPtr map=XkbGetMap(display,XkbAllClientInfoMask,XkbUseCoreKbd);
XkbStateRec state;
size_t count=0;
if (map && XkbGetState(display,XkbUseCoreKbd,&state)==Success &&
XkbGetNames(display,XkbKeyNamesMask,map)==Success)
count=text_plan(map,&state,text,length,plan,capacity);
if (map) XkbFreeKeyboard(map,XkbAllComponentsMask,True);
XCloseDisplay(display);
return count;
}
+9
View File
@@ -0,0 +1,9 @@
#ifndef UU_UINPUT_KEYMAP_H
#define UU_UINPUT_KEYMAP_H
#include <stddef.h>
#include <stdint.h>
typedef struct { uint16_t code, shift; } UuTextKey;
/* Read-only XKB lookup; emits no input and never changes the keymap or clipboard.
* Return the number of initial ASCII characters representable by physical keys. */
size_t uu_uinput_text_plan(const uint8_t *text, size_t length, UuTextKey *plan, size_t capacity);
#endif
+39 -13
View File
@@ -268,33 +268,57 @@ VaapiEngine* vaapi_create(const VaapiConfig* config) {
}
int vaapi_import_dma_buffer(VaapiEngine* engine, int dma_fd, uint32_t stride) {
if (!engine || dma_fd < 0) return -1;
if (!engine) return -1;
UuDmaFrame frame = {
.fd=dma_fd, .fourcc=0x34325258, .width=engine->cap_width, .height=engine->cap_height,
.stride=stride, .size=stride * engine->cap_height, .modifier=0
};
return vaapi_import_frame(engine, &frame);
}
if (engine->in_rgb_surf != VA_INVALID_ID) {
RT.vaDestroySurfaces(engine->va_dpy, &engine->in_rgb_surf, 1);
engine->in_rgb_surf = VA_INVALID_ID;
}
static void vaapi_clear_input(VaapiEngine *engine) {
if (engine->vpp_buf != VA_INVALID_ID) {
RT.vaDestroyBuffer(engine->va_dpy, engine->vpp_buf);
engine->vpp_buf = VA_INVALID_ID;
}
if (engine->in_rgb_surf != VA_INVALID_ID) {
RT.vaDestroySurfaces(engine->va_dpy, &engine->in_rgb_surf, 1);
engine->in_rgb_surf = VA_INVALID_ID;
}
engine->dma_fd = -1;
}
engine->dma_fd = dma_fd;
engine->stride = stride;
int vaapi_import_frame(VaapiEngine *engine, const UuDmaFrame *frame) {
if (!engine || !frame || frame->fd < 0 || frame->width != engine->cap_width ||
frame->height != engine->cap_height || !frame->height || frame->stride < (uint64_t)frame->width * 4 ||
(uint64_t)frame->offset + (uint64_t)(frame->height - 1) * frame->stride + (uint64_t)frame->width * 4 > frame->size)
return -1;
uint32_t va_fourcc;
switch (frame->fourcc) {
case 0x34325258: va_fourcc=VA_FOURCC_BGRX; break; /* DRM_FORMAT_XRGB8888 */
case 0x34325241: va_fourcc=VA_FOURCC_BGRA; break; /* DRM_FORMAT_ARGB8888 */
case 0x34324258: va_fourcc=VA_FOURCC_RGBX; break; /* DRM_FORMAT_XBGR8888 */
case 0x34324241: va_fourcc=VA_FOURCC_RGBA; break; /* DRM_FORMAT_ABGR8888 */
default: return -1;
}
vaapi_clear_input(engine);
engine->dma_fd = frame->fd;
engine->stride = frame->stride;
VADRMPRIMESurfaceDescriptor prime_desc;
memset(&prime_desc, 0, sizeof(prime_desc));
prime_desc.fourcc = VA_FOURCC_BGRX;
prime_desc.fourcc = va_fourcc;
prime_desc.width = engine->cap_width;
prime_desc.height = engine->cap_height;
prime_desc.num_objects = 1;
prime_desc.objects[0].fd = dma_fd;
prime_desc.objects[0].size = stride * engine->cap_height;
prime_desc.objects[0].drm_format_modifier = 0;
prime_desc.objects[0].fd = frame->fd;
prime_desc.objects[0].size = frame->size;
prime_desc.objects[0].drm_format_modifier = frame->modifier;
prime_desc.num_layers = 1;
prime_desc.layers[0].drm_format = 0x34325258; // DRM_FORMAT_XRGB8888
prime_desc.layers[0].drm_format = frame->fourcc;
prime_desc.layers[0].num_planes = 1;
prime_desc.layers[0].pitch[0] = stride;
prime_desc.layers[0].pitch[0] = frame->stride;
prime_desc.layers[0].offset[0] = frame->offset;
VASurfaceAttrib attribs[2];
attribs[0].type = VASurfaceAttribMemoryType;
@@ -322,6 +346,8 @@ int vaapi_import_dma_buffer(VaapiEngine* engine, int dma_fd, uint32_t stride) {
int vaapi_upload_host_buffer(VaapiEngine* engine, const uint8_t* host_ptr, uint32_t pitch) {
if (!engine || !host_ptr) return -1;
/* Never write a fallback image into the compositor's imported buffer. */
if (engine->dma_fd >= 0) vaapi_clear_input(engine);
if (engine->in_rgb_surf == VA_INVALID_ID) {
VAStatus st = RT.vaCreateSurfaces(engine->va_dpy, VA_RT_FORMAT_RGB32, engine->cap_width, engine->cap_height, &engine->in_rgb_surf, 1, NULL, 0);
+2
View File
@@ -3,6 +3,7 @@
#include <stdint.h>
#include <stddef.h>
#include "dmabuf_frame.h"
#ifdef __cplusplus
extern "C" {
@@ -28,6 +29,7 @@ VaapiEngine* vaapi_create(const VaapiConfig* config);
// Import a DRI3 / GBM DMA-BUF fd as the zero-copy input surface
int vaapi_import_dma_buffer(VaapiEngine* engine, int dma_fd, uint32_t stride);
int vaapi_import_frame(VaapiEngine* engine, const UuDmaFrame *frame);
// Host fallback: upload ARGB host memory if DMA-BUF is unavailable
int vaapi_upload_host_buffer(VaapiEngine* engine, const uint8_t* host_ptr, uint32_t pitch);
+6 -16
View File
@@ -10,6 +10,7 @@
#include <time.h>
#include <unistd.h>
#include "i18n.h"
#include "ui_theme.h"
#define QSIZE 64
static char queue[QSIZE][4096];
@@ -46,26 +47,17 @@ static gboolean toast_idle(gpointer d) { show_toast(d); g_free(d); return G_SOUR
void uu_tools_ui_toast(const char *text) { g_idle_add(toast_idle, g_strdup(text)); }
static gboolean on_delete(GtkWidget *w, GdkEvent *e, gpointer d) { (void)e; (void)d; gtk_widget_hide(w); atomic_store(&closed, 1); return TRUE; }
static const char *css =
"window { background: #f5f6f8; }\n"
".title { font-size: 22px; font-weight: bold; color: #111827; }\n"
".tag { background: #e5e7eb; color: #4b5563; border-radius: 6px; padding: 2px 8px; }\n"
".tag.remote { background: #d1fae5; color: #047857; }\n"
".card { background: white; border: 1px solid #e5e7eb; border-radius: 10px; padding: 8px; }\n"
".section { font-size: 17px; font-weight: bold; }\n"
".toast { background: rgba(17,24,39,0.88); color: white; border-radius: 8px; padding: 10px 18px; }\n"
".primary { background-image: none; background-color: #10b981; color: white; border: none; }\n"
".empty { color: #6b7280; font-size: 15px; }\n"
".online { color: #10b981; }\n";
static GtkWidget *frame(const char *title, GtkWidget **content) {
GtkCssProvider *p = gtk_css_provider_new(); gtk_css_provider_load_from_data(p, css, -1, NULL);
gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), GTK_STYLE_PROVIDER(p), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
uu_theme_init();
uu_theme_load_css(".card { padding: 12px; } treeview.view { padding: 6px; }");
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), title);
g_signal_connect(window, "delete-event", G_CALLBACK(on_delete), NULL);
GtkWidget *overlay = gtk_overlay_new(); *content = vbox(14);
gtk_container_set_border_width(GTK_CONTAINER(*content), 22);
GtkWidget *appearance = uu_theme_settings_button(GTK_WINDOW(window));
gtk_widget_set_halign(appearance, GTK_ALIGN_END);
gtk_box_pack_start(GTK_BOX(*content), appearance, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(overlay), *content);
toast = label("", "toast"); gtk_widget_set_halign(toast, GTK_ALIGN_CENTER); gtk_widget_set_valign(toast, GTK_ALIGN_END);
gtk_widget_set_margin_bottom(toast, 30); gtk_widget_set_no_show_all(toast, TRUE);
@@ -476,8 +468,6 @@ static void *ui_thread(void *d) {
(void)d;
if (!gtk_init_check(NULL, NULL)) { pthread_mutex_lock(&init_lock); init_state = -1; pthread_cond_signal(&init_cond); pthread_mutex_unlock(&init_lock); return NULL; }
gtk_window_set_default_icon_name("uu-remote-linux"); // same taskbar icon as the host (#13)
// Light palette in CSS; keep a dark system theme from making unstyled text white on white (#43).
g_object_set(gtk_settings_get_default(), "gtk-theme-name", "Adwaita", "gtk-application-prefer-dark-theme", FALSE, NULL);
show_window(NULL); gtk_main(); return NULL;
}
/* Hidden windows retain their widgets so queued idle callbacks stay valid. */
+64 -61
View File
@@ -11,45 +11,32 @@
#include <time.h>
#include <sys/stat.h>
#include "i18n.h"
#include "ui_theme.h"
static const char *CSS =
"window { background-color: #ffffff; }\n"
"* { font-family: 'Noto Sans CJK SC', 'Noto Sans SC', sans-serif; }\n"
".sidebar { background-color: #e9e9ec; }\n"
".section { font-size: 16px; font-weight: 600; color: #1d1d1f; }\n"
".sidebar { background-color: @theme_bg_color; border-right: 1px solid @uu_border; }\n"
".sidebar list, .sidebar row { background-color: transparent; }\n"
".sidebar row { border-radius: 8px; margin: 1px 10px; padding: 8px 10px; }\n"
".sidebar row:selected { background-color: #d4d4d9; color: #1d1d1f; }\n"
".devname { font-size: 15px; color: #1d1d1f; }\n"
".offline { color: #9ca3af; }\n"
".dot { color: #22c55e; font-size: 10px; }\n"
".sidebar row { border-radius: 8px; margin: 3px 12px; padding: 10px 12px; }\n"
".sidebar row:hover { background-color: @uu_tint; }\n"
".sidebar row:selected { background-color: @uu_tint; color: @uu_fg; }\n"
".devname { font-size: 15px; color: @uu_fg; }\n"
".offline { color: @uu_muted; }\n"
".dot { font-size: 10px; }\n"
".dot.off { color: transparent; }\n"
".icon { background-color: #2f7bff; color: #ffffff; border-radius: 6px; font-size: 11px; font-weight: 700; padding: 2px 5px; }\n"
".icon.off { background-color: #c4c7cf; }\n"
".tag { background-color: #e8f0ff; color: #2f6bff; border-radius: 4px; font-size: 12px; padding: 1px 6px; }\n"
".title { font-size: 20px; font-weight: 700; color: #1d1d1f; }\n"
".header { border-bottom: 1px solid #e5e7eb; padding: 12px 22px; background-color: #f7f7f8; }\n"
".badge { background-color: #1d1d1f; color: #ffffff; border-radius: 12px; padding: 3px 12px; font-size: 13px; }\n"
".badge.off { background-color: #9ca3af; }\n"
".hbtn { background-image: none; background-color: transparent; border: none; font-size: 17px; color: #4b5563; padding: 4px 10px; }\n"
".preview { background-image: linear-gradient(135deg, #a8c0ff 0%, #e2c2f2 50%, #f6c8a8 100%); border-radius: 12px 12px 0 0; }\n"
".enter { background-image: none; background-color: rgba(0,0,0,0.18); color: #ffffff; border: none; font-size: 19px; padding: 8px 20px; border-radius: 8px; }\n"
".toolbar { border: 1px solid #e5e7eb; border-top: none; border-radius: 0 0 12px 12px; padding: 4px; }\n"
".tool { background-image: none; background-color: transparent; border: none; font-size: 15px; color: #374151; padding: 10px; }\n"
".dashed { border: 1px dashed #d1d5db; border-radius: 12px; padding: 36px; }\n"
".round { background-image: none; background-color: #f3f4f6; border: none; border-radius: 40px; font-size: 26px; min-width: 64px; min-height: 64px; }\n"
".card { background-color: #fafafa; border: 1px solid #e5e7eb; border-radius: 10px; padding: 14px 18px; }\n"
".cardbtn { background-image: none; background-color: #fafafa; border: 1px solid #e5e7eb; border-radius: 10px; padding: 12px 16px; }\n"
".banner { background-color: #f7f8fa; border: 1px solid #e5e7eb; border-radius: 10px; padding: 14px 18px; }\n"
".group { font-size: 16px; font-weight: 600; color: #1d1d1f; }\n"
".h2 { font-size: 19px; font-weight: 700; color: #1d1d1f; }\n"
".big { font-size: 30px; font-weight: 800; color: #111111; }\n"
".hint { font-size: 14px; color: #6b7280; }\n"
".primary { background-image: none; background-color: #3b82f6; color: #ffffff; border: none; border-radius: 8px; font-size: 16px; padding: 8px 26px; }\n"
".secondary { background-image: none; background-color: #ffffff; border: 1px solid #d1d5db; border-radius: 8px; padding: 6px 16px; }\n"
".qrbox { background-color: #ffffff; border-radius: 12px; border: 1px solid #e5e7eb; padding: 14px; }\n"
".status { font-size: 13px; color: #2f6bff; }\n"
".toast { background-color: #ffffff; border: 1px solid #e5e7eb; border-radius: 10px; padding: 10px 18px; font-size: 15px; }\n";
".icon { background-color: @uu_accent; color: @uu_accent_fg; border-radius: 6px; font-size: 11px; font-weight: 700; padding: 3px 6px; }\n"
".icon.off { background-color: @uu_border; color: @uu_muted; }\n"
".header { border-bottom: 1px solid @uu_border; padding: 16px 24px; }\n"
".badge { background-color: @uu_tint; color: @uu_success; border-radius: 8px; padding: 4px 10px; font-size: 13px; }\n"
".badge.off { background-color: @theme_bg_color; color: @uu_muted; }\n"
".hbtn { font-size: 17px; padding: 6px 10px; }\n"
".preview { background-image: none; background-color: @uu_tint; border-radius: 12px 12px 0 0; }\n"
".enter { font-size: 18px; }\n"
".toolbar { background-color: @uu_surface; border: 1px solid @uu_border; border-top: none; border-radius: 0 0 12px 12px; padding: 6px; }\n"
".tool { font-size: 15px; padding: 10px; }\n"
".dashed { border: 1px dashed @uu_border; border-radius: 12px; padding: 36px; }\n"
".round { background-color: @uu_tint; border: none; border-radius: 16px; font-size: 26px; min-width: 64px; min-height: 64px; }\n"
".card, .banner { padding: 18px 20px; }\n"
".cardbtn { padding: 14px 18px; }\n";
typedef struct { char id[64]; char name[128]; int platform, online, current; char thumb[512]; } Device;
static Device devices[64];
@@ -86,6 +73,14 @@ static GtkWidget *label(const char *text, const char *cls) {
return l;
}
static GtkWidget *button(const char *text, const char *cls) { GtkWidget *b = gtk_button_new_with_label(text); if (cls) add_class(b, cls); return b; }
static GtkWidget *icon(const char *name, int size) {
GtkWidget *image = gtk_image_new_from_icon_name(name, GTK_ICON_SIZE_BUTTON);
gtk_image_set_pixel_size(GTK_IMAGE(image), size); return image;
}
static GtkWidget *icon_button(const char *text, const char *name, const char *cls) {
GtkWidget *b = button(text, cls); gtk_button_set_image(GTK_BUTTON(b), icon(name, 17));
gtk_button_set_always_show_image(GTK_BUTTON(b), TRUE); return b;
}
static GtkWidget *hbox(int spacing) { return gtk_box_new(GTK_ORIENTATION_HORIZONTAL, spacing); }
static GtkWidget *vbox(int spacing) { return gtk_box_new(GTK_ORIENTATION_VERTICAL, spacing); }
static GtkWidget *platform_icon(int platform, int online) {
@@ -137,10 +132,12 @@ static void open_more(void) {
GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dialog)), *box = vbox(10);
gtk_container_set_border_width(GTK_CONTAINER(box), 22);
gtk_box_pack_start(GTK_BOX(box), label(L("更多工具", "More tools"), "h2"), FALSE, FALSE, 6);
const char *names[] = {L("🗂 文件传输", "🗂 File transfer"), L("▶ 观看模式", "▶ Watch mode"), L("⌨ 终端", "⌨ Terminal"), L("⇄ 端口映射", "⇄ Port mapping"), L("⏻ 远程开机", "⏻ Wake on LAN"), L("↻ 重启", "↻ Restart"), L("⏻ 关机", "⏻ Shut down"), L("🗑 删除设备", "🗑 Remove device")};
const char *names[] = {L("文件传输", "File transfer"), L("观看模式", "Watch mode"), L("终端", "Terminal"), L("端口映射", "Port mapping"), L("远程开机", "Wake on LAN"), L("重启", "Restart"), L("关机", "Shut down"), L("删除设备", "Remove device")};
const char *icons[] = {"folder-symbolic", "media-playback-start-symbolic", "utilities-terminal-symbolic", "network-wired-symbolic", "computer-symbolic", "view-refresh-symbolic", "system-shutdown-symbolic", "user-trash-symbolic"};
const char *kinds[] = {"file", "watch", "terminal", "portmap", "wol", "reboot", "shutdown", "unbind"};
for (int i = 0; i < 8; i++) {
GtkWidget *b = gtk_button_new(), *line = hbox(10); add_class(b, "cardbtn");
gtk_box_pack_start(GTK_BOX(line), icon(icons[i], 20), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(line), label(names[i], "devname"), TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(line), label("›", "hint"), FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(b), line);
@@ -217,7 +214,7 @@ static void show_device(int index) {
pthread_mutex_unlock(&d_lock);
load_thumb(thumb);
set_header(name, 1);
gtk_label_set_markup(GTK_LABEL(badge), online ? L("<span foreground='#22c55e'>●</span> 在线", "<span foreground='#22c55e'>●</span> Online") : L("离线", "Offline"));
gtk_label_set_text(GTK_LABEL(badge), online ? L("● 在线", "● Online") : L("离线", "Offline"));
GtkStyleContext *ctx = gtk_widget_get_style_context(badge);
if (online) gtk_style_context_remove_class(ctx, "off"); else gtk_style_context_add_class(ctx, "off");
gtk_stack_set_visible_child_name(GTK_STACK(stack), "device");
@@ -237,7 +234,8 @@ static void on_card(GtkButton *b, gpointer index) { (void)b; show_device(GPOINTE
static GtkWidget *nav_row(const char *icon, const char *text, const char *kind) {
GtkWidget *row = gtk_list_box_row_new(), *line = hbox(10);
gtk_box_pack_start(GTK_BOX(line), label(icon, "devname"), FALSE, FALSE, 0);
GtkWidget *image = gtk_image_new_from_icon_name(icon, GTK_ICON_SIZE_BUTTON);
gtk_box_pack_start(GTK_BOX(line), image, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(line), label(text, "devname"), TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(row), line);
g_object_set_data_full(G_OBJECT(row), "kind", g_strdup(kind), g_free);
@@ -311,7 +309,7 @@ static gboolean apply_devices(gpointer d) {
gtk_box_pack_start(GTK_BOX(all_box), card, FALSE, FALSE, 4);
}
pthread_mutex_unlock(&d_lock);
gtk_list_box_insert(GTK_LIST_BOX(device_list), nav_row("◼", L("全部设备", "All devices"), "all"), -1);
gtk_list_box_insert(GTK_LIST_BOX(device_list), nav_row("view-grid-symbolic", L("全部设备", "All devices"), "all"), -1);
gtk_widget_show_all(device_list); gtk_widget_show_all(all_box);
return G_SOURCE_REMOVE;
}
@@ -380,9 +378,10 @@ static GtkWidget *build_device(void) {
gtk_overlay_add_overlay(GTK_OVERLAY(preview), enter);
gtk_box_pack_start(GTK_BOX(page), preview, FALSE, FALSE, 0);
GtkWidget *tools = hbox(0); add_class(tools, "toolbar");
const char *names[] = {L("🗂 文件传输", "🗂 File transfer"), L("▶ 观看模式", "▶ Watch mode"), L("⌨ 终端", "⌨ Terminal"), L("⇄ 端口映射", "⇄ Port mapping"), "▦"}, *kinds[] = {"file", "watch", "terminal", "portmap", "more"};
const char *names[] = {L("文件传输", "File transfer"), L("观看模式", "Watch mode"), L("终端", "Terminal"), L("端口映射", "Port mapping"), L("更多", "More")}, *kinds[] = {"file", "watch", "terminal", "portmap", "more"};
const char *tool_icons[] = {"folder-symbolic", "media-playback-start-symbolic", "utilities-terminal-symbolic", "network-wired-symbolic", "view-more-symbolic"};
for (int i = 0; i < 5; i++) {
GtkWidget *b = button(names[i], "tool");
GtkWidget *b = icon_button(names[i], tool_icons[i], "tool");
g_signal_connect(b, "clicked", G_CALLBACK(on_tool), (gpointer)kinds[i]);
gtk_box_pack_start(GTK_BOX(tools), b, i < 4, TRUE, 0);
if (i < 4) gtk_box_pack_start(GTK_BOX(tools), gtk_separator_new(GTK_ORIENTATION_VERTICAL), FALSE, FALSE, 0);
@@ -574,6 +573,10 @@ static void open_settings(void) {
GtkWidget *g0[] = { acct };
gtk_box_pack_start(GTK_BOX(general), settings_card(g0, 1), FALSE, FALSE, 0);
refresh_account();
const char *languages[] = {"中文", "English"}; GtkWidget *language = combo(languages, 2);
gtk_combo_box_set_active(GTK_COMBO_BOX(language), uu_i18n_english()); g_signal_connect(language, "changed", G_CALLBACK(on_language), NULL);
GtkWidget *g4[] = { setting_row("语言 / Language", NULL, language), uu_theme_selector() };
gtk_box_pack_start(GTK_BOX(general), settings_card(g4, 2), FALSE, FALSE, 0);
const char *wake[] = {L("永不", "Never"), L("接通电源时", "When plugged in"), L("始终", "Always")}, *close_opts[] = {L("最小化", "Minimize"), L("退出程序", "Quit")};
GtkWidget *g1[] = { setting_row(L("开机自启动", "Start at login"), NULL, gtk_switch_new()),
setting_row(L("保持唤醒状态", "Stay awake"), L("防止电脑进入睡眠状态,导致无法远程访问。", "Keep the computer from sleeping so it stays reachable."), combo(wake, 3)),
@@ -587,11 +590,10 @@ static void open_settings(void) {
GtkWidget *real = button(L("在手机 App 中查看", "View in the mobile app"), "secondary"); gtk_widget_set_sensitive(real, FALSE);
GtkWidget *g3[] = { setting_row(L("实名认证", "Identity verification"), NULL, real) };
gtk_box_pack_start(GTK_BOX(general), settings_card(g3, 1), FALSE, FALSE, 0);
const char *languages[] = {"中文", "English"}; GtkWidget *language = combo(languages, 2);
gtk_combo_box_set_active(GTK_COMBO_BOX(language), uu_i18n_english()); g_signal_connect(language, "changed", G_CALLBACK(on_language), NULL);
GtkWidget *g4[] = { setting_row("语言 / Language", NULL, language) };
gtk_box_pack_start(GTK_BOX(general), settings_card(g4, 1), FALSE, FALSE, 0);
gtk_stack_add_titled(GTK_STACK(tabs), general, "general", L("⚙ 常规", "⚙ General"));
GtkWidget *gscroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(gscroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(gscroll), general);
gtk_stack_add_titled(GTK_STACK(tabs), gscroll, "general", L("常规", "General"));
// 安全
GtkWidget *security = settings_page();
const char *verify[] = {L("仅使用临时验证码", "Temporary code only"), L("仅使用自定义验证码", "Custom code only"), L("临时与自定义验证码", "Temporary and custom codes")};
@@ -603,7 +605,7 @@ static void open_settings(void) {
gtk_box_pack_start(GTK_BOX(security), settings_card(s1, 2), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(security), settings_card(s2, 1), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(security), settings_card(s3, 1), FALSE, FALSE, 0);
gtk_stack_add_titled(GTK_STACK(tabs), security, "security", L("🔒 安全", "🔒 Security"));
gtk_stack_add_titled(GTK_STACK(tabs), security, "security", L("安全", "Security"));
// 键盘
GtkWidget *keys = settings_page();
gtk_box_pack_start(GTK_BOX(keys), label(L("仅控制端响应的快捷键", "Viewer-only shortcuts"), "h2"), FALSE, FALSE, 0);
@@ -618,13 +620,13 @@ static void open_settings(void) {
for (int i = 0; i < 8; i++) k2[i] = setting_row(fns[i], NULL, edit_button(fns[i]));
gtk_box_pack_start(GTK_BOX(keys), settings_card(k2, 8), FALSE, FALSE, 0);
GtkWidget *kscroll = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(kscroll), keys);
gtk_stack_add_titled(GTK_STACK(tabs), kscroll, "keys", L("⌨ 键盘", "⌨ Keyboard"));
gtk_stack_add_titled(GTK_STACK(tabs), kscroll, "keys", L("键盘", "Keyboard"));
// 网络
GtkWidget *network = settings_page();
const char *proxy[] = {L("使用系统环境代理", "Use system proxy"), L("不使用代理", "No proxy")};
GtkWidget *n1[] = { setting_row(L("代理设置", "Proxy"), NULL, combo(proxy, 2)) };
gtk_box_pack_start(GTK_BOX(network), settings_card(n1, 1), FALSE, FALSE, 0);
gtk_stack_add_titled(GTK_STACK(tabs), network, "network", L("🌐 网络", "🌐 Network"));
gtk_stack_add_titled(GTK_STACK(tabs), network, "network", L("网络", "Network"));
gtk_box_pack_start(GTK_BOX(root), tabs, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(settings_window), root);
gtk_widget_show_all(settings_window);
@@ -666,12 +668,9 @@ static void *run(void *arg) {
(void)arg;
int ok = gtk_init_check(NULL, NULL);
if (ok) { gtk_window_set_default_icon_name("uu-remote-linux"); } // same taskbar icon as the host (#13)
// The CSS hard-codes a light palette; a dark system theme would turn unstyled text white on white (#43).
if (ok) g_object_set(gtk_settings_get_default(), "gtk-theme-name", "Adwaita", "gtk-application-prefer-dark-theme", FALSE, NULL);
if (ok) {
GtkCssProvider *css = gtk_css_provider_new();
gtk_css_provider_load_from_data(css, CSS, -1, NULL);
gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), GTK_STYLE_PROVIDER(css), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
uu_theme_init();
uu_theme_load_css(CSS);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), L("UU 远程 Linux 控制端(非官方)", "UU Remote Linux viewer (unofficial)"));
gtk_window_set_default_size(GTK_WINDOW(window), 1180, 780);
@@ -682,18 +681,21 @@ static void *run(void *arg) {
GtkWidget *side = vbox(0); add_class(side, "sidebar"); gtk_widget_set_size_request(side, 270, -1);
my_section = vbox(0);
GtkWidget *mh = hbox(8); gtk_widget_set_margin_start(mh, 18); gtk_widget_set_margin_top(mh, 22); gtk_widget_set_margin_bottom(mh, 6);
gtk_box_pack_start(GTK_BOX(mh), label(L("⧉ 我的设备", "⧉ My devices"), "section"), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(mh), icon("computer-symbolic", 17), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mh), label(L("我的设备", "My devices"), "section"), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(my_section), mh, FALSE, FALSE, 0);
device_list = gtk_list_box_new(); g_signal_connect(device_list, "row-activated", G_CALLBACK(on_row), NULL);
gtk_box_pack_start(GTK_BOX(my_section), device_list, FALSE, FALSE, 0);
GtkWidget *scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
GtkWidget *side_inner = vbox(0); gtk_box_pack_start(GTK_BOX(side_inner), my_section, FALSE, FALSE, 0);
GtkWidget *welcome_nav = gtk_list_box_new(); g_signal_connect(welcome_nav, "row-activated", G_CALLBACK(on_row), NULL);
GtkWidget *ah = label(L("⧉ 远程协助", "⧉ Remote assistance"), "section"); gtk_widget_set_margin_start(ah, 18); gtk_widget_set_margin_top(ah, 16); gtk_widget_set_margin_bottom(ah, 6);
GtkWidget *ah = hbox(8); gtk_widget_set_margin_start(ah, 18); gtk_widget_set_margin_top(ah, 16); gtk_widget_set_margin_bottom(ah, 6);
gtk_box_pack_start(GTK_BOX(ah), icon("network-workgroup-symbolic", 17), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(ah), label(L("远程协助", "Remote assistance"), "section"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(side_inner), ah, FALSE, FALSE, 0);
GtkWidget *assist = assist_list = gtk_list_box_new(); g_signal_connect(assist, "row-activated", G_CALLBACK(on_row), NULL);
gtk_list_box_insert(GTK_LIST_BOX(assist), nav_row("◧", L("开始协助", "Start assistance"), "assist"), -1);
gtk_list_box_insert(GTK_LIST_BOX(assist), nav_row("★", L("收藏设备", "Favorites"), "favorite"), -1);
gtk_list_box_insert(GTK_LIST_BOX(assist), nav_row("network-workgroup-symbolic", L("开始协助", "Start assistance"), "assist"), -1);
gtk_list_box_insert(GTK_LIST_BOX(assist), nav_row("starred-symbolic", L("收藏设备", "Favorites"), "favorite"), -1);
gtk_box_pack_start(GTK_BOX(side_inner), assist, FALSE, FALSE, 0);
gtk_list_box_unselect_all(GTK_LIST_BOX(assist));
(void)welcome_nav;
@@ -704,12 +706,13 @@ static void *run(void *arg) {
GtkWidget *main = vbox(0), *header = hbox(10); add_class(header, "header");
badge = gtk_label_new(""); add_class(badge, "badge");
title_label = label(L("全部设备", "All devices"), "title");
more_button = button("⋮", "hbtn"); g_signal_connect(more_button, "clicked", G_CALLBACK(on_more), NULL);
more_button = icon_button("", "view-more-symbolic", "hbtn"); gtk_widget_set_tooltip_text(more_button, L("设备信息", "Device information")); g_signal_connect(more_button, "clicked", G_CALLBACK(on_more), NULL);
gtk_box_pack_start(GTK_BOX(header), badge, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(header), title_label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(header), more_button, FALSE, FALSE, 0);
const char *icons[] = {"☰", "◉", "🔔"}, *kinds[] = {"menu", "account", "notice"};
for (int i = 0; i < 3; i++) { GtkWidget *b = button(icons[i], "hbtn"); g_signal_connect(b, "clicked", G_CALLBACK(popup), (gpointer)kinds[i]); gtk_box_pack_end(GTK_BOX(header), b, FALSE, FALSE, 0); }
const char *icons[] = {"open-menu-symbolic", "avatar-default-symbolic", "preferences-system-notifications-symbolic"}, *kinds[] = {"menu", "account", "notice"};
const char *tips[] = {L("菜单", "Menu"), L("账号", "Account"), L("通知", "Notifications")};
for (int i = 0; i < 3; i++) { GtkWidget *b = icon_button("", icons[i], "hbtn"); gtk_widget_set_tooltip_text(b, tips[i]); g_signal_connect(b, "clicked", G_CALLBACK(popup), (gpointer)kinds[i]); gtk_box_pack_end(GTK_BOX(header), b, FALSE, FALSE, 0); }
gtk_box_pack_start(GTK_BOX(main), header, FALSE, FALSE, 0);
GtkWidget *overlay = gtk_overlay_new();
stack = gtk_stack_new();
+34 -60
View File
@@ -159,37 +159,10 @@ static size_t symbols_close(const char *text) {
}
return 0;
}
/* Named keycodes the keymap gives no symbol to. Reading the compositor's own list is the only
portable way: pressing an unmapped keycode types nothing, and uu_wl_key never matches one
because it searches by keysym. Highest first, since uu_wl_key takes the lowest match. */
/* Reusable codes for the separate text-only keyboard. Remapping real printable keys on that device
keeps the physical-key map untouched and is the form Chromium accepts; the evdev "reserved" codes
that have no symbol are discarded by some clients. */
static unsigned find_spare_codes(xkb_keycode_t *out,unsigned limit) {
unsigned count=0;
xkb_keycode_t min=xkb_keymap_min_keycode(keymap);
for(xkb_keycode_t code=xkb_keymap_max_keycode(keymap);code>min && count<limit;code--) {
if(code<8 || code>=sizeof(held_keys) || !xkb_keymap_key_get_name(keymap,code)) continue;
int mapped=0;
for(xkb_level_index_t level=0;level<xkb_keymap_num_levels_for_key(keymap,code,0) && !mapped;level++) {
const xkb_keysym_t *syms;
if(xkb_keymap_key_get_syms_by_level(keymap,code,0,level,&syms)>0) mapped=1;
}
if(!mapped) out[count++]=code;
}
return count;
}
/* A keycode the session keymap already produces this symbol with, unshifted. Typing through it
needs no upload, so no client can mistranslate it - and it is how plain latin text and spaces
arrive without touching the keymap at all. Spares never match: the pristine keymap leaves them
unmapped. */
static xkb_keycode_t existing_keycode(xkb_keysym_t symbol) {
for(xkb_keycode_t code=xkb_keymap_min_keycode(keymap);code<=xkb_keymap_max_keycode(keymap);code++) {
if(code<8 || code>=sizeof(held_keys)) continue;
const xkb_keysym_t *syms;
if(xkb_keymap_key_get_syms_by_level(keymap,code,0,0,&syms)==1 && syms[0]==symbol) return code;
}
return 0;
}
static unsigned find_niri_text_codes(xkb_keycode_t *out,unsigned limit) {
/* Printable physical keys work in Chromium; reserved evdev codes can be discarded. */
static const xkb_keycode_t text_codes[]={24,25,26,27,28,29,30,31,32,33,38,39,40,41,42,43,44,45,46,52,53,54,55,56,57,58};
unsigned count=0;
for(unsigned i=0;i<sizeof(text_codes)/sizeof(text_codes[0]) && count<limit;i++)
@@ -216,8 +189,12 @@ static void release_held_keys_locked(void) {
key_state and held_keys: pressed and released here. */
static int flush_batch(char *buffer,size_t capacity,const char names[][64],const xkb_keycode_t *codes,unsigned count,int *typed) {
release_held_keys_locked();
if(getenv("NIRI_SOCKET")) {if(sync_display()!=0) return -1;usleep(8000);}
else if(rekey_keyboard()!=0) return -1;
if(sync_display()!=0) return -1;
usleep(8000);
/* A keymap re-sent on a keyboard the client already knows is not handed to it again, so the
next batch would still decode with the previous one and repeat it. Re-attaching the text
keyboard is what makes the compositor deliver the new keymap. */
if(rekey_keyboard()!=0) return -1;
size_t at=keymap_insert;
memcpy(buffer,keymap_text,at);
for(unsigned i=0;i<count;i++) {
@@ -227,16 +204,16 @@ static int flush_batch(char *buffer,size_t capacity,const char names[][64],const
}
memcpy(buffer+at,keymap_text+keymap_insert,keymap_text_len-keymap_insert);
if(upload_keymap(buffer,at+(keymap_text_len-keymap_insert))!=0) return -1;
if(getenv("NIRI_SOCKET")) zwp_virtual_keyboard_v1_modifiers(keyboard,0,0,0,0);
zwp_virtual_keyboard_v1_modifiers(keyboard,0,0,0,0);
if(sync_display()!=0) return -1;
if(getenv("NIRI_SOCKET")) usleep(8000);
usleep(8000);
for(unsigned i=0;i<count;i++) { press_keycode(codes[i]); (*typed)++; }
if(getenv("NIRI_SOCKET")) {if(sync_display()!=0) return -1;usleep(8000);}
if(sync_display()!=0) return -1;
return 0;
}
/* Type UTF-8 like xdotool type does on X11, but on Wayland: characters the session keymap already
has go out as ordinary keycodes, the rest share the spares of one keymap upload (~70 KB, so one
batch per upload), in text order. Never logs the text. */
/* Type UTF-8 like xdotool type does on X11: each character is a Unicode keysym carried by the
text-only keyboard's printable codes, one keymap upload (~70 KB, so one batch per upload) in text
order. Never logs the text. */
static int type_utf8_locked(const char *text) {
size_t capacity=keymap_text_len+(size_t)UU_TEXT_SPARE*96+64;
char *buffer=malloc(capacity);
@@ -258,16 +235,11 @@ static int type_utf8_locked(const char *text) {
if(cp=='\n') sym=0xff0d; /* Return */
else if(cp=='\t') sym=0xff09; /* Tab */
else if(cp<0x20 || cp==0x7f || (cp>=0x80 && cp<0xa0)) continue; /* controls carry no text */
else if(cp<0x100) sym=cp; /* Latin-1 keysyms equal the code point */
else sym=(xkb_keysym_t)(0x1000000|cp); /* Unicode keysym */
xkb_keycode_t existing=getenv("NIRI_SOCKET")?0:existing_keycode(sym);
if(existing) {
if(count && flush_batch(buffer,capacity,names,codes,count,&typed)!=0) { failed=1; break; }
count=0;
press_keycode(existing); typed++;
continue;
}
if(count==(getenv("NIRI_SOCKET")?spare_count:UU_TEXT_SPARE)) {
/* Every character goes out as a Unicode keysym, including ASCII: a plain Latin-1 keysym
is what a running input method composes as pinyin, so "abc" would turn into candidates
instead of reaching the field. */
else sym=(xkb_keysym_t)(0x1000000|cp);
if(count==spare_count) {
if(flush_batch(buffer,capacity,names,codes,count,&typed)!=0) { failed=1; break; }
count=0;
}
@@ -278,23 +250,25 @@ static int type_utf8_locked(const char *text) {
}
if(!failed && count) failed=flush_batch(buffer,capacity,names,codes,count,&typed)!=0;
free(buffer);
/* Restore the pristine keymap whatever happened above, so uu_wl_key keeps its own symbol map. */
if(getenv("NIRI_SOCKET")) {if(sync_display()!=0) return -1;usleep(8000);}
else if(upload_keymap(keymap_text,keymap_text_len)!=0) return -1;
return failed && !typed?-1:typed;
}
int uu_wl_type_utf8(const char *text) {
pthread_mutex_lock(&lock);
int typed=-1;
if(initialized && text && keymap_text && keymap_insert && spare_count) {
if(getenv("NIRI_SOCKET")) {
/* Only niri uses printable codes on a separate text device; preserve the Hyprland path. */
release_held_keys_locked();
struct zwp_virtual_keyboard_v1 *saved=keyboard;
keyboard=zwp_virtual_keyboard_manager_v1_create_virtual_keyboard(keyboard_manager,seat);
if(keyboard) {typed=type_utf8_locked(text);sync_display();usleep(8000);if(keyboard) zwp_virtual_keyboard_v1_destroy(keyboard);}
keyboard=saved;
} else typed=type_utf8_locked(text);
if(!keyboard_manager) { pthread_mutex_unlock(&lock); return -1; }
/* Text has its own device: remapping printable codes must not change physical-key input. */
release_held_keys_locked();
/* The original device stays alive, so key-up alone must not leave its modifiers held. */
zwp_virtual_keyboard_v1_modifiers(keyboard,
xkb_state_serialize_mods(key_state,XKB_STATE_MODS_DEPRESSED),
xkb_state_serialize_mods(key_state,XKB_STATE_MODS_LATCHED),
xkb_state_serialize_mods(key_state,XKB_STATE_MODS_LOCKED),
xkb_state_serialize_layout(key_state,XKB_STATE_LAYOUT_EFFECTIVE));
struct zwp_virtual_keyboard_v1 *saved=keyboard;
keyboard=zwp_virtual_keyboard_manager_v1_create_virtual_keyboard(keyboard_manager,seat);
if(keyboard) {typed=type_utf8_locked(text);sync_display();usleep(8000);if(keyboard) zwp_virtual_keyboard_v1_destroy(keyboard);}
keyboard=saved;
}
if(typed>=0 && wl_display_flush(display)<0) typed=-1;
pthread_mutex_unlock(&lock); return typed;
@@ -597,7 +571,7 @@ int uu_wl_init(int32_t *w,int32_t *h) {
/* Text typing needs unmapped keycodes and a place to declare them. A keymap without either
only costs that path - uu_wl_type_utf8 refuses and the caller keeps its own fallback. */
keymap_insert=symbols_close(keymap_text);
spare_count=getenv("NIRI_SOCKET")?find_niri_text_codes(spare_codes,UU_TEXT_SPARE):find_spare_codes(spare_codes,UU_TEXT_SPARE);
spare_count=find_spare_codes(spare_codes,UU_TEXT_SPARE);
}
initialized=1; *w=width; *h=height; result=0;
end:
+36 -4
View File
@@ -331,12 +331,30 @@ static int class_is_terminal(const char *value) {
return 0;
}
/* Returns 1 when the focused window belongs to a terminal emulator, else 0. */
/* Returns 1 when the focused window belongs to a terminal emulator, else 0.
Cached by focused Window with a 1000ms TTL, so key bursts on the same window
avoid redundant 12-level XQueryTree walks, while focus changes invalidate immediately. */
int x11_terminal_shortcut_state(void) {
static Window cached_window = 0;
static int cached_terminal = 0;
static struct timespec last_query = {0, 0};
if (!g_probe && !(g_probe = XOpenDisplay(NULL))) return 0;
Window focus = 0; int revert = 0;
XGetInputFocus(g_probe, &focus, &revert);
if (focus == None || focus == PointerRoot) return 0;
if (focus == None || focus == PointerRoot) {
cached_window = 0;
cached_terminal = 0;
return 0;
}
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
long diff_ms = (now.tv_sec - last_query.tv_sec) * 1000 + (now.tv_nsec - last_query.tv_nsec) / 1000000;
if (focus == cached_window && last_query.tv_sec != 0 && diff_ms >= 0 && diff_ms < 1000) {
return cached_terminal;
}
Window cur = focus;
for (int depth = 0; depth < 12 && cur; depth++) {
XClassHint hint = {0};
@@ -344,14 +362,28 @@ int x11_terminal_shortcut_state(void) {
int terminal = class_is_terminal(hint.res_name) || class_is_terminal(hint.res_class);
if (hint.res_name) XFree(hint.res_name);
if (hint.res_class) XFree(hint.res_class);
cached_window = focus;
cached_terminal = terminal;
last_query = now;
return terminal;
}
Window root, parent, *children = NULL; unsigned int n = 0;
if (!XQueryTree(g_probe, cur, &root, &parent, &children, &n)) return 0;
if (!XQueryTree(g_probe, cur, &root, &parent, &children, &n)) {
cached_window = 0;
cached_terminal = 0;
return 0;
}
if (children) XFree(children);
if (parent == root) return 0;
if (parent == root) {
cached_window = 0;
cached_terminal = 0;
return 0;
}
cur = parent;
}
cached_window = focus;
cached_terminal = 0;
last_query = now;
return 0;
}
+103
View File
@@ -0,0 +1,103 @@
# UU native gamepad experiment / 原生手柄实验
Status: experimental and default OFF; opt in with `UU_VIEWER_NATIVE_GAMEPAD=1`.
One reporting user tested input, phone-hotspot WAN, reconnect and rumble on one
Windows/Steam Deck pair; the upstream maintainer has not independently tested it.
This does not establish compatibility with every official UU version.
## Evidence (2026-10-31)
Official Windows installer 4.45.0.4318, obtained from NetEase's release endpoint
`https://api.nrd.nie.163.com/api/v1/release/dl/1?channel=gwqd`.
Only inspected locally; no NetEase binaries/assets are included in this project or deliverable.
- `GameViewerServer.exe` SHA256 `af3a15c3887e06bfa9506971e01cd8ec58f41efe8ac9eb5831e31dae1fc1cef8`
- `GameViewer.exe` SHA256 `ef7112e173cdc6d74735c50292cf9750082ce351cdea60dc068fc2b60f3aa92e`
- All addresses below are RVAs, not absolute process addresses. Image base is 0x140000000.
- Lead: https://github.com/djkcyl/uu-enhance/blob/main/src/hooks.cpp identifies older
GamepadManager Connect/Disconnect/Update log strings. Its server.cpp identifies corresponding
GamepadManagerServer handlers. No hook code or DLL injection is used here.
Receiver static inspection:
| RVA | Observation |
| --- | --- |
| 0x5dea50 | Raw JSON handler skips heartbeat messages, reads `action`, routes prefix `gpd_` to dispatcher through thunk 0x657d0. |
| 0x5dde60 | Dispatcher recognizes `gpd_update`, `gpd_connect`, `gpd_disconnect`. Connect/disconnect read `index` as a byte. |
| 0x5ddb30 | State decoder requires `index`, `buttons`, `left_trigger`, `right_trigger`, `left_thumb_x`, `left_thumb_y`, `right_thumb_x`, `right_thumb_y`. |
| 0x5dfba0 | ViGEm output: low 16 bits of buttons, two 8-bit triggers and four 16-bit stick values copied into an XUSB report; target selected by index. Missing target attempts auto-connect; missing driver drops updates. |
| 0x5df5d0 | Vibration JSON builder: `action: gpd_vibration`, `index`, `left_motor`, `right_motor`; all three numeric values read as bytes. |
| 0x5dfe80 | ViGEm feedback callback constructs index/left/right byte record, calls vibration serializer, then 0x5df580 (via thunk 0x1c1e3) to forward JSON through its session interface. |
Official viewer corroboration:
- 0x10369d0 builds JSON object with `action: gpd_connect`, numeric `index`.
- 0x1036d20 builds disconnect object.
- 0x1037070 builds update object using exactly the receiver fields above, unsigned numeric
buttons/index/triggers and signed thumb values.
- Viewer 0xc1c630 dispatches raw JSON action `gpd_vibration` alongside cursor notifications.
Viewer 0x10331a0 parses index/left_motor/right_motor into three bytes.
This supports sending JSON through the existing binary CONTROL input path (`Peer::send_input`),
with input reported working by the reporting user on their Windows/Deck pair.
No guessed new protobuf feature flags are advertised. Existing desktop negotiation is retained.
## Implementation and limits
`src/viewer/native_gamepad.rs` reads a single SDL GameController inside the desktop viewer.
It maps SDL buttons to XInput and reverses Y axes (including -32768 saturation), converts triggers
0..32767 to 0..255, uses slot 0, sends changes and a 100 ms state refresh. Guide button is omitted.
More than one mapped controller at discovery is deliberately ambiguous and none is opened.
Focus loss, local control menu, view-only, unplug or normal shutdown: send neutral then disconnect.
On entry/re-entry, require released buttons/triggers/sticks before arming. Back+Start toggles pause.
Normal cleanup uses bounded send attempts. Host behavior after SIGKILL/network loss remains
unverified; no host-side input watchdog interval has been established.
Very short taps entirely between SDL samples can be missed. Multi-controller is not implemented.
Logged markers describe local activity only; CONNECT_QUEUED is not an ACK.
## Rumble / 震动回传
`native_rumble.rs` parses the verified flat JSON `{action:"gpd_vibration",index:0,left_motor:0..255,right_motor:0..255}`
on the existing peer's CONTROL channel. It rejects malformed/duplicate fields, wrong types/ranges,
nonzero slot and messages over 512 bytes. The exact shape is backed by static inspection; receipt
on the CONTROL hook must still be verified on other Windows/Deck configurations; the reporting user has reported successful rumble on their pair.
Only the current focused, armed SDL controller enables its peer-local inbox; a single latest-value slot
prevents a backlog from replaying after a pause. Feedback for inactive sessions is discarded.
Motor strength scales by 257 into SDL's 0..65535 range. SDL `set_rumble` receives left/low-frequency
and right/high-frequency values. Normal zero feedback stops immediately. Sustained rumble refreshes
every 250 ms with a finite 1000 ms hardware effect, because the host may send only state changes.
An active viewer keeps the last desired state until a new message or focus/connection/pause change;
there is no unsupported assumption that a quiet host must periodically repeat feedback.
Pending nonzero commands older than 500 ms are discarded; stop commands are always honored.
Pause, focus loss, view-only, unplug, detected peer disconnection and normal exit stop rumble and
discard the queue. A blocked/crashed viewer cannot keep renewing the 1000 ms SDL effect. Physical
network loss detection still depends on WebRTC; this is not a one-second network watchdog.
Output failure disables rumble until controller rediscovery/restart while preserving input.
SDL API reference: https://wiki.libsdl.org/SDL2/SDL_GameControllerRumble . A successful SDL call
does not prove the hardware moved. Steam Input/SteamOS rumble configuration and physical Deck
feedback remain dependent on each installation. This implements ordinary two-motor rumble, not adaptive
triggers or arbitrary touchpad haptic waveforms. `UU_VIEWER_NATIVE_RUMBLE=0` disables feedback.
Markers (no payload values): RUMBLE_SUPPORTED/UNAVAILABLE describe SDL capabilities;
RUMBLE_RECEIVED means a valid active-session message arrived; RUMBLE_APPLIED means SDL returned
success for a nonzero effect; RUMBLE_OUTPUT_FAILED means the output API failed. All have DECKPAD_ prefix.
## Validation / 验证
Use the CI checks on the current PR head as the automated validation record.
The tests cover protocol fields and ranges, activation/release gating, bounded
feedback delivery, finite rumble effects and shared CONTROL delivery alongside
file operations. Automated tests do not exercise physical controller feedback
or establish official-host compatibility.
自动验证以当前 PR 提交的 CI 结果为准;实机结果来自报告用户,不能视为上游维护者
已验收,也不涵盖全部主机版本、休眠、强制退出和断网恢复场景。
## Attribution / AI assistance
The native gamepad and rumble implementation, regression tests and this evidence document were
prepared with OpenAI Codex assistance. The user supplied requirements and reported the hardware
acceptance results. Existing project design, code and attribution belong to the upstream contributors.
Binary file not shown.

After

Width:  |  Height:  |  Size: 50 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 51 KiB

+166
View File
@@ -0,0 +1,166 @@
# 实验性防窥 / Experimental privacy screen
仅支持 KDE Plasma Wayland(portal 后端)。开启后,采集和输入切换到 KWin 虚拟输出
(portal ScreenCast 的 VIRTUAL 源),再用 `kscreen-doctor` 禁用物理屏;远程操作不会点亮
本机屏幕。关闭、最后一个桌面连接断开或正常退出时,先重新启用物理屏,再结束虚拟输出、切回物理屏采集。
顺序参考 KRdp 虚拟显示器的 replace 策略和 Sunshine 的 KDE 方案:创建虚拟输出前记录物理屏,
从不禁用虚拟输出本身(KWin bug 527747)。GNOME、其他 Wayland 桌面和 X11 不支持。
壁纸模式:窗口随物理屏禁用迁到虚拟输出后,重新启用物理屏,把虚拟输出设为主屏、用 KWin 脚本把窗口
留在虚拟输出上,再由 `privacy-wallpaper` 子进程在每块物理屏上全屏置顶显示 Plasma 当前桌面壁纸和
“此设备正在被远程控制”。物理屏开着时 uinput 绝对坐标覆盖整个布局,主机按虚拟输出在布局中的位置换算。
需要 GTK3。
KDE Plasma Wayland only (portal backend). Enabling moves capture and input to a KWin virtual
output (portal ScreenCast VIRTUAL source) and disables the physical outputs with `kscreen-doctor`,
so remote input cannot wake them. Disabling, the last desktop disconnect or a normal exit re-enables
the physical outputs first, then ends the virtual share and returns to the monitor. Physical outputs
are recorded before the virtual one exists; the virtual output itself is never disabled (KWin bug
527747). GNOME, other Wayland desktops and X11 are unsupported.
Wallpaper mode: after the windows have moved to the virtual output, the physical outputs are turned
back on as secondary outputs, a KWin script keeps the windows on the virtual one, and the
`privacy-wallpaper` child process covers each physical output with Plasma's desktop wallpaper and a
notice (fullscreen, keep-above). uinput's absolute axes then span the whole layout, so pointer input
is aimed at the virtual output's region. Needs GTK3.
注意 / Notes:
- 虚拟屏分辨率由 KDE 决定(默认 1920x1080,首次可能在本机弹窗选择,之后沿用保存的授权
`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.
- KDE 不处理虚拟输出共享上的 portal 输入,防窥期间指针、按键和文字改走 uinput(需要 `/dev/uinput`
权限,见 README);手机拖动手势在此期间按普通鼠标拖动处理。
KDE ignores portal input on a virtual-output share, so pointer, keys and text use uinput while the
privacy screen is on (`/dev/uinput` access required); mobile drag gestures act as plain mouse drags.
- 开启期间通过 KWin 的 InputDevice 接口禁用本地键盘、鼠标、触摸板和触摸屏(含手势守护进程、ydotoold
等由本机驱动的虚拟设备),保留电源键、合盖开关和主机自己的 uinput 设备;`UU_PRIVACY_BLOCK_INPUT=0` 关闭此项。
KWin 会保存设备开关,所以主机另起 `privacy-guard` 子进程:主机以任何方式结束(包括 SIGKILL)都会按恢复记录
重新启用设备和物理屏;下次启动也会重试。防窥期间新插入的设备不会被禁用。
While on, local keyboards, pointers, touchpads and touchscreens are disabled through KWin's
InputDevice interface (including software devices fed by local hardware such as gesture daemons and
ydotoold); the power button, lid switch and the host's own uinput devices stay. Set
`UU_PRIVACY_BLOCK_INPUT=0` to keep local input. KWin saves the device flag, so a `privacy-guard`
child restores devices and outputs from the record whenever the host ends, including SIGKILL; the
next start retries too. Devices plugged in during privacy are not blocked.
- 自动开启:`UU_PRIVACY_AUTO=picture`(或 `2`)在第一个桌面控制端连上后自动启用隐私屏保,
`UU_PRIVACY_AUTO=screen-off`(或 `3`)自动关屏;默认关闭。远程协助(访客)的桌面会话同样适用。
控制端自己的请求优先:一次会话里只要客户端发过隐私请求(包括连接刚建立、会话计数还没开始的
那一刻),待执行的自动开启就不再触发;断开后照常恢复。主机不支持或依赖缺失时只记日志,不影响连接。
自动开启后主机会向控制端推送一次 SystemMetrics 和 SystemStateChange,控制端菜单随之更新。支持的主机上,
每次桌面连接也会先推送一次当前状态(关闭时为关闭),这是新增的主动上报。
Auto: `UU_PRIVACY_AUTO=picture` (or `2`) enables picture mode when the first desktop controller
connects; `screen-off` (or `3`) turns the physical screens off. Off by default. Remote-assistance
(guest) desktop sessions are covered too. The viewer's own request wins for that session, including
one that arrives right after the connection opens and before the session counter starts: a pending
auto-enable then does not run, and a disconnect restores as usual. Unsupported hosts or missing
tools only log; the connection is unaffected. After an auto-enable the host pushes SystemMetrics
and SystemStateChange once, so the viewer's menu follows; on supported hosts every desktop
connection also pushes the current state first (off when it is off), which is new outbound traffic.
- 这是尽力而为的遮挡,不是保密边界。/ This is best-effort obscuring, not a confidentiality boundary.
- 恢复记录保存在配置文件旁的 `privacy-power.json`(0600);崩溃后下次启动重新启用记录的物理屏。
若主机无法启动,可在本机终端执行 `kscreen-doctor output.<name>.enable`。
The recovery record `privacy-power.json` (0600) re-enables the recorded outputs at the next start
after a crash; manually: `kscreen-doctor output.<name>.enable`.
- 需要 coreutils `timeout`、`gdbus` 和可用的 uinput(`/dev/uinput` 可写,且未设 `UU_INPUT_BACKEND=native`);
缺少时请求在改动屏幕和设备之前被拒绝。隐私模式的遮挡窗口建好后才算开启,失败即回滚。
Requires coreutils `timeout`, `gdbus` and working uinput (`/dev/uinput` writable, not
`UU_INPUT_BACKEND=native`); otherwise the request is refused before outputs or devices change.
Picture mode counts as on only after the cover window reports ready; a failure rolls back.
## 协议 / Protocol
字段号来自官方 Mac 客户端的 SwiftProtobuf name map / Field numbers from the Mac UURemote name maps:
- RPC 7 `PrivateScreenSettingRequest {1 enable, 2 privacy_type, 3 setting_source}` → RpcResponse 3
`{1 error_code, 2 req_privacy_type, 3 cur_privacy_type}`;PrivateScreenType 2 隐私/picture, 3 关屏/screen off。
主机先应答再切换(客户端约数秒超时,报 9998);切换失败发 ReportError -7。
The host answers before switching (the viewer times out with 9998); a failed switch sends ReportError -7.
成功不发送 ReportError;Mac 4.43.0 的 -9 是系统会话变化提示,不是防窥成功通知。
Success does not send ReportError; -9 in Mac 4.43.0 reports a system session change, not privacy success.
- 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`
上报当前实际模式(1 关闭、2 屏保、3 关屏),不使用 host_settings.json 中的历史选项;SystemStateChange 5
`PrivateScreenState` 在状态变化时推送。
SettingMetric 4/7 report the effective mode (1 off, 2 picture, 3 screen off), not the saved preference;
SystemStateChange 5 is sent after a switch.
Mac 4.43.0 从 CONTROL 发送请求,但只在 TEXT 接收分支处理上述 RPC 应答与 SystemMetrics。
防窥与屏保应答走 TEXT;SystemMetrics 同步发送到 TEXT,并保留 CONTROL 上报以兼容其他客户端。
每个 peer 独立排队,TEXT 打开后才发送;待发 SystemMetrics 只保留最新一条,其他应答最多 64 条,
按入队顺序发送。满队列时丢弃新增应答并记录一次警告,不阻塞 CONTROL 请求处理。
SystemMetrics 优先读取非零的 field 7,仅在其为 0 时回退
到 field 4。SystemMetrics field 1 `metrics` 必须列出本次报告的类型(general=1、setting=2),
否则客户端直接忽略消息内容。已用原签名 Mac 4.43.0 客户端验证三种模式的安全浮层回显,
关屏后断开恢复物理屏与输入设备,再次连接回显“不启用”。
Mac 4.43.0 sends requests on CONTROL, but handles these RPC responses and SystemMetrics only on TEXT.
Privacy/screensaver replies use TEXT; SystemMetrics are also sent on TEXT, retaining CONTROL for other
viewers. Each peer queues messages until its TEXT channel opens, retaining only the latest pending
SystemMetrics and up to 64 other replies in FIFO order. Excess replies are dropped with one warning
per peer, without blocking CONTROL request handling. Nonzero field 7 takes precedence over
field 4. SystemMetrics field 1 `metrics` must list the reported sections (general=1, setting=2), or the
viewer ignores the payload. The original signed Mac 4.43.0 viewer was verified for all three labels,
physical-screen/input restoration on disconnect, and an off label after reconnecting.
官方主机侧依据:原签名 Mac `UURemoteServer` 4.43.0(626),arm64 UUID
`7E10CB24-F516-3728-8375-BA5EC124A2C5`。`SystemMetricsHandler.handleSystemMetrics`(`0x10000a96c`)
按请求填充各节,general 分支在 `0x10000abe8` 追加 `1`,setting helper(`0x10000a230`)
在 `0x10000a64c` 追加 `2`;`GvPb_SystemMetrics.traverse`(`0x100423840`)将列表按 packed enum
写入 field 1。发送链 `0x10000b11c → 0x10018e948 → ControlledSendTextData:data:` 使用 TEXT。
这是静态主机代码依据:请求 general 和 setting 时得到 `[1,2]`,不是抓包,也不表示每条响应都固定
包含两节或证明官方 CONTROL 报文。本实现总是报告两节,因此列出 `[1,2]`。
Official host evidence: the original signed Mac `UURemoteServer` 4.43.0 (626), arm64 UUID
`7E10CB24-F516-3728-8375-BA5EC124A2C5`. `SystemMetricsHandler.handleSystemMetrics` (`0x10000a96c`)
fills the requested sections, appending GENERAL=1 at `0x10000abe8` and SETTING=2 at `0x10000a64c`
in helper `0x10000a230`. `GvPb_SystemMetrics.traverse` (`0x100423840`) encodes that list as packed
field 1. The send chain `0x10000b11c → 0x10018e948 → ControlledSendTextData:data:` uses TEXT.
This is static host-code evidence: requesting both sections produces `[1,2]`; it is not a packet
capture or proof that every response includes both sections or that the official host sends it on
CONTROL. Our payload always reports both sections, so it lists `[1,2]`.
Android 4.43.0 已确认打开 TEXT;主机日志和手机端人工验收确认,关屏、隐私屏保、取消三种操作的
实际模式与菜单选中状态均正确。Windows/iOS 未在本轮验收。
Android 4.43.0 opens TEXT; host logs and manual phone-side acceptance confirmed that screen-off,
picture and off operations update both the effective mode and the selected menu item.
Windows/iOS were not tested in this round.
## 本机诊断 / Local diagnostic
禁用物理屏 5 秒后恢复,不登录、不启动第二个主机;先停止使用同一配置目录的主机。
Disables the physical outputs for five seconds, then restores them. Stop the host first.
```sh
cargo build --locked --features wayland,portal --bin uuremote-server
target/debug/uuremote-server privacy-screen-probe
UU_PRIVACY_PROBE_WALLPAPER=1 target/debug/uuremote-server privacy-screen-probe # 壁纸模式 / wallpaper mode
```
## 代码结构 / Code layout
`src/privacy_screen/` 分两层:与桌面无关的控制器和共享部件,以及每种桌面一个后端。
The module has a desktop-independent controller with shared parts, and one backend per desktop.
| 文件 / File | 职责 / Responsibility |
|---|---|
| `mod.rs` | 控制器:桌面会话计数、模式切换(先恢复再进入)、失败回滚、崩溃恢复、probe / controller: sessions, mode switch (leave, then enter), rollback, crash recovery, probe |
| `mode.rs` | `Mode { Picture, ScreenOff }` ↔ 协议 `privacy_type` 1 关 / 2 隐私 / 3 关屏 |
| `protocol.rs` | RPC 7 请求解析与 RpcResponse 3 编码 / request parsing and response encoding |
| `backend.rs` | `Backend` trait 与按桌面选择后端 / the trait and backend selection |
| `record.rs` | 恢复记录 `{backend, mode, data}`、进程锁、`Journal` / recovery record, process lock, journal |
| `guard.rs` | `privacy-guard` 子进程:主机以任何方式结束都按记录恢复 / restores from the record however the host ends |
| `cover.rs` | `privacy-wallpaper` 子进程:GTK 全屏遮挡窗口 / GTK cover window process |
| `tool.rs` | 带超时的外部命令、gdbus、等待生效 / bounded tool calls, gdbus, wait-until |
| `kde/` | KDE 后端:`outputs.rs` kscreen-doctor 布局,`input.rs` KWin 输入设备,`kwin.rs` KWin 脚本,`mod.rs` 编排 |
新增桌面(X11、GNOME…)只需实现 `Backend` 并在 `backend::detect` / `backend::named` 登记:
`enter` 在每一步改动之前通过 `Journal::save` 写入足以撤销它的数据;`leave` 只依据这些数据撤销,
因为崩溃恢复时(守护进程或下次启动)没有桌面视频流。Picture 模式可复用 `cover::show`;
若物理屏保持开启而 uinput 坐标覆盖整个布局,返回 `Entered::pointer_region`。
To add a desktop (X11, GNOME, ...), implement `Backend` and register it in `backend::detect` and
`backend::named`. `enter` saves, through `Journal::save`, what undoes each step before making it;
`leave` must undo from that data alone, because crash recovery (guard or next start) has no
desktop stream. Picture mode can reuse `cover::show`; when physical outputs stay on and uinput's
axes span the whole layout, return `Entered::pointer_region`.
+25
View File
@@ -0,0 +1,25 @@
控制端新增可选手柄/震动与外观设置,修复 niri 剪贴板与高帧率丢帧;源码构建的 Portal 进程内 VAAPI/音频。/ Opt-in gamepad and appearance settings for the viewer, niri clipboard and high-frame-rate fixes, and in-process Portal VAAPI/audio for source builds.
### 修复 / Fixed
- **niri 主控端与官方 Windows 被控端的双向文本剪贴板(#139、#138,感谢 @tingfeng347)**:niri + Wayland 下检测到 `wl-paste`/`wl-copy` 时改用 wl-clipboard,同步不再依赖窗口焦点;缺少时回退 SDL,其他桌面不变。
niri viewer: two-way text clipboard with official Windows hosts now uses wl-clipboard when available, falling back to SDL.
- **控制端高帧率(如 144 FPS)下压缩帧队列溢出、反复请求关键帧(#143,感谢 @azuredreamblu-design)**:每轮最多解码 8 个单元(4 ms 软预算),只呈现最新画面,队列 3→8。
Viewer: compressed frames are decoded in bounded batches so sustained 144 FPS no longer overflows the queue.
- **`inproc-av` 在 GNU ld `--as-needed` 下链接失败(#105,感谢 @ferstar)**:依赖库改到静态引擎库之后链接(仅影响源码构建)。
Source builds: `inproc-av` link order fixed for `--as-needed`.
### 新增 / Added
- **控制端可选原生手柄与震动(连官方 Windows 被控端,#142,感谢 @azuredreamblu-design)**:`UU_VIEWER_NATIVE_GAMEPAD=1` 启用转发,`UU_VIEWER_NATIVE_RUMBLE=0` 单独关闭震动;默认关闭。
Viewer: opt-in controller forwarding and rumble for Windows hosts (`UU_VIEWER_NATIVE_GAMEPAD=1`).
- **GTK 界面统一扁平样式,新增 跟随系统 / 浅色 / 深色 外观选项(#144,感谢 @xfjm136)**。
GTK windows: refreshed styling with System / Light / Dark appearance.
- **源码构建 `wayland,portal,inproc-av` + 显式 VAAPI:Portal DMA-BUF 零拷贝编码、进程内 Opus 音频、锁屏下控制经 uinput(#145,感谢 @ferstar)**;失败时回退原 FFmpeg 管线。预编译包不含该特性。
Source builds with `wayland,portal,inproc-av`: zero-copy VAAPI from Portal DMA-BUF, in-process Opus audio and lock-screen input via uinput. Not in prebuilt packages.
### 验证范围 / Validation
单元测试与 CI(含 GTK 冒烟测试、`inproc-av`/Portal 特性构建)。手柄、高帧率解码、niri 剪贴板和 Portal VAAPI 由各贡献者在各自环境实机验证;维护者尚未用官方客户端复测。
### 下载 / Download
`uu-remote-linux_0.2.42_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.42-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.42`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+15
View File
@@ -0,0 +1,15 @@
KDE Wayland 被控端新增实验性防窥模式。/ Experimental privacy screen for KDE Wayland hosts.
### 新增 / Added
- **KDE Wayland 被控端防窥模式(隐私 / 关屏,#146,感谢 @ferstar,对应 #140)**:控制端开启防窥后,采集与输入切到 KWin 虚拟输出,物理屏关闭或以壁纸遮挡,本地键鼠暂停;主机进程以任何方式退出都会恢复屏幕和输入。需要 `kscreen-doctor` 与 uinput 权限。
KDE Wayland hosts: privacy screen (privacy / screen-off) switches capture and input to a KWin virtual output and blanks or covers the physical display; local input is paused and restored on any host exit. Requires `kscreen-doctor` and uinput access.
- 已知限制:Mac 控制端的防窥菜单切换后仍显示“不启用”,实际模式正确;X11 与其他 Wayland 桌面暂不支持。
Known limitation: the Mac viewer menu still shows "off" after switching; X11 and other Wayland desktops are not supported yet.
### 验证范围 / Validation
单元测试与 CI。防窥模式由贡献者在 KDE Wayland 实机验证;维护者尚未用官方客户端复测。
### 下载 / Download
`uu-remote-linux_0.2.43_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.43-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.43`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+13
View File
@@ -0,0 +1,13 @@
Mac 控制端防窥菜单正确显示当前模式。/ The Mac viewer privacy menu now shows the active mode.
### 修复 / Fixed
- **Mac 控制端防窥状态回显(#147、#148,感谢 @ferstar)**:防窥切换应答与 SystemMetrics 改经 TEXT 通道发送(TEXT 打开前排队,metrics 只保留最新一份),SystemMetrics 带上报告的分节列表并报告当前防窥模式,修复 v0.2.43 中菜单切换后仍显示“不启用”的问题。
Privacy replies and SystemMetrics are now also delivered over the TEXT channel (queued until it opens, keeping only the latest metrics); SystemMetrics lists its reported sections and the current privacy mode, so the Mac viewer menu no longer shows "off" after switching.
### 验证范围 / Validation
单元测试与 CI。贡献者在 KDE Wayland + Mac 控制端实机验证;维护者尚未用 Windows/iOS/Android 控制端复测。
### 下载 / Download
`uu-remote-linux_0.2.44_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.44-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.44`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+13
View File
@@ -0,0 +1,13 @@
控制端远程窗口不再被本地输入法截获按键。/ The viewer's remote window no longer lets the local IME swallow keys.
### 修复 / Fixed
- **控制端本地输入法截获按键(#149、#150,感谢 @xfjm136)**:SDL 远程桌面窗口创建后关闭本地文本输入,按键只按物理键转发,由被控端输入法处理;修复本地与远端都用 Shift 切换中英文时,Shift 等按键被本地输入法吞掉的问题。不修改系统输入法设置,GTK 启动器不受影响。
The SDL remote desktop window now disables local text input after creation, so keys are forwarded as physical keys and the remote IME handles composition; Shift and similar keys are no longer swallowed by the local IME. System IME settings and the GTK launcher are unchanged.
### 验证范围 / Validation
单元测试(含 SDL dummy 子进程测试)与 CI。贡献者在 KDE Wayland + Fcitx5 连接 Windows 实机验证;其他桌面/输入法后端未复测。
### 下载 / Download
`uu-remote-linux_0.2.45_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.45-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.45`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+13
View File
@@ -0,0 +1,13 @@
Linux 复制的文本可直接粘贴到 Windows 控制端。/ Text copied on Linux now pastes in the Windows viewer.
### 修复 / Fixed
- **Linux → Windows 文本剪贴板无法粘贴(#151,感谢 @afwer1231 的定位)**:主机提供 Unicode 文本格式时,格式名改用官方 Windows 端的 `predefined_13`(id 仍为 13)。此前的 `CF_UNICODETEXT` 名字会让 Windows 控制端注册一个同名的自定义格式,文本虽已到达但普通粘贴读不到。Mac 控制端按 id 13 识别,不受影响。
The host now names its Unicode text offer `predefined_13` (id 13), as official Windows peers do. The previous `CF_UNICODETEXT` name made the Windows viewer register a custom format of that name, so the text arrived but normal paste could not read it. The Mac viewer matches by id 13 and is unaffected.
### 验证范围 / Validation
单元测试与 CI;格式名依据官方 Windows/Mac 程序中的字符串对照(推断)。尚未在 Windows 控制端实机验证。
### 下载 / Download
`uu-remote-linux_0.2.46_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.46-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.46`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+17
View File
@@ -0,0 +1,17 @@
官方客户端的设备卡片在未连接时也能显示 Linux 主机的壁纸。/ Device cards in official clients now show the Linux host's wallpaper while disconnected.
### 新增 / Added
- **上报系统壁纸(#152/#153,感谢 @ferstar)**:已登录的图形主机按官方 Windows 被控端的流程获取文件令牌、上传当前壁纸并回报地址,每 60 秒检查一次,内容不变不重复上传。支持 GNOME/Cinnamon、KDE(Plasma 5/6,含壁纸包和主题默认壁纸)、Xfce;其他桌面可用 `UU_WALLPAPER=/绝对路径/图片` 指定(PNG/JPEG/WebP)。访客与无桌面模式不上报。
Signed-in graphical hosts fetch a file token, upload the current wallpaper and report its URL, following the official Windows host. Checks run every 60 seconds; unchanged content is not re-uploaded. Supports GNOME/Cinnamon, KDE (Plasma 5/6, including wallpaper packages and theme defaults) and Xfce; other desktops can set `UU_WALLPAPER=/absolute/path/image`. Guest and headless hosts skip it.
### 隐私 / Privacy
默认会把当前壁纸图片上传到 UU 的文件服务;设置 `UU_WALLPAPER_UPLOAD=0` 可关闭。日志只记录结果和失败阶段。
By default the current wallpaper image is uploaded to UU's file service; set `UU_WALLPAPER_UPLOAD=0` to disable. Logs record only the outcome and failing stage.
### 验证范围 / Validation
单元测试与 CI;贡献者在 KDE 上实机确认官方客户端显示壁纸。GNOME/Cinnamon、Xfce 尚无实机验收;多屏、动态/XML 壁纸不在本次范围。
### 下载 / Download
`uu-remote-linux_0.2.47_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.47-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.47`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+19
View File
@@ -0,0 +1,19 @@
防窥模式可在连接时自动开启,查看端组合键和启动器图标修复,信令失败日志更易诊断。/ Optional auto-enabled privacy screen, viewer modifier and launcher icon fixes, and clearer signaling failure logs.
### 新增 / Added
- **连接时自动开启防窥(#161,感谢 @RiverOnVenus)**:设置 `UU_PRIVACY_AUTO=picture`(隐私屏保)或 `screen-off`(关闭显示屏),第一个桌面控制端连上后自动开启;默认关闭。控制端自己的防窥请求优先,不覆盖已保存的偏好;远程协助会话同样适用。仅 KDE Plasma Wayland(portal)。
Set `UU_PRIVACY_AUTO=picture` or `screen-off` to enable the privacy screen when the first desktop controller connects (off by default). The viewer's own request wins and the saved preference is not overwritten; remote-assistance sessions are covered too. KDE Plasma Wayland (portal) only.
- **Omarchy 壁纸自动发现(#157,感谢 @ferstar)**:Hyprland 下的 Omarchy 自动跟随当前壁纸上报。/ Omarchy on Hyprland reports its current background automatically.
### 修复 / Fixed
- **查看端组合键(#163/#165,感谢 @Zhenqiang-Weng)**:窗口失焦再聚焦后,仍按住的 Shift/Ctrl/Alt/Win(Mac 为 Command)在下一次按键前恢复,不再丢失修饰键。/ The native viewer restores still-held modifiers after a focus change.
- **启动器图标(#158,感谢 @Zhenqiang-Weng)**:改用系统主题符号图标,缺少 emoji 字体时不再显示方框。/ Launcher icons use the system icon theme instead of emoji glyphs.
- **信令连接失败日志(#166)**:记录脱敏后的失败原因(类别或 HTTP 状态码,不含 token 和地址),区分服务端拒绝与网络问题。/ Signaling connection failures now log a sanitized reason (category or HTTP status).
### 验证范围 / Validation
单元测试与 CI;防窥自动开启由贡献者在 KDE Plasma 6 Wayland + iOS 客户端实机验证。查看端修复为合成事件测试,未做 Mac 主机实机验收。
### 下载 / Download
`uu-remote-linux_0.2.48_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.48-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.48`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+16
View File
@@ -0,0 +1,16 @@
查看端显示远端光标形状,KDE 防窥遮罩不再出现在任务栏。/ The native viewer mirrors remote cursor shapes, and the KDE privacy cover no longer appears in the task manager.
### 新增 / Added
- **查看端远端光标形状(#168,感谢 @Zhenqiang-Weng)**:SDL 查看端使用主机经现有 CONTROL 消息发来的光标图片和热点(文本、调整大小等),指针离开画面、悬停本地控件或失焦时恢复本地箭头。光标 PNG 有大小和尺寸上限,日志只记录数量和尺寸。
The SDL viewer applies the host's cursor image and hotspot from the existing CONTROL message, restoring the local arrow outside the picture, over local controls and on focus loss. Cursor PNGs are size-bounded; logs record only counts and dimensions.
### 修复 / Fixed
- **KDE 防窥遮罩不进任务栏(#169,感谢 @RiverOnVenus)**:隐私屏保模式下,遮罩窗口通过 KWin 脚本设为不显示在任务管理器中(含多显示器的每个遮罩)。/ In picture mode, the cover windows (one per monitor) are hidden from the task manager through KWin scripting.
### 验证范围 / Validation
单元测试与 CI;KDE 遮罩修复由贡献者在 Plasma 6.8 Wayland 单屏实机验证,多屏未实测。光标形状未做官方主机实机验收。
### 下载 / Download
`uu-remote-linux_0.2.49_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.49-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.49`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+18
View File
@@ -0,0 +1,18 @@
观看模式「批注」可用(X11),空闲主机 CPU 占用下降,防窥重启后可恢复输入设备,Portal 授权不再因中途失败丢失。/ Watch-mode annotation works on X11, idle hosts use less CPU, privacy restore survives a reboot, and rotated Portal consent is no longer lost.
### 新增 / Added
- **观看模式批注(#174,感谢 @Chr0mium24)**:主机应答官方查看端的批注 RPC(draw_req),笔迹画在可穿透点击的 X11 覆盖窗口上(需要合成器),分辨率变化时覆盖层随之重建。此前查看端报「批注开启失败(9998)」。仅 X11;Wayland、移动端查看端和多显示器未实测。
The host answers the official viewer's annotation RPC (draw_req) and draws strokes on a click-through X11 overlay (needs a compositor), rebuilt when the resolution changes. X11 only; Wayland, mobile viewers and multiple monitors untested.
### 修复 / Fixed
- **空闲主机 CPU(#172,感谢 @ferstar)**:指针工作线程在没有指针/滚轮/按键/触控手势时挂起,不再以 4 ms 周期空转(无查看端时约 3% CPU)。/ The pointer worker parks while no pointer, scroll, button or gesture work is pending, instead of ticking every 4 ms (~3% CPU idle).
- **防窥重启后恢复输入设备(#173,感谢 @RiverOnVenus)**:KDE 防窥记录按设备名称/产品/厂商匹配,重启后 eventN 编号变化也能重新启用被禁用的设备;已不存在的设备跳过,不再让后续防窥切换一直失败。/ KDE privacy records match devices by name/product/vendor, so a renumbered device is re-enabled after a reboot; missing devices are skipped.
- **Portal 授权先持久化(#175,感谢 @jinpeng2700-tech)**:Portal 返回轮换后的一次性 restore token 时立即保存,不再等首帧;采集失败或取消时不会丢失授权、下次重新弹窗。/ Rotated single-use Portal restore tokens are saved as soon as Portal returns them, so a failed or cancelled capture no longer forces a new consent prompt.
### 验证范围 / Validation
单元测试与 CI。批注由贡献者用 Mac 查看端 4.42.0 在 Ubuntu 22.04 GNOME X11 实机验证;#172 在报告者的 KDE Wayland 主机验证原始版本;#173 由贡献者在 KDE Plasma 6.8 用 release 构建回放记录验证;#175 为单元/合成测试。
### 下载 / Download
`uu-remote-linux_0.2.50_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.50-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.50`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+12
View File
@@ -0,0 +1,12 @@
Hyprland 等 wlroots 合成器上,手机查看端输入法打出的中文/符号文字可正常上屏。/ Phone IME text (Chinese and symbols) from mobile viewers now types correctly on Hyprland and other wlroots compositors.
### 修复 / Fixed
- **wlroots 手机输入法文字(#176,感谢 @Onekki)**:所有 wlroots 合成器统一用独立的虚拟文字键盘,每批文字重新 attach 键位表,ASCII 也按 Unicode keysym 发送;Wayland 下先走 keysym、失败再回退 uinput;输入前释放按键后同步原设备的修饰键状态,避免 Ctrl/Shift 残留。/ All wlroots compositors use a dedicated virtual text keyboard, re-attaching the keymap per batch and sending ASCII as Unicode keysyms; Wayland tries keysyms before falling back to uinput, and modifier state is re-synced to the original device so Ctrl/Shift do not stick.
### 验证范围 / Validation
单元测试与 CI;贡献者在 Hyprland 0.56.2 + fcitx5 实机验证。niri 等其他 wlroots 合成器未实测。
### 下载 / Download
`uu-remote-linux_0.2.51_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.51-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.51`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+18
View File
@@ -0,0 +1,18 @@
性能优化版:降低视频推流与输入通道的拷贝和解析开销,功能行为不变。/ Performance release: less copying and parsing on the video and input paths; no behavior change.
### 优化 / Improved
- **编码帧零拷贝(#184)**:编码完成帧改用共享缓冲,去掉每帧码流深拷贝。/ Encoded frames use shared buffers, removing a per-frame bitstream deep copy.
- **H.265 关键帧检测与 RTP 分包(#180、#182)**:IRAP 检测改为单趟流式扫描,HEVC RTP 分包改为零拷贝子切片。/ Single-pass streaming IRAP scan; zero-copy sub-slices for HEVC RTP packetization.
- **数据通道解析(#180、#191)**:数据通道包单次解码、CONTROL 通道 JSON 单次解析。/ Single-pass data-channel decoding and single JSON parse on the CONTROL channel.
- **X11 终端检测缓存(#182)**:100ms 缓存,减少高频查询。/ 100 ms cache for X11 terminal detection.
- **文字输入不阻塞(#189)**:文字输入移到阻塞线程池执行,保持先后顺序。/ Text input runs on the blocking pool while preserving order.
感谢 @ferstar 提交这批优化。/ Thanks to @ferstar for these optimizations.
### 验证范围 / Validation
单元测试与 CI;各 PR 经 Codex 审查。未做实机性能对比与 Mac/手机客户端界面验收。
### 下载 / Download
`uu-remote-linux_0.2.52_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.52-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.52`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+14
View File
@@ -0,0 +1,14 @@
性能优化版:Wayland(Portal)进程内推流改为事件驱动取帧,功能行为不变。/ Performance release: event-driven frame wait for in-process Wayland (Portal) streaming; no behavior change.
### 优化 / Improved
- **Portal 取帧事件驱动(#193,关闭 #192)**:Portal VAAPI 推流循环由固定间隔休眠轮询改为条件变量等待新帧(单调时钟),新帧到达即编码,空闲时不再空转。/ The Portal VAAPI loop waits on a condition variable (monotonic clock) for new frames instead of sleep-polling, so frames are encoded as soon as they arrive and idle loops no longer spin.
感谢 @ferstar 提交这项优化。/ Thanks to @ferstar for this optimization.
### 验证范围 / Validation
单元测试与 CI;PR 经 Codex 审查。未做 Wayland 实机性能对比与 Mac/手机客户端界面验收。
### 下载 / Download
`uu-remote-linux_0.2.53_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.53-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.53`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+51
View File
@@ -0,0 +1,51 @@
# SDL viewer video scheduling
## Problem and cause
The SDL viewer previously consumed at most one compressed access unit per 8 ms
tick: approximately 125 units/s. With one unit per picture, sustained 144 FPS
input can overflow its bounded queue even when decoding keeps up. Lost compressed
units can break reference-frame dependencies, causing repeated decoder resets
and keyframe recovery. Increasing queue capacity alone only delays the overflow.
## Implementation
Each tick feeds queued compressed units to the existing decoder in FIFO order,
up to 8 units. A 4 ms elapsed-work budget is checked between calls. The viewer
then presents only the newest completed picture, avoiding redundant presentation
of older decoded pictures. It also polls asynchronous decoder output on idle ticks.
The compressed queue holds 8 units instead of 3 to absorb short presentation
stalls; processing starts immediately without waiting for a full batch. Actual
compressed-unit loss still resets the decoder and uses the existing keyframe
gate and PLI requests. Decoder interfaces, counters and opt-in diagnostic dumps
remain available; the presentation counter counts pictures actually presented.
There are no new settings or protocol fields.
## Verification
The desktop regression tests simulate 8 seconds of 144 units/s input and 125
processing ticks/s. The old one-unit policy drops 150 units with capacity 3 and
145 with capacity 8. Bounded batching delivers all 1,152 units to a mock decoder
in order without compressed-unit loss or resets, presenting at most once per tick.
Other tests cover newest-picture selection, idle asynchronous output, recovery
after real queue overflow, and count/time budgets leaving work for the next tick.
Budget tests inject elapsed time internally rather than depending on CI timing.
Run the full viewer checks without test filters or skips:
```sh
cargo test --locked --features native-viewer,viewer-sdl --bin uuremote-viewer
cargo build --locked --features native-viewer,viewer-sdl --bin uuremote-viewer
```
## Limits and scope
The 4 ms budget cannot interrupt an already-blocked decoder call and does not
bound the subsequent presentation call. Slow decoding or rendering can still
overflow the queue. This adds no hardware decoding and guarantees neither stable
144 FPS nor 144 distinct displayed pictures on a 90 Hz screen.
Startup timeout, stream-profile synchronization, gamepad/rumble and installation
changes are outside this patch.
Implementation and regression tests were prepared with Codex assistance.
+47
View File
@@ -0,0 +1,47 @@
# Device-card wallpaper reporting
The official Windows host publishes the system wallpaper for device cards. This is separate from
the Linux viewer's local last-frame cache and does not require capturing desktop windows on disconnect.
## Static protocol evidence
Read-only analysis of the locally installed `GameViewerServer.exe` (SHA-256
`af3a15c3887e06bfa9506971e01cd8ec58f41efe8ac9eb5831e31dae1fc1cef8`) found:
- `ApplicationManager::updateWallpaper`, `getWallpaperPath`, `uploadWallpaper`, and log strings
`wallpaper check`, `wallpaper is not changed, the same md5`, `wallpaper file upload succeeded`.
The source path recorded in the executable is `server_core/business/apps/application_manager.cpp`.
- `0x140ade430`: GET `/api/v1/tool/fp/token?filetype=1`. Response parser `0x140ae3410`
reads `token`, `req_url`, `ttl`, optional `max_size` from API data.
- `0x140aeb8c0`: POST raw file bytes to `req_url`, with `Authorization` set directly to the
file token (no Bearer prefix, multipart wrapper, or account credentials).
- Upload callback `0x140ad1010` requires HTTP 200; parser `0x140ae1550` reads top-level
`fsize`, `url`, `md5`, `mime`. The wallpaper callback `0x1404206c0` uses `url`.
- `0x140b48d80`: POST `/api/v1/device/wallpaper`, JSON `{"wallpaper_url":"<uploaded URL>"}`.
Device response parsers and the official viewer also contain `wallpaper_url`.
Addresses are preferred virtual addresses for that executable only. No official binary, assets,
account data, upload tokens, desktop pictures, or account URLs are included here.
This establishes the wallpaper flow statically; it does not prove that every official client's
last-frame display uses this flow or establish the official timer interval.
## Linux behavior
Signed-in graphical hosts check the configured wallpaper on startup and every 60 seconds, upload
only changed supported image bytes, and retry failures on a later check. Guest and headless hosts skip
reporting. Account renewal replaces the reporting task; stopping the host cancels it. Network work
does not block signaling or alter peer connections. Images are bounded to 10 MiB and the file service's
advertised limit. HTTPS is required and upload redirects are disabled.
GNOME/Unity/Cinnamon use GSettings (GNOME dark preference included); KDE reads the first image
wallpaper containment, including image packages, or the installed look-and-feel's default wallpaper
when no explicit wallpaper is configured; Xfce reads the first `last-image`. Multi-monitor selection, slideshow/XML
wallpapers and unsupported formats are not inferred.
On Hyprland, Omarchy's `omarchy/current/background` link is read from `XDG_STATE_HOME`
(default `~/.local/state`), falling back to the older `XDG_CONFIG_HOME` location
(default `~/.config`). Wallpaper/theme changes are followed on the next check.
Other compositor-specific wallpaper daemons are not inferred.
`UU_WALLPAPER=/absolute/path/image.png` selects a file explicitly; `UU_WALLPAPER_UPLOAD=0` disables
reporting. PNG, JPEG, and WebP are supported. No desktop screenshot fallback is used.
Only success/failure is logged. Paths, hashes, URLs, response bodies and credentials stay out of logs.
+538
View File
@@ -0,0 +1,538 @@
//! Viewer annotation (观看模式「批注」): the viewer draws on the host screen while watching.
//!
//! RpcRequest field 27 `draw_req` (gv_pb.DrawRequest) is answered with RpcResponse field 23
//! `draw_resp` (gv_pb.DrawResponse). Schema read from the official Mac 4.42.0 build
//! (UURemoteService: SwiftProtobuf name maps and Swift field metadata):
//!
//! - DrawRequest { oneof: 1 stroke_request, 2 clear_request, 3 toggle_request }
//! - DrawResponse { oneof: 1 stroke_response, 2 clear_response, 3 toggle_response }
//! - DrawStrokeRequest { 1 uint32 stroke_id, 2 repeated DrawPoint points, 3 optional int32 screen_id,
//! 4 optional float line_width, 5 optional uint32 color }; DrawPoint { 1 float x, 2 float y }
//! - DrawClearRequest { 1 ClearType clear_type (1 all, 2 by id), 2 uint32 stroke_id, 3 optional int32 screen_id }
//! - DrawToggleRequest { 1 bool enable }
//! - Draw*Response { 1 int32 error_code }, 0 = success
//!
//! The Mac viewer sends normalized points (`annotationNormalizedPoint`) in batches that share a
//! stroke id (`flushAnnotationStrokePoints`), clears before a screen switch and toggles off on exit.
//! Without this handler the request went unanswered and the viewer showed 「批注开启失败」.
//!
//! The strokes are drawn on a click-through X11 overlay (c_engine/annotation_overlay.c), so the
//! person at the host sees them and the capture streams them back to the viewer.
use crate::protocol::{decode_wire, WireField, WireValue};
use std::sync::mpsc;
use std::sync::{Mutex, OnceLock};
use std::time::Duration;
pub const RPC_REQUEST: u32 = 27;
pub const RPC_RESPONSE: u64 = 23;
const SLOT_STROKE: u64 = 1;
const SLOT_CLEAR: u64 = 2;
const SLOT_TOGGLE: u64 = 3;
/// error_code: the overlay cannot be shown (no X display, no compositor or no ARGB visual).
const ERR_UNAVAILABLE: i32 = 1;
/// iOS system red, opaque: the viewer sends no color of its own (Mac 4.42.0).
const DEFAULT_COLOR: u32 = 0xFFFF_3B30;
#[cfg(target_os = "linux")]
extern "C" {
fn uu_annotation_open(display: *const libc::c_char, x: libc::c_int, y: libc::c_int, width: libc::c_int,
height: libc::c_int, error: *mut libc::c_int) -> *mut libc::c_void;
fn uu_annotation_size(handle: *mut libc::c_void, width: *mut libc::c_int, height: *mut libc::c_int);
fn uu_annotation_polyline(handle: *mut libc::c_void, points: *const i16, count: libc::c_int, argb: libc::c_uint,
line_width: libc::c_int);
fn uu_annotation_clear(handle: *mut libc::c_void);
fn uu_annotation_flush(handle: *mut libc::c_void);
fn uu_annotation_poll(handle: *mut libc::c_void) -> libc::c_int;
fn uu_annotation_close(handle: *mut libc::c_void);
}
// macOS development builds: no X display, so the overlay never opens.
#[cfg(not(target_os = "linux"))]
unsafe fn uu_annotation_open(_: *const libc::c_char, _: libc::c_int, _: libc::c_int, _: libc::c_int, _: libc::c_int,
error: *mut libc::c_int) -> *mut libc::c_void { *error = 1; std::ptr::null_mut() }
#[cfg(not(target_os = "linux"))]
unsafe fn uu_annotation_size(_: *mut libc::c_void, _: *mut libc::c_int, _: *mut libc::c_int) {}
#[cfg(not(target_os = "linux"))]
unsafe fn uu_annotation_polyline(_: *mut libc::c_void, _: *const i16, _: libc::c_int, _: libc::c_uint, _: libc::c_int) {}
#[cfg(not(target_os = "linux"))]
unsafe fn uu_annotation_clear(_: *mut libc::c_void) {}
#[cfg(not(target_os = "linux"))]
unsafe fn uu_annotation_flush(_: *mut libc::c_void) {}
#[cfg(not(target_os = "linux"))]
unsafe fn uu_annotation_poll(_: *mut libc::c_void) -> libc::c_int { 0 }
#[cfg(not(target_os = "linux"))]
unsafe fn uu_annotation_close(_: *mut libc::c_void) {}
#[derive(Debug, Clone, PartialEq)]
pub enum Request {
Stroke { id: u32, points: Vec<(f32, f32)>, screen: Option<i32>, width: Option<f32>, color: Option<u32> },
Clear { all: bool, id: u32 },
Toggle(bool),
}
fn varint_field(fields: &[WireField], number: u32) -> Option<u64> {
fields.iter().find_map(|f| match (f.number, &f.value) { (n, WireValue::Varint(v)) if n == number => Some(*v), _ => None })
}
fn float_field(fields: &[WireField], number: u32) -> Option<f32> {
fields.iter().find_map(|f| match (f.number, &f.value) { (n, WireValue::Fixed32(b)) if n == number => Some(f32::from_le_bytes(*b)), _ => None })
}
fn bytes_field<'a>(fields: &'a [WireField<'a>], number: u32) -> Option<&'a [u8]> {
fields.iter().find_map(|f| match (f.number, &f.value) { (n, WireValue::Bytes(b)) if n == number => Some(*b), _ => None })
}
/// Decodes a DrawRequest body (the bytes of RpcRequest field 27).
pub fn parse(body: &[u8]) -> Option<Request> {
let fields = decode_wire(body).ok()?;
if let Some(stroke) = bytes_field(&fields, 1) {
let s = decode_wire(stroke).ok()?;
let mut points = Vec::new();
for field in &s {
if let (2, WireValue::Bytes(point)) = (field.number, &field.value) {
let p = decode_wire(point).ok()?;
points.push((float_field(&p, 1).unwrap_or(0.0), float_field(&p, 2).unwrap_or(0.0)));
}
}
return Some(Request::Stroke {
id: varint_field(&s, 1).unwrap_or(0) as u32,
points,
screen: varint_field(&s, 3).map(|v| v as i32),
width: float_field(&s, 4),
color: varint_field(&s, 5).map(|v| v as u32),
});
}
if let Some(clear) = bytes_field(&fields, 2) {
let c = decode_wire(clear).ok()?;
let kind = varint_field(&c, 1).unwrap_or(0);
return Some(Request::Clear { all: kind != 2, id: varint_field(&c, 2).unwrap_or(0) as u32 });
}
if let Some(toggle) = bytes_field(&fields, 3) {
let t = decode_wire(toggle).ok()?;
return Some(Request::Toggle(varint_field(&t, 1).unwrap_or(0) != 0));
}
None
}
fn varint(mut v: u64, out: &mut Vec<u8>) {
while v >= 128 { out.push((v as u8 & 127) | 128); v >>= 7; }
out.push(v as u8);
}
fn bytes(field: u64, v: &[u8], out: &mut Vec<u8>) {
varint(field << 3 | 2, out);
varint(v.len() as u64, out);
out.extend_from_slice(v);
}
/// RpcResponse { 1 response_header (echoed request header), 23 DrawResponse { slot: { 1 error_code } } }.
pub fn encode_response(header: &[u8], slot: u64, error_code: i32) -> Vec<u8> {
let mut result = Vec::new();
if error_code != 0 { varint(1 << 3, &mut result); varint(error_code as i64 as u64, &mut result); }
let mut draw = Vec::new();
bytes(slot, &result, &mut draw);
let mut out = Vec::new();
bytes(1, header, &mut out);
bytes(RPC_RESPONSE, &draw, &mut out);
out
}
/// (request header, DrawRequest body) of an RpcRequest 27 draw_req; None for every other RPC.
pub fn draw_request(rpc: &[WireField]) -> Option<(Vec<u8>, Vec<u8>)> {
let body = bytes_field(rpc, RPC_REQUEST)?;
Some((bytes_field(rpc, 1).unwrap_or(&[]).to_vec(), body.to_vec()))
}
/// The peer a request came from: the address of that peer's `PeerActions`. Its session tracker
/// holds the Arc until it has sent its last reset, so a newer peer cannot reuse the key meanwhile.
pub type Owner = usize;
pub fn owner<T>(peer: &std::sync::Arc<T>) -> Owner { std::sync::Arc::as_ptr(peer) as *const () as usize }
/// Applies a draw_req from `owner` and builds its RpcResponse. Blocking: a toggle waits for the overlay.
pub fn respond(owner: Owner, header: &[u8], body: &[u8]) -> Vec<u8> {
let Some(request) = parse(body) else {
log::warn!("Annotation request not understood: {}", crate::protocol::wire_shape(body, 3));
return encode_response(header, SLOT_TOGGLE, ERR_UNAVAILABLE);
};
let (slot, code) = match request {
Request::Toggle(enable) => {
let (reply, result) = mpsc::channel();
send(Command::Toggle { owner, enable, reply });
// Opening the overlay is a few X round trips; never stall the channel for long.
let code = result.recv_timeout(Duration::from_secs(2)).unwrap_or(ERR_UNAVAILABLE);
log::info!("Annotation toggle: enable={} error_code={}", enable, code);
(SLOT_TOGGLE, code)
}
Request::Clear { all, id } => {
log::info!("Annotation clear: all={} stroke_present={}", all, id != 0);
send(Command::Clear { owner, all, id });
(SLOT_CLEAR, 0)
}
stroke @ Request::Stroke { .. } => {
send(Command::Stroke(owner, stroke));
(SLOT_STROKE, 0)
}
};
encode_response(header, slot, code)
}
/// `owner`'s desktop session ended: remove its overlay and strokes. A delayed reset from a replaced
/// peer leaves the annotation of the viewer that took over alone.
pub fn reset(owner: Owner) {
if let Some(worker) = WORKER.get() {
let _ = worker.lock().unwrap().send(Command::Reset(owner));
}
}
enum Command {
Toggle { owner: Owner, enable: bool, reply: mpsc::Sender<i32> },
Stroke(Owner, Request),
Clear { owner: Owner, all: bool, id: u32 },
Reset(Owner),
/// Tests: (owner, overlay size, stroke count) while an overlay is shown.
#[cfg(test)]
Probe(mpsc::Sender<Option<(Owner, i32, i32, usize)>>),
}
static WORKER: OnceLock<Mutex<mpsc::Sender<Command>>> = OnceLock::new();
fn send(command: Command) {
let worker = WORKER.get_or_init(|| {
let (tx, rx) = mpsc::channel();
std::thread::Builder::new().name("annotation".into()).spawn(move || run(rx)).expect("annotation thread");
Mutex::new(tx)
});
let _ = worker.lock().unwrap().send(command);
}
/// A stroke keeps the viewer's points, so it can be laid out again when the overlay is rebuilt.
struct Stroke { id: u32, normalized: bool, argb: u32, line: Option<f32>, raw: Vec<(f32, f32)>, width: i32, points: Vec<i16> }
impl Stroke {
fn new(id: u32, raw: Vec<(f32, f32)>, line: Option<f32>, color: Option<u32>) -> Self {
let normalized = raw.iter().all(|&(x, y)| x.abs() <= 1.5 && y.abs() <= 1.5);
Self { id, normalized, argb: argb(color), line, raw, width: 0, points: Vec::new() }
}
/// Overlay pixels for all points; a single point is a dot (a zero-length round-capped segment).
fn layout(&mut self, width: i32, height: i32) {
self.width = line_width(self.line, height);
self.points = to_pixels(&self.raw, self.normalized, width, height);
if self.points.len() == 2 { self.points.extend_from_within(0..2); }
}
}
struct Overlay { handle: *mut libc::c_void, screen: Option<i32>, region: (i32, i32, i32, i32), width: i32, height: i32 }
impl Overlay {
fn open(screen: Option<i32>) -> Result<Self, i32> {
let region = region(screen);
let display = crate::capture::x11_display().and_then(|d| std::ffi::CString::new(d).ok());
let mut error = 0;
let handle = unsafe {
uu_annotation_open(display.as_ref().map_or(std::ptr::null(), |d| d.as_ptr()), region.0, region.1, region.2, region.3, &mut error)
};
if handle.is_null() { return Err(error); }
let (mut width, mut height) = (0, 0);
unsafe { uu_annotation_size(handle, &mut width, &mut height) };
log::info!("Annotation overlay shown: {}x{}+{}+{}", width, height, region.0, region.1);
Ok(Self { handle, screen, region, width, height })
}
fn draw(&self, stroke: &Stroke, from: usize) {
let points = &stroke.points[from.min(stroke.points.len())..];
if points.len() < 2 { return; }
unsafe { uu_annotation_polyline(self.handle, points.as_ptr(), (points.len() / 2) as libc::c_int, stroke.argb, stroke.width) };
}
fn repaint(&self, strokes: &[Stroke]) {
unsafe { uu_annotation_clear(self.handle) };
for stroke in strokes { self.draw(stroke, 0); }
self.flush();
}
fn flush(&self) { unsafe { uu_annotation_flush(self.handle) } }
}
impl Drop for Overlay {
fn drop(&mut self) {
unsafe { uu_annotation_close(self.handle) };
log::info!("Annotation overlay removed");
}
}
/// The capture region a screen id maps to: an X11 multi-screen monitor, else the whole root (0 size).
fn region(screen: Option<i32>) -> (i32, i32, i32, i32) {
if crate::wayland::x11_multiscreen() {
let id = screen.filter(|s| *s >= 0).map_or_else(crate::wayland::selected, |s| s as usize);
if let Some(o) = crate::wayland::source(id) { return (o.x, o.y, o.width as i32, o.height as i32); }
}
(0, 0, 0, 0)
}
/// Premultiplied ARGB for the 32-bit visual; a color without alpha is opaque.
pub fn argb(color: Option<u32>) -> u32 {
let c = color.unwrap_or(DEFAULT_COLOR);
let c = if c >> 24 == 0 { c | 0xFF00_0000 } else { c };
let a = c >> 24;
let mul = |shift: u32| (((c >> shift) & 0xFF) * a / 255) << shift;
a << 24 | mul(16) | mul(8) | mul(0)
}
/// Line width in overlay pixels: values up to 1 are a fraction of the height, larger ones pixels.
pub fn line_width(width: Option<f32>, height: i32) -> i32 {
match width {
Some(w) if w.is_finite() && w > 0.0 => (if w <= 1.0 { w * height as f32 } else { w }).round().clamp(1.0, 64.0) as i32,
_ => (height as f32 / 360.0).round().max(3.0) as i32,
}
}
pub fn to_pixels(points: &[(f32, f32)], normalized: bool, width: i32, height: i32) -> Vec<i16> {
let mut out = Vec::with_capacity(points.len() * 2);
for &(x, y) in points {
let (x, y) = if normalized { (x * width as f32, y * height as f32) } else { (x, y) };
let clamp = |v: f32| if v.is_finite() { v.round().clamp(-16_000.0, 16_000.0) as i16 } else { 0 };
out.push(clamp(x));
out.push(clamp(y));
}
out
}
/// The worker's state: one overlay at a time, owned by the peer that last toggled it on or drew.
#[derive(Default)]
struct Annotation { overlay: Option<Overlay>, strokes: Vec<Stroke>, owner: Owner, unavailable: bool, logged: usize }
impl Annotation {
fn close(&mut self) { self.overlay = None; self.strokes.clear(); }
/// A request from another peer: the newer viewer takes over and the old strokes go.
fn claim(&mut self, owner: Owner) {
if self.owner != owner { self.close(); self.owner = owner; self.unavailable = false; }
}
fn open(&mut self, screen: Option<i32>) -> bool {
match Overlay::open(screen) {
Ok(o) => { self.overlay = Some(o); true }
Err(error) => { log::warn!("Annotation overlay unavailable: error={}", error); self.unavailable = true; false }
}
}
fn stroke(&mut self, id: u32, points: Vec<(f32, f32)>, screen: Option<i32>, width: Option<f32>, color: Option<u32>) {
if self.overlay.as_ref().is_some_and(|o| o.region != region(screen)) { self.close(); }
// A stroke without a toggle (e.g. after a host restart) shows the overlay anyway, but only
// one attempt until the next toggle instead of one per batch.
if self.overlay.is_none() && (self.unavailable || !self.open(screen)) { return; }
if self.logged < 8 {
// Counts and presence only: the drawing itself is the viewer's content.
self.logged += 1;
let normalized = points.iter().all(|&(x, y)| x.abs() <= 1.5 && y.abs() <= 1.5);
log::info!("Annotation stroke batch: points={} normalized={} screen_set={} width_set={} color_set={}",
points.len(), normalized, screen.is_some(), width.is_some(), color.is_some());
}
let o = self.overlay.as_ref().unwrap();
match self.strokes.iter_mut().find(|s| s.id == id) {
Some(stroke) => {
let from = stroke.points.len().saturating_sub(2);
stroke.points.extend(to_pixels(&points, stroke.normalized, o.width, o.height));
stroke.raw.extend(points);
o.draw(stroke, from);
}
None => {
let mut stroke = Stroke::new(id, points, width, color);
stroke.layout(o.width, o.height);
o.draw(&stroke, 0);
self.strokes.push(stroke);
}
}
o.flush();
}
/// The root was resized (RandR; on X11 the viewer's resolution choice does this): rebuild the
/// overlay at the new geometry and lay the strokes out again.
fn follow_resize(&mut self) {
let Some(screen) = self.overlay.take().map(|o| o.screen) else { return };
if !self.open(screen) { self.strokes.clear(); return; }
let o = self.overlay.as_ref().unwrap();
for stroke in &mut self.strokes { stroke.layout(o.width, o.height); }
o.repaint(&self.strokes);
}
fn handle(&mut self, command: Command) {
match command {
Command::Toggle { owner, enable: true, reply } => {
self.claim(owner);
self.unavailable = false;
let code = if self.overlay.is_some() || self.open(None) { 0 } else { ERR_UNAVAILABLE };
let _ = reply.send(code);
}
Command::Toggle { owner, enable: false, reply } => {
if owner == self.owner { self.close(); }
let _ = reply.send(0);
}
Command::Reset(owner) => {
if owner != self.owner { return; }
if self.overlay.is_some() { log::info!("Annotation ended with the viewer session"); }
self.close();
self.unavailable = false;
}
Command::Clear { owner, all, id } => {
if owner != self.owner { return; }
if all { self.strokes.clear(); } else { self.strokes.retain(|s| s.id != id); }
if let Some(o) = &self.overlay { o.repaint(&self.strokes); }
}
Command::Stroke(owner, Request::Stroke { id, points, screen, width, color }) => {
self.claim(owner);
self.stroke(id, points, screen, width, color);
}
Command::Stroke(..) => {}
#[cfg(test)]
Command::Probe(reply) => {
let _ = reply.send(self.overlay.as_ref().map(|o| (self.owner, o.width, o.height, self.strokes.len())));
}
}
}
}
fn run(rx: mpsc::Receiver<Command>) {
let mut state = Annotation::default();
loop {
let wait = if state.overlay.is_some() { Duration::from_millis(50) } else { Duration::from_secs(3600) };
match rx.recv_timeout(wait) {
Ok(command) => state.handle(command),
Err(mpsc::RecvTimeoutError::Timeout) => {}
Err(mpsc::RecvTimeoutError::Disconnected) => return,
}
match state.overlay.as_ref().map_or(0, |o| unsafe { uu_annotation_poll(o.handle) }) {
2 => state.follow_resize(),
1 => if let Some(o) = &state.overlay { o.repaint(&state.strokes); },
_ => {}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn float(field: u64, v: f32, out: &mut Vec<u8>) { varint(field << 3 | 5, out); out.extend_from_slice(&v.to_le_bytes()); }
#[test]
fn parses_toggle_stroke_and_clear() {
let mut toggle = Vec::new();
bytes(3, &[8, 1], &mut toggle);
assert_eq!(parse(&toggle), Some(Request::Toggle(true)));
let mut off = Vec::new();
bytes(3, &[], &mut off);
assert_eq!(parse(&off), Some(Request::Toggle(false)));
let mut point = Vec::new();
float(1, 0.25, &mut point);
float(2, 0.75, &mut point);
let mut stroke = vec![8, 7];
bytes(2, &point, &mut stroke);
bytes(2, &point, &mut stroke);
stroke.extend_from_slice(&[24, 0]);
float(4, 4.0, &mut stroke);
stroke.push(40);
varint(0xFF00_FF00, &mut stroke);
let mut request = Vec::new();
bytes(1, &stroke, &mut request);
assert_eq!(parse(&request), Some(Request::Stroke {
id: 7, points: vec![(0.25, 0.75), (0.25, 0.75)], screen: Some(0), width: Some(4.0), color: Some(0xFF00_FF00) }));
let mut clear = Vec::new();
bytes(2, &[8, 2, 16, 9], &mut clear);
assert_eq!(parse(&clear), Some(Request::Clear { all: false, id: 9 }));
let mut clear_all = Vec::new();
bytes(2, &[8, 1], &mut clear_all);
assert_eq!(parse(&clear_all), Some(Request::Clear { all: true, id: 0 }));
}
#[test]
fn response_echoes_header_in_field_23() {
let ok = encode_response(&[8, 5], SLOT_TOGGLE, 0);
assert_eq!(ok, vec![10, 2, 8, 5, 186, 1, 2, 26, 0]);
let failed = encode_response(&[], SLOT_STROKE, 1);
assert_eq!(failed, vec![10, 0, 186, 1, 4, 10, 2, 8, 1]);
let fields = decode_wire(&failed).unwrap();
assert_eq!(fields[1].number, 23);
}
#[test]
fn answers_only_draw_requests() {
let mut other = Vec::new();
bytes(1, &[8, 1], &mut other);
bytes(28, &[], &mut other);
assert!(draw_request(&decode_wire(&other).unwrap()).is_none());
let mut draw = Vec::new();
bytes(1, &[8, 5], &mut draw);
bytes(27, &[26, 2, 8, 1], &mut draw);
assert_eq!(draw_request(&decode_wire(&draw).unwrap()), Some((vec![8, 5], vec![26, 2, 8, 1])));
}
/// Needs a composited X display: DISPLAY=:0 cargo test -- --ignored annotation_overlay_smoke
/// On a disposable display, UU_ANNOTATION_SMOKE_RESIZE=1024x768 also resizes the root (xrandr --fb).
#[test]
#[ignore]
fn annotation_overlay_smoke() {
let wait = Duration::from_secs(5);
let toggle = |owner, enable| { let (reply, r) = mpsc::channel(); send(Command::Toggle { owner, enable, reply }); r.recv_timeout(wait).unwrap() };
let probe = || { let (reply, r) = mpsc::channel(); send(Command::Probe(reply)); r.recv_timeout(wait).unwrap() };
let stroke = |owner, id, points: &[(f32, f32)], width, color| send(Command::Stroke(owner, Request::Stroke {
id, points: points.to_vec(), screen: None, width, color }));
assert_eq!(toggle(1, true), 0);
let diagonal: Vec<(f32, f32)> = (0..=20).map(|i| (0.3 + i as f32 * 0.02, 0.3 + i as f32 * 0.01)).collect();
stroke(1, 1, &diagonal[..10], None, None);
stroke(1, 1, &diagonal[10..], None, None);
stroke(1, 2, &[(0.5, 0.6)], Some(30.0), Some(0x0000FF));
std::thread::sleep(Duration::from_secs(
std::env::var("UU_ANNOTATION_SMOKE_SECS").ok().and_then(|s| s.parse().ok()).unwrap_or(3)));
assert_eq!(probe().map(|p| (p.0, p.3)), Some((1, 2)));
if let Ok(size) = std::env::var("UU_ANNOTATION_SMOKE_RESIZE") {
// xrandr may report an error for an output larger than the new size yet still resize.
let _ = std::process::Command::new("xrandr").args(["--fb", &size]).status();
std::thread::sleep(Duration::from_millis(500));
let (w, h) = size.split_once('x').map(|(w, h)| (w.parse().unwrap(), h.parse().unwrap())).unwrap();
assert_eq!(probe().map(|p| (p.1, p.2, p.3)), Some((w, h, 2)), "overlay follows the {size} root");
}
// A newer viewer takes over; the replaced peer's delayed reset and toggle-off leave it alone.
assert_eq!(toggle(2, true), 0);
reset(1);
assert_eq!(toggle(1, false), 0);
assert_eq!(probe().map(|p| (p.0, p.3)), Some((2, 0)));
stroke(2, 1, &diagonal, None, None);
assert_eq!(probe().map(|p| (p.0, p.3)), Some((2, 1)));
reset(2);
assert_eq!(probe(), None);
}
#[test]
fn strokes_are_laid_out_again_after_a_resize() {
let mut dot = Stroke::new(1, vec![(0.5, 0.5)], None, None);
dot.layout(100, 200);
assert_eq!((dot.points.clone(), dot.width), (vec![50, 100, 50, 100], 3));
dot.layout(3840, 2160);
assert_eq!((dot.points.clone(), dot.width), (vec![1920, 1080, 1920, 1080], 6));
let mut pixels = Stroke::new(2, vec![(10.0, 20.0), (30.0, 40.0)], Some(8.0), None);
pixels.layout(100, 200);
assert_eq!((pixels.normalized, pixels.points.clone(), pixels.width), (false, vec![10, 20, 30, 40], 8));
}
#[test]
fn colors_widths_and_points() {
assert_eq!(argb(None), 0xFFFF_3B30);
assert_eq!(argb(Some(0x00FF00)), 0xFF00_FF00);
assert_eq!(argb(Some(0x80FF_0000)), 0x8080_0000);
assert_eq!(line_width(None, 2160), 6);
assert_eq!(line_width(None, 720), 3);
assert_eq!(line_width(Some(8.0), 2160), 8);
assert_eq!(line_width(Some(0.01), 2000), 20);
assert_eq!(to_pixels(&[(0.5, 1.0)], true, 3840, 2160), vec![1920, 2160]);
assert_eq!(to_pixels(&[(12.4, f32::NAN)], false, 3840, 2160), vec![12, 0]);
}
}
+100 -1
View File
@@ -1,6 +1,6 @@
//! Desktop sound for the viewer's 声音 menu: the default output's monitor (PulseAudio or
//! PipeWire-pulse) is encoded to Opus and sent on the negotiated audio m-line.
//! An FFmpeg child process does the encoding.
//! inproc-av uses libpulse/libopus directly; other builds and native failures use FFmpeg.
//! PipeWire monitors ignore the sink's mute by default, so 被控端静音运行 keeps the stream audible.
//! `UU_AUDIO=0` disables it; `UU_AUDIO_SOURCE` picks another Pulse source.
@@ -56,12 +56,78 @@ fn read_packets(stdout: impl Read, tx: &tokio::sync::mpsc::Sender<bytes::Bytes>)
fn start(source: &str, tx: tokio::sync::mpsc::Sender<bytes::Bytes>)
-> Result<(Stopper, tokio::task::JoinHandle<Result<(), String>>), String> {
let stop = Arc::new(AtomicBool::new(false));
#[cfg(all(target_os = "linux", feature = "inproc-av"))]
if !crate::inproc_encoder::disabled() {
let source = std::ffi::CString::new(source).map_err(|_| "Audio source contains NUL")?;
let worker_stop = stop.clone();
let job = tokio::task::spawn_blocking(move || {
match native_packets(&source, &tx, &worker_stop) {
Ok(()) => Ok(()),
Err(error) if !worker_stop.load(Ordering::Relaxed) && !tx.is_closed() => {
log::warn!("In-process audio unavailable: {error}; falling back to FFmpeg Opus");
let mut child = spawn_encoder(source.to_str().map_err(|_| "Invalid audio source")?)?;
let stdout = child.stdout.take().ok_or("Encoder stdout missing")?;
// Supervise the process separately so cancellation also interrupts a blocked read.
let (done_tx, done_rx) = std::sync::mpsc::channel();
let reader_tx = tx.clone();
let reader = std::thread::spawn(move || {
let result = read_packets(stdout, &reader_tx);
let _ = done_tx.send(result);
});
let result = loop {
match done_rx.recv_timeout(Duration::from_millis(20)) {
Ok(result) => break result,
Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => break Err("Audio reader ended".into()),
Err(_) => if worker_stop.load(Ordering::Relaxed) || tx.is_closed() { break Ok(()); },
}
};
let _ = child.kill();
let _ = child.wait();
let _ = reader.join();
result
},
Err(_) => Ok(()),
}
});
return Ok((Stopper { stop, child: None }, job));
}
let mut child = spawn_encoder(source)?;
let stdout = child.stdout.take().ok_or("Encoder stdout missing")?;
let job = tokio::task::spawn_blocking(move || read_packets(stdout, &tx));
Ok((Stopper { stop, child: Some(child) }, job))
}
#[cfg(all(target_os = "linux", feature = "inproc-av"))]
fn native_packets(source: &std::ffi::CStr, tx: &tokio::sync::mpsc::Sender<bytes::Bytes>, stop: &AtomicBool) -> Result<(), String> {
extern "C" {
fn uu_audio_open(source: *const libc::c_char) -> *mut libc::c_void;
fn uu_audio_packet(audio: *mut libc::c_void, packet: *mut u8, capacity: libc::c_int) -> libc::c_int;
fn uu_audio_close(audio: *mut libc::c_void);
}
struct Capture(*mut libc::c_void);
impl Drop for Capture {
fn drop(&mut self) { unsafe { uu_audio_close(self.0) }; }
}
let capture = Capture(unsafe { uu_audio_open(source.as_ptr()) });
if capture.0.is_null() { return Err("Native audio initialization failed".into()); }
let mut packet = [0; 4000];
let mut last_packet = std::time::Instant::now();
let mut announced = false;
while !stop.load(Ordering::Relaxed) && !tx.is_closed() {
let size = unsafe { uu_audio_packet(capture.0, packet.as_mut_ptr(), packet.len() as libc::c_int) };
if size < 0 { return Err(format!("Native audio capture/encode failed: {size}")); }
if size == 0 {
if last_packet.elapsed() >= Duration::from_secs(5) { return Err("Native audio capture timed out".into()); }
std::thread::sleep(Duration::from_millis(2));
continue;
}
if !announced { log::info!("Desktop audio pipeline=in-process opus 48k stereo"); announced = true; }
last_packet = std::time::Instant::now();
if tx.blocking_send(bytes::Bytes::copy_from_slice(&packet[..size as usize])).is_err() { break; }
}
Ok(())
}
fn closed(pc: &RTCPeerConnection) -> bool {
matches!(pc.connection_state(), RTCPeerConnectionState::Closed | RTCPeerConnectionState::Failed)
}
@@ -140,3 +206,36 @@ pub async fn probe(seconds: u64) -> Result<(), String> {
let result = job.await.map_err(|e| e.to_string())?;
if packets == 0 { result } else { Ok(()) }
}
#[cfg(all(test, target_os = "linux", feature = "inproc-av"))]
mod native_tests {
use super::*;
#[tokio::test]
#[ignore = "requires a running PulseAudio or PipeWire-pulse server"]
async fn native_opus_packets_decode_and_capture_stops_promptly() {
extern "C" {
fn opus_decoder_create(rate: i32, channels: i32, error: *mut i32) -> *mut libc::c_void;
fn opus_decode(decoder: *mut libc::c_void, data: *const u8, length: i32, pcm: *mut i16, size: i32, fec: i32) -> i32;
fn opus_decoder_destroy(decoder: *mut libc::c_void);
}
let source = std::ffi::CString::new("@DEFAULT_MONITOR@").unwrap();
let (tx, mut rx) = tokio::sync::mpsc::channel(2);
let stop = Arc::new(AtomicBool::new(false));
let worker_stop = stop.clone();
let job = tokio::task::spawn_blocking(move || native_packets(&source, &tx, &worker_stop));
let stopper = Stopper { stop, child: None };
let packet = tokio::time::timeout(Duration::from_secs(6), rx.recv()).await.unwrap().unwrap();
let mut error = 0;
let decoder = unsafe { opus_decoder_create(48000, 2, &mut error) };
assert_eq!(error, 0);
assert!(!decoder.is_null());
let mut pcm = [0; 960 * 2];
let samples = unsafe { opus_decode(decoder, packet.as_ptr(), packet.len() as i32, pcm.as_mut_ptr(), 960, 0) };
unsafe { opus_decoder_destroy(decoder) };
assert_eq!(samples, 960);
drop(rx);
drop(stopper);
tokio::time::timeout(Duration::from_secs(1), job).await.unwrap().unwrap().unwrap();
}
}
+1
View File
@@ -181,6 +181,7 @@ impl Drop for ScreenCapture {
/// Keep the display visible only while a peer is streaming; never unlock it.
pub fn keep_display_awake() -> Result<(), String> {
if crate::privacy_screen::active() { return Ok(()); }
if crate::desktop_backend::detect()? == crate::desktop_backend::DesktopBackend::Kms { return Ok(()); }
if crate::desktop_backend::detect()? == crate::desktop_backend::DesktopBackend::Portal {
return crate::desktop_power::wake();
+10 -2
View File
@@ -17,6 +17,9 @@ impl TextFormat {
}
fn id(self)->u64{match self{Self::Windows=>UNICODE_TEXT,Self::Mac=>0}}
fn name(self)->&'static str{match self{Self::Windows=>"CF_UNICODETEXT",Self::Mac=>MAC_TEXT}}
/// Name in a format-list offer. Official Windows peers name predefined formats `predefined_<id>`; a plain
/// `CF_UNICODETEXT` makes the Windows viewer register a custom format instead of id 13 (issue #151).
fn offer_name(self)->&'static str{match self{Self::Windows=>WINDOWS_OFFER_NAME,Self::Mac=>MAC_TEXT}}
fn encode(self,text:&str)->Vec<u8>{match self{Self::Windows=>encode_windows(text),Self::Mac=>text.as_bytes().to_vec()}}
fn decode(self,data:&[u8])->Result<String,&'static str>{
match self{
@@ -31,6 +34,7 @@ impl TextFormat {
}
}
}
const WINDOWS_OFFER_NAME:&str="predefined_13";
const BLOCK_BYTES:usize=0x20000;
const MAX_BYTES:usize=MAX_TEXT*2+2;
pub struct ResultMessages {pub messages:Vec<(u32,Vec<u8>)>,pub text:Option<String>}
@@ -96,7 +100,7 @@ impl State{
if text.contains('\0')||encode_windows(&text).len()>MAX_BYTES{return Err("clipboard encoded text exceeds limit");}
self.local=Some(text);
let mut list=Vec::new();
for kind in formats {let mut format=Vec::new();int(1,kind.id(),&mut format);string(2,kind.name(),&mut format);nested(1,&format,&mut list);}
for kind in formats {let mut format=Vec::new();int(1,kind.id(),&mut format);string(2,kind.offer_name(),&mut format);nested(1,&format,&mut list);}
Ok(request(id,1,&list))
}
pub fn request(&mut self,rpc:&[u8],next:&mut impl FnMut()->u64)->Result<ResultMessages,&'static str>{
@@ -210,7 +214,11 @@ mod tests{
let data=bytes(bytes(bytes(&out.messages[1].1,9).unwrap().unwrap(),3).unwrap().unwrap(),3).unwrap().unwrap();
assert_eq!(data,b"hi");
// Host-side offers are unchanged: CF_UNICODETEXT only.
assert_eq!(format_ids(&State::default().offer(1,"hi".into()).unwrap()),vec![13]);
let host_offer=State::default().offer(1,"hi".into()).unwrap();
assert_eq!(format_ids(&host_offer),vec![13]);
let list=bytes(bytes(&host_offer,9).unwrap().unwrap(),1).unwrap().unwrap();
let format=bytes(list,1).unwrap().unwrap();
assert_eq!(text_field(format,2),Ok(WINDOWS_OFFER_NAME));
}
#[test]
fn desktop_clipboard_negotiates_and_buffers_unicode_until_confirmation(){
+6 -5
View File
@@ -180,11 +180,12 @@ pub fn encode_echo_response_with_clipboard(seq: u64, timestamp: u64, request_seq
// FeatureFlag: 1 ff_capture_setting = CUSTOM_BITRATE (fps/quality/bitrate RPCs),
// 2 ff_simple_action = AUTO_LOCK (mute + lock after session), 3 ff_system_metrics = SETTING_AUTO_LOCK,
// 6 ff_file_transfer_ftp = LIST_COMPRESS (zlib dir_data), 8 ff_clipboard = SUPPORT_TEXT_CHANGE.
// On X11: 3 ff_system_metrics = SETTING_PRIVATE_SCREEN (3), 4 ff_private_screen = INIT_VERION (normal privacy).
let mut flags = vec![8, crate::capture_setting::FEATURE_VERSION as u8, 16, crate::system_actions::FF_SIMPLE_ACTION];
if crate::privacy_screen::supported() { flags.extend_from_slice(&[24, 3, 32, crate::privacy_screen::FF_PRIVATE_SCREEN]); }
else { flags.extend_from_slice(&[24, crate::system_actions::FF_SYSTEM_METRICS]); }
flags.extend_from_slice(&[48, 2]);
let mut flags = vec![8, crate::capture_setting::FEATURE_VERSION as u8,
16, crate::system_actions::FF_SIMPLE_ACTION, 24, crate::system_actions::FF_SYSTEM_METRICS, 48, 2];
// Privacy screen (Mac UURemote name maps): 3 ff_system_metrics = FF_SYSTEM_METRICS_SETTING_PRIVATE_SCREEN
// (3, after AUTO_LOCK 2; the viewer then reads SettingMetric 4/7), 4 ff_private_screen =
// FF_PRIVATE_SCREEN_ENHANCED_PRIVACY (2): screen off besides the picture mode.
if crate::privacy_screen::supported() { flags[5] = 3; flags.extend([32, 2]); }
if clipboard { flags.extend_from_slice(&[64, 3]); }
action.push(34);
action.push(flags.len() as u8);
+101
View File
@@ -79,6 +79,107 @@ fn mapping(kind: u8, payload: &[u8]) -> Vec<u8> {
crate::initialization::envelope(1, 0, 27, &frame)
}
#[tokio::test]
async fn privacy_replies_wait_for_each_peers_text_channel() {
tokio::time::timeout(Duration::from_secs(25), async {
let mut peers = Vec::new();
for request_id in [41, 51] {
let (host, mut viewer) = connect(Arc::new(InputInjector::without_desktop()), false, None,
&["CONTROL_DATA_CHANNEL"]).await;
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 13).await;
for (id, case, payload) in [(request_id, 25, &[][..]), (request_id + 1, 7, &[8, 1, 16, 3][..])] {
let mut rpc = bytes(1, &[8, id]);
rpc.extend(bytes(case, payload));
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(1, 0, 21, &rpc)).await;
}
// A synthetic host rejects privacy without touching a physical desktop.
// Echo is a dispatch barrier: both replies are queued before TEXT exists.
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(2, 0, 3, &[8, 0])).await;
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 3).await;
peers.push((request_id, host, viewer));
}
for (request_id, host, mut viewer) in peers {
let text = viewer.pc.create_data_channel("TEXT_DATA_CHANNEL", None).await.unwrap();
let (tx, messages) = mpsc::unbounded_channel();
text.on_message(Box::new(move |message| {
let _ = tx.send(("TEXT_DATA_CHANNEL".into(), message.data.to_vec()));
Box::pin(async {})
}));
viewer.messages = messages;
let mut replies = Vec::new();
let mut metrics_seen = false;
while replies.len() < 2 || !metrics_seen {
let (channel, message) = tokio::time::timeout(Duration::from_secs(5), viewer.messages.recv()).await
.expect("late TEXT delivery timed out").expect("peer stopped responding");
assert_eq!(channel, "TEXT_DATA_CHANNEL");
if let Some(metrics) = body(&message, 13) {
assert_eq!(body(metrics, 1), Some([1, 2].as_slice()));
metrics_seen = true;
}
if body(&message, 22).is_some() { replies.push(message); }
}
for ((id, case), message) in [(request_id, 21), (request_id + 1, 3)].into_iter().zip(replies) {
let rpc = body(&message, 22).unwrap();
assert_eq!(body(rpc, 1), Some([8, id].as_slice()));
let response = body(rpc, case).expect("wrong RPC response case");
if case == 3 {
assert!(decode_wire(response).unwrap().iter().any(|f| f.number == 1 && f.value == WireValue::Varint(1)));
}
}
host.pc.close().await.unwrap();
viewer.pc.close().await.unwrap();
viewer.router.lock().await.stop().await.unwrap();
}
}).await.expect("privacy TEXT routing regression exceeded deadline");
}
#[tokio::test]
async fn ready_portal_control_input_is_forwarded_while_locked() {
tokio::time::timeout(Duration::from_secs(20), async {
let input = Arc::new(InputInjector::without_desktop());
let mut screen = ScreenCapture::unavailable("synthetic ready desktop".into());
screen.backend = crate::desktop_backend::DesktopBackend::Portal;
screen.init_error = None;
let (lock, locked) = tokio::sync::watch::channel(Some(true));
let portal = Arc::new(crate::desktop_session::PortalDesktop::with_lock_state(Arc::new(screen), locked));
let (host, mut viewer) = connect(input.clone(), true, Some(portal.clone()), &["CONTROL_DATA_CHANNEL"]).await;
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 13).await;
for (index, state) in [Some(true), None].into_iter().enumerate() {
lock.send(state).unwrap();
let before = input.portal_input_counts_for_test();
for message in [
br#"{"action":"kbd_press","key":65}"#.as_slice(),
br#"{"action":"kbd_release","key":65}"#.as_slice(),
br#"{"action":"mouse_press","button":1}"#.as_slice(),
br#"{"action":"mouse_release","button":1}"#.as_slice(),
] {
send(&viewer, "CONTROL_DATA_CHANNEL", message.to_vec()).await;
}
let sequence = 310 + index as u64;
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(sequence, 0, 3, &[8, 0])).await;
loop {
let response = receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 3).await;
let args: serde_json::Value = serde_json::from_slice(body(body(&response, 3).unwrap(), 2).unwrap()).unwrap();
if args["seq"] == sequence { break; }
}
let after = input.portal_input_counts_for_test();
assert_eq!(after[2] - before[2], 2, "keyboard dropped for lock state {state:?}");
assert_eq!(after[1] - before[1], 2, "mouse buttons dropped for lock state {state:?}");
}
let before = input.portal_input_counts_for_test();
let mut unavailable = ScreenCapture::unavailable("synthetic closed source".into());
unavailable.backend = crate::desktop_backend::DesktopBackend::Portal;
portal.publish_test_screen(Arc::new(unavailable));
send(&viewer, "CONTROL_DATA_CHANNEL", br#"{"action":"kbd_click","key":65}"#.to_vec()).await;
send(&viewer, "CONTROL_DATA_CHANNEL", crate::initialization::envelope(320, 0, 3, &[8, 0])).await;
receive(&mut viewer.messages, "CONTROL_DATA_CHANNEL", 3).await;
assert_eq!(input.portal_input_counts_for_test(), before, "unavailable source accepted input");
host.pc.close().await.unwrap();
viewer.pc.close().await.unwrap();
viewer.router.lock().await.stop().await.unwrap();
}).await.expect("locked CONTROL input regression exceeded deadline");
}
#[tokio::test]
async fn closing_unnegotiated_peers_releases_callback_state() {
for desktop in [false, true] {
+1
View File
@@ -38,6 +38,7 @@ mod native {
/// Set GNOME's display power-save mode to on. This does not unlock the session or change
/// lock-screen policy. Session-bus setup and each method call are bounded to three seconds.
pub fn wake() -> Result<(), String> {
if crate::privacy_screen::active() { return Ok(()); }
if !gnome_portal_active() {
return Ok(());
}
+40
View File
@@ -36,6 +36,46 @@ pub fn payload(mtu: usize, annex_b: &[u8]) -> Result<Vec<Bytes>, String> {
Ok(out)
}
/// Payload HEVC Annex-B bitstream with zero-copy sub-slicing for single NAL units <= MTU.
pub fn payload_bytes(mtu: usize, annex_b: &Bytes) -> Result<Vec<Bytes>, String> {
if mtu < 4 { return Err("HEVC payload MTU too small".into()); }
let mut starts = Vec::new();
let mut i = 0;
let bytes = annex_b.as_ref();
while i + 3 <= bytes.len() {
let prefix = if bytes[i..].starts_with(&[0, 0, 0, 1]) { 4 }
else if bytes[i..].starts_with(&[0, 0, 1]) { 3 } else { i += 1; continue; };
starts.push((i, i + prefix)); i += prefix;
}
if starts.is_empty() { return Err("HEVC access unit has no Annex-B start code".into()); }
let mut out = Vec::new();
for (index, &(_, start)) in starts.iter().enumerate() {
let mut end = starts.get(index + 1).map_or(bytes.len(), |s| s.0);
while end > start && bytes[end - 1] == 0 { end -= 1; } // trailing_zero_8bits
let nal_slice = &bytes[start..end];
if nal_slice.len() < 2 || nal_slice[0] & 0x80 != 0 || nal_slice[1] & 7 == 0 {
return Err("Invalid HEVC NAL header".into());
}
let kind = (nal_slice[0] >> 1) & 63;
if kind >= 48 { return Err("HEVC Annex-B contains RTP packet type".into()); }
if nal_slice.len() <= mtu {
// Zero-copy reference-counted sub-slice:
out.push(annex_b.slice(start..end));
continue;
}
let chunks = nal_slice[2..].chunks(mtu - 3);
let last = chunks.len() - 1;
for (n, chunk) in chunks.enumerate() {
let mut fu = Vec::with_capacity(3 + chunk.len());
// Keep F, LayerId and TID, replacing only the NAL type with FU=49.
fu.extend_from_slice(&[(nal_slice[0] & 0x81) | (49 << 1), nal_slice[1],
kind | if n == 0 { 0x80 } else { 0 } | if n == last { 0x40 } else { 0 }]);
fu.extend_from_slice(chunk); out.push(fu.into());
}
}
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
+401
View File
@@ -2,6 +2,7 @@
//! With UU_VIDEO_ENCODER=vaapi, H.264 / HEVC go through VAAPI instead: a DRI3 DMA-BUF of the root window is
//! imported as a VA surface and converted/scaled by VPP, so the CPU never touches the pixels (XShm upload
//! when DRI3 is unavailable).
//! Portal sessions can instead upload their existing BGRA frames, sharing the same GPU VPP and encoder.
//! When capture and encoder sizes match, the XShm buffer is registered as CUDA pinned memory and
//! NVENC reads it by DMA, so there is no host-to-device copy (the X server still writes XShm).
@@ -77,6 +78,7 @@ extern "C" {
fn vaapi_create(config: *const VaapiConfigFFI) -> *mut VaapiEngineOpaque;
fn vaapi_import_dma_buffer(engine: *mut VaapiEngineOpaque, dma_fd: libc::c_int, stride: u32) -> libc::c_int;
fn vaapi_import_frame(engine: *mut VaapiEngineOpaque, frame: *const crate::portal::DmaFrame) -> libc::c_int;
fn vaapi_upload_host_buffer(engine: *mut VaapiEngineOpaque, host_ptr: *const u8, pitch: u32) -> libc::c_int;
fn vaapi_encode_frame(
engine: *mut VaapiEngineOpaque,
@@ -130,6 +132,7 @@ impl Drop for SafeDri3Capture {
}
pub struct Config {
pub portal: Option<Arc<crate::portal::PortalSession>>,
pub display: String,
pub input: (u32, u32),
pub output: Option<(u32, u32)>,
@@ -218,6 +221,28 @@ pub fn run(
}
}
pub fn black_frame(codec: crate::capture_setting::VideoCodec) -> Result<bytes::Bytes, String> {
let device = CString::new(crate::video::vaapi_device()).map_err(|_| "Invalid VAAPI device")?;
let config = VaapiConfigFFI {
width: 1280, height: 720, cap_width: 1280, cap_height: 720, fps: 1, gop: 1,
target_bps: 1_000_000, max_bps: 2_000_000, buffer_bits: 500_000,
is_hevc: libc::c_int::from(codec == crate::capture_setting::VideoCodec::H265),
device: device.as_ptr(),
};
let engine = SafeVaapiEngine(unsafe { vaapi_create(&config) });
if engine.0.is_null() { return Err("Locked video VAAPI initialization failed".into()); }
let pixels = vec![0; 1280 * 720 * 4];
if unsafe { vaapi_upload_host_buffer(engine.0, pixels.as_ptr(), 1280 * 4) } != 0 {
return Err("Locked video VAAPI upload failed".into());
}
let mut data = std::ptr::null();
let mut length = 0;
if unsafe { vaapi_encode_frame(engine.0, 1, &mut data, &mut length) } != 0 || data.is_null() || length == 0 {
return Err("Locked video VAAPI encode failed".into());
}
Ok(bytes::Bytes::copy_from_slice(unsafe { std::slice::from_raw_parts(data, length as usize) }))
}
fn run_vaapi(
config: Config,
units: mpsc::Sender<EncodedUnit>,
@@ -257,6 +282,9 @@ fn run_vaapi(
return Err("Failed to create native VAAPI engine".into());
}
let engine = SafeVaapiEngine(raw_engine);
if let Some(portal) = config.portal.as_ref() {
return run_portal_vaapi(&config, portal, &engine, units, stop, idr, budget);
}
// Capture stays at the full input size; VPP scales (or pads) to the encoder size.
let display = CString::new(config.display.as_str()).map_err(|_| "DISPLAY contains NUL".to_string())?;
@@ -392,6 +420,126 @@ fn run_vaapi(
keepalive = random_keepalive(&mut seed);
}
}
fn vaapi_packet(engine: &SafeVaapiEngine, idr: &AtomicBool) -> Result<Vec<u8>, String> {
let mut data = std::ptr::null();
let mut length = 0;
let force_idr = libc::c_int::from(idr.swap(false, Ordering::AcqRel));
let result = unsafe { vaapi_encode_frame(engine.0, force_idr, &mut data, &mut length) };
if result != 0 { return Err(format!("VAAPI encode failed: {result}")); }
if data.is_null() || length == 0 { return Ok(Vec::new()); }
Ok(unsafe { std::slice::from_raw_parts(data, length as usize) }.to_vec())
}
fn run_portal_vaapi(
config: &Config, portal: &crate::portal::PortalSession, engine: &SafeVaapiEngine,
units: mpsc::Sender<EncodedUnit>, stop: Arc<AtomicBool>, idr: Arc<AtomicBool>, budget: Arc<Semaphore>,
) -> Result<(), String> {
use crate::portal::DmaCapture;
let interval = Duration::from_nanos(1_000_000_000 / u64::from(config.fps));
let mut next_poll = Instant::now();
let mut last_send = Instant::now();
let mut seed = 1;
let mut keepalive = random_keepalive(&mut seed);
let mut dma_version = None;
let mut cpu_version = None;
let mut cpu_frame = Vec::new();
let mut uploaded = false;
let mut input_dma = false;
let mut blank_frame = false;
let mut dma_disabled = std::env::var("UU_PORTAL_DMABUF").is_ok_and(|v| v == "0");
if dma_disabled { log::info!("Portal VAAPI DMA-BUF disabled by setting; pipeline=host-upload"); }
loop {
if stop.load(Ordering::Relaxed) || units.is_closed() { return Ok(()); }
let wait_dur = next_poll.saturating_duration_since(Instant::now());
if wait_dur > Duration::ZERO {
match portal.wait_frame(wait_dur) {
Ok(true) | Ok(false) => (),
Err(_) => {
// Frame wait failed or stream closed/stalled: back off to next_poll
// (preventing 100% core busy-spin) and allow existing recovery in with_dmabuf
// and capture_changed to handle lock/scaling without prematurely aborting the encoder.
std::thread::sleep(wait_dur);
}
}
}
let now = Instant::now();
if now < next_poll { continue; }
next_poll = (next_poll + interval).max(now);
if portal.size() != config.input { return Err("Portal size changed; restart encoder".into()); }
let Some(permit) = acquire(&budget, &units) else { return Ok(()); };
if stop.load(Ordering::Relaxed) { return Ok(()); }
let due = last_send.elapsed() >= keepalive || idr.load(Ordering::Acquire);
let captured = if dma_disabled { Ok(DmaCapture::Cpu) } else {
portal.with_dmabuf(&mut dma_version, |frame, changed| {
if !changed && input_dma && !due { return Ok(None); }
if changed || !input_dma {
let result = unsafe { vaapi_import_frame(engine.0, frame) };
if result != 0 { return Err(format!("VAAPI DMA-BUF import failed: {result}")); }
}
// vaapi_encode_frame waits for VA completion before the PipeWire lease is released.
let packet = vaapi_packet(engine, &idr)?;
if !input_dma {
log::info!("Portal VAAPI capture pipeline=dma-buf zero_cpu_copy=true source={}x{} fourcc={} modifier={}",
frame.width, frame.height, frame.fourcc, frame.modifier);
}
input_dma = true;
blank_frame = false;
uploaded = true;
Ok(Some(packet))
})
};
let captured = match captured {
Ok(DmaCapture::Unavailable(code)) => {
let reason = match code {
14 => "buffer layout unsupported or DMA-BUF disabled for this session",
16 => "compositor selected shared memory",
17 => "DMA-BUF negotiation or first frame timed out",
18 => "explicit synchronization unsupported",
19 => "nonlinear modifier unsupported",
_ => "DMA-BUF interface unavailable",
};
log::warn!("Portal DMA-BUF unavailable: {reason} (code={code}); falling back to native VAAPI host upload");
dma_disabled = true; portal.disable_dmabuf();
DmaCapture::Cpu
},
Err(error) => {
log::warn!("Portal DMA-BUF unavailable: {error}; falling back to native VAAPI host upload");
dma_disabled = true; portal.disable_dmabuf();
DmaCapture::Cpu
},
Ok(value) => value,
};
let data = match captured {
DmaCapture::Frame(Some(packet)) => packet,
DmaCapture::Frame(None) | DmaCapture::Pending => continue,
state @ (DmaCapture::Cpu | DmaCapture::Blank) => {
cpu_frame.resize(config.input.0 as usize * config.input.1 as usize * 4, 0);
let changed = if matches!(state, DmaCapture::Blank) {
let changed = !blank_frame;
if changed { cpu_frame.fill(0); }
blank_frame = true;
changed
} else {
blank_frame = false;
portal.capture_changed(&mut cpu_frame, &mut cpu_version)?
};
if !changed && !input_dma && uploaded && !due { continue; }
if changed || input_dma || !uploaded {
let result = unsafe { vaapi_upload_host_buffer(engine.0, cpu_frame.as_ptr(), config.input.0 * 4) };
if result != 0 { return Err(format!("Portal VAAPI upload failed: {result}")); }
input_dma = false; uploaded = true;
}
vaapi_packet(engine, &idr)?
},
DmaCapture::Unavailable(_) => unreachable!(),
};
if data.is_empty() { continue; }
if units.blocking_send(EncodedUnit { data, permit, completed_at: Instant::now() }).is_err() { return Ok(()); }
last_send = Instant::now();
keepalive = random_keepalive(&mut seed);
}
}
fn vaapi_wait(dri3: &Option<SafeDri3Capture>, capture: &mut Option<DamageCapture>, timeout: Duration) -> Result<bool, String> {
match (dri3, capture) {
(Some(c), _) => match unsafe { dri3_capture_wait_damage(c.0, timeout.as_millis().min(1000) as i32) } {
@@ -664,6 +812,24 @@ fn pad_argb32(src: &[u8], src_w: u32, src_h: u32, dst: &mut [u8], dst_w: u32, ds
#[cfg(test)]
mod budget_tests {
use super::*;
#[test]
#[ignore = "requires a VAAPI render node and FFmpeg for independent decode verification"]
fn vaapi_locked_frames_decode_as_black_in_both_codecs() {
use std::io::Write;
use std::process::{Command, Stdio};
for codec in [crate::capture_setting::VideoCodec::H264, crate::capture_setting::VideoCodec::H265] {
let frame = black_frame(codec).unwrap();
let mut decoder = Command::new("ffmpeg").args(["-hide_banner", "-loglevel", "error", "-i", "pipe:0",
"-frames:v", "1", "-vf", "scale=1:1", "-pix_fmt", "rgb24", "-f", "rawvideo", "pipe:1"])
.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped()).spawn().unwrap();
decoder.stdin.take().unwrap().write_all(&frame).unwrap();
let decoded = decoder.wait_with_output().unwrap();
assert!(decoded.status.success(), "decode failed for {codec:?}");
assert_eq!(decoded.stdout.len(), 3);
assert!(decoded.stdout.iter().all(|&value| value <= 3), "frame is not black for {codec:?}");
}
}
#[tokio::test]
async fn closing_encoder_output_wakes_a_blocked_capture() {
let budget = Arc::new(Semaphore::new(0));
@@ -726,3 +892,238 @@ mod frame_tests {
}
}
}
#[cfg(all(test, target_os = "linux", feature = "portal"))]
mod portal_hardware_tests {
// Run on an unlocked desktop with saved Portal consent and VAAPI selected.
// FFmpeg is used only for independent decode verification; desktop contents
// are neither saved nor printed. These tests do not lock the real desktop
// or replace system lock-screen acceptance in an isolated VM.
use super::*;
use crate::capture_setting::VideoCodec;
struct Runner {
stop: Arc<AtomicBool>,
idr: Arc<AtomicBool>,
rx: mpsc::Receiver<EncodedUnit>,
job: Option<tokio::task::JoinHandle<Result<(), String>>>,
}
impl Drop for Runner {
fn drop(&mut self) { self.stop.store(true, Ordering::Release); self.rx.close(); }
}
impl Runner {
fn start(portal: Arc<crate::portal::PortalSession>, codec: VideoCodec) -> Self {
let config = Config {
input: portal.size(), portal: Some(portal), display: "wayland:portal".into(),
output: None, fps: 60, gop: 120, cq: 18, target_bps: 16_000_000,
max_bps: 30_000_000, buffer_bits: 500_000, codec,
chroma: crate::capture_setting::CHROMA_420, vaapi: true,
};
let (tx, rx) = mpsc::channel(4);
let stop = Arc::new(AtomicBool::new(false));
let idr = Arc::new(AtomicBool::new(false));
let worker_stop = stop.clone();
let worker_idr = idr.clone();
let job = tokio::task::spawn_blocking(move || run(config, tx, worker_stop, worker_idr, Arc::new(Semaphore::new(4))));
Self { stop, idr, rx, job: Some(job) }
}
async fn frame(&mut self) -> Vec<u8> {
tokio::time::timeout(Duration::from_secs(10), self.rx.recv()).await.unwrap()
.expect("native capture stopped").data
}
async fn hevc_idr(&mut self) -> Vec<u8> {
tokio::time::timeout(Duration::from_secs(10), async {
loop {
let frame = self.frame().await;
let nals = crate::hevc::payload(usize::MAX, &frame).unwrap();
if nals.iter().any(|nal| (16..=21).contains(&((nal[0] >> 1) & 63))) { return frame; }
}
}).await.expect("requested HEVC IDR did not arrive")
}
async fn finish(mut self) {
self.stop.store(true, Ordering::Release);
self.rx.close();
tokio::time::timeout(Duration::from_secs(2), self.job.take().unwrap()).await
.expect("native encoder did not stop").unwrap().unwrap();
}
}
fn decoded_is_black(data: &[u8], codec: VideoCodec) -> bool {
use std::io::Write;
use std::process::{Command, Stdio};
let format = if codec == VideoCodec::H265 { "hevc" } else { "h264" };
let mut decoder = Command::new("ffmpeg").args(["-hide_banner", "-loglevel", "error", "-f", format,
"-i", "pipe:0", "-frames:v", "1", "-pix_fmt", "rgb24", "-f", "rawvideo", "pipe:1"])
.stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped()).spawn().unwrap();
// Concurrent writing avoids filling stdin while the decoder is blocked on raw RGB output.
let mut input = decoder.stdin.take().unwrap();
let encoded = data.to_vec();
let writer = std::thread::spawn(move || input.write_all(&encoded));
let decoded = decoder.wait_with_output().unwrap();
writer.join().unwrap().unwrap();
assert!(decoded.status.success() && !decoded.stdout.is_empty(), "native frame decode failed");
decoded.stdout.iter().all(|&value| value <= 8)
}
fn resources() -> (usize, u64) {
let fds = std::fs::read_dir("/proc/self/fd").unwrap().count();
let rss = std::fs::read_to_string("/proc/self/status").unwrap().lines()
.find(|line| line.starts_with("VmRSS:")).unwrap().split_whitespace().nth(1).unwrap().parse().unwrap();
(fds, rss)
}
async fn reopen(portal: Arc<crate::portal::PortalSession>) {
tokio::task::spawn_blocking(move || {
portal.end();
assert!(portal.recover(&AtomicBool::new(false)).unwrap());
}).await.unwrap();
}
#[tokio::test]
#[ignore = "requires an unlocked Portal desktop and saved consent"]
async fn portal_snapshot_after_dma_initialization() {
let _ = env_logger::builder().is_test(true).try_init();
tokio::task::spawn_blocking(|| {
let mut portal = crate::portal::PortalSession::open().unwrap();
let (locked, watch) = tokio::sync::watch::channel(Some(false));
portal.test_lock_watch(watch);
assert!(matches!(portal.with_dmabuf(&mut None, |_, _| Ok(())).unwrap(), crate::portal::DmaCapture::Frame(())));
let (width, height) = portal.size();
let mut pixels = vec![0; width as usize * height as usize * 4];
for state in [Some(true), None, Some(false)] {
locked.send(state).unwrap();
portal.pause();
portal.capture(&mut pixels).unwrap();
assert!(pixels.chunks_exact(4).any(|p| p[..3].iter().any(|&v| v > 8)),
"healthy snapshot was blanked for lock state {state:?}");
println!("snapshot_lock_state={state:?} valid_frame=true");
}
}).await.unwrap();
}
// RUST_LOG=info cargo test --release --locked --features wayland,portal,inproc-av portal_five_minute_endurance_with_full_decode -- --ignored --nocapture
// Run for five minutes, independently decode every output frame, require equal
// encoded/decoded counts and no decode errors, and report CPU, RSS and FDs.
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[ignore = "five-minute real Portal/VAAPI run; FFmpeg is used only as an independent decoder"]
async fn portal_five_minute_endurance_with_full_decode() {
use std::process::Stdio;
use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
let _ = env_logger::builder().is_test(true).try_init();
let session = tokio::task::spawn_blocking(crate::portal::PortalSession::open).await.unwrap().unwrap();
let mut runner = Runner::start(Arc::new(session), VideoCodec::H265);
let mut decoder = tokio::process::Command::new("ffmpeg").args([
"-hide_banner", "-loglevel", "error", "-nostats", "-threads", "2", "-f", "hevc", "-i", "pipe:0",
"-progress", "pipe:1", "-fps_mode", "passthrough", "-f", "null", "/dev/null",
]).stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped()).kill_on_drop(true).spawn().unwrap();
let mut input = decoder.stdin.take().unwrap();
let mut errors = decoder.stderr.take().unwrap();
let error_reader = tokio::spawn(async move {
let mut total = 0usize;
let mut buffer = [0; 2048];
loop {
let count = errors.read(&mut buffer).await.unwrap();
if count == 0 { return total; }
total += count;
}
});
let output = decoder.stdout.take().unwrap();
let progress_reader = tokio::spawn(async move {
let mut lines = BufReader::new(output).lines();
let mut frames = 0u64;
while let Some(line) = lines.next_line().await.unwrap() {
if let Some(count) = line.strip_prefix("frame=") { frames = count.trim().parse().unwrap(); }
}
frames
});
let ticks = || {
let stat = std::fs::read_to_string("/proc/self/stat").unwrap();
let fields: Vec<_> = stat.split_once(") ").unwrap().1.split_whitespace().collect();
fields[11].parse::<u64>().unwrap() + fields[12].parse::<u64>().unwrap()
};
let hz = unsafe { libc::sysconf(libc::_SC_CLK_TCK) } as f64;
let started = Instant::now();
let mut last_report = started;
let mut last_ticks = ticks();
let mut frames = 0u64;
while started.elapsed() < Duration::from_secs(300) {
let data = runner.frame().await;
tokio::time::timeout(Duration::from_secs(5), input.write_all(&data)).await
.expect("verification decoder stopped consuming").unwrap();
frames += 1;
if last_report.elapsed() >= Duration::from_secs(30) {
let now_ticks = ticks();
let cpu = (now_ticks - last_ticks) as f64 / hz / last_report.elapsed().as_secs_f64() * 100.0;
let (fds, rss_kb) = resources();
println!("endurance elapsed_s={} encoded_frames={} cpu_percent={cpu:.2} fds={fds} rss_kb={rss_kb}",
started.elapsed().as_secs(), frames);
last_ticks = now_ticks; last_report = Instant::now();
}
}
runner.finish().await;
drop(input);
assert!(tokio::time::timeout(Duration::from_secs(15), decoder.wait()).await.unwrap().unwrap().success());
assert_eq!(error_reader.await.unwrap(), 0, "verification decoder reported errors");
let decoded = progress_reader.await.unwrap();
assert_eq!(decoded, frames, "decoder lost encoded frames");
println!("portal_endurance_passed duration_s={:.2} encoded_frames={} decoded_frames={} decode_errors=0",
started.elapsed().as_secs_f64(), frames, decoded);
}
// RUST_LOG=info cargo test --release --locked --features wayland,portal,inproc-av portal_restart_resources_and_injected_lock_recovery -- --ignored --nocapture
// Recreate the Portal session 20 times, check resource growth, then inject
// locked/unknown/unlocked observations to check healthy-frame passthrough.
// Actually close/restore the source to check placeholder black and recovery.
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[ignore = "requires an unlocked Portal desktop, saved consent, VAAPI and FFmpeg decode verification"]
async fn portal_restart_resources_and_injected_lock_recovery() {
let _ = env_logger::builder().is_test(true).try_init();
let mut session = tokio::task::spawn_blocking(crate::portal::PortalSession::open).await.unwrap().unwrap();
// Inject only the lock observation; actual session closure/recovery and GPU encoding remain real.
// This does not lock the user's desktop or bypass the isolated-VM acceptance guard.
let (locked, watch) = tokio::sync::watch::channel(Some(false));
session.test_lock_watch(watch);
let portal = Arc::new(session);
let mut snapshots = Vec::new();
for cycle in 0..20 {
let codec = if cycle % 2 == 0 { VideoCodec::H264 } else { VideoCodec::H265 };
let mut runner = Runner::start(portal.clone(), codec);
let frame = runner.frame().await;
assert!(!decoded_is_black(&frame, codec), "restarted stream stayed black");
runner.finish().await;
reopen(portal.clone()).await;
let (fds, rss_kb) = resources();
snapshots.push((fds, rss_kb));
println!("restart_cycle={} fds={} rss_kb={}", cycle + 1, fds, rss_kb);
}
let warm = snapshots[3];
let last = *snapshots.last().unwrap();
assert!(last.0 <= warm.0 + 2, "file descriptors grew across reconnects");
assert!(last.1 <= warm.1 + 32 * 1024, "resident memory grew across reconnects");
let mut runner = Runner::start(portal.clone(), VideoCodec::H265);
assert!(!decoded_is_black(&runner.hevc_idr().await, VideoCodec::H265));
for state in [Some(true), None, Some(false)] {
locked.send(state).unwrap();
portal.pause();
runner.idr.store(true, Ordering::Release);
assert!(!decoded_is_black(&runner.hevc_idr().await, VideoCodec::H265),
"healthy DMA source was blanked for lock state {state:?}");
assert!(matches!(portal.with_dmabuf(&mut None, |_, _| Ok(())).unwrap(), crate::portal::DmaCapture::Frame(())));
println!("dma_lock_state={state:?} valid_frame=true");
}
for cycle in 0..3 {
locked.send(Some(true)).unwrap();
portal.end();
runner.idr.store(true, Ordering::Release);
assert!(decoded_is_black(&runner.hevc_idr().await, VideoCodec::H265), "closed Portal source did not produce placeholder frame");
assert!(matches!(portal.with_dmabuf(&mut None, |_, _| Ok(())).unwrap(), crate::portal::DmaCapture::Cpu));
locked.send(Some(false)).unwrap();
let session = portal.clone();
tokio::task::spawn_blocking(move || { session.recover(&AtomicBool::new(false)).unwrap(); }).await.unwrap();
runner.idr.store(true, Ordering::Release);
assert!(!decoded_is_black(&runner.hevc_idr().await, VideoCodec::H265), "desktop did not recover after unlock observation");
println!("injected_lock_cycle={} source_closed=true placeholder_black=true same_arc_recovered=true", cycle + 1);
}
runner.finish().await;
println!("portal_restart_resources_passed cycles=20 fd_growth={} rss_growth_kb={} injected_lock_cycles=3",
last.0 as i64 - warm.0 as i64, last.1 as i64 - warm.1 as i64);
}
}
+425 -12
View File
@@ -99,7 +99,27 @@ impl Controller {
#[derive(Default)]
struct CmdState { held: bool, pending: bool, passthrough: bool, combos: std::collections::BTreeMap<i32, bool> }
pub struct InputInjector { mac_controller: std::sync::atomic::AtomicBool, cmd: std::sync::Mutex<CmdState>, serial:std::sync::Mutex<()>, owner:std::sync::Mutex<DesktopOwner>, shortcuts: std::sync::Mutex<Shortcuts>, uinput: Option<crate::uinput::Devices>, screen: std::sync::Mutex<(u32,u32)>, portal_failures: std::sync::atomic::AtomicUsize, portal_outcomes: [std::sync::atomic::AtomicUsize; 3], portal:std::sync::Mutex<Option<std::sync::Arc<crate::portal::PortalSession>>>, backend: crate::desktop_backend::DesktopBackend, pending: std::sync::Mutex<PendingPointer>, held: std::sync::Mutex<HeldInput>, touch: std::sync::Mutex<TouchDrag> }
pub struct InputInjector { mac_controller: std::sync::atomic::AtomicBool, cmd: std::sync::Mutex<CmdState>, serial:std::sync::Mutex<()>, owner:std::sync::Mutex<DesktopOwner>, shortcuts: std::sync::Mutex<Shortcuts>, uinput: Option<crate::uinput::Devices>, uinput_pointer: bool, screen: std::sync::Mutex<(u32,u32)>, portal_failures: std::sync::atomic::AtomicUsize, portal_outcomes: [std::sync::atomic::AtomicUsize; 3], portal:std::sync::Mutex<Option<std::sync::Arc<crate::portal::PortalSession>>>, backend: crate::desktop_backend::DesktopBackend, pending: std::sync::Mutex<PendingPointer>, held: std::sync::Mutex<HeldInput>, touch: std::sync::Mutex<TouchDrag>, pointer_wake: tokio::sync::Notify }
fn active_output_count(json: &[u8]) -> Option<usize> {
let data: serde_json::Value = serde_json::from_slice(json).ok()?;
Some(data.get("outputs")?.as_array()?.iter()
.filter(|o| o["enabled"] == true && o["connected"] == true).count())
}
fn single_portal_output() -> bool {
if cfg!(test) { return false; }
let monitors = crate::portal::monitors();
if !monitors.is_empty() { return monitors.len() == 1; }
// KDE has no Mutter monitor API. Query once at injector creation, never during input.
std::process::Command::new("timeout").args(["2s", "kscreen-doctor", "-j"]).output().ok()
.filter(|output| output.status.success())
.and_then(|output| active_output_count(&output.stdout)) == Some(1)
}
/// The desktop injector opened uinput devices. The privacy screen needs them: KDE ignores portal
/// input on its virtual-output share, so without uinput nobody could operate the desktop.
static UINPUT_READY: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
pub fn uinput_ready() -> bool { UINPUT_READY.load(std::sync::atomic::Ordering::Acquire) }
impl InputInjector {
pub fn new() -> Self {
@@ -110,7 +130,12 @@ impl InputInjector {
Err(e) => { log::warn!("uinput unavailable ({}); using the desktop input path. See README for the udev rule.", e.kind()); None }
}
} else { None };
Self { mac_controller: std::sync::atomic::AtomicBool::new(false), cmd: std::sync::Mutex::new(CmdState::default()), serial:std::sync::Mutex::new(()), owner:std::sync::Mutex::new(DesktopOwner::default()), shortcuts: std::sync::Mutex::new(Shortcuts::default()), uinput, screen: std::sync::Mutex::new((0,0)), portal_failures: std::sync::atomic::AtomicUsize::new(0), portal_outcomes: std::array::from_fn(|_| std::sync::atomic::AtomicUsize::new(0)), portal:std::sync::Mutex::new(None), backend:crate::desktop_backend::detect().unwrap_or(crate::desktop_backend::DesktopBackend::X11), pending: std::sync::Mutex::new(PendingPointer::default()), held:std::sync::Mutex::new(HeldInput::default()), touch:std::sync::Mutex::new(TouchDrag::default()) }
if uinput.is_some() { UINPUT_READY.store(true, std::sync::atomic::Ordering::Release); }
let uinput_pointer = uinput.is_some() && (std::env::var("UU_INPUT_BACKEND").as_deref() == Ok("uinput")
|| (backend == crate::desktop_backend::DesktopBackend::Portal && single_portal_output()));
if uinput_pointer { log::info!("Input pointer backend: uinput (motion, buttons and wheel)"); }
else if backend == crate::desktop_backend::DesktopBackend::Portal { log::info!("Input pointer backend: portal (monitor-local coordinates)"); }
Self { mac_controller: std::sync::atomic::AtomicBool::new(false), cmd: std::sync::Mutex::new(CmdState::default()), serial:std::sync::Mutex::new(()), owner:std::sync::Mutex::new(DesktopOwner::default()), shortcuts: std::sync::Mutex::new(Shortcuts::default()), uinput, uinput_pointer, screen: std::sync::Mutex::new((0,0)), portal_failures: std::sync::atomic::AtomicUsize::new(0), portal_outcomes: std::array::from_fn(|_| std::sync::atomic::AtomicUsize::new(0)), portal:std::sync::Mutex::new(None), backend, pending: std::sync::Mutex::new(PendingPointer::default()), held:std::sync::Mutex::new(HeldInput::default()), touch:std::sync::Mutex::new(TouchDrag::default()), pointer_wake: tokio::sync::Notify::new() }
}
pub fn bind_portal(&self,session:Option<std::sync::Arc<crate::portal::PortalSession>>) {
@@ -128,6 +153,7 @@ impl InputInjector {
let mut pending = self.pending.lock().unwrap();
pending.absolute = Some(position);
pending.relative = (0,0);
self.pointer_wake.notify_one();
}
}
pub fn mouse_relative(&self, dx: i32, dy: i32) {
@@ -135,6 +161,7 @@ impl InputInjector {
let mut pending = self.pending.lock().unwrap();
pending.relative.0 = (pending.relative.0 + i64::from(dx)).clamp(-65535,65535);
pending.relative.1 = (pending.relative.1 + i64::from(dy)).clamp(-65535,65535);
self.pointer_wake.notify_one();
}
}
pub fn mouse_scroll(&self, dx: i32, dy: i32) {
@@ -142,15 +169,38 @@ impl InputInjector {
let mut pending = self.pending.lock().unwrap();
pending.scroll.0 = (pending.scroll.0 + i64::from(dx)).clamp(-12000,12000);
pending.scroll.1 = (pending.scroll.1 + i64::from(dy)).clamp(-12000,12000);
self.pointer_wake.notify_one();
}
pub fn start_pointer_worker(self: &std::sync::Arc<Self>) -> tokio::task::JoinHandle<()> {
let input = self.clone();
tokio::spawn(async move {
// Parked until pointer work exists: a fixed 4 ms tick burned ~250 wakeups/s
// (≈3% CPU with pow-heavy flush math) even with no viewer connected.
// notify_one() stores a permit, so an event racing the park check cannot be lost.
let mut tick = tokio::time::interval(std::time::Duration::from_millis(4));
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
loop { tick.tick().await; input.flush_pointer(); }
loop {
input.pointer_wake.notified().await;
// The first event is immediate; later events coalesce until the next tick.
tick.reset();
loop {
input.flush_pointer();
tick.tick().await;
if input.pointer_idle() { break; }
}
}
})
}
/// Whether the worker may park: nothing accumulated, no full scroll notch waiting and no
/// touch gesture in flight (`Pending` needs ticks until its hold resolves, `Scroll`/`Select`
/// and `down` until release). Sub-notch scroll residue cannot inject alone, so it parks.
fn pointer_idle(&self) -> bool {
let pending = self.pending.lock().unwrap();
let touch = self.touch.lock().unwrap();
pending.absolute.is_none() && pending.relative == (0,0)
&& pending.scroll.0 / 120 == 0 && pending.scroll.1 / 120 == 0
&& !touch.down && touch.finger == Finger::Up
}
pub fn discard_pointer(&self) { *self.pending.lock().unwrap() = PendingPointer::default(); }
pub fn flush_pointer(&self) {
let _serial=self.serial.lock().unwrap();
@@ -204,6 +254,8 @@ impl InputInjector {
}
pub fn mouse_button(&self, button: i32, is_press: bool) {
let _serial=self.serial.lock().unwrap();
// The worker cannot consume the wake and flush until this transition is published.
self.pointer_wake.notify_one();
self.flush_pointer_locked();
if button == 1 && self.touch_button(is_press) { return; }
let result = self.inject_button(button,is_press);
@@ -251,7 +303,7 @@ impl InputInjector {
*self.cmd.lock().unwrap() = CmdState::default();
let mut touch = self.touch.lock().unwrap();
self.lift_finger(&mut touch);
let mode = if controller != Controller::Mobile { TouchMode::Mouse } else {
let mode = if controller != Controller::Mobile || self.uinput_pointer { TouchMode::Mouse } else {
match std::env::var("UU_TOUCH_INPUT").as_deref() { Ok("0") => TouchMode::Mouse, Ok("touch") => TouchMode::Touch, _ => TouchMode::Gesture }
};
*touch = TouchDrag { mode, ..TouchDrag::default() };
@@ -303,7 +355,8 @@ impl InputInjector {
};
}
if touch.finger != Finger::Up { return true }
let bound = self.backend == crate::desktop_backend::DesktopBackend::Portal && self.portal.lock().unwrap().is_some();
// Gesture scrolling is portal-only; on the privacy screen's virtual share drags stay mouse drags.
let bound = self.backend == crate::desktop_backend::DesktopBackend::Portal && self.portal.lock().unwrap().is_some() && !self.virtual_uinput();
let Some(start) = touch.at.filter(|_| bound) else { return false };
static REPORTED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
if !REPORTED.swap(true, std::sync::atomic::Ordering::Relaxed) { log::info!("Mobile controller drag input: gesture (drag scrolls, hold selects)"); }
@@ -478,6 +531,21 @@ impl InputInjector {
}
}
fn inject_move(&self,x:i32,y:i32,relative:bool)->i32 {
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)); }
let (w,h) = *self.screen.lock().unwrap();
if w > 1 && h > 1 {
let (ax, ay) = self.privacy_absolute(x, y, (w, h)).unwrap_or_else(|| {
let scale = |v: i32, extent: u32| (i64::from(v).clamp(0, i64::from(extent - 1))
* i64::from(crate::uinput::ABS_MAX) / i64::from(extent - 1)) as i32;
(scale(x, w), scale(y, h))
});
return Self::uinput_result(uinput.move_absolute(ax, ay));
}
return -1;
}
}
// uinput ABS axes span the compositor's whole desktop. A captured output
// uses its own pixel space; bind absolute motion to that Wayland output,
// including when uinput remains in use for keyboard/buttons/relative input.
@@ -490,7 +558,12 @@ impl InputInjector {
// Portal (GNOME/KDE): absolute motion is addressed to the shared stream, i.e. the captured
// monitor; a uinput tablet would stretch the point across every monitor of the desktop.
if !relative && self.backend==crate::desktop_backend::DesktopBackend::Portal {
if let Some(portal)=self.portal.lock().unwrap().as_ref() { return self.portal_result("motion", portal.move_pointer(f64::from(x),f64::from(y),false)); }
// Privacy screen: KDE accepts absolute motion for a virtual-output stream but does not
// move the pointer. The physical outputs are disabled then, so the uinput tablet's
// desktop-wide axes cover exactly the virtual output.
if !self.virtual_uinput() {
if let Some(portal)=self.portal.lock().unwrap().as_ref() { return self.portal_result("motion", portal.move_pointer(f64::from(x),f64::from(y),false)); }
}
}
// X11 multi-screen: the point is inside the selected monitor; XTest and uinput span the root.
let placement=if relative || self.backend!=crate::desktop_backend::DesktopBackend::X11 {None} else {crate::wayland::x11_placement()};
@@ -500,6 +573,7 @@ impl InputInjector {
let (w,h)=placement.and_then(|_|crate::capture::x11_last_size()).unwrap_or(*self.screen.lock().unwrap());
if w > 1 && h > 1 {
let scale = |v: i32, extent: u32| (i64::from(v) * i64::from(crate::uinput::ABS_MAX) / i64::from(extent - 1)) as i32;
if let Some((ax, ay)) = self.privacy_absolute(x, y, (w, h)) { return Self::uinput_result(uinput.move_absolute(ax, ay)); }
return Self::uinput_result(uinput.move_absolute(scale(x,w),scale(y,h)));
}
}
@@ -509,10 +583,23 @@ impl InputInjector {
if self.backend==crate::desktop_backend::DesktopBackend::Wayland { crate::wayland::move_pointer(x,y,relative) }
else if relative { unsafe { x11_mouse_relative(x,y) } } else { unsafe { x11_mouse_move(x,y) } }
}
/// Privacy picture mode keeps the physical outputs on, so uinput's axes span them too: aim the
/// stream point inside the virtual output's region of the layout.
fn privacy_absolute(&self, x: i32, y: i32, (w, h): (u32, u32)) -> Option<(i32, i32)> {
let [rx, ry, rw, rh] = crate::privacy_screen::pointer_region().filter(|_| self.virtual_uinput())?;
let abs = |v: i32, extent: u32, o: f64, span: f64| ((o + f64::from(v.clamp(0, extent as i32 - 1)) / f64::from(extent - 1) * span)
* f64::from(crate::uinput::ABS_MAX)).round() as i32;
Some((abs(x, w, rx, rw), abs(y, h, ry, rh)))
}
/// Privacy screen: KDE ignores portal pointer events (motion and buttons) on a virtual-output
/// share, so the pointer uses uinput, whose axes then span just the virtual output.
fn virtual_uinput(&self)->bool {
self.uinput.is_some() && self.portal.lock().unwrap().as_ref().is_some_and(|p| p.is_virtual())
}
fn inject_button(&self,button:i32,pressed:bool)->i32 {
// 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.backend==crate::desktop_backend::DesktopBackend::Portal {
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(uinput)=&self.uinput {
@@ -619,11 +706,67 @@ impl InputInjector {
true
}
/// Mobile input-method text (`text_input`). X11 types it directly; Wayland re-maps a spare
/// keycode in the virtual keyboard's keymap. Portal and other Wayland environments inject
/// via clipboard paste (Shift+Insert). Set UU_WAYLAND_TEXT=0 to disable Wayland text injection.
fn emit_uinput_text(&self, plan: &[crate::uinput::TextKey]) -> usize {
let Some(devices) = self.uinput.as_ref() else { return 0 };
let (mut typed, mut shift) = (0, 0);
for key in plan {
if key.code == 0 || key.code > 248 || key.shift > 248 { break; }
if shift != key.shift {
if shift != 0 {
if Self::uinput_result(devices.key(shift, false)) != 0 { break; }
shift = 0;
}
if key.shift != 0 {
if Self::uinput_result(devices.key(key.shift, true)) != 0 { break; }
shift = key.shift;
}
}
let pressed = Self::uinput_result(devices.key(key.code, true)) == 0;
let released = Self::uinput_result(devices.key(key.code, false)) == 0;
if pressed { typed += 1; }
if !pressed || !released { break; }
}
if shift != 0 { Self::uinput_result(devices.key(shift, false)); }
typed
}
fn type_uinput_text(&self, text: &str) -> usize {
self.type_uinput_text_when(text, || {
uinput_layout_types_ascii(&std::env::var("XDG_CURRENT_DESKTOP").unwrap_or_default(), gnome_layout_types_ascii)
})
}
fn type_uinput_text_when(&self, text: &str, layout_allowed: impl FnOnce() -> bool) -> usize {
if self.uinput.is_none() || !self.held.lock().unwrap().keys.is_empty() { return 0; }
// XKB can still report US while IBus consumes physical keys for composition.
// Leave committed text intact for the existing native/clipboard fallback.
if !layout_allowed() { return 0; }
self.emit_uinput_text(&crate::uinput::text_plan(text))
}
/// Mobile input-method text (`text_input`). X11 types directly. Native Wayland uses the text
/// keyboard's Unicode keysyms first: uinput sends physical keycodes, which a running input
/// method composes as pinyin, so "hello" would become candidates instead of text. uinput stays
/// as the fallback when the keymap path is unavailable. Portal and other Wayland environments
/// inject via clipboard paste (Shift+Insert).
/// Set UU_WAYLAND_TEXT=0 to disable Wayland text injection.
pub fn text_input(&self, text: &str) {
let _serial=self.serial.lock().unwrap();
if self.backend != crate::desktop_backend::DesktopBackend::X11 {
if std::env::var("UU_WAYLAND_TEXT").is_ok_and(|v| v == "0") { return; }
if self.backend == crate::desktop_backend::DesktopBackend::Wayland
&& crate::wayland::type_utf8(text) >= 0 {
log::info!("Desktop text input: chars={} result=keysyms", text.chars().count());
return;
}
let typed = self.type_uinput_text(text);
if typed > 0 { log::info!("Desktop text input (uinput): chars={typed}"); }
if typed == text.len() { return; }
// The uinput planner consumes ASCII only, so the character count is also a byte offset.
let rest = &text[typed..];
return self.desktop_text_input(rest);
}
self.desktop_text_input(text);
}
fn desktop_text_input(&self, text: &str) {
let Ok(c_text)=std::ffi::CString::new(text.replace('\0',"")) else { return };
if self.backend==crate::desktop_backend::DesktopBackend::X11 {
let typed=unsafe { x11_type_utf8(c_text.as_ptr()) };
@@ -675,9 +818,27 @@ impl InputInjector {
fn type_portal_keysyms(&self, text: &str) -> usize {
let Some(symbols)=ascii_keysyms(text) else { return 0 };
if !gnome_layout_types_ascii() { return 0; }
if self.virtual_uinput() { return self.type_uinput_ascii(&symbols); }
let Some(portal)=self.portal.lock().unwrap().clone() else { return 0 };
symbols.iter().take_while(|&&symbol| portal.type_keysym(symbol).is_ok()).count()
}
/// Privacy screen: KDE ignores portal keysyms on a virtual-output share. Type through uinput
/// on the US layout the keysym path already requires, adding Shift for shifted characters.
fn type_uinput_ascii(&self, symbols: &[u32]) -> usize {
const SHIFTED: &str = "~!@#$%^&*()_+{}|:\"<>?";
const BASE: &str = "`1234567890-=[]\\;',./";
symbols.iter().take_while(|&&symbol| {
let c=char::from_u32(symbol).unwrap_or('\0');
let (base, shift)=if c.is_ascii_uppercase() { (c.to_ascii_lowercase() as u64, true) }
else if let Some(i)=SHIFTED.find(c) { (BASE.as_bytes()[i] as u64, true) }
else { (u64::from(symbol), false) };
if crate::uinput::keysym_to_evdev(base).is_none() { return false; }
if shift && self.inject_key(0xffe1, true)!=0 { return false; }
let ok=self.inject_key(base, true)==0 && self.inject_key(base, false)==0;
if shift { self.inject_key(0xffe1, false); }
ok
}).count()
}
pub fn key_event(&self, keycode: i32, is_press: bool) {
let _serial=self.serial.lock().unwrap();
if self.backend!=crate::desktop_backend::DesktopBackend::X11 { return; }
@@ -714,6 +875,241 @@ mod motion_tests {
input.mouse_relative(1,2); input.discard_pointer();
assert_eq!(input.pending.lock().unwrap().relative,(0,0));
}
#[test]
fn parks_when_pointer_state_is_idle() {
let input = InputInjector::new();
assert!(input.pointer_idle());
input.mouse_relative(5,5);
assert!(!input.pointer_idle());
input.flush_pointer();
assert!(input.pointer_idle());
input.mouse_scroll(0,125); input.flush_pointer();
assert!(input.pointer_idle(), "sub-notch scroll residue cannot inject alone");
}
#[test]
fn live_touch_gesture_stays_busy_until_it_resolves() {
let input = InputInjector::new();
input.touch.lock().unwrap().finger = Finger::Pending { start: (5,5), at: std::time::Instant::now() };
assert!(!input.pointer_idle());
input.touch.lock().unwrap().finger = Finger::Scroll { last: (9,9) };
assert!(!input.pointer_idle());
*input.touch.lock().unwrap() = TouchDrag::default();
assert!(input.pointer_idle());
}
#[test]
fn button_wake_waits_for_the_serialized_transition() {
use futures_util::FutureExt;
let input = std::sync::Arc::new(InputInjector::without_desktop());
let serial = input.serial.lock().unwrap();
let ready = std::sync::Arc::new(std::sync::Barrier::new(2));
let pressing = input.clone();
let started = ready.clone();
let button = std::thread::spawn(move || { started.wait(); pressing.mouse_button(1,true); });
ready.wait();
let runtime = tokio::runtime::Builder::new_current_thread().enable_time().build().unwrap();
let premature = runtime.block_on(async {
tokio::time::timeout(std::time::Duration::from_millis(50), input.pointer_wake.notified()).await.is_ok()
});
drop(serial);
button.join().unwrap();
assert!(!premature, "a parked worker must not wake before the button owns the serial lock");
assert!(input.pointer_wake.notified().now_or_never().is_some());
}
#[tokio::test(start_paused = true)]
async fn worker_coalesces_one_ms_motion_on_four_ms_ticks() {
let input = std::sync::Arc::new(InputInjector::without_desktop());
let worker = input.start_pointer_worker();
input.mouse_relative(1,0);
tokio::task::yield_now().await;
assert_eq!(input.portal_input_counts_for_test()[0],1, "first motion is immediate");
for ms in 1..=12 {
tokio::time::advance(std::time::Duration::from_millis(1)).await;
tokio::task::yield_now().await;
input.mouse_relative(1,0);
tokio::task::yield_now().await;
assert_eq!(input.portal_input_counts_for_test()[0],1+ms/4, "motion at {ms} ms bypassed the cadence");
}
tokio::time::advance(std::time::Duration::from_millis(4)).await;
tokio::task::yield_now().await;
assert_eq!(input.portal_input_counts_for_test()[0],5);
assert_eq!(input.pending.lock().unwrap().relative,(0,0));
worker.abort();
assert!(worker.await.unwrap_err().is_cancelled());
}
#[tokio::test(start_paused = true)]
async fn worker_parks_and_resets_the_tick_after_a_quiet_period() {
let input = std::sync::Arc::new(InputInjector::without_desktop());
let worker = input.start_pointer_worker();
tokio::task::yield_now().await;
// Without a notification, raw queued state must remain untouched while parked.
input.pending.lock().unwrap().relative = (1,0);
tokio::time::advance(std::time::Duration::from_secs(1)).await;
tokio::task::yield_now().await;
assert_eq!(input.portal_input_counts_for_test()[0],0);
input.mouse_relative(1,0);
tokio::task::yield_now().await;
assert_eq!(input.portal_input_counts_for_test()[0],1);
tokio::time::advance(std::time::Duration::from_millis(4)).await;
tokio::task::yield_now().await;
input.pending.lock().unwrap().relative = (1,0);
tokio::time::advance(std::time::Duration::from_millis(997)).await;
tokio::task::yield_now().await;
assert_eq!(input.portal_input_counts_for_test()[0],1, "idle ticks must stop after activity");
input.mouse_relative(1,0);
tokio::task::yield_now().await;
assert_eq!(input.portal_input_counts_for_test()[0],2);
input.mouse_relative(1,0);
tokio::task::yield_now().await;
assert_eq!(input.portal_input_counts_for_test()[0],2, "a stale interval must not flush a second time immediately");
tokio::time::advance(std::time::Duration::from_millis(4)).await;
tokio::task::yield_now().await;
assert_eq!(input.portal_input_counts_for_test()[0],3);
worker.abort();
assert!(worker.await.unwrap_err().is_cancelled());
}
}
#[cfg(all(test, target_os = "linux"))]
mod kernel_pointer_tests {
use super::*;
#[test]
fn committed_text_with_gnome_ime_emits_no_uinput_keys() {
for source in ["[('ibus', 'libpinyin'), ('xkb', 'us')]", "@a(ss) []"] {
let (devices, mut keyboard, _) = crate::uinput::Devices::recording_for_test();
let mut input = InputInjector::without_desktop(); input.uinput = Some(devices);
let checked = std::cell::Cell::new(false);
let text = "fixture";
let typed = input.type_uinput_text_when(text, || {
checked.set(true);
uinput_layout_types_ascii("GNOME", || first_source_types_ascii(source))
});
assert!(checked.get());
assert_eq!(typed, 0);
assert!(crate::uinput::Devices::recorded_events_for_test(&mut keyboard).is_empty());
}
}
#[test]
fn text_plan_emits_balanced_modifiers_without_portal_or_clipboard() {
let (devices, mut keyboard, _) = crate::uinput::Devices::recording_for_test();
let mut input = InputInjector::without_desktop(); input.uinput = Some(devices);
let plan = [
crate::uinput::TextKey { code:30, shift:42 },
crate::uinput::TextKey { code:48, shift:42 },
crate::uinput::TextKey { code:2, shift:0 },
];
assert_eq!(input.emit_uinput_text(&plan), 3);
let keys: Vec<_> = crate::uinput::Devices::recorded_events_for_test(&mut keyboard).into_iter()
.filter(|event| event.0 == 1).collect();
assert_eq!(keys, [(1,42,1),(1,30,1),(1,30,0),(1,48,1),(1,48,0),(1,42,0),(1,2,1),(1,2,0)]);
assert_eq!(input.portal_input_counts_for_test(), [0; 3]);
}
#[test]
fn partial_text_plan_releases_shift_and_does_not_disturb_held_keys() {
let (devices, mut keyboard, _) = crate::uinput::Devices::recording_for_test();
let mut input = InputInjector::without_desktop(); input.uinput = Some(devices);
assert_eq!(input.emit_uinput_text(&[
crate::uinput::TextKey { code:30, shift:42 },
crate::uinput::TextKey { code:0, shift:0 },
]), 1);
let keys: Vec<_> = crate::uinput::Devices::recorded_events_for_test(&mut keyboard).into_iter()
.filter(|event| event.0 == 1).collect();
assert_eq!(keys, [(1,42,1),(1,30,1),(1,30,0),(1,42,0)]);
input.held.lock().unwrap().keys.insert(0xffe3);
assert_eq!(input.type_uinput_text("fixture"), 0);
assert_eq!(input.held.lock().unwrap().keys.len(), 1);
}
#[test]
#[ignore = "requires the current X11/XWayland layout; records events without desktop injection"]
fn committed_ascii_text_bypasses_portal_with_live_keymap() {
let fixture = "aAzZ09!@#$%^&*()_+-=[]{};:'\",.<>/?\\|`~\t\n";
assert_eq!(crate::uinput::text_plan(fixture).len(), fixture.len(), "fixture not available in idle host keymap");
let (devices, mut keyboard, _) = crate::uinput::Devices::recording_for_test();
let mut input = InputInjector::without_desktop(); input.uinput = Some(devices);
let input = std::sync::Arc::new(input);
let binding = input.portal.lock().unwrap();
let worker_input = input.clone();
let (done, received) = std::sync::mpsc::channel();
let worker = std::thread::spawn(move || { worker_input.text_input(fixture); let _ = done.send(()); });
// On failure panic with the binding held: poisoning prevents a fallback from touching the clipboard.
assert!(received.recv_timeout(std::time::Duration::from_secs(2)).is_ok(), "text path waited for Portal/clipboard");
drop(binding);
worker.join().unwrap();
let keys = crate::uinput::Devices::recorded_events_for_test(&mut keyboard);
let down = keys.iter().filter(|e| e.0 == 1 && e.2 == 1).count();
let up = keys.iter().filter(|e| e.0 == 1 && e.2 == 0).count();
assert!(down >= fixture.len());
assert_eq!(down, up);
assert_eq!(input.portal_input_counts_for_test(), [0; 3]);
}
#[test]
fn full_uinput_bypasses_portal_binding_and_preserves_move_click_order() {
for controller in [Controller::Other, Controller::Mobile] {
let (devices, mut keyboard, mut pointer) = crate::uinput::Devices::recording_for_test();
let mut input = InputInjector::without_desktop();
input.uinput = Some(devices);
input.uinput_pointer = true;
let input = std::sync::Arc::new(input);
// A blocked Portal must not stall any kernel-routed input. The recording
// files exercise the real event writer without typing or clicking on the desktop.
let binding = input.portal.lock().unwrap();
let worker_input = input.clone();
let (done, received) = std::sync::mpsc::channel();
let worker = std::thread::spawn(move || {
worker_input.set_controller(controller);
assert_eq!(worker_input.touch.lock().unwrap().mode, TouchMode::Mouse);
worker_input.windows_key_event(65, true);
worker_input.windows_key_event(65, false);
worker_input.mouse_absolute_normalized(1.0, 0.0, (3072, 1920));
worker_input.wire_mouse_button(1, true);
worker_input.wire_mouse_button(1, false);
worker_input.mouse_scroll(120, 240);
worker_input.flush_pointer();
let _ = done.send(());
});
let completed = received.recv_timeout(std::time::Duration::from_secs(1));
drop(binding);
worker.join().unwrap();
assert!(completed.is_ok(), "kernel input waited for a Portal binding");
assert_eq!(input.portal_input_counts_for_test(), [0; 3]);
let keys = crate::uinput::Devices::recorded_events_for_test(&mut keyboard);
assert_eq!(keys, [(1, 30, 1), (0, 0, 0), (1, 30, 0), (0, 0, 0)]);
let mouse = crate::uinput::Devices::recorded_events_for_test(&mut pointer);
assert_eq!(&mouse[..7], &[
(3, 0, 65535), (3, 1, 0), (0, 0, 0),
(1, 0x110, 1), (0, 0, 0), (1, 0x110, 0), (0, 0, 0),
]);
assert_eq!(mouse.iter().filter(|e| e.0 == 2 && e.1 == 8).map(|e| e.2).sum::<i32>(), 2);
assert_eq!(mouse.iter().filter(|e| e.0 == 2 && e.1 == 6).map(|e| e.2).sum::<i32>(), 1);
}
}
#[test]
fn full_uinput_clamps_coordinates_and_keeps_relative_motion_on_kernel() {
let (devices, mut keyboard, mut pointer) = crate::uinput::Devices::recording_for_test();
let mut input = InputInjector::without_desktop();
input.uinput = Some(devices); input.uinput_pointer = true;
*input.screen.lock().unwrap() = (3072, 1920);
assert_eq!(input.inject_move(-5, 4000, false), 0);
assert_eq!(crate::uinput::Devices::recorded_events_for_test(&mut pointer),
[(3, 0, 0), (3, 1, 65535), (0, 0, 0)]);
assert_eq!(input.inject_move(4, -3, true), 0);
assert_eq!(crate::uinput::Devices::recorded_events_for_test(&mut keyboard),
[(2, 0, 4), (2, 1, -3), (0, 0, 0)]);
assert_eq!(input.portal_input_counts_for_test(), [0; 3]);
}
#[test]
fn kde_output_count_ignores_disabled_and_disconnected_outputs() {
assert_eq!(active_output_count(br#"{"outputs":[{"enabled":true,"connected":true},{"enabled":false,"connected":true}]}"#), Some(1));
assert_eq!(active_output_count(br#"{"outputs":[{"enabled":true,"connected":true},{"enabled":true,"connected":true}]}"#), Some(2));
assert_eq!(active_output_count(br#"{"outputs":[{"enabled":true,"connected":false}]}"#), Some(0));
assert_eq!(active_output_count(br#"{}"#), None);
assert_eq!(active_output_count(b"invalid"), None);
}
}
#[cfg(test)]
@@ -807,15 +1203,18 @@ impl Drop for DesktopInputSession {fn drop(&mut self) {self.disconnected();}}
#[cfg(test)]
impl InputInjector {
pub fn portal_input_counts_for_test(&self) -> [usize; 3] {
std::array::from_fn(|i| self.portal_outcomes[i].load(std::sync::atomic::Ordering::Relaxed))
}
pub fn without_desktop() -> Self {
Self { mac_controller:std::sync::atomic::AtomicBool::new(false),
cmd:std::sync::Mutex::new(CmdState::default()), serial:std::sync::Mutex::new(()),
owner:std::sync::Mutex::new(DesktopOwner::default()), shortcuts:std::sync::Mutex::new(Shortcuts::default()),
uinput:None, screen:std::sync::Mutex::new((0,0)), portal_failures:std::sync::atomic::AtomicUsize::new(0),
uinput:None, uinput_pointer:false, screen:std::sync::Mutex::new((0,0)), portal_failures:std::sync::atomic::AtomicUsize::new(0),
portal_outcomes:std::array::from_fn(|_|std::sync::atomic::AtomicUsize::new(0)),
portal:std::sync::Mutex::new(None), backend:crate::desktop_backend::DesktopBackend::Portal,
pending:std::sync::Mutex::new(PendingPointer::default()), held:std::sync::Mutex::new(HeldInput::default()),
touch:std::sync::Mutex::new(TouchDrag::default()) }
touch:std::sync::Mutex::new(TouchDrag::default()), pointer_wake: tokio::sync::Notify::new() }
}
}
@@ -835,6 +1234,9 @@ fn first_source_types_ascii(sources: &str) -> bool {
const NON_LATIN: &[&str]=&["af","am","ara","bd","bg","bt","by","eg","et","ge","gr","il","in","iq","ir","kg","kh","kz","la","lk","mk","mm","mn","mv","np","ru","sy","th","tj","ua"];
kind=="xkb" && !NON_LATIN.contains(&base) && !variant.contains("cyrillic") && (base!="rs" || variant.contains("latin"))
}
fn uinput_layout_types_ascii(desktop: &str, gnome_layout: impl FnOnce() -> bool) -> bool {
!desktop.split(':').any(|name| name.eq_ignore_ascii_case("gnome")) || gnome_layout()
}
/// GNOME's active input source is the first of `mru-sources` (else of `sources`). Cached for 2 s.
fn gnome_layout_types_ascii() -> bool {
#[cfg(test)]
@@ -857,6 +1259,17 @@ fn gnome_layout_types_ascii() -> bool {
mod text_keysym_tests {
use super::*;
#[test]
fn uinput_preserves_gnome_input_source_guard_without_gating_other_desktops() {
for desktop in ["GNOME", "ubuntu:GNOME", "gnome:GNOME-Classic"] {
assert!(!uinput_layout_types_ascii(desktop, || first_source_types_ascii("[('ibus', 'libpinyin'), ('xkb', 'us')]")));
assert!(!uinput_layout_types_ascii(desktop, || false));
assert!(uinput_layout_types_ascii(desktop, || first_source_types_ascii("[('xkb', 'us'), ('ibus', 'libpinyin')]")));
}
for desktop in ["KDE", "Hyprland", ""] {
assert!(uinput_layout_types_ascii(desktop, || panic!("GNOME input-source state must not gate another desktop")));
}
}
#[test]
fn ascii_text_becomes_keysyms_and_other_text_does_not() {
assert_eq!(ascii_keysyms("Hi!\n\t~"), Some(vec![0x48,0x69,0x21,0xff0d,0xff09,0x7e]));
assert_eq!(ascii_keysyms("čaj"), None);
+8
View File
@@ -5,6 +5,14 @@ use webrtc::{media::Sample, peer_connection::{RTCPeerConnection, peer_connection
use crate::{capture_setting::VideoCodec, desktop_session::PortalDesktop, video_track::VideoTrack};
async fn black_frame(codec: VideoCodec) -> Result<Bytes, String> {
#[cfg(feature = "inproc-av")]
if crate::video::native_engine_eligible(crate::video_select::selection().encoder, crate::video::NativeDisplayKind::Portal) {
match tokio::task::spawn_blocking(move || crate::inproc_encoder::black_frame(codec)).await {
Ok(Ok(frame)) => return Ok(frame),
Ok(Err(error)) => log::warn!("Locked video in-process VAAPI unavailable: {error}; falling back to FFmpeg"),
Err(_) => log::warn!("Locked video in-process worker failed; falling back to FFmpeg"),
}
}
let mut command = crate::video::ffmpeg_command();
command.args(["-hide_banner", "-loglevel", "error", "-nostdin",
"-f", "lavfi", "-i", "color=c=black:s=1280x720:r=1", "-frames:v", "1",
+25 -8
View File
@@ -5,6 +5,7 @@ mod ws_transport;
mod engine_plugin;
mod doctor;
mod wol;
mod wallpaper;
mod desktop_backend;
mod desktop_mode;
mod desktop_session;
@@ -45,8 +46,9 @@ mod inproc_encoder;
mod capture_setting;
mod audio;
mod virtual_audio;
mod system_actions;
mod privacy_screen;
mod system_actions;
mod annotation;
mod capability;
mod protocol;
mod control_protocol;
@@ -209,7 +211,7 @@ pub(crate) fn cli_pref_ok(which: &str, value: &str) -> bool {
}
}
const SUBCOMMANDS: [&str; 17] = ["doctor", "show", "assist", "set-encoder", "set-codec", "desktop-input-probe", "virtual-audio-probe", "login", "unlock-check", "desktop-probe", "desktop-video-probe", "desktop-audio-probe", "wayland-capture",
const SUBCOMMANDS: [&str; 20] = ["privacy-guard", "privacy-wallpaper", "privacy-screen-probe", "doctor", "show", "assist", "set-encoder", "set-codec", "desktop-input-probe", "virtual-audio-probe", "login", "unlock-check", "desktop-probe", "desktop-video-probe", "desktop-audio-probe", "wayland-capture",
"wayland-input-probe", "wayland-text-probe", "clipboard-acceptance", "portal-acceptance"];
/// Unknown arguments and illegal set-encoder / set-codec values exit 2 (never start a second host).
@@ -631,6 +633,20 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
if login::run(gui).await.is_err() { std::process::exit(1); } // error already shown
return Ok(());
}
if std::env::args().nth(1).as_deref() == Some("privacy-guard") { std::process::exit(privacy_screen::guard_main()); }
if std::env::args().nth(1).as_deref() == Some("privacy-wallpaper") {
std::process::exit(privacy_screen::cover_main(&std::env::args().skip(2).collect::<Vec<_>>()));
}
if std::env::args().nth(1).as_deref() == Some("privacy-screen-probe") {
let screen = ScreenCapture::new()?;
if screen.portal.is_none() { return Err(std::io::Error::other("privacy screen needs the portal backend").into()); }
let _input = input::InputInjector::new(); // the privacy screen requires its uinput devices
let mode = if std::env::var("UU_PRIVACY_PROBE_WALLPAPER").as_deref() == Ok("1") { privacy_screen::Mode::Picture } else { privacy_screen::Mode::ScreenOff };
tokio::task::spawn_blocking(move || privacy_screen::probe(mode)).await?.map_err(std::io::Error::other)?;
drop(screen);
return Ok(());
}
privacy_screen::recover();
virtual_audio::init();
let _audio_cleanup=virtual_audio::Cleanup;
log::info!("Starting uu-remote-linux host v{}...", env!("CARGO_PKG_VERSION"));
@@ -657,7 +673,6 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
let input = Arc::new(InputInjector::new());
input.bind_portal(capture.portal.clone());
input.release_held(); // recover stale input before accepting any peer
privacy_screen::recover(); // monitors a previous run left black
let _pointer_worker = input.start_pointer_worker();
let (shutdown_tx, mut shutdown) = tokio::sync::watch::channel(false);
let shutdown_input = input.clone();
@@ -670,8 +685,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
}
#[cfg(not(target_os="linux"))]
let _ = tokio::signal::ctrl_c().await;
let _ = tokio::task::spawn_blocking(privacy_screen::disable).await;
if !assist_enabled { shutdown_input.shutdown(); virtual_audio::disable(); terminal::shutdown_all(); std::process::exit(0); }
if !assist_enabled { privacy_screen::shutdown(); shutdown_input.shutdown(); 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 };
@@ -702,7 +716,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; }
virtual_audio::disable(); input.shutdown(); terminal::shutdown_all();
privacy_screen::shutdown(); 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.
@@ -763,6 +777,7 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
client
};
let mut wallpaper_task = AbortOnDrop(wallpaper::start(auth.clone()));
// One peer per viewer connection (desktop, file transfer, terminal...), keyed by ice_id.
let mut next_capture_type: Option<(u64,crate::session_ice::SessionIce)> = None;
let mut capture_types: HashMap<String, (u64,crate::session_ice::SessionIce)> = HashMap::new();
@@ -800,6 +815,8 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
log::error!("UU login is invalid or expired; a new QR login is required");
let stale = config::read_fresh().ok().flatten().and_then(|f| f.get("token").and_then(|t| t.as_str()).map(str::to_owned));
auth = Arc::new(UUAuthClient::new(login::wait_for_credentials(stale).await));
wallpaper_task.0.abort();
wallpaper_task = AbortOnDrop(wallpaper::start(auth.clone()));
continue;
}
Err(e) => {
@@ -839,8 +856,8 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
Arc::new(cli)
}
Err(e) => {
let _ = e;
log::error!("Failed to connect signaling; retrying in 5s (details omitted)");
// ws_transport errors carry only a category or HTTP status, never the token or URL.
log::error!("Failed to connect signaling; retrying in 5s: {e}");
tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
continue;
}
+281 -57
View File
@@ -15,16 +15,33 @@ impl std::error::Error for PortalError {}
#[derive(Clone, Copy, PartialEq, Eq)]
pub struct FrameVersion(usize, u64);
#[repr(C)]
#[derive(Default)]
pub struct DmaFrame {
pub fd: i32,
pub fourcc: u32,
pub width: u32,
pub height: u32,
pub stride: u32,
pub offset: u32,
pub size: u32,
pub modifier: u64,
}
pub enum DmaCapture<T> { Frame(T), Pending, Cpu, Blank, Unavailable(i32) }
#[cfg(unix)]
#[path = "portal_permissions.rs"]
mod permissions;
#[cfg(all(target_os = "linux", feature = "portal"))]
mod native {
use std::{ffi::c_void, ptr::NonNull, sync::{Mutex, MutexGuard, TryLockError}};
use std::{ffi::c_void, ptr::NonNull, sync::{Arc, Mutex, MutexGuard, TryLockError}};
crate::engine_ffi! { crate::engine_plugin::Engine::Portal;
fn uu_portal_open_persist(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
fn uu_portal_open_virtual(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
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_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;
@@ -32,9 +49,13 @@ mod native {
fn uu_portal_close(portal: *mut c_void);
fn uu_portal_alive(portal: *mut c_void) -> i32;
fn uu_portal_capture_alive(portal: *mut c_void) -> i32;
fn uu_portal_wait_frame(portal: *mut c_void, timeout_us: i64) -> i32;
fn uu_portal_input_dispatch(portal: *mut c_void);
fn uu_portal_reset_frame(portal: *mut c_void);
fn uu_portal_capture_since(portal: *mut c_void, bgra: *mut u8, length: usize, revision: *mut u64) -> i32;
fn uu_portal_dmabuf_acquire(portal: *mut c_void, frame: *mut super::DmaFrame, revision: *mut u64) -> i32;
fn uu_portal_dmabuf_release(portal: *mut c_void);
fn uu_portal_dmabuf_disable(portal: *mut c_void);
fn uu_portal_move(portal: *mut c_void, x: f64, y: f64, relative: i32) -> i32;
fn uu_portal_button(portal: *mut c_void, button: i32, pressed: i32) -> i32;
fn uu_portal_key(portal: *mut c_void, keysym: u32, keycode: i32, pressed: i32) -> i32;
@@ -48,9 +69,14 @@ mod native {
}
struct Handle(NonNull<c_void>);
fn pack(width: u32, height: u32) -> u64 { (u64::from(width) << 32) | u64::from(height) }
// The engine owns callback threads; public calls are serialized by Mutex.
// Calls are serialized by Session's mutex except wait_frame, whose C-side
// condition wait synchronizes with callbacks and input through the engine lock.
unsafe impl Send for Handle {}
unsafe impl Sync for Handle {}
impl Drop for Handle { fn drop(&mut self) { unsafe { uu_portal_close(self.0.as_ptr()) } } }
fn lease_handle<T>(current: &Mutex<Arc<T>>) -> Result<Arc<T>, String> {
current.lock().map(|handle| Arc::clone(&handle)).map_err(|_| "Portal session lock poisoned".into())
}
fn blank_changed(frame: &mut [u8], version: &mut Option<super::FrameVersion>) -> bool {
if *version == Some(super::FrameVersion(0, 0)) { return false; }
super::blank(frame); *version = Some(super::FrameVersion(0, 0)); true
@@ -92,7 +118,7 @@ mod native {
was_locked.store(false, std::sync::atomic::Ordering::Release);
}
}
pub struct Session { handle: Mutex<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>> }
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 }
impl Session {
fn take_lock_observation(&self) -> Result<bool, String> {
// A recovery in progress must see the lock even if another capture
@@ -119,7 +145,8 @@ mod native {
/// Opens a session for `monitor` (a Mutter connector) with that monitor's saved consent;
/// None means the screen currently selected, or the only monitor.
/// `fresh` asks the host again instead of restoring the saved consent (which stays saved).
fn open_inner(cancelled: Option<&std::sync::atomic::AtomicBool>, monitor: Option<&str>, fresh: bool) -> Result<Self, super::PortalError> {
/// `virtual_output` shares a KWin virtual output instead (privacy screen) with its own consent.
fn open_inner(cancelled: Option<&std::sync::atomic::AtomicBool>, monitor: Option<&str>, fresh: bool, virtual_output: bool) -> Result<Self, super::PortalError> {
extern "C" fn is_cancelled(data: *mut c_void) -> i32 {
let cancelled = unsafe { &*(data as *const std::sync::atomic::AtomicBool) };
i32::from(cancelled.load(std::sync::atomic::Ordering::Acquire))
@@ -132,50 +159,114 @@ mod native {
let (mut error, mut width, mut height) = (0, 0, 0);
let directory = super::permissions::directory();
let key = super::permissions::desktop_key();
let wanted = monitor.map(str::to_owned).or_else(crate::wayland::portal_monitor);
let wanted = if virtual_output { None } else { monitor.map(str::to_owned).or_else(crate::wayland::portal_monitor) };
let wanted_key = wanted.as_deref().map(super::permissions::monitor_key);
let virtual_key = format!("{key}-virtual");
// One opener at a time: consent tokens are single-use, and two concurrent openers
// (privacy virtual-output switch and closure recovery after a quick reconnect) each
// consumed one and both failed, leaving no saved consent (seen live, KDE).
static OPENING: Mutex<()> = Mutex::new(());
let _opening = OPENING.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
// Each monitor has its own consent; the desktop-wide key is the single-monitor one.
let token = directory.as_deref().filter(|_| !fresh).and_then(|dir| {
wanted.as_deref().and_then(|name| super::permissions::take(dir, &super::permissions::monitor_key(name)))
.or_else(|| super::permissions::take(dir, key))
}).and_then(|value| std::ffi::CString::new(value).ok());
// The new token is saved once the granted monitor is known (after open).
let mut cache: Option<String> = None;
extern "C" fn save_token(token: *const libc::c_char, data: *mut c_void) {
// Callback is synchronous during open; cache lives through the call.
let taken = directory.as_deref().filter(|_| !fresh).and_then(|dir| {
let take = |k: String| super::permissions::take(dir, &k).map(|v| (k, v));
if virtual_output { return take(virtual_key.clone()); }
wanted_key.as_ref().and_then(|name| take(super::permissions::pending_key(name)).or_else(|| take(name.clone())))
.or_else(|| take(super::permissions::pending_key(key))).or_else(|| take(key.to_owned()))
});
let token = taken.as_ref().and_then(|(_, value)| std::ffi::CString::new(value.as_str()).ok());
let requested_key = if virtual_output { &virtual_key } else { wanted_key.as_deref().unwrap_or(key) };
struct TokenCache { rotation: super::permissions::Rotation, virtual_key: Option<String>, fresh: bool }
let mut cache = TokenCache {
rotation: super::permissions::Rotation::new(directory.clone(), requested_key),
virtual_key: virtual_output.then(|| virtual_key.clone()), fresh,
};
extern "C" fn save_detailed(token: *const libc::c_char, data: *mut c_void, has_position: i32, x: i32, y: i32) {
let result = std::panic::catch_unwind(|| unsafe {
let cache = &mut *(data as *mut Option<String>);
*cache = std::ffi::CStr::from_ptr(token).to_str().ok().map(str::to_owned);
let cache = &mut *(data as *mut TokenCache);
if let Ok(token) = std::ffi::CStr::from_ptr(token).to_str() {
if cache.fresh { cache.rotation.remember(token); return; }
let granted = cache.virtual_key.clone().or_else(||
(has_position != 0).then(|| crate::wayland::portal_monitor_at(x, y)).flatten()
.map(|name| super::permissions::monitor_key(&name)));
if cache.rotation.record(token, granted.as_deref()).is_err() { log::warn!("Portal permission cache could not be saved"); }
}
});
if result.is_err() { log::warn!("Portal permission cache callback failed"); }
}
// Older plugins lack the position-aware entry point; use the pending slot.
extern "C" fn save_token(token: *const libc::c_char, data: *mut c_void) {
save_detailed(token, data, 0, 0, 0);
}
let restore = token.as_ref().map_or(std::ptr::null(), |value| value.as_ptr());
let pointer = unsafe {
if let Some(cancelled) = cancelled {
uu_portal_open_persist_cancellable(
restore, save_token, &mut cache as *mut _ as *mut c_void,
is_cancelled, cancelled as *const _ as *mut c_void,
&mut error, &mut width, &mut height,
)
} else {
uu_portal_open_persist(restore, save_token, &mut cache as *mut _ as *mut c_void, &mut error, &mut width, &mut height)
let failed = |code: i32, cache: &TokenCache| {
if let (Some(dir), Some((k, value)), false) = (directory.as_deref(), taken.as_ref(), cache.rotation.received()) {
if super::permissions::save(dir, k, value).is_err() { log::warn!("Portal permission cache could not be restored"); }
}
super::PortalError { code }
};
let handle = NonNull::new(pointer).ok_or(super::PortalError { code: error })?;
// Release packages can temporarily have an older libuu-portal.so than the host.
#[cfg(feature = "engine-plugins")]
let detailed = crate::engine_plugin::symbol(crate::engine_plugin::Engine::Portal, "uu_portal_open_detailed\0") != 0;
#[cfg(not(feature = "engine-plugins"))]
let detailed = true;
#[allow(unused_mut)]
let mut prefer_dmabuf = false;
#[cfg(feature = "inproc-av")]
if !virtual_output && crate::video::native_engine_eligible(crate::video_select::selection().encoder, crate::video::NativeDisplayKind::Portal)
&& !std::env::var("UU_PORTAL_DMABUF").is_ok_and(|v| v == "0") {
prefer_dmabuf = true;
}
let pointer = if detailed {
let cancel = cancelled.filter(|_| !virtual_output);
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(
restore, save_detailed, &mut cache as *mut _ as *mut c_void, callback, cancel_data,
i32::from(prefer_dmabuf), if virtual_output { 4 } else { 1 },
&mut error, &mut width, &mut height,
) }
} else {
#[allow(unused_mut)]
let mut pointer: *mut c_void = std::ptr::null_mut();
#[cfg(feature = "inproc-av")]
if prefer_dmabuf {
let callback = cancelled.map(|_| is_cancelled as extern "C" fn(*mut c_void) -> i32);
let cancel_data = cancelled.map_or(std::ptr::null_mut(), |value| value as *const _ as *mut c_void);
pointer = unsafe { uu_portal_open_persist_capture(
restore, save_token, &mut cache as *mut _ as *mut c_void, callback, cancel_data, 1,
&mut error, &mut width, &mut height,
) };
if pointer.is_null() && error != 0 { return Err(failed(error, &cache)); }
if pointer.is_null() { log::warn!("Portal engine lacks DMA-BUF initialization; falling back to legacy initialization"); }
}
if !pointer.is_null() { pointer } else { unsafe {
if virtual_output {
uu_portal_open_virtual(restore, save_token, &mut cache as *mut _ as *mut c_void, &mut error, &mut width, &mut height)
} else if let Some(cancelled) = cancelled {
uu_portal_open_persist_cancellable(restore, save_token, &mut cache as *mut _ as *mut c_void,
is_cancelled, cancelled as *const _ as *mut c_void, &mut error, &mut width, &mut height)
} else {
uu_portal_open_persist(restore, save_token, &mut cache as *mut _ as *mut c_void, &mut error, &mut width, &mut height)
}
} }
};
let Some(handle) = NonNull::new(pointer) else { return Err(failed(if error == 0 { 15 } else { error }, &cache)) };
let (mut x, mut y) = (0, 0);
let granted = (unsafe { uu_portal_stream_position(handle.as_ptr(), &mut x, &mut y) } == 0)
let granted = (!virtual_output && unsafe { uu_portal_stream_position(handle.as_ptr(), &mut x, &mut y) } == 0)
.then(|| crate::wayland::portal_monitor_at(x, y)).flatten();
if let (Some(dir), Some(token)) = (directory.as_deref(), cache.take()) {
let saved = match &granted {
Some(name) => super::permissions::monitor_key(name),
None => key.to_owned(),
};
if super::permissions::save(dir, &saved, &token).is_err() { log::warn!("Portal permission cache could not be saved"); }
let saved = match &granted {
_ if virtual_output => virtual_key.clone(),
Some(name) => super::permissions::monitor_key(name),
None => key.to_owned(),
};
if cache.rotation.finish(&saved, fresh || virtual_output || granted.is_some()).is_err() {
log::warn!("Portal permission cache could not be saved");
}
if wanted.is_some() && granted != wanted { log::warn!("Portal granted a different monitor than requested"); }
// A freshly opened session holds no lock-screen frame: only an observed lock (or a
// closed stream) must discard the cached frame. Starting "locked" cleared the first
// valid frame, and a static desktop sends no new one, so the viewer stayed black (#2).
Ok(Self { handle: Mutex::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) })
// 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() })
}
/// Frame pixels of the monitor the stream currently follows.
pub fn size(&self) -> (u32, u32) {
@@ -193,7 +284,7 @@ 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(()); }
let replacement = Self::open_inner(None, Some(connector), false).map_err(|error| error.to_string())?;
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());
}
@@ -208,8 +299,36 @@ mod native {
drop(previous);
Ok(())
}
pub fn is_virtual(&self) -> bool { self.virtual_output.load(std::sync::atomic::Ordering::Acquire) }
/// Privacy screen: capture and input move to a KWin virtual output (on) or back to the
/// physical monitor (off). The caller enables physical outputs before switching back.
pub fn set_virtual(&self, on: bool) -> Result<(), String> {
if self.is_virtual() == on { return Ok(()); }
// Closure recovery would otherwise see the replaced share end and reopen the wrong source.
let _recovery = self.recovery.lock().map_err(|_| "Portal recovery lock poisoned")?;
let monitor = self.monitor();
// KDE restores a monitor share against the whole workspace while the virtual output
// 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);
log::info!("Portal capture source: virtual={on} size={}x{}", size.0, size.1);
Ok(())
}
pub fn open() -> Result<Self, String> {
Self::open_inner(None, None, false).map_err(|error| error.to_string())
Self::open_inner(None, None, false, false).map_err(|error| error.to_string())
}
#[cfg(test)]
pub(crate) fn test_lock_watch(&mut self, locked: tokio::sync::watch::Receiver<Option<bool>>) {
self.locked = locked;
}
/// A consent saved before touch support restores keyboard and pointer only. Ask the host once
/// more (GNOME shows its share dialog; the consent timeout closes it) and swap the new session
@@ -220,7 +339,7 @@ mod native {
if !available || self.touch_supported() { return Ok(false); }
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).map_err(|error| error.to_string())?;
let replacement = Self::open_inner(None, monitor.as_deref(), true, self.is_virtual()).map_err(|error| error.to_string())?;
// The new consent is saved for whichever monitor was granted, so a later connection uses it.
if replacement.monitor() != monitor { return Err("another monitor was shared".into()); }
if !replacement.touch_supported() { return Err("the touchscreen was not granted".into()); }
@@ -231,7 +350,7 @@ mod native {
Ok(true)
}
pub fn open_cancellable(cancelled: &std::sync::atomic::AtomicBool) -> Result<Self, super::PortalError> {
Self::open_inner(Some(cancelled), None, false)
Self::open_inner(Some(cancelled), None, false, false)
}
pub fn recover(&self, cancelled: &std::sync::atomic::AtomicBool) -> Result<bool, super::PortalError> {
use std::sync::atomic::Ordering;
@@ -256,7 +375,10 @@ mod native {
};
if alive { return Ok(false); }
let result = super::open_then_install(cancelled, || Self::open_cancellable(cancelled), |replacement| {
// The privacy screen's virtual share is reopened as itself, not as the monitor.
let virtual_output = self.is_virtual();
let monitor = self.monitor();
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 mut handle = self.handle.lock().map_err(|_| super::PortalError { code: 3 })?;
@@ -276,6 +398,7 @@ mod native {
}
pub fn pause(&self) {
if let Ok(handle) = self.handle.lock() {
if unsafe { uu_portal_capture_alive(handle.0.as_ptr()) } != 0 { return; }
unsafe { uu_portal_reset_frame(handle.0.as_ptr()) };
self.was_locked.store(true, std::sync::atomic::Ordering::Release);
} else {
@@ -283,7 +406,46 @@ mod native {
}
}
pub fn capture(&self, frame: &mut [u8]) -> Result<(), String> {
self.capture_changed(frame, &mut None).map(|_| ())
let mut version = None;
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(1);
loop {
self.capture_changed(frame, &mut version)?;
// A one-shot snapshot must wait for SHM renegotiation after DMA initialization.
// Release the handle between attempts so input and recovery remain responsive.
if version != Some(super::FrameVersion(0, 0)) || std::time::Instant::now() >= deadline { return Ok(()); }
std::thread::sleep(std::time::Duration::from_millis(10));
}
}
pub fn disable_dmabuf(&self) {
if let Ok(handle) = self.handle.lock() { unsafe { uu_portal_dmabuf_disable(handle.0.as_ptr()) }; }
}
pub fn with_dmabuf<T>(&self, version: &mut Option<super::FrameVersion>,
encode: impl FnOnce(&super::DmaFrame, bool) -> Result<T, String>,
) -> Result<super::DmaCapture<T>, String> {
let handle = self.handle.lock().map_err(|_| "Portal session lock poisoned")?;
unsafe { uu_portal_input_dispatch(handle.0.as_ptr()) };
// Hold the handle guard through GPU completion, so monitor swaps cannot invalidate a lease.
if unsafe { uu_portal_capture_alive(handle.0.as_ptr()) } == 0 {
return Ok(super::DmaCapture::Cpu);
}
let identity = handle.0.as_ptr() as usize;
let mut revision = version.filter(|v| v.0 == identity).map_or(0, |v| v.1);
let mut frame = super::DmaFrame::default();
match unsafe { uu_portal_dmabuf_acquire(handle.0.as_ptr(), &mut frame, &mut revision) } {
code @ (0 | 12) => {
struct Lease(*mut c_void);
impl Drop for Lease {
fn drop(&mut self) { unsafe { uu_portal_dmabuf_release(self.0) }; }
}
let _lease = Lease(handle.0.as_ptr());
let encoded = encode(&frame, code == 0)?;
*version = Some(super::FrameVersion(identity, revision));
Ok(super::DmaCapture::Frame(encoded))
},
10 => Ok(super::DmaCapture::Pending),
15 => Ok(super::DmaCapture::Blank),
code => Ok(super::DmaCapture::Unavailable(code)),
}
}
pub fn capture_changed(&self, frame: &mut [u8], version: &mut Option<super::FrameVersion>) -> Result<bool, String> {
let (width, height) = self.size();
@@ -293,21 +455,18 @@ mod native {
// Drain EIS even on a static desktop so pause/disconnect and sync
// events are processed without waiting for remote input.
unsafe { uu_portal_input_dispatch(handle.0.as_ptr()) };
let state = *self.locked.borrow();
if state != Some(false) {
// Unknown state (watcher not reported yet): show nothing but keep the cached frame.
if state == Some(true) {
if unsafe { uu_portal_capture_alive(handle.0.as_ptr()) } == 0 {
// A healthy source is forwarded regardless of lock state. Only an unavailable
// source is blanked; wait for unlock before reopening a compositor-closed session.
if *self.locked.borrow() != Some(false) {
unsafe { uu_portal_reset_frame(handle.0.as_ptr()) };
self.was_locked.store(true, std::sync::atomic::Ordering::Release);
return Ok(blank_changed(frame, version));
}
if self.was_locked.load(std::sync::atomic::Ordering::Acquire) {
if self.take_lock_observation()? { unsafe { uu_portal_reset_frame(handle.0.as_ptr()) }; }
return Ok(blank_changed(frame, version));
}
return Ok(blank_changed(frame, version));
}
if self.was_locked.load(std::sync::atomic::Ordering::Acquire) {
// First unlocked capture after a real lock: drop frames captured while locked.
if self.take_lock_observation()? { unsafe { uu_portal_reset_frame(handle.0.as_ptr()) }; }
return Ok(blank_changed(frame, version));
}
if unsafe { uu_portal_capture_alive(handle.0.as_ptr()) } == 0 {
// Serialize recovery without making another capture worker hold
// the input mutex while waiting for this worker's Portal calls.
let mut recovery = match self.recovery.try_lock() {
@@ -329,7 +488,7 @@ mod native {
self.was_locked.store(true, std::sync::atomic::Ordering::Release);
false
}) { return Ok(None); }
let replacement = match Self::open_inner(None, self.monitor().as_deref(), false) {
let replacement = match Self::open_inner(None, self.monitor().as_deref(), false, self.is_virtual()) {
Ok(value) => value,
Err(error) => {
log::warn!("Portal capture recovery deferred: {error}");
@@ -351,6 +510,7 @@ mod native {
// Recheck lock state on the next capture before showing the new session.
return Ok(blank_changed(frame, version));
} else {
self.was_locked.store(false, std::sync::atomic::Ordering::Release);
match self.recovery.try_lock() {
Ok(mut recovery) => recovery.retry_at = None,
Err(TryLockError::WouldBlock) => (),
@@ -370,6 +530,17 @@ mod native {
pub fn clipboard_supported(&self) -> bool {
self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_clipboard_supported(handle.0.as_ptr()) != 0 })
}
pub fn wait_frame(&self, timeout: std::time::Duration) -> Result<bool, String> {
let handle = lease_handle(&self.handle)?;
// Retain sub-millisecond precision across the FFI boundary and clamp to 5s.
let us = (timeout.as_micros().min(5_000_000) as i64).max(1);
let ret = unsafe { uu_portal_wait_frame(handle.0.as_ptr(), us) };
if ret < 0 {
Err("Portal stream closed or failed during frame wait".into())
} else {
Ok(ret > 0)
}
}
pub fn clipboard_ready(&self) -> bool {
self.handle.lock().is_ok_and(|handle| unsafe { uu_portal_clipboard_ready(handle.0.as_ptr()) != 0 })
}
@@ -447,12 +618,12 @@ mod native {
fn new(physical: (u32, u32)) -> Self {
let (_, locked) = tokio::sync::watch::channel(None);
Self(ManuallyDrop::new(Session {
handle: Mutex::new(Handle(NonNull::dangling())),
handle: Mutex::new(Arc::new(Handle(NonNull::dangling()))),
locked,
was_locked: std::sync::atomic::AtomicBool::new(false),
recovery: Mutex::new(Recovery::default()),
size: pack(physical.0, physical.1).into(),
monitor: Mutex::new(None),
monitor: Mutex::new(None), virtual_output: false.into(),
}))
}
@@ -486,6 +657,35 @@ mod native {
button_held: bool,
retirement: Option<(std::sync::mpsc::Sender<()>, std::sync::mpsc::Receiver<()>)>,
}
#[test]
fn frame_wait_lease_keeps_replaced_handle_alive_without_blocking_input() {
use std::sync::{atomic::{AtomicBool, Ordering}, mpsc::channel};
struct Tracked(Arc<AtomicBool>);
impl Drop for Tracked { fn drop(&mut self) { self.0.store(true, Ordering::SeqCst); } }
let dropped = Arc::new(AtomicBool::new(false));
let current = Arc::new(Mutex::new(Arc::new(Tracked(dropped.clone()))));
let (waiting, ready) = channel();
let (resume, resumed) = channel();
let worker = {
let current = current.clone();
std::thread::spawn(move || {
let lease = lease_handle(&current).unwrap();
waiting.send(()).unwrap();
resumed.recv_timeout(std::time::Duration::from_secs(3)).unwrap();
assert!(!lease.0.load(Ordering::SeqCst));
})
};
ready.recv_timeout(std::time::Duration::from_secs(3)).unwrap();
let old = {
let mut guard = current.try_lock().expect("frame wait must not block input");
std::mem::replace(&mut *guard, Arc::new(Tracked(Arc::new(AtomicBool::new(false)))))
};
drop(old);
assert!(!dropped.load(Ordering::SeqCst));
resume.send(()).unwrap();
worker.join().unwrap();
assert!(dropped.load(Ordering::SeqCst));
}
impl Drop for TestHandle {
fn drop(&mut self) {
if let Some((entered, resume)) = self.retirement.take() {
@@ -719,6 +919,8 @@ impl PortalSession {
pub fn monitor(&self) -> Option<String> { None }
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 is_virtual(&self) -> bool { false }
}
#[cfg(not(all(target_os = "linux", feature = "portal")))]
impl PortalSession {
@@ -739,6 +941,11 @@ impl PortalSession {
pub fn pause(&self) {}
pub fn capture(&self, _: &mut [u8]) -> Result<(), String> { Err(error(15)) }
pub fn capture_changed(&self, _: &mut [u8], _: &mut Option<FrameVersion>) -> Result<bool, String> { Err(error(15)) }
pub fn disable_dmabuf(&self) {}
pub fn wait_frame(&self, _: std::time::Duration) -> Result<bool, String> { Err(error(15)) }
pub fn with_dmabuf<T>(&self, _: &mut Option<FrameVersion>, _: impl FnOnce(&DmaFrame, bool) -> Result<T, String>) -> Result<DmaCapture<T>, String> {
Ok(DmaCapture::Unavailable(-1))
}
pub fn move_pointer(&self, _: f64, _: f64, _: bool) -> Result<(), String> { Err(error(15)) }
pub fn button(&self, _: i32, _: bool) -> Result<(), String> { Err(error(15)) }
pub fn touch_supported(&self) -> bool { false }
@@ -753,9 +960,21 @@ impl PortalSession {
static ACTIVE: std::sync::Mutex<Option<std::sync::Weak<PortalSession>>> = std::sync::Mutex::new(None);
pub fn permissions_directory() -> Option<std::path::PathBuf> { permissions::directory() }
pub fn monitor_key(connector: &str) -> String { permissions::monitor_key(connector) }
pub fn permission_exists(dir: &std::path::Path, key: &str) -> bool { permissions::exists(dir, key) }
pub fn register(session: &Arc<PortalSession>) {
*ACTIVE.lock().unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Arc::downgrade(session));
}
/// Whether a desktop capture session is registered for monitor/virtual switching.
pub fn available() -> bool {
ACTIVE.lock().unwrap_or_else(std::sync::PoisonError::into_inner).as_ref().and_then(std::sync::Weak::upgrade).is_some()
}
/// Privacy screen: see `Session::set_virtual`. Restoring without a live session is a no-op;
/// failures switching a live session must reach the controller so its recovery record survives.
pub fn set_virtual_active(on: bool) -> Result<(), String> {
let session = ACTIVE.lock().unwrap_or_else(std::sync::PoisonError::into_inner).as_ref().and_then(std::sync::Weak::upgrade);
let Some(session) = session else { return if on { Err("Portal desktop unavailable".into()) } else { Ok(()) }; };
session.set_virtual(on)
}
pub fn switch_active(connector: &str) -> Result<(), 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")?;
@@ -796,6 +1015,11 @@ pub fn write_frames(session: Arc<PortalSession>, mut output: impl std::io::Write
#[cfg(test)]
mod tests {
#[test]
fn privacy_restore_without_a_desktop_is_a_noop_but_enable_fails() {
assert!(super::set_virtual_active(false).is_ok());
assert_eq!(super::set_virtual_active(true).unwrap_err(), "Portal desktop unavailable");
}
#[test]
fn monitor_lines_parse_and_reject_unsafe_connectors() {
let m = super::parse_monitors("eDP-1\t2880\t1800\t0\t0\t1\nHDMI-1\t2560\t1440\t1920\t0\t0\n../x\t1\t1\t0\t0\t0\n");
+109
View File
@@ -26,6 +26,58 @@ pub fn desktop_key() -> &'static str {
/// Consent for one monitor (Mutter connector); connectors are checked to be file-name safe.
pub fn monitor_key(connector: &str) -> String { format!("{}@{}", desktop_key(), connector) }
/// An unclassified grant is kept separately until its monitor is known.
pub fn pending_key(key: &str) -> String { format!("{key}.pending") }
pub fn exists(dir: &Path, key: &str) -> bool {
dir.join(key).exists() || dir.join(pending_key(key)).exists()
}
pub struct Rotation {
directory: Option<PathBuf>,
pending: String,
saved: Option<String>,
token: Option<String>,
}
impl Rotation {
pub fn new(directory: Option<PathBuf>, requested_key: &str) -> Self {
Self { directory, pending: pending_key(requested_key), saved: None, token: None }
}
pub fn received(&self) -> bool { self.token.is_some() }
/// A fresh request has not consumed the old grant; keep it until the new session opens.
pub fn remember(&mut self, token: &str) { self.token = Some(token.to_owned()); }
/// Persist before PipeWire starts; `known_key` comes from the actual granted source.
pub fn record(&mut self, token: &str, known_key: Option<&str>) -> std::io::Result<()> {
self.remember(token);
let Some(dir) = self.directory.as_deref() else { return Ok(()); };
let destination = known_key.unwrap_or(&self.pending);
save(dir, destination, token)?;
self.saved = Some(destination.to_owned());
if let Some(key) = known_key { let _ = fs::remove_file(dir.join(pending_key(key))); }
Ok(())
}
/// Move, rather than copy, so a single-use token never has two cache entries.
pub fn finish(&mut self, destination: &str, replace: bool) -> std::io::Result<()> {
let (Some(dir), Some(token)) = (self.directory.as_deref(), self.token.as_deref()) else { return Ok(()); };
if self.saved.as_deref() == Some(destination) { return Ok(()); }
if !replace && dir.join(destination).exists() { return Ok(()); }
if let Some(source) = self.saved.as_deref() {
fs::rename(dir.join(source), dir.join(destination))?;
fs::File::open(dir)?.sync_all()?;
} else {
save(dir, destination, token)?;
}
self.saved = Some(destination.to_owned());
let _ = fs::remove_file(dir.join(pending_key(destination)));
Ok(())
}
}
pub fn take(dir: &Path, key: &str) -> Option<String> {
let path = dir.join(key);
let mut file = OpenOptions::new().read(true).custom_flags(libc::O_NOFOLLOW).open(&path).ok()?;
@@ -71,4 +123,61 @@ mod tests {
assert!(save(&dir, "gnome", &"x".repeat(4097)).is_err());
fs::remove_dir_all(dir).unwrap();
}
#[test]
fn rotated_grant_survives_failure_and_is_moved_after_success() {
let dir = std::env::temp_dir().join(format!("uu-rotation-{}", std::process::id()));
fs::create_dir_all(&dir).unwrap();
save(&dir, "gnome@other", "other-grant").unwrap();
let mut rotation = Rotation::new(Some(dir.clone()), "gnome@wanted");
rotation.record("new-grant", None).unwrap();
// Simulate capture failure: no finish callback runs.
assert!(exists(&dir, "gnome@wanted"));
assert_eq!(take(&dir, &pending_key("gnome@wanted")).as_deref(), Some("new-grant"));
assert!(!exists(&dir, "gnome@wanted"));
assert_eq!(take(&dir, "gnome@other").as_deref(), Some("other-grant"));
let mut rotation = Rotation::new(Some(dir.clone()), "gnome@wanted");
rotation.record("newer-grant", None).unwrap();
rotation.finish("gnome@actual", true).unwrap();
assert!(!dir.join(pending_key("gnome@wanted")).exists());
assert_eq!(take(&dir, "gnome@actual").as_deref(), Some("newer-grant"));
fs::remove_dir_all(dir).unwrap();
}
#[test]
fn known_grants_replace_only_their_monitor_and_unknown_grants_do_not_overwrite() {
let dir = std::env::temp_dir().join(format!("uu-rotation-known-{}", std::process::id()));
fs::create_dir_all(&dir).unwrap();
save(&dir, "gnome", "existing-grant").unwrap();
save(&dir, "gnome@other", "other-grant").unwrap();
let mut unknown = Rotation::new(Some(dir.clone()), "gnome@wanted");
unknown.record("unknown-grant", None).unwrap();
unknown.finish("gnome", false).unwrap();
assert_eq!(take(&dir, "gnome").as_deref(), Some("existing-grant"));
assert_eq!(take(&dir, &pending_key("gnome@wanted")).as_deref(), Some("unknown-grant"));
let mut known = Rotation::new(Some(dir.clone()), "gnome@wanted");
known.record("known-grant", Some("gnome@actual")).unwrap();
assert_eq!(take(&dir, "gnome@actual").as_deref(), Some("known-grant"));
assert_eq!(take(&dir, "gnome@other").as_deref(), Some("other-grant"));
let mut no_token = Rotation::new(Some(dir.clone()), "gnome");
no_token.finish("gnome", true).unwrap();
assert!(!no_token.received());
assert!(!dir.join("gnome").exists());
fs::remove_dir_all(dir).unwrap();
}
#[test]
fn fresh_request_keeps_existing_grant_until_open_succeeds() {
let dir = std::env::temp_dir().join(format!("uu-rotation-fresh-{}", std::process::id()));
fs::create_dir_all(&dir).unwrap();
save(&dir, "gnome", "existing-grant").unwrap();
let mut fresh = Rotation::new(Some(dir.clone()), "gnome");
fresh.remember("fresh-grant");
assert_eq!(fs::read_to_string(dir.join("gnome")).unwrap(), "existing-grant");
assert!(!dir.join(pending_key("gnome")).exists());
fresh.finish("gnome", true).unwrap();
assert_eq!(take(&dir, "gnome").as_deref(), Some("fresh-grant"));
fs::remove_dir_all(dir).unwrap();
}
}
-228
View File
@@ -1,228 +0,0 @@
//! 防窥模式 (privacy screen) on X11: the physical monitors go black while the stream keeps
//! showing the desktop. Official protocol (Mac UURemoteServer / Windows GameViewerServer maps):
//! Message 21 RpcRequest field 7 PrivateScreenSettingRequest { 1 enable, 2 privacy_type, 3 setting_source }
//! -> Message 22 RpcResponse field 3 PrivateScreenSettingResponse { 1 error_code, 2 req_privacy_type,
//! 3 cur_privacy_type }; PrivateScreenType 1 NOT_SET, 2 NORMAL_PRIVACY, 3 ENHANCED_PRIVACY (wallpaper).
//! Declared through FeatureFlag 4 ff_private_screen = INIT_VERION (1, normal privacy only) and
//! ff_system_metrics = SETTING_PRIVATE_SCREEN (3); SettingMetric 4 private_screen, 7 private_screen_type.
//! The official host answers cur_privacy_type from its saved type (NORMAL/ENHANCED, else NOT_SET).
//!
//! Linux has no capture-excluded overlay window, so the CRTC gamma ramps are zeroed instead
//! (`xrandr --brightness 0`): scanout turns black, the framebuffer the capture reads is unchanged.
//! The previous gamma/brightness is saved to a file first, so a restart restores a screen a crash left black.
use std::process::Command;
use std::sync::Mutex;
pub const FF_PRIVATE_SCREEN: u8 = 1;
pub const PS_NOT_SET: u64 = 1;
pub const PS_NORMAL: u64 = 2;
const PS_ENHANCED: u64 = 3;
const ERROR_FAILED: u64 = 1;
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
struct Output { name: String, gamma: String, brightness: String }
#[derive(Debug, PartialEq, serde::Serialize, serde::Deserialize)]
struct Saved { display: String, outputs: Vec<Output> }
static ACTIVE: Mutex<Option<Saved>> = Mutex::new(None);
fn saved_path() -> std::path::PathBuf { crate::config::path().with_file_name("privacy_screen.json") }
/// Only the X11 engine can black out scanout without blacking out the capture.
pub fn supported() -> bool {
!cfg!(test) && !crate::desktop_backend::headless()
&& matches!(crate::desktop_backend::detect(), Ok(crate::desktop_backend::DesktopBackend::X11))
&& crate::capture::x11_display().is_some()
}
pub fn active() -> bool { ACTIVE.lock().map(|a| a.is_some()).unwrap_or(false) }
/// The saved type the viewer shows: NORMAL once privacy was used or chosen, else NOT_SET.
pub fn current_type() -> u64 {
if crate::system_actions::load_settings().privacy_screen_type == PS_NORMAL { PS_NORMAL } else { PS_NOT_SET }
}
fn xrandr(display: &str, args: &[String]) -> Result<String, String> {
let output = Command::new("xrandr").arg("--display").arg(display).args(args).output()
.map_err(|e| format!("xrandr unavailable: {}", e.kind()))?;
if !output.status.success() { return Err(format!("xrandr exited with {}", output.status)); }
Ok(String::from_utf8_lossy(&output.stdout).into_owned())
}
/// Connected outputs that drive a CRTC (geometry WxH+X+Y on the header line), with their gamma.
fn parse_outputs(verbose: &str) -> Vec<Output> {
let mut outputs: Vec<Output> = Vec::new();
let mut current: Option<usize> = None;
for line in verbose.lines() {
if !line.starts_with([' ', '\t']) {
current = None;
let mut words = line.split_whitespace();
let (Some(name), Some("connected")) = (words.next(), words.next()) else { continue };
if words.take(2).any(|w| w.contains('x') && w.contains('+')) {
outputs.push(Output { name: name.into(), gamma: "1.0:1.0:1.0".into(), brightness: "1.0".into() });
current = Some(outputs.len() - 1);
}
} else if let Some(i) = current {
let line = line.trim();
if let Some(v) = line.strip_prefix("Gamma:") { outputs[i].gamma = v.trim().into(); }
if let Some(v) = line.strip_prefix("Brightness:") { outputs[i].brightness = v.trim().into(); }
}
}
// A black screen saved by a crashed run must not become the value restored later.
for output in &mut outputs {
if output.brightness.parse::<f64>().map_or(true, |b| !(b > 0.0)) { output.brightness = "1.0".into(); }
}
outputs
}
fn black_args(outputs: &[Output]) -> Vec<String> {
outputs.iter().flat_map(|o| ["--output".into(), o.name.clone(), "--brightness".into(), "0".into()]).collect()
}
fn restore_args(outputs: &[Output]) -> Vec<String> {
outputs.iter().flat_map(|o| ["--output".into(), o.name.clone(), "--gamma".into(), o.gamma.clone(),
"--brightness".into(), o.brightness.clone()]).collect()
}
fn turn_on() -> Result<(), String> {
let mut active = ACTIVE.lock().map_err(|_| "privacy state poisoned")?;
if active.is_some() { return Ok(()); }
let display = crate::capture::x11_display().ok_or("X11 display not open")?;
let outputs = parse_outputs(&xrandr(&display, &["--verbose".into()])?);
if outputs.is_empty() { return Err("no active output".into()); }
let saved = Saved { display, outputs };
std::fs::write(saved_path(), serde_json::to_vec(&saved).map_err(|e| e.to_string())?).map_err(|e| e.kind().to_string())?;
if let Err(e) = xrandr(&saved.display, &black_args(&saved.outputs)) {
let _ = xrandr(&saved.display, &restore_args(&saved.outputs));
let _ = std::fs::remove_file(saved_path());
return Err(e);
}
log::info!("Privacy screen on: outputs={}", saved.outputs.len());
*active = Some(saved);
Ok(())
}
/// Restores the monitors; also used on session end and shutdown. Blocking.
pub fn disable() {
let Ok(mut active) = ACTIVE.lock() else { return };
let Some(saved) = active.take() else { return };
match xrandr(&saved.display, &restore_args(&saved.outputs)) {
Ok(_) => { let _ = std::fs::remove_file(saved_path()); log::info!("Privacy screen off"); }
Err(e) => log::warn!("Privacy screen restore failed: {e}"),
}
}
/// At startup: a previous run that ended while private left the monitors black.
pub fn recover() {
let Ok(bytes) = std::fs::read(saved_path()) else { return };
match serde_json::from_slice::<Saved>(&bytes) {
Ok(saved) => match xrandr(&saved.display, &restore_args(&saved.outputs)) {
Ok(_) => { let _ = std::fs::remove_file(saved_path()); log::info!("Privacy screen left by a previous run restored"); }
Err(e) => log::warn!("Privacy screen left by a previous run not restored: {e}"),
},
Err(_) => { let _ = std::fs::remove_file(saved_path()); }
}
}
/// RpcRequest field 7 -> RpcResponse { 1 header, 3 PrivateScreenSettingResponse }. Blocking (xrandr).
pub fn rpc_response(rpc: &[crate::protocol::WireField]) -> 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 = decode_wire(body(7)?).ok()?;
let varint = |n: u32| request.iter().find_map(|f| match (f.number, &f.value) { (x, WireValue::Varint(v)) if x == n => Some(*v), _ => None });
let (enable, requested) = (varint(1).unwrap_or(0) != 0, varint(2).unwrap_or(0));
let result = if requested == PS_ENHANCED {
Err("enhanced privacy (wallpaper) is not supported".to_owned())
} else if !supported() {
Err("privacy screen needs the X11 desktop".to_owned())
} else {
if requested == PS_NORMAL || enable {
if let Err(e) = crate::system_actions::merge_save(|s| s.privacy_screen_type = PS_NORMAL) { log::warn!("Privacy type not saved: {e}"); }
}
if enable { turn_on() } else { disable(); Ok(()) }
};
let error = match result {
Ok(()) => 0,
Err(e) => { log::warn!("Privacy screen request failed: enable={enable} type={requested}: {e}"); ERROR_FAILED }
};
log::info!("Privacy screen request: enable={} type={} source={:?} error={}", enable, requested, varint(3), error);
let mut payload = Vec::new();
if error != 0 { payload.extend_from_slice(&[8, error as u8]); }
if requested != 0 { payload.push(16); varint_into(requested, &mut payload); }
payload.push(24); varint_into(current_type(), &mut payload);
let header = body(1).unwrap_or(&[]);
let mut out = vec![10];
varint_into(header.len() as u64, &mut out);
out.extend_from_slice(header);
out.push(26);
varint_into(payload.len() as u64, &mut out);
out.extend_from_slice(&payload);
Some(out)
}
pub fn is_request(rpc: &[crate::protocol::WireField]) -> bool { rpc.iter().any(|f| f.number == 7) }
fn varint_into(mut v: u64, out: &mut Vec<u8>) {
while v >= 128 { out.push((v as u8 & 127) | 128); v >>= 7; }
out.push(v as u8);
}
#[cfg(test)]
mod tests {
use super::*;
const VERBOSE: &str = "Screen 0: minimum 8 x 8, current 4480 x 1440, maximum 32767 x 32767
HDMI-1 connected primary 2560x1440+0+0 (0x46) normal (normal left inverted right x axis y axis) 597mm x 336mm
\tIdentifier: 0x42
\tGamma: 1.0:1.0:1.0
\tBrightness: 1.0
2560x1440 (0x46) 241.500MHz +HSync -VSync *current +preferred
DP-1 connected 1920x1080+2560+0 (0x50) normal (normal left inverted right x axis y axis) 527mm x 296mm
\tGamma: 1.0:0.9:0.8
\tBrightness: 0.0
DP-2 connected (normal left inverted right x axis y axis)
\tGamma: 1.0:1.0:1.0
HDMI-2 disconnected (normal left inverted right x axis y axis)
";
#[test]
fn active_outputs_keep_gamma_and_a_black_brightness_is_not_saved() {
let outputs = parse_outputs(VERBOSE);
assert_eq!(outputs, vec![
Output { name: "HDMI-1".into(), gamma: "1.0:1.0:1.0".into(), brightness: "1.0".into() },
Output { name: "DP-1".into(), gamma: "1.0:0.9:0.8".into(), brightness: "1.0".into() },
]);
assert_eq!(black_args(&outputs[..1]), ["--output", "HDMI-1", "--brightness", "0"]);
assert_eq!(restore_args(&outputs[1..]), ["--output", "DP-1", "--gamma", "1.0:0.9:0.8", "--brightness", "1.0"]);
}
#[test]
fn settings_report_private_screen_on_and_its_type() {
use crate::system_metrics::{payload_with_settings, Permission::Allow, Settings};
let on = payload_with_settings(Allow, Allow, Allow, "", &Settings { private_screen: Some((true, PS_NORMAL)), ..Default::default() });
assert!(on.ends_with(&[34, 10, 32, 1, 56, 2, 64, 2, 72, 2, 80, 2]));
let unset = payload_with_settings(Allow, Allow, Allow, "", &Settings { private_screen: Some((false, PS_NOT_SET)), ..Default::default() });
assert!(unset.ends_with(&[34, 8, 56, 1, 64, 2, 72, 2, 80, 2]));
}
#[test]
fn unsupported_request_answers_failure_with_the_header() {
use crate::protocol::{decode_wire, WireValue};
// RpcRequest { 1 header{1:5}, 7 { 1 enable, 2 NORMAL, 3 source 1 } }
let rpc = [10, 2, 8, 5, 58, 6, 8, 1, 16, 2, 24, 1];
let fields = decode_wire(&rpc).unwrap();
assert!(is_request(&fields));
let out = rpc_response(&fields).unwrap();
let outer = decode_wire(&out).unwrap();
assert_eq!(outer[0].value, WireValue::Bytes(&[8, 5]));
let WireValue::Bytes(payload) = outer[1].value else { panic!("payload") };
assert_eq!(outer[1].number, 3);
let payload = decode_wire(payload).unwrap();
assert_eq!(payload[0].value, WireValue::Varint(ERROR_FAILED));
assert_eq!(payload[1].value, WireValue::Varint(PS_NORMAL));
assert_eq!(payload[2].number, 3);
assert!(!active());
}
}
+33
View File
@@ -0,0 +1,33 @@
//! One implementation per desktop. The controller (mod.rs) owns sessions, mode switching, the
//! recovery record and the guard; a backend only changes and restores its desktop.
use super::{record::Journal, Mode};
/// What the controller keeps while privacy is on.
#[derive(Default)]
pub struct Entered {
/// Picture mode keeps physical outputs on, so uinput's absolute axes span them too: the
/// captured (virtual) output as fractions (x, y, w, h) of the layout's bounding box.
pub pointer_region: Option<[f64; 4]>,
}
pub trait Backend: Send + Sync {
/// Stored in the recovery record to pick the same backend for recovery.
fn name(&self) -> &'static str;
/// Why `mode` cannot be served on this desktop.
fn unavailable(&self, mode: Mode) -> Option<String>;
/// Hide the local screen and block local input. Save what undoes each step through `journal`
/// before making it; on an error the controller calls `leave` with the last saved data.
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>;
}
/// The backend for this session, if the desktop has one.
pub fn detect() -> Option<&'static dyn Backend> {
if cfg!(test) { return None; }
if super::kde::Kde::detected() { return Some(&super::kde::Kde); }
None
}
pub fn named(name: &str) -> Option<&'static dyn Backend> {
match name { super::kde::NAME => Some(&super::kde::Kde), _ => None }
}
+45
View File
@@ -0,0 +1,45 @@
//! Picture mode's cover: a fullscreen keep-above window per physical monitor (GTK, in its own
//! process so it cannot disturb the host's UI thread), killed on restore and with the host.
use std::{process::{Child, Command, Stdio}, sync::Mutex};
static COVER: Mutex<Option<Child>> = Mutex::new(None);
pub fn supported() -> bool { cfg!(uu_gtk) }
/// `rects` are the monitors to cover in the desktop's logical coordinates (x, y, w, h).
pub fn show(image: Option<&std::path::Path>, rects: &[[f64; 4]]) -> Result<(), String> {
hide();
let exe = std::env::current_exe().map_err(|e| e.kind().to_string())?;
let mut command = Command::new(exe);
command.arg("privacy-wallpaper").arg(image.map(|p| p.as_os_str().to_owned()).unwrap_or_default());
for rect in rects { command.arg(rect.iter().map(|v| (v.round() as i64).to_string()).collect::<Vec<_>>().join(",")); }
// Keep the pipe writer in Child for the host's lifetime, independently of its spawning thread.
let mut child = command.stdin(Stdio::piped()).stdout(Stdio::piped()).spawn().map_err(|e| format!("cover window: {}", e.kind()))?;
// A spawned child is not a shown cover: GTK init or monitor matching can still fail (exit 1/2).
let stdout = child.stdout.take().ok_or("cover window: no stdout")?;
let (tx, rx) = std::sync::mpsc::channel();
std::thread::spawn(move || {
use std::io::BufRead;
let mut line = String::new();
let _ = tx.send(std::io::BufReader::new(stdout).read_line(&mut line).is_ok() && line.trim() == "ready");
});
if rx.recv_timeout(std::time::Duration::from_secs(5)) != Ok(true) {
let _ = child.kill();
let status = child.wait().ok().and_then(|s| s.code());
return Err(format!("cover window not shown (exit {status:?})"));
}
*COVER.lock().map_err(|_| "cover state poisoned")? = Some(child);
Ok(())
}
pub fn hide() {
if let Some(mut child) = COVER.lock().ok().and_then(|mut c| c.take()) { let _ = child.kill(); let _ = child.wait(); }
}
/// `privacy-wallpaper <image> <x,y,w,h>...`: the cover window process.
pub fn main(args: &[String]) -> i32 {
let rects: Vec<i32> = args.iter().skip(1).flat_map(|r| r.split(',').map(|v| v.parse().unwrap_or(-1))).collect();
#[cfg(uu_gtk)] {
extern "C" { fn uu_privacy_wallpaper_run(image: *const libc::c_char, rects: *const i32, count: i32) -> i32; }
let image = std::ffi::CString::new(args.first().cloned().unwrap_or_default()).unwrap_or_default();
unsafe { uu_privacy_wallpaper_run(image.as_ptr(), rects.as_ptr(), (rects.len() / 4) as i32) }
}
#[cfg(not(uu_gtk))] { let _ = rects; 1 }
}
+31
View File
@@ -0,0 +1,31 @@
//! Desktops may persist what a backend changes (KWin saves input-device flags), so a killed host
//! could leave local input or screens off for good. This child recovers from the record when the
//! host's end of its stdin pipe closes, however the host ends; after a normal restore the record is
//! gone and it just exits.
use std::{process::{Child, Command, Stdio}, sync::Mutex};
static GUARD: Mutex<Option<Child>> = Mutex::new(None);
pub fn start() -> Result<(), String> {
let mut guard = GUARD.lock().map_err(|_| "guard state poisoned")?;
if guard.is_some() { return Ok(()); }
let exe = std::env::current_exe().map_err(|e| e.kind().to_string())?;
let child = Command::new(exe).arg("privacy-guard").stdin(Stdio::piped()).stdout(Stdio::null()).spawn()
.map_err(|e| format!("privacy guard: {}", e.kind()))?;
*guard = Some(child);
Ok(())
}
pub fn stop() {
if let Some(mut child) = GUARD.lock().ok().and_then(|mut g| g.take()) { drop(child.stdin.take()); let _ = child.wait(); }
}
/// `privacy-guard`: waits for the host to go away, then recovers.
pub fn main() -> i32 {
use std::io::Read;
let _ = std::io::stdin().read_to_end(&mut Vec::new());
// A normal restore removes the record before closing the pipe.
if !super::record::pending() { return 0; }
// The host's flock is released with its last descriptor; give a dying host a moment.
super::tool::wait_until(|| super::record::ownership().is_ok());
if super::record::pending() { log::warn!("Privacy guard: host ended without restoring; recovering"); super::recover(); }
0
}
+190
View File
@@ -0,0 +1,190 @@
//! Local input devices through KWin's InputDevice D-Bus interface (sysName `eventN`). KWin saves
//! the enabled flag, which is why the controller runs the guard.
//!
//! `eventN` comes from udev enumeration and can change between boots, while a recovery record may
//! be replayed after a reboot. Records therefore store the name/product/vendor KWin reports next
//! to the sysName, and a restore matches the current device by that identity.
use super::super::tool::{gdbus, variant};
use serde::{Deserialize, Serialize};
fn call(object: &str, method: &str, args: &[&str]) -> Result<String, String> { gdbus("org.kde.KWin", object, method, args) }
/// One blocked device. `Legacy` is a record written before identities were stored.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(untagged)]
pub enum Device {
Named { sys: String, name: String, product: u32, vendor: u32 },
Legacy(String),
}
impl Device {
pub fn sys(&self) -> &str {
match self { Self::Named { sys, .. } | Self::Legacy(sys) => sys }
}
fn name(&self) -> &str {
match self { Self::Named { name, .. } => name, Self::Legacy(sys) => sys }
}
fn identity(&self) -> Option<(&str, u32, u32)> {
match self { Self::Named { name, product, vendor, .. } => Some((name, *product, *vendor)), Self::Legacy(_) => None }
}
}
/// `'key': <uint32 16500>` carries a type prefix; strings and booleans do not.
fn number(text: &str, key: &str) -> Option<u32> { variant(text, key)?.split_whitespace().last()?.parse().ok() }
#[derive(Clone, Copy, Default)]
struct Flags { keyboard: bool, pointer: bool, touch: bool, switch: bool, enabled: bool }
/// Every device KWin lists, blocked or not: restore must find a device that is still disabled.
/// The flag says whether a property read failed. A restore re-enables the readable devices, then
/// returns the flag as an error so its record and the guard stay for another attempt; blocking
/// skips such a device, which is all it can do.
fn enumerate() -> Result<(Vec<(Device, Flags)>, bool), String> {
let list = call("/org/kde/KWin/InputDevice", "org.freedesktop.DBus.Properties.Get", &["org.kde.KWin.InputDeviceManager", "devicesSysNames"])?;
let mut devices = Vec::new();
let mut incomplete = false;
for sys in list.split('\'').skip(1).step_by(2).filter(|n| n.strip_prefix("event").is_some_and(|d| !d.is_empty() && d.bytes().all(|b| b.is_ascii_digit()))) {
let text = match call(&format!("/org/kde/KWin/InputDevice/{sys}"), "org.freedesktop.DBus.Properties.GetAll", &["org.kde.KWin.InputDevice"]) {
Ok(text) => text,
Err(_) => { incomplete = true; continue; }
};
let yes = |key| variant(&text, key) == Some("true");
devices.push((Device::Named {
sys: sys.to_owned(),
name: variant(&text, "name").unwrap_or_default().to_owned(),
product: number(&text, "product").unwrap_or(0),
vendor: number(&text, "vendor").unwrap_or(0),
}, Flags { keyboard: yes("keyboard"), pointer: yes("pointer"), touch: yes("touch"), switch: yes("switchDevice"), enabled: yes("enabled") }));
}
Ok((devices, incomplete))
}
/// Keyboards, pointers and touch to block: everything except our own uinput devices, the power
/// button and switches (lid). Software devices fed by local hardware (gesture daemons, ydotoold)
/// are blocked too.
pub fn local() -> Result<Vec<Device>, String> {
Ok(enumerate()?.0.into_iter().filter(|(d, f)| {
(f.keyboard || f.pointer || f.touch) && !f.switch && f.enabled
&& !d.name().starts_with("uu-remote-linux") && d.name() != "Power Button"
}).map(|(d, _)| d).collect())
}
/// Every current device matching `wanted`: same name/product/vendor, or the exact sysName for a
/// legacy record. Several devices can share one identity (two identical keyboards, or one receiver
/// exposing several event nodes under the same name), so callers must handle every match.
fn matching<'a>(devices: &'a [Device], wanted: &Device) -> impl Iterator<Item = &'a Device> + 'a {
let identity = wanted.identity().map(|(name, product, vendor)| (name.to_owned(), product, vendor));
let sys = wanted.sys().to_owned();
devices.iter().filter(move |d| match (&identity, d.identity()) {
(Some((name, product, vendor)), Some((current, p, v))) => current == name && p == *product && v == *vendor,
_ => d.sys() == sys,
})
}
fn set_sys<'a>(devices: impl Iterator<Item = &'a str>, enabled: bool) -> Result<(), String> {
let value = if enabled { "<true>" } else { "<false>" };
let mut failure = None;
for sys in devices {
if let Err(e) = call(&format!("/org/kde/KWin/InputDevice/{sys}"), "org.freedesktop.DBus.Properties.Set", &["org.kde.KWin.InputDevice", "enabled", value]) {
failure = Some(e);
}
}
failure.map_or(Ok(()), Err)
}
pub fn set(devices: &[Device], enabled: bool) -> Result<(), String> {
set_sys(devices.iter().map(Device::sys), enabled)
}
/// Current sysNames to re-enable and how many record entries have no current match.
fn restore_targets<'a>(now: &'a [Device], recorded: &[Device]) -> (Vec<&'a str>, usize) {
let mut targets: Vec<&str> = Vec::new();
let mut gone = 0;
for wanted in recorded {
let mut found = false;
for current in matching(now, wanted) {
found = true;
if !targets.contains(&current.sys()) { targets.push(current.sys()); }
}
if !found { gone += 1; }
}
(targets, gone)
}
/// Re-enables every current device matching a record entry, deduplicated by sysName: two record
/// entries can describe the same device, and one identity can cover several devices. A recorded
/// device that no longer exists is skipped: its `eventN` may belong to a different device after a
/// reboot, and failing the whole restore would keep the recovery record forever. A device that
/// exists but cannot be enabled still fails the restore, so the record and the guard stay for the
/// next attempt.
pub fn restore(devices: &[Device]) -> Result<(), String> {
if devices.is_empty() { return Ok(()); }
let (found, incomplete) = enumerate()?;
let now: Vec<Device> = found.into_iter().map(|(d, _)| d).collect();
let (targets, gone) = restore_targets(&now, devices);
// Counts only: device names and sysNames are not logged (AGENTS.md).
if gone > 0 { log::warn!("Privacy restore: {gone} recorded device(s) are gone; skipping"); }
// Re-enable the readable devices first: one unreadable device must not keep every other one
// off. The error afterwards keeps the record and the guard for another attempt.
set_sys(targets.into_iter(), true)?;
if incomplete { return Err("input device properties could not be read; retrying later".into()); }
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
fn named(sys: &str, name: &str, product: u32, vendor: u32) -> Device {
Device::Named { sys: sys.into(), name: name.into(), product, vendor }
}
#[test]
fn parses_numbered_variants() {
let text = "({'name': <'Logitech G304'>, 'product': <uint32 16500>, 'vendor': <uint32 1133>},)";
assert_eq!(number(text, "product"), Some(16500));
assert_eq!(number(text, "vendor"), Some(1133));
assert_eq!(number(text, "missing"), None);
}
#[test]
fn reads_legacy_and_named_records() {
let legacy: Vec<Device> = serde_json::from_str(r#"["event5","event6"]"#).unwrap();
assert!(matches!(&legacy[0], Device::Legacy(sys) if sys == "event5"));
let named: Device = serde_json::from_str(r#"{"sys":"event12","name":"Logitech G304","product":16500,"vendor":1133}"#).unwrap();
assert_eq!(named.identity(), Some(("Logitech G304", 16500, 1133)));
}
#[test]
fn matches_a_renumbered_device_by_identity() {
let mouse = named("event12", "Logitech G304", 16500, 1133);
let keyboard = named("event3", "AT Translated Set 2 keyboard", 1, 1);
let recorded = [named("event14", "Logitech G304", 16500, 1133)];
let now = [keyboard, mouse];
assert_eq!(super::restore_targets(&now, &recorded), (vec!["event12"], 0));
}
#[test]
fn enables_every_device_sharing_an_identity_once() {
let first = named("event12", "Logitech G304", 16500, 1133);
let second = named("event15", "Logitech G304", 16500, 1133);
let now = [first, second];
// Two record entries for one identity, as a receiver exposing several event nodes produces.
let recorded = [named("event14", "Logitech G304", 16500, 1133), named("event16", "Logitech G304", 16500, 1133)];
assert_eq!(super::restore_targets(&now, &recorded), (vec!["event12", "event15"], 0));
}
#[test]
fn a_missing_device_counts_as_gone() {
let recorded = [named("event14", "Logitech G304", 16500, 1133)];
let now = [named("event3", "AT Translated Set 2 keyboard", 1, 1)];
assert_eq!(super::restore_targets(&now, &recorded), (Vec::new(), 1));
}
#[test]
fn a_legacy_record_matches_the_exact_sysname() {
let recorded = [Device::Legacy("event5".into())];
let now = [named("event5", "AT Translated Set 2 keyboard", 1, 1)];
assert_eq!(super::restore_targets(&now, &recorded), (vec!["event5"], 0));
}
}
+34
View File
@@ -0,0 +1,34 @@
//! One-shot KWin scripts (org.kde.kwin.Scripting).
use super::super::tool::gdbus;
fn call(object: &str, method: &str, args: &[&str]) -> Result<String, String> { gdbus("org.kde.KWin", object, method, args) }
fn script(js: &str) -> 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()));
std::fs::write(&file, js).map_err(|e| e.kind().to_string())?;
let name = "uu-privacy";
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();
if id.is_empty() { return Err("script not loaded".into()); }
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]);
let _ = std::fs::remove_file(file);
result.map(|_| ())
}
/// Sends every normal window and dialog to `output` (a name from kscreen-doctor, file-name safe).
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);"#))
}
/// 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
/// generic "wayland" icon. `skipTaskbar` is writable through KWin scripting. Picture mode creates
/// one cover per physical monitor with the same title, and KWin appends " <2>" and so on to
/// 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;"#)
}
+102
View File
@@ -0,0 +1,102 @@
//! KDE Plasma Wayland: capture and input move to a KWin virtual output through the portal
//! (ScreenCast source type VIRTUAL), then the physical outputs are disabled with kscreen-doctor,
//! so remote input cannot wake them (KWin treats injected input as user activity and undoes DPMS).
//! Same order as KRdp's virtual-monitor "replace" policy and Sunshine's KDE setup: snapshot the
//! 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.
mod input;
mod kwin;
mod outputs;
use super::{backend::{Backend, Entered}, record::Journal, tool, Mode};
pub const NAME: &str = "kde";
pub struct Kde;
#[derive(Default, serde::Serialize, serde::Deserialize)]
struct Data { outputs: Vec<String>, #[serde(default)] devices: Vec<input::Device> }
impl Kde {
pub fn detected() -> bool {
let kde = std::env::var_os("WAYLAND_DISPLAY").is_some()
&& std::env::var("XDG_CURRENT_DESKTOP").unwrap_or_default().split(':').any(|s| s.eq_ignore_ascii_case("KDE"));
cfg!(feature = "portal") && kde && tool::available("timeout") && tool::available("kscreen-doctor")
&& crate::desktop_backend::detect().ok() == Some(crate::desktop_backend::DesktopBackend::Portal)
}
}
fn block_input() -> bool { std::env::var("UU_PRIVACY_BLOCK_INPUT").as_deref() != Ok("0") }
/// Plasma's desktop wallpaper image, if it is a plain file.
fn wallpaper() -> Option<std::path::PathBuf> {
let home = std::env::var_os("HOME").map(std::path::PathBuf::from)?;
let config = std::env::var_os("XDG_CONFIG_HOME").map(std::path::PathBuf::from).unwrap_or(home.join(".config"));
let text = std::fs::read_to_string(config.join("plasma-org.kde.plasma.desktop-appletsrc")).ok()?;
text.lines().find_map(|l| l.strip_prefix("Image=")).map(|v| std::path::PathBuf::from(v.trim().trim_start_matches("file://")))
.filter(|p| p.is_file())
}
/// Windows moved to the virtual output when the physical outputs went away. Turn those back on as
/// 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")?;
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}"))?;
let layout = outputs::layout()?;
let physical: Vec<[f64; 4]> = layout.iter().filter(|o| data.outputs.contains(&o.name)).map(|o| o.rect).collect();
if physical.len() != data.outputs.len() { return Err("physical outputs did not come back".into()); }
let region = outputs::region(&layout, &virtual_name).ok_or("virtual output geometry")?;
super::cover::show(wallpaper().as_deref(), &physical)?;
// The cover is a plain Wayland toplevel: GTK's skip-taskbar hint is X11-only, so without this
// the task manager shows it as an unidentified window with the theme's generic "wayland" icon.
// KWin lists a freshly mapped window asynchronously, so one more pass catches a late cover.
for pass in 0..2 {
if let Err(e) = kwin::hide_cover_from_taskbar() { log::warn!("Privacy cover taskbar: {e}"); break; }
if pass == 0 { std::thread::sleep(std::time::Duration::from_millis(200)); }
}
Ok(region)
}
impl Backend for Kde {
fn name(&self) -> &'static str { NAME }
fn unavailable(&self, mode: Mode) -> Option<String> {
if !tool::available("gdbus") { return Some("privacy screen needs gdbus".into()); }
// Checked before any output or device changes: on the virtual share KDE drops portal input,
// and local devices get blocked, so without uinput neither side could operate.
if !crate::input::uinput_ready() { return Some("privacy screen needs uinput input (UU_INPUT_BACKEND=native or /dev/uinput unavailable)".into()); }
(mode == Mode::Picture && !super::cover::supported()).then(|| "picture mode needs GTK".into())
}
fn enter(&self, mode: Mode, journal: &mut Journal) -> Result<Entered, String> {
let mut data = Data { outputs: outputs::physical()?, devices: Vec::new() };
journal.save(&data)?;
crate::portal::set_virtual_active(true).map_err(|e| format!("virtual output: {e}"))?;
outputs::set(&data.outputs, false).map_err(|e| format!("disable outputs: {e}"))?;
let mut entered = Entered::default();
if mode == Mode::Picture { entered.pointer_region = Some(cover(&data)?); }
if block_input() {
data.devices = input::local().map_err(|e| format!("input devices: {e}"))?;
journal.save(&data)?;
input::set(&data.devices, false).map_err(|e| format!("block input: {e}"))?;
}
log::info!("Privacy KDE: outputs={} input_devices={}", data.outputs.len(), data.devices.len());
Ok(entered)
}
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}"));
// 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).
if let Err(e) = outputs::set(&data.outputs, true) {
if !outputs::physical().is_ok_and(|now| data.outputs.iter().all(|o| now.contains(o))) { return Err(format!("enable outputs: {e}")); }
}
std::thread::sleep(std::time::Duration::from_millis(500));
crate::portal::set_virtual_active(false).map_err(|e| format!("restore capture source: {e}"))?;
devices?;
log::info!("Privacy KDE restored: outputs={} input_devices={}", data.outputs.len(), data.devices.len());
Ok(())
}
}
+76
View File
@@ -0,0 +1,76 @@
//! KWin output layout through libkscreen's `kscreen-doctor`.
use super::super::tool::{run, wait_until};
#[derive(Debug, PartialEq)]
pub struct Output { pub name: String, pub rect: [f64; 4] }
fn json() -> Result<String, String> { run("kscreen-doctor", &["-j".into()]) }
/// Enabled, connected outputs that KWin did not create for a screencast.
fn physical_in(text: &str) -> Result<Vec<String>, String> {
let json: serde_json::Value = serde_json::from_str(text).map_err(|_| "invalid output configuration")?;
let outputs = json["outputs"].as_array().ok_or("missing outputs")?;
let names: Vec<String> = outputs.iter()
.filter(|o| o["enabled"] == true && o["connected"] == true)
.filter_map(|o| o["name"].as_str())
.filter(|name| !name.starts_with("Virtual") && name.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_'))
.map(str::to_owned).collect();
if names.is_empty() { return Err("no active physical outputs".into()); }
Ok(names)
}
pub fn physical() -> Result<Vec<String>, String> { physical_in(&json()?) }
/// Enabled outputs in KWin's logical coordinates (mode size / scale, rotated).
fn layout_in(text: &str) -> Result<Vec<Output>, String> {
let json: serde_json::Value = serde_json::from_str(text).map_err(|_| "invalid output configuration")?;
let outputs = json["outputs"].as_array().ok_or("missing outputs")?;
// KWin's screencast virtual output has no "enabled" field (seen live, Plasma 6).
Ok(outputs.iter().filter(|o| o["enabled"] != false).filter_map(|o| {
let mode = o["modes"].as_array()?.iter().find(|m| m["id"] == o["currentModeId"])?;
let (mut w, mut h) = (mode["size"]["width"].as_f64()?, mode["size"]["height"].as_f64()?);
if matches!(o["rotation"].as_u64(), Some(2 | 8)) { std::mem::swap(&mut w, &mut h); }
let scale = o["scale"].as_f64().filter(|s| *s > 0.0).unwrap_or(1.0);
Some(Output { name: o["name"].as_str()?.into(), rect: [o["pos"]["x"].as_f64()?, o["pos"]["y"].as_f64()?, w / scale, h / scale] })
}).collect())
}
pub fn layout() -> Result<Vec<Output>, String> { layout_in(&json()?) }
/// `name` as fractions (x, y, w, h) of the layout's bounding box.
pub fn region(layout: &[Output], name: &str) -> Option<[f64; 4]> {
let target = layout.iter().find(|o| o.name == name)?.rect;
let (x0, y0) = layout.iter().fold((f64::MAX, f64::MAX), |(x, y), o| (x.min(o.rect[0]), y.min(o.rect[1])));
let (x1, y1) = layout.iter().fold((f64::MIN, f64::MIN), |(x, y), o| (x.max(o.rect[0] + o.rect[2]), y.max(o.rect[1] + o.rect[3])));
let (w, h) = (x1 - x0, y1 - y0);
(w > 0.0 && h > 0.0).then(|| [(target[0] - x0) / w, (target[1] - y0) / h, target[2] / w, target[3] / h])
}
/// Enables or disables `outputs` and waits until KWin has applied it.
pub fn set(outputs: &[String], enable: bool) -> Result<(), String> {
let action = if enable { "enable" } else { "disable" };
run("kscreen-doctor", &outputs.iter().map(|o| format!("output.{o}.{action}")).collect::<Vec<_>>())?;
let applied = wait_until(|| {
let now = physical().unwrap_or_default();
outputs.iter().all(|o| now.contains(o) == enable)
});
if applied { Ok(()) } else { Err(format!("outputs not {action}d")) }
}
pub fn set_primary(name: &str) -> Result<(), String> { run("kscreen-doctor", &[format!("output.{name}.priority.1")]).map(|_| ()) }
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn snapshot_keeps_enabled_physical_outputs_only() {
let names = physical_in(r#"{"outputs":[{"name":"eDP-1","enabled":true,"connected":true},
{"name":"DP-1","enabled":false,"connected":true},{"name":"Virtual-uu","enabled":true,"connected":true},
{"name":"HDMI-A-1","enabled":true,"connected":false}]}"#).unwrap();
assert_eq!(names, ["eDP-1"]);
assert!(physical_in(r#"{"outputs":[{"name":"Virtual-x","enabled":true,"connected":true}]}"#).is_err());
}
#[test]
fn pointer_region_is_the_virtual_output_in_the_layout() {
let all = layout_in(r#"{"outputs":[
{"name":"eDP-1","enabled":true,"currentModeId":"2","modes":[{"id":"2","size":{"width":3072,"height":1920}}],"pos":{"x":0,"y":0},"scale":1.5,"rotation":1},
{"name":"Virtual-1","currentModeId":"1","modes":[{"id":"1","size":{"width":1920,"height":1080}}],"pos":{"x":2048,"y":0},"scale":1,"rotation":1},
{"name":"DP-1","enabled":false,"currentModeId":"1","modes":[{"id":"1","size":{"width":1,"height":1}}],"pos":{"x":0,"y":0}}]}"#).unwrap();
assert_eq!(all.len(), 2);
assert_eq!(all[0].rect, [0.0, 0.0, 2048.0, 1280.0]);
assert_eq!(region(&all, "Virtual-1").unwrap(), [2048.0 / 3968.0, 0.0, 1920.0 / 3968.0, 1080.0 / 1280.0]);
}
}
+256
View File
@@ -0,0 +1,256 @@
//! Host privacy screen (防窥): the viewer's RPC 7 hides the local screen and blocks local input
//! while it controls the desktop. This module is the desktop-independent controller: it counts
//! desktop sessions, switches modes, rolls back failures, keeps the recovery record and the guard,
//! and serves the protocol. Desktop work lives behind `backend::Backend` (only `kde` so far).
mod backend;
mod cover;
mod guard;
mod kde;
mod mode;
mod protocol;
mod record;
mod tool;
pub use mode::Mode;
use std::sync::{atomic::{AtomicBool, Ordering}, Mutex};
struct Active { mode: Mode, record: Option<record::Record> }
struct State { sessions: usize, active: Option<Active> }
static STATE: Mutex<State> = Mutex::new(State { sessions: 0, active: None });
/// Lock-free view of `STATE.active` for capture/input paths.
static ACTIVE: AtomicBool = AtomicBool::new(false);
static PICTURE: AtomicBool = AtomicBool::new(false);
static POINTER: Mutex<Option<[f64; 4]>> = Mutex::new(None);
/// Set by any viewer RPC 7 during the current desktop sessions and cleared when the last one
/// 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);
pub fn supported() -> bool { backend::detect().is_some() }
pub fn active() -> bool { ACTIVE.load(Ordering::Relaxed) }
/// The viewer's privacy_type now in effect.
pub fn current_type() -> u8 {
if !active() { mode::TYPE_OFF } else if PICTURE.load(Ordering::Relaxed) { Mode::Picture.wire_type() } else { Mode::ScreenOff.wire_type() }
}
/// Message 15 SystemStateChange { 5 PrivateScreenState } for the state now in effect.
pub fn state_message(seq: u64, timestamp: u64) -> Vec<u8> {
crate::initialization::envelope(seq, timestamp, 15, &protocol::state_change(current_type()))
}
/// See `backend::Entered::pointer_region`.
pub fn pointer_region() -> Option<[f64; 4]> { *POINTER.lock().ok()? }
fn publish(active: Option<&Active>) {
ACTIVE.store(active.is_some(), Ordering::Relaxed);
PICTURE.store(active.is_some_and(|a| a.mode == Mode::Picture), Ordering::Relaxed);
}
fn leave(state: &mut State) -> Result<(), String> {
let Some(active) = state.active.as_ref() else { return Ok(()) };
cover::hide();
if let Ok(mut p) = POINTER.lock() { *p = None; }
if let Some(record) = &active.record {
let backend = backend::named(&record.backend).ok_or("unknown privacy backend in the recovery record")?;
backend.leave(&record.data)?;
}
record::remove()?;
state.active = None;
publish(None);
guard::stop();
log::info!("Privacy screen restored");
Ok(())
}
fn enter(state: &mut State, mode: Mode) -> Result<(), String> {
record::ownership()?;
if state.active.as_ref().is_some_and(|a| a.mode == mode) { return Ok(()); }
// Switching mode: start over from the restored desktop.
leave(state)?;
let backend = backend::detect().ok_or("privacy screen is not supported on this desktop")?;
if let Some(reason) = backend.unavailable(mode) { return Err(reason); }
// A pending recovery must never be overwritten by a new snapshot.
if record::pending() { return Err("previous output recovery is pending".into()); }
guard::start()?;
// Published before the backend runs: capture keep-awake paths must not undo its changes.
state.active = Some(Active { mode, record: None });
publish(state.active.as_ref());
let mut journal = record::Journal::new(backend.name(), mode);
let result = backend.enter(mode, &mut journal);
if let Some(active) = state.active.as_mut() { active.record = journal.into_record(); }
let entered = result?;
*POINTER.lock().map_err(|_| "pointer state poisoned")? = entered.pointer_region;
log::info!("Privacy screen enabled: backend={} mode={mode:?}", backend.name());
Ok(())
}
fn save_preference(mode: Mode) {
// Session lifecycle takes the settings lock before STATE; never take it while holding STATE.
if let Err(e) = crate::system_actions::merge_save(|s| s.privacy_type = Some(mode.wire_type())) { log::warn!("Privacy mode not saved: {e}"); }
}
/// RPC 7: `mode` is None for an unknown privacy_type.
fn set(enable: bool, mode: Option<Mode>) -> Result<(), String> { set_inner(enable, mode, true) }
/// `save` records the viewer's preference; the auto-enable path must not overwrite it.
fn set_inner(enable: bool, mode: Option<Mode>, save: bool) -> Result<(), String> {
let mut state = STATE.lock().map_err(|_| "privacy state poisoned")?;
if !enable { return leave(&mut state); }
let mode = mode.ok_or("unsupported privacy type")?;
if state.sessions == 0 { return Err("no active desktop session".into()); }
let result = enter(&mut state, mode);
// A failed rollback keeps the record and the guard: the next request, exit or start retries.
if result.is_err() { if let Err(e) = leave(&mut state) { log::warn!("Privacy rollback failed: {e}"); } }
drop(state);
if result.is_ok() && save { save_preference(mode); }
result
}
/// Why RPC 7 cannot be served at all; checked before answering.
fn refuse(enable: bool, mode: Option<Mode>) -> Option<String> {
if !enable { return None; }
let Some(mode) = mode else { return Some("unsupported privacy type".into()) };
if STATE.lock().map_or(true, |s| s.sessions == 0) { return Some("no active desktop session".into()); }
let Some(backend) = backend::detect() else { return Some("privacy screen is not supported on this desktop".into()) };
backend.unavailable(mode)
}
/// A switch the RPC accepted; run it with `Accepted::apply` after sending the response.
pub struct Accepted { enable: bool, mode: Option<Mode> }
/// RPC 7 answer, sent before the switch: the Mac viewer gives up on the RPC after a few seconds
/// (error 9998 + n in its RPC failure handler) and a switch takes longer. A later failure is
/// reported as ReportError -7, which the viewer handles by resetting its privacy menu.
pub fn rpc_accept(rpc: &[crate::protocol::WireField]) -> Option<(Vec<u8>, Option<Accepted>)> {
let (header, request) = protocol::parse(rpc)?;
if let Some(e) = refuse(request.enable, request.mode) {
log::warn!("Privacy request refused: enable={} mode={:?}: {e}", request.enable, request.mode);
return Some((protocol::response(&header, &request, true, current_type()), None));
}
let expected = if request.enable { request.mode.map_or(mode::TYPE_OFF, Mode::wire_type) } else { mode::TYPE_OFF };
Some((protocol::response(&header, &request, false, expected), Some(Accepted { enable: request.enable, mode: request.mode })))
}
/// Mac 4.43.0 handleForReportError: -7 resets privacy to off; -9 reports an RDP session change,
/// not privacy success. Success is carried by RpcResponse 3 and SystemMetrics.setting 7.
pub const REPORT_ERROR: i32 = -7;
impl Accepted {
pub fn apply(self) -> Result<(), String> {
VIEWER_OVERRIDE.store(true, Ordering::Relaxed);
let result = set(self.enable, self.mode);
if let Err(e) = &result { log::warn!("Privacy request failed: enable={} mode={:?}: {e}", self.enable, self.mode); }
result
}
}
/// `UU_PRIVACY_AUTO` accepts `picture`/`2` and `screen-off`/`3`; anything else leaves the viewer
/// in charge (and so does the viewer's own RPC 7, which cancels a pending auto-enable).
fn parse_auto(value: &str) -> Option<Mode> {
match value.trim().to_ascii_lowercase().as_str() {
"2" | "picture" => Some(Mode::Picture),
"3" | "screen-off" | "screen_off" => Some(Mode::ScreenOff),
_ => None,
}
}
fn auto_mode() -> Option<Mode> { std::env::var("UU_PRIVACY_AUTO").ok().as_deref().and_then(parse_auto) }
/// Enter the auto mode with the viewer-override check inside the STATE lock, so a request that
/// lands between the caller's check and this lock still wins. Ok(false): the viewer overrode it.
fn auto_set(mode: Mode) -> Result<bool, String> {
let mut state = STATE.lock().map_err(|_| "privacy state poisoned")?;
if VIEWER_OVERRIDE.load(Ordering::Relaxed) { return Ok(false); }
if state.sessions == 0 { return Err("no active desktop session".into()); }
let result = enter(&mut state, mode);
if result.is_err() { if let Err(e) = leave(&mut state) { log::warn!("Privacy rollback failed: {e}"); } }
result.map(|_| 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) {
for attempt in 1..=5 {
if VIEWER_OVERRIDE.load(Ordering::Relaxed) {
log::info!("Privacy auto: skipped, the viewer already chose a mode");
return;
}
// Not a failure yet: the desktop capture opens its portal session a moment after the peer
// connects, and entering without it would roll back and log a restore for nothing.
if !crate::portal::available() {
log::info!("Privacy auto: waiting for the desktop capture (attempt {attempt})");
std::thread::sleep(std::time::Duration::from_secs(1));
continue;
}
match auto_set(mode) {
Ok(true) => { log::info!("Privacy auto: enabled mode={mode:?} on attempt {attempt}"); return; }
Ok(false) => { log::info!("Privacy auto: skipped, the viewer already chose a mode"); return; }
Err(e) if e.contains("no active desktop session") => return,
Err(e) if e.contains("Portal desktop unavailable") => {
log::info!("Privacy auto: desktop capture not ready (attempt {attempt})");
std::thread::sleep(std::time::Duration::from_secs(1));
}
Err(e) => { log::warn!("Privacy auto failed: {e}"); return; }
}
}
log::warn!("Privacy auto: giving up; the viewer can still enable the privacy screen");
}
pub fn session_started() {
let auto = auto_mode();
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; }
std::thread::spawn(move || {
std::thread::sleep(std::time::Duration::from_millis(1500));
auto_enable(mode);
});
}
pub fn session_ended() {
if let Ok(mut s) = STATE.lock() {
s.sessions = s.sessions.saturating_sub(1);
if s.sessions == 0 {
VIEWER_OVERRIDE.store(false, Ordering::Relaxed);
if let Err(e) = leave(&mut s) { log::warn!("Privacy restore failed: {e}"); }
}
}
}
pub fn shutdown() {
if let Ok(mut s) = STATE.lock() {
s.sessions = 0;
VIEWER_OVERRIDE.store(false, Ordering::Relaxed);
if let Err(e) = leave(&mut s) { log::warn!("Privacy restore failed: {e}"); }
}
}
/// Undo a record left by a crash (host start, guard). Failure keeps the record for the next try.
pub fn recover() {
if let Err(e) = record::ownership() { log::warn!("Privacy control unavailable: {e}"); return; }
let Some(saved) = record::load() else { return };
if let Ok(mut state) = STATE.lock() {
state.active = Some(Active { mode: saved.mode, record: Some(saved) });
if let Err(e) = leave(&mut state) { log::warn!("Privacy recovery failed: {e}"); }
}
}
/// Local diagnostic: needs an existing portal session (registered by the caller).
pub fn probe(mode: Mode) -> Result<(), String> {
recover();
let result = {
let mut state = STATE.lock().map_err(|_| "privacy state poisoned")?;
state.sessions = 1;
enter(&mut state, mode)
};
if result.is_ok() { save_preference(mode); }
if result.is_ok() { std::thread::sleep(std::time::Duration::from_secs(5)); }
let mut state = STATE.lock().map_err(|_| "privacy state poisoned")?;
let restored = leave(&mut state);
if restored.is_err() { log::warn!("Privacy probe restore failed; the next start retries"); }
result.and(restored)
}
pub use protocol::screensaver_response;
pub fn guard_main() -> i32 { guard::main() }
pub fn cover_main(args: &[String]) -> i32 { cover::main(args) }
#[cfg(test)]
mod tests {
#[test]
fn parses_auto_privacy_modes() {
use super::{parse_auto, Mode};
assert_eq!(parse_auto("picture"), Some(Mode::Picture));
assert_eq!(parse_auto("2"), Some(Mode::Picture));
assert_eq!(parse_auto(" screen-off "), Some(Mode::ScreenOff));
assert_eq!(parse_auto("3"), Some(Mode::ScreenOff));
assert_eq!(parse_auto("0"), None);
assert_eq!(parse_auto("off"), None);
assert_eq!(parse_auto(""), None);
}
#[test]
fn enabling_without_a_backend_is_refused_and_reports_off() {
let bytes = [10, 2, 8, 42, 58, 4, 8, 1, 16, 3];
let (response, accepted) = super::rpc_accept(&crate::protocol::decode_wire(&bytes).unwrap()).unwrap();
assert_eq!(response, [10, 2, 8, 42, 26, 6, 8, 1, 16, 3, 24, 1]);
assert!(accepted.is_none());
}
}
+29
View File
@@ -0,0 +1,29 @@
/// What the viewer asks the local screen to show while it controls the desktop.
#[derive(Clone, Copy, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Mode {
/// A picture covers the physical screens (the official viewer's privacy/wallpaper mode).
Picture,
/// The physical screens are off.
ScreenOff,
}
/// `privacy_type` as the official viewer numbers it (seen live): 1 off, 2 picture, 3 screen off.
pub const TYPE_OFF: u8 = 1;
impl Mode {
pub fn from_type(value: u64) -> Option<Self> {
match value { 2 => Some(Self::Picture), 3 => Some(Self::ScreenOff), _ => None }
}
pub fn wire_type(self) -> u8 { match self { Self::Picture => 2, Self::ScreenOff => 3 } }
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn wire_types_round_trip() {
for mode in [Mode::Picture, Mode::ScreenOff] { assert_eq!(Mode::from_type(mode.wire_type().into()), Some(mode)); }
assert_eq!(Mode::from_type(1), None);
assert_eq!(Mode::from_type(0), None);
}
}
+74
View File
@@ -0,0 +1,74 @@
//! Official protobuf maps: RpcRequest 7 {1 enable, 2 privacy_type, 3 setting_source};
//! RpcResponse 3 {1 error_code, 2 req_privacy_type, 3 cur_privacy_type}. Types: see `Mode`.
//! Field numbers and enums verified against the Mac UURemote SwiftProtobuf name maps.
use super::Mode;
pub struct Request { pub enable: bool, pub mode: Option<Mode>, requested: u64 }
pub fn parse(rpc: &[crate::protocol::WireField]) -> Option<(Vec<u8>, Request)> {
use crate::protocol::{decode_wire, WireValue};
let body = |n| rpc.iter().find_map(|f| match &f.value { WireValue::Bytes(b) if f.number == n => Some(*b), _ => None });
let header = body(1)?.to_vec();
let req = decode_wire(body(7)?).ok()?;
let value = |n| req.iter().find_map(|f| match f.value { WireValue::Varint(v) if f.number == n => Some(v), _ => None }).unwrap_or(0);
log::info!("Privacy request: enable_value={} requested_type={} source={}", value(1), value(2), value(3));
Some((header, Request { enable: value(1) != 0, mode: Mode::from_type(value(2)), requested: value(2) }))
}
/// RpcResponse with the request's header, error_code 1 on failure, and the type now in effect.
pub fn response(header: &[u8], request: &Request, failed: bool, current: u8) -> Vec<u8> {
let mut payload = Vec::new();
if failed { payload.extend([8, 1]); }
if request.requested != 0 { payload.push(16); varint(request.requested, &mut payload); }
payload.extend([24, current]);
let mut out = vec![10];
varint(header.len() as u64, &mut out);
out.extend(header);
out.push(26);
varint(payload.len() as u64, &mut out);
out.extend(payload);
out
}
/// RpcRequest 25 update_screen_saver_req → RpcResponse 21 update_screen_saver_rsp (Mac UURemote
/// name maps). The viewer sends it before enabling picture mode (notifyScreensaverUpdate) and aborts
/// with error 9998 when it times out. The picture itself is the host's: answer an empty (success) one.
pub fn screensaver_response(rpc: &[crate::protocol::WireField]) -> Option<Vec<u8>> {
use crate::protocol::WireValue;
if !rpc.iter().any(|f| f.number == 25) { return None; }
let header = rpc.iter().find_map(|f| match &f.value { WireValue::Bytes(b) if f.number == 1 => Some(*b), _ => None })?;
let mut out = vec![10];
varint(header.len() as u64, &mut out);
out.extend(header);
out.extend([0xaa, 1, 0]); // field 21, length-delimited, empty
log::info!("Privacy screensaver update answered");
Some(out)
}
/// SystemStateChange { 5 PrivateScreenState { 1 error_code, 2 req_privacy_type, 3 cur_privacy_type } }
/// (field numbers from the Mac UURemote name map); the host pushes it when the state changes.
pub fn state_change(current: u8) -> Vec<u8> {
let state = [16, current, 24, current];
let mut out = vec![42, state.len() as u8];
out.extend(state);
out
}
fn varint(mut n: u64, out: &mut Vec<u8>) {
while n >= 128 { out.push((n as u8 & 127) | 128); n >>= 7; }
out.push(n as u8);
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parses_request_and_echoes_header() {
let bytes = [10, 2, 8, 42, 58, 4, 8, 1, 16, 3];
let (header, request) = parse(&crate::protocol::decode_wire(&bytes).unwrap()).unwrap();
assert!(request.enable);
assert_eq!(request.mode, Some(Mode::ScreenOff));
assert_eq!(response(&header, &request, true, 1), [10, 2, 8, 42, 26, 6, 8, 1, 16, 3, 24, 1]);
assert_eq!(response(&header, &request, false, 3), [10, 2, 8, 42, 26, 4, 16, 3, 24, 3]);
assert_eq!(state_change(2), [42, 4, 16, 2, 24, 2]);
let saver = crate::protocol::decode_wire(&[10, 2, 8, 7, 0xca, 1, 0]).unwrap();
assert_eq!(screensaver_response(&saver).unwrap(), [10, 2, 8, 7, 0xaa, 1, 0]);
}
}
+61
View File
@@ -0,0 +1,61 @@
//! Recovery record beside the config (`privacy-power.json`, 0600) and the process lock.
use super::Mode;
/// What a backend changed, so the guard or the next start can undo it after a crash.
/// `data` belongs to the backend named in `backend`.
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct Record { pub backend: String, pub mode: Mode, pub data: serde_json::Value }
pub fn path() -> std::path::PathBuf { crate::config::path().with_file_name("privacy-power.json") }
pub fn pending() -> bool { path().exists() }
/// One process controls the outputs of a config directory (host, probe, guard). Only success is
/// kept: a lock still held by a dying host must be retried (the guard polls this).
pub fn ownership() -> Result<(), String> {
use std::os::{fd::AsRawFd, unix::fs::OpenOptionsExt};
static LOCK: std::sync::Mutex<Option<std::fs::File>> = std::sync::Mutex::new(None);
let mut held = LOCK.lock().map_err(|_| "privacy lock state poisoned")?;
if held.is_some() { return Ok(()); }
let path = path().with_extension("lock");
std::fs::create_dir_all(path.parent().ok_or("missing config directory")?).map_err(|e| e.kind().to_string())?;
let file = std::fs::OpenOptions::new().read(true).write(true).create(true).mode(0o600)
.open(path).map_err(|e| e.kind().to_string())?;
if unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) } != 0 {
return Err("output control is owned by another process".into());
}
*held = Some(file);
Ok(())
}
pub fn load() -> Option<Record> { serde_json::from_slice(&std::fs::read(path()).ok()?).ok() }
fn store(record: &Record) -> Result<(), String> {
use std::{io::Write, os::unix::fs::OpenOptionsExt};
let path = path();
std::fs::create_dir_all(path.parent().ok_or("missing config directory")?).map_err(|e| e.kind().to_string())?;
let tmp = path.with_extension("tmp");
let mut file = std::fs::OpenOptions::new().write(true).create(true).truncate(true).mode(0o600)
.open(&tmp).map_err(|e| e.kind().to_string())?;
file.write_all(&serde_json::to_vec(record).map_err(|_| "invalid saved state")?).map_err(|e| e.kind().to_string())?;
file.sync_all().map_err(|e| e.kind().to_string())?;
std::fs::rename(tmp, path).map_err(|e| e.kind().to_string())
}
pub fn remove() -> Result<(), String> {
std::fs::remove_file(path()).or_else(|e| if e.kind() == std::io::ErrorKind::NotFound { Ok(()) } else { Err(e) })
.map_err(|e| format!("remove recovery record: {}", e.kind()))
}
/// Handed to `Backend::enter`: save what undoes a step before making it.
pub struct Journal { record: Record, saved: bool }
impl Journal {
pub fn new(backend: &str, mode: Mode) -> Self {
Self { record: Record { backend: backend.into(), mode, data: serde_json::Value::Null }, saved: false }
}
pub fn save<T: serde::Serialize>(&mut self, data: &T) -> Result<(), String> {
self.record.data = serde_json::to_value(data).map_err(|_| "invalid saved state")?;
store(&self.record)?;
self.saved = true;
Ok(())
}
/// The last saved record; None when the backend changed nothing.
pub fn into_record(self) -> Option<Record> { self.saved.then_some(self.record) }
}
+50
View File
@@ -0,0 +1,50 @@
//! External desktop tools shared by the backends.
use std::process::{Command, Stdio};
// timeout bounds desktop tools even when their compositor/D-Bus service stops responding.
pub fn run(tool: &str, args: &[String]) -> Result<String, String> {
let out = Command::new("timeout").args(["--kill-after=1", "5", tool]).args(args)
.env("LC_ALL", "C").stdin(Stdio::null()).stderr(Stdio::null()).output()
.map_err(|e| format!("{tool} unavailable: {}", e.kind()))?;
if !out.status.success() { return Err(format!("{tool} failed: {}", out.status)); }
String::from_utf8(out.stdout).map_err(|_| "invalid display tool output".into())
}
pub fn available(tool: &str) -> bool {
use std::os::unix::fs::PermissionsExt;
std::env::var_os("PATH").is_some_and(|paths| std::env::split_paths(&paths).any(|p|
p.join(tool).metadata().is_ok_and(|m| m.is_file() && m.permissions().mode() & 0o111 != 0)))
}
/// One session-bus method call through gdbus; returns its GVariant text.
pub fn gdbus(destination: &str, object: &str, method: &str, args: &[&str]) -> Result<String, String> {
let mut all: Vec<String> = ["call", "--session", "-d", destination, "-o", object, "-m", method].map(String::from).into();
all.extend(args.iter().map(|a| a.to_string()));
run("gdbus", &all)
}
/// `'key': <value>` from gdbus's text for an a{sv} (strings unquoted).
pub fn variant<'a>(text: &'a str, key: &str) -> Option<&'a str> {
let start = text.find(&format!("'{key}': <"))? + key.len() + 5;
let rest = &text[start..];
if let Some(quoted) = rest.strip_prefix('\'') { return quoted.split('\'').next(); }
rest.split('>').next()
}
/// Polls `done` for up to three seconds: desktop tools return before the compositor applies a change.
pub fn wait_until(mut done: impl FnMut() -> bool) -> bool {
for _ in 0..30 {
if done() { return true; }
std::thread::sleep(std::time::Duration::from_millis(100));
}
false
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn reads_properties_from_gdbus_text() {
let text = "({'alphaNumericKeyboard': <true>, 'enabled': <true>, 'name': <'AT Translated Set 2 keyboard'>, 'pointer': <false>},)";
assert_eq!(variant(text, "name"), Some("AT Translated Set 2 keyboard"));
assert_eq!(variant(text, "enabled"), Some("true"));
assert_eq!(variant(text, "pointer"), Some("false"));
assert_eq!(variant(text, "touch"), None);
}
}
+1 -2
View File
@@ -92,8 +92,7 @@ pub fn watch_locked() -> watch::Receiver<Option<bool>> {
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" });
// The viewer only sees black frames while locked and gives no hint (#61).
if locked == Some(true) { log::info!("Desktop is locked: viewers see a black screen until it is unlocked (viewer 自动解锁被控端, or `loginctl unlock-session` on the host)"); }
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));
+1 -1
View File
@@ -248,7 +248,7 @@ impl SignalingClient {
let mut req = ws_url
.clone()
.into_client_request()
.map_err(|e| format!("Invalid WS request: {}", e))?;
.map_err(|_| "Invalid WS request".to_string())?;
req.headers_mut().insert(
"X-NRD-AUTH",
+5 -4
View File
@@ -32,12 +32,12 @@ pub(crate) struct Settings {
#[serde(default)] auto_lock: bool,
#[serde(default)] keep_mute: bool,
#[serde(default)] mute_permanent: bool,
/// 防窥 type the viewer chose (privacy_screen::PS_NORMAL), 0 = never set.
#[serde(default)] pub(crate) privacy_screen_type: u64,
/// "auto" or absent does not override the environment. A non-string value becomes None so a bad
/// video field cannot drop auto_lock / mute when the document is loaded.
#[serde(default, deserialize_with = "lenient_string")] pub(crate) video_encoder: Option<String>,
#[serde(default, deserialize_with = "lenient_string")] pub(crate) video_codec: Option<String>,
/// Last privacy_type the viewer enabled (2 picture, 3 screen off), not the current live state.
#[serde(default)] pub(crate) privacy_type: Option<u8>,
}
fn lenient_string<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<Option<String>, D::Error> {
@@ -262,6 +262,7 @@ impl PeerActions {
if self.started.swap(true, Ordering::Relaxed) { return; }
let mut state = state().lock().unwrap();
state.desktop_sessions += 1;
crate::privacy_screen::session_started();
if state.desktop_sessions == 1 && state.settings.keep_mute {
mute_for_session(&mut state);
log::info!("Host muted for remote session (静音运行)");
@@ -274,8 +275,8 @@ impl PeerActions {
if !self.started.swap(false, Ordering::Relaxed) { return; }
let mut state = state().lock().unwrap();
state.desktop_sessions = state.desktop_sessions.saturating_sub(1);
crate::privacy_screen::session_ended();
if state.desktop_sessions > 0 { return; }
crate::privacy_screen::disable();
crate::virtual_audio::disable();
if !state.settings.mute_permanent { restore_mute(&mut state); }
if state.settings.auto_lock {
@@ -290,7 +291,7 @@ impl PeerActions {
let current = state().lock().unwrap().settings.clone();
payload_with_settings(desktop, desktop, desktop, &home, &crate::system_metrics::Settings {
sound, keep_mute: current.keep_mute, mute_permanent: current.mute_permanent, auto_lock: current.auto_lock,
private_screen: crate::privacy_screen::supported().then(|| (crate::privacy_screen::active(), crate::privacy_screen::current_type())),
private_screen: crate::privacy_screen::supported().then(crate::privacy_screen::current_type),
})
}
}
+38 -17
View File
@@ -25,23 +25,25 @@ pub fn payload_with_location(capture: Permission, operation: Permission, control
}
/// Optional host settings the viewer shows in 声音 / 安全 (SettingMetric 1 keep_mute,
/// 2 mute_permanent, 3 auto_lock; GeneralMetric 2 system_sound_support), and 防窥 when the host
/// supports it (SettingMetric 4 private_screen on, 7 private_screen_type).
/// 2 mute_permanent, 3 auto_lock; GeneralMetric 2 system_sound_support).
#[derive(Debug, Default, Clone, Copy)]
pub struct Settings { pub sound: bool, pub keep_mute: bool, pub mute_permanent: bool, pub auto_lock: bool, pub private_screen: Option<(bool, u64)> }
pub struct Settings { pub sound: bool, pub keep_mute: bool, pub mute_permanent: bool, pub auto_lock: bool, pub private_screen: Option<u8> }
pub fn payload_with_settings(capture: Permission, operation: Permission, control: Permission, location: &str, settings: &Settings) -> Vec<u8> {
let mut setting = Vec::new();
// Mac 4.43.0 callBackSystemMetrics reads field 7 first, falling back to field 4 only when 7=0.
// Report the effective mode (1 off, 2 picture, 3 screen off), not the saved preference.
if let Some(kind) = settings.private_screen {
setting.extend([4 << 3, u8::from(kind != 1), 7 << 3, kind]);
}
for (field, on) in [(1u8, settings.keep_mute), (2, settings.mute_permanent), (3, settings.auto_lock)] {
if on { setting.push(field << 3); setting.push(1); }
}
if let Some((true, _)) = settings.private_screen { setting.extend_from_slice(&[4 << 3, 1]); }
if !location.is_empty() {
setting.push(5 << 3 | 2);
varint(location.len() as u64, &mut setting);
setting.extend_from_slice(location.as_bytes());
}
if let Some((_, kind)) = settings.private_screen { setting.push(7 << 3); varint(kind, &mut setting); }
for (field, state) in [(8u8, capture), (9u8, operation), (10u8, control)] {
if state != Permission::Unknown {
setting.push(field << 3);
@@ -50,8 +52,14 @@ pub fn payload_with_settings(capture: Permission, operation: Permission, control
}
// SystemMetrics.general: system_sound_support = SS_SUPPORT (2) when desktop audio is streamed
// (GvPb_SystemSoundSupport: 0 unknown, 1 nonsupport, 2 support).
let mut out = if settings.sound { vec![26, 2, 16, 2] } else { vec![26, 0] };
// No support_touch, sound capability, win_os_ver, virtual
// Official Mac host 4.43.0 (626), arm64: SystemMetricsHandler (0x10000a96c)
// appends GENERAL=1 (0x10000abe8) and SETTING=2 (helper 0x10000a230, write
// 0x10000a64c) as it fills those sections; traverse (0x100423840) packs field 1.
// We always report both sections. The Mac viewer ignores an empty list
// (callBackSystemMetrics, 0x1003b4584). Host evidence: docs/privacy-screen.md.
let mut out = vec![10, 2, 1, 2];
out.extend(if settings.sound { &[26, 2, 16, 2][..] } else { &[26, 0][..] });
// No support_touch, sound capability, win_os_ver, private-screen, virtual
// mouse, auto-lock, file path or optional feature claims are fabricated.
out.push(34); // SystemMetrics.setting field 4
varint(setting.len() as u64, &mut out);
@@ -84,27 +92,29 @@ mod tests {
fn measured_allow_capabilities_use_official_enum_values() {
let p = payload(Permission::Allow, Permission::Allow, Permission::Allow);
let fields = decode_wire(&p).unwrap();
assert_eq!(fields.len(), 2);
assert_eq!(fields[0].number, 3);
assert_eq!(fields[0].value, WireValue::Bytes(&[]));
let WireValue::Bytes(setting) = fields[1].value else { panic!("setting not a message") };
assert_eq!(fields[1].number, 4);
assert_eq!(fields.len(), 3);
assert_eq!(fields[0].number, 1);
assert_eq!(fields[0].value, WireValue::Bytes(&[1, 2]));
assert_eq!(fields[1].number, 3);
assert_eq!(fields[1].value, WireValue::Bytes(&[]));
let WireValue::Bytes(setting) = fields[2].value else { panic!("setting not a message") };
assert_eq!(fields[2].number, 4);
let s = decode_wire(setting).unwrap();
assert_eq!(s.iter().map(|f| f.number).collect::<Vec<_>>(), vec![8, 9, 10]);
assert!(s.iter().all(|f| f.value == WireValue::Varint(2)));
}
#[test]
fn rejected_and_unknown_observations_are_not_promoted_to_allow() {
assert_eq!(payload(Permission::Unknown, Permission::Unknown, Permission::Unknown), vec![26, 0, 34, 0]);
assert_eq!(payload(Permission::Allow, Permission::Reject, Permission::Reject), vec![26, 0, 34, 6, 64, 2, 72, 1, 80, 1]);
assert_eq!(payload(Permission::Unknown, Permission::Unknown, Permission::Unknown), vec![10, 2, 1, 2, 26, 0, 34, 0]);
assert_eq!(payload(Permission::Allow, Permission::Reject, Permission::Reject), vec![10, 2, 1, 2, 26, 0, 34, 6, 64, 2, 72, 1, 80, 1]);
}
#[test]
fn emits_no_audio_touch_windows_or_auto_unlock_capability() {
let p = payload(Permission::Allow, Permission::Allow, Permission::Allow);
let fields = decode_wire(&p).unwrap();
let WireValue::Bytes(general) = fields[0].value else { panic!() };
let WireValue::Bytes(general) = fields[1].value else { panic!() };
assert!(general.is_empty());
let WireValue::Bytes(setting) = fields[1].value else { panic!() };
let WireValue::Bytes(setting) = fields[2].value else { panic!() };
assert!(decode_wire(setting).unwrap().iter().all(|f| (8..=10).contains(&f.number)));
}
#[test]
@@ -112,10 +122,21 @@ mod tests {
let home = "/home/user/".repeat(12);
let p = payload_with_location(Permission::Allow, Permission::Allow, Permission::Allow, &home);
let fields = decode_wire(&p).unwrap();
let WireValue::Bytes(setting) = fields[1].value else { panic!() };
let WireValue::Bytes(setting) = fields[2].value else { panic!() };
let s = decode_wire(setting).unwrap();
assert_eq!(s[0].number, 5);
assert_eq!(s[0].value, WireValue::Bytes(home.as_bytes()));
assert_eq!(decode_wire(&remote_download_path("/home/x")).unwrap()[0].value, WireValue::Bytes(b"/home/x"));
}
#[test]
fn privacy_modes_report_matching_flag_and_current_type() {
for (kind, expected) in [(1, [32, 0, 56, 1]), (2, [32, 1, 56, 2]), (3, [32, 1, 56, 3])] {
let settings = Settings { private_screen: Some(kind), ..Settings::default() };
let p = payload_with_settings(Permission::Unknown, Permission::Unknown, Permission::Unknown, "", &settings);
let fields = decode_wire(&p).unwrap();
assert_eq!(fields[0].number, 1);
assert_eq!(fields[0].value, WireValue::Bytes(&[1, 2]));
assert_eq!(fields.iter().find(|f| f.number == 4).unwrap().value, WireValue::Bytes(&expected));
}
}
}
+92
View File
@@ -0,0 +1,92 @@
//! Per-peer TEXT backlog: one current metrics snapshot and bounded ordered replies.
use std::sync::{Arc, atomic::{AtomicBool, Ordering}};
use tokio::sync::{mpsc, watch};
const REPLY_CAPACITY: usize = 64;
#[derive(Clone)]
pub(super) struct Sender {
replies: mpsc::Sender<Vec<u8>>,
metrics: watch::Sender<Option<Vec<u8>>>,
overflow_reported: Arc<AtomicBool>,
}
pub(super) struct Receiver {
replies: mpsc::Receiver<Vec<u8>>,
metrics: watch::Receiver<Option<Vec<u8>>>,
metrics_open: bool,
replies_open: bool,
}
pub(super) fn channel() -> (Sender, Receiver) {
let (replies, rx) = mpsc::channel(REPLY_CAPACITY);
let (metrics, latest) = watch::channel(None);
(Sender { replies, metrics, overflow_reported: Arc::new(AtomicBool::new(false)) },
Receiver { replies: rx, metrics: latest, metrics_open: true, replies_open: true })
}
impl Sender {
pub(super) fn send(&self, message: Vec<u8>) -> Result<(), mpsc::error::SendError<Vec<u8>>> {
self.replies.try_send(message).map_err(|error| {
// Never wait for TEXT inside CONTROL's request handler: some viewers never open it.
if matches!(error, mpsc::error::TrySendError::Full(_))
&& !self.overflow_reported.swap(true, Ordering::Relaxed) {
log::warn!("TEXT reply queue full; dropping excess replies");
}
mpsc::error::SendError(error.into_inner())
})
}
pub(super) fn metrics(&self, message: Vec<u8>) {
let _ = self.metrics.send(Some(message));
}
}
impl Receiver {
pub(super) async fn recv(&mut self) -> Option<Vec<u8>> {
loop {
if !self.metrics_open && !self.replies_open { return None; }
tokio::select! {
changed = self.metrics.changed(), if self.metrics_open => {
if changed.is_err() { self.metrics_open = false; continue; }
if let Some(message) = self.metrics.borrow_and_update().clone() { return Some(message); }
}
message = self.replies.recv(), if self.replies_open => match message {
Some(message) => return Some(message),
None => self.replies_open = false,
},
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn unopened_text_keeps_latest_metrics_and_bounded_fifo_replies() {
let (tx, mut rx) = channel();
for i in 0..10_000u32 { tx.metrics(i.to_le_bytes().to_vec()); }
for i in 0..REPLY_CAPACITY { tx.send(vec![i as u8]).unwrap(); }
assert_eq!(tx.send(vec![255]).unwrap_err().0, vec![255]);
let mut replies = Vec::new();
let mut metrics = Vec::new();
for _ in 0..REPLY_CAPACITY + 1 {
let message = rx.recv().await.unwrap();
if message.len() == 4 { metrics.push(message); } else { replies.push(message[0]); }
}
assert_eq!(metrics, vec![9_999u32.to_le_bytes().to_vec()]);
assert_eq!(replies, (0..REPLY_CAPACITY as u8).collect::<Vec<_>>());
assert!(tokio::time::timeout(std::time::Duration::from_millis(20), rx.recv()).await.is_err());
tx.send(vec![100]).unwrap();
assert_eq!(rx.recv().await, Some(vec![100]));
drop(tx);
assert_eq!(rx.recv().await, None);
}
#[tokio::test]
async fn closed_text_rejects_replies() {
let (tx, rx) = channel();
tx.metrics(vec![13]);
tx.send(vec![22]).unwrap();
drop(rx);
assert!(tx.send(vec![23]).is_err());
tx.metrics(vec![14]);
}
}
+48
View File
@@ -10,6 +10,29 @@
//! buttons and wheels, like a QEMU tablet). Mixing relative and absolute axes in one device
//! confuses libinput.
#[repr(C)]
#[derive(Clone, Copy, Default)]
pub struct TextKey { pub code: u16, pub shift: u16 }
/// Resolve an ASCII prefix against the host's current XKB layout and locked modifiers.
/// X11/XWayland is queried read-only; the returned events are emitted through uinput.
pub fn text_plan(text: &str) -> Vec<TextKey> {
#[cfg(target_os = "linux")]
{
extern "C" {
fn uu_uinput_text_plan(text: *const u8, length: usize, plan: *mut TextKey, capacity: usize) -> usize;
}
let capacity = text.bytes().take_while(u8::is_ascii).count();
if capacity == 0 { return Vec::new(); }
let mut plan = vec![TextKey::default(); capacity];
let count = unsafe { uu_uinput_text_plan(text.as_ptr(), text.len(), plan.as_mut_ptr(), plan.len()) };
plan.truncate(count);
plan
}
#[cfg(not(target_os = "linux"))]
{ let _ = text; Vec::new() }
}
#[cfg(target_os = "linux")]
mod imp {
use std::fs::{File, OpenOptions};
@@ -95,6 +118,31 @@ mod imp {
pub struct Devices { keyboard: Mutex<Device>, pointer: Mutex<Device> }
impl Devices {
#[cfg(test)]
pub fn recording_for_test() -> (Self, File, File) {
let recording = || {
let path = std::env::temp_dir().join(format!("uu-uinput-test-{}-{}", std::process::id(), rand::random::<u64>()));
let file = OpenOptions::new().read(true).write(true).create_new(true).mode(0o600).open(&path).unwrap();
std::fs::remove_file(path).unwrap();
let reader = file.try_clone().unwrap();
(Mutex::new(Device(file)), reader)
};
let (keyboard, keys) = recording();
let (pointer, mouse) = recording();
(Self { keyboard, pointer }, keys, mouse)
}
#[cfg(test)]
pub fn recorded_events_for_test(file: &mut File) -> Vec<(u16, u16, i32)> {
use std::io::{Read, Seek, SeekFrom};
file.seek(SeekFrom::Start(0)).unwrap();
let mut data = Vec::new();
file.read_to_end(&mut data).unwrap();
assert_eq!(data.len() % std::mem::size_of::<InputEvent>(), 0);
data.chunks_exact(std::mem::size_of::<InputEvent>()).map(|chunk| {
let event = unsafe { std::ptr::read_unaligned(chunk.as_ptr().cast::<InputEvent>()) };
(event.kind, event.code, event.value)
}).collect()
}
pub fn open() -> std::io::Result<Self> {
let keyboard = Device::create("uu-remote-linux keyboard", 1, |d| {
d.ioctl(UI_SET_EVBIT, EV_KEY.into())?;
+67 -19
View File
@@ -154,8 +154,25 @@ fn is_independent_frame_for(bytes: &[u8], codec: VideoCodec) -> bool {
match codec {
VideoCodec::H264 => !nal_offsets_for(bytes, 5, codec).is_empty() && nal_offsets_for(bytes, 1, codec).is_empty(),
// BLA/IDR/CRA are IRAP (RFC 7798 §4.1); no leading pictures with our no-B-frame encoder.
VideoCodec::H265 => (16..=21).any(|kind| !nal_offsets_for(bytes, kind, codec).is_empty())
&& !(0..16).any(|kind| !nal_offsets_for(bytes, kind, codec).is_empty()),
VideoCodec::H265 => {
let mut has_irap = false;
let mut has_non_irap_vcl = false;
let mut i = 0;
while i + 3 < bytes.len() {
let prefix = if bytes[i..].starts_with(&[0, 0, 0, 1]) { 4 }
else if bytes[i..].starts_with(&[0, 0, 1]) { 3 } else { i += 1; continue };
let header = i + prefix;
if let Some(kind) = hevc_nal_kind(bytes, header) {
if (16..=21).contains(&kind) {
has_irap = true;
} else if kind < 16 {
has_non_irap_vcl = true;
}
}
i += prefix;
}
has_irap && !has_non_irap_vcl
}
}
}
#[cfg(test)]
@@ -169,7 +186,7 @@ struct CompleteFrame {
codec: VideoCodec,
sequence: u64,
completed_at: Instant,
data: Vec<u8>,
data: bytes::Bytes,
_permit: Option<OwnedSemaphorePermit>,
}
@@ -374,6 +391,9 @@ pub async fn ffmpeg_encoders() -> Option<Vec<&'static str>> {
/// Installing FFmpeg clears the window line on the next check; no restart is needed.
pub fn check_ffmpeg_usable() {
if crate::desktop_backend::headless() { return; }
#[cfg(feature = "inproc-av")]
if native_engine_eligible(crate::video_select::selection().encoder, NativeDisplayKind::Portal)
&& native_display_kind() == NativeDisplayKind::Portal { return; }
tokio::spawn(async {
static LAST_NOTICE: std::sync::Mutex<Option<Instant>> = std::sync::Mutex::new(None);
let summary = crate::i18n::s("无法传输远程画面","Cannot stream the remote desktop");
@@ -515,7 +535,7 @@ pub(crate) async fn probe_encoder_idr(encoder: Encoder) -> crate::video_select::
}
/// True when `read_encoder_with` would open the in-process engine for this candidate
/// on the selected desktop backend (X11 only; not Wayland, portal, KMS, or headless).
/// on the selected backend (X11 hardware encoders, or Portal VAAPI).
fn native_engine_would_run(encoder: Encoder) -> bool {
native_engine_eligible(encoder, native_display_kind())
}
@@ -695,7 +715,7 @@ async fn read_encoder(
if encoder == Encoder::Cpu { return read_encoder_with(size,display,portal,latest,Encoder::Cpu,true,sequence,settings,idr,budget,selection).await; }
#[cfg_attr(not(feature = "inproc-av"), allow(unused_mut))]
let mut result = read_encoder_with(size,display.clone(),portal.clone(),latest.clone(),encoder,true,sequence.clone(),settings,idr.clone(),budget.clone(),selection).await;
// A failed native NVENC session (old driver, unsupported mode) still leaves FFmpeg's NVENC process pipeline.
// A failed native session still leaves the matching FFmpeg hardware pipeline.
#[cfg(feature = "inproc-av")]
if let Err(error) = &result {
if !latest.is_closed() && native_inproc(&display, portal.is_some(), encoder) && x11_resized(&display, portal.is_some(), size).is_none() {
@@ -720,18 +740,19 @@ fn x11_resized(display: &str, portal: bool, size: (u32, u32)) -> Option<(u32, u3
crate::capture::x11_size().filter(|current| *current != size)
}
/// Same predicate `native_inproc` uses: X11 only, and the in-process engine is selected.
/// Same predicate `native_inproc` uses for backend/encoder eligibility.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum NativeDisplayKind { X11, Wayland, Portal, Kms, None }
pub(crate) fn native_engine_eligible(encoder: Encoder, kind: NativeDisplayKind) -> bool {
#[cfg(feature = "inproc-av")]
{ kind == NativeDisplayKind::X11 && crate::inproc_encoder::selected(encoder) }
{ (kind == NativeDisplayKind::X11 || (kind == NativeDisplayKind::Portal && encoder == Encoder::Vaapi))
&& crate::inproc_encoder::selected(encoder) }
#[cfg(not(feature = "inproc-av"))]
{ let _ = (encoder, kind); false }
}
/// The native in-process NVENC path serves X11 only (not Wayland/KMS capture or a portal session).
/// NVENC serves X11; VAAPI also accepts frames from the existing Portal session.
#[cfg(feature = "inproc-av")]
fn native_inproc(display: &str, portal: bool, encoder: Encoder) -> bool {
native_engine_eligible(encoder, display_kind(display, portal))
@@ -749,7 +770,7 @@ fn display_kind(display: &str, portal: bool) -> NativeDisplayKind {
#[cfg(feature = "inproc-av")]
async fn read_inprocess(
config: crate::inproc_encoder::Config, latest: mpsc::Sender<Arc<CompleteFrame>>,
sequence: Arc<std::sync::atomic::AtomicU64>, idr: Arc<AtomicBool>, budget: Arc<Semaphore>,
sequence: Arc<std::sync::atomic::AtomicU64>, idr: Arc<AtomicBool>, budget: Arc<Semaphore>, source: (usize, u64),
) -> Result<(), String> {
let codec = config.codec;
let (units_tx, mut units) = mpsc::channel::<crate::inproc_encoder::EncodedUnit>(4);
@@ -765,7 +786,7 @@ async fn read_inprocess(
let mut gate = DependencyGate::default();
while let Some(unit) = units.recv().await {
let sequence = sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1;
gate.submit(&latest, Arc::new(CompleteFrame { source_generation: 0, source_id: 0, codec, sequence, completed_at: unit.completed_at, data: unit.data, _permit: Some(unit.permit) }));
gate.submit(&latest, Arc::new(CompleteFrame { source_generation: source.1, source_id: source.0, codec, sequence, completed_at: unit.completed_at, data: unit.data.into(), _permit: Some(unit.permit) }));
if latest.is_closed() { break; }
}
// Dropping the receiver also unblocks the encoder if it is waiting to send.
@@ -832,6 +853,7 @@ async fn read_encoder_with(
if allow_inproc && x11_region.is_none() && native_inproc(&display, portal.is_some(), encoder) {
let max_kbps = settings.max_kbps().unwrap_or(30_000) as i64;
let config = crate::inproc_encoder::Config {
portal: portal.clone(),
display: display.clone(), input: size, output: settings.output, fps: u32::from(settings.fps),
gop: gop_frames(settings.fps, true) as u32, cq: settings.cq() as u32,
target_bps: settings.max_kbps().map_or(16_000, |k| i64::from(k) * 3 / 4) * 1000,
@@ -841,7 +863,7 @@ async fn read_encoder_with(
log::info!("Desktop encoder: display={} source={}x{} output={:?} fps={} cq={} maxrate={}k encoder={} source={} pipeline=in-process",
display,size.0,size.1,settings.output,settings.fps,config.cq,max_kbps,encoder.name_for(settings.codec),
crate::video_select::encoder_source_label(selection.encoder_source));
return read_inprocess(config, latest, sequence, idr, budget).await;
return read_inprocess(config, latest, sequence, idr, budget, (settings.source_id, settings.source_generation)).await;
}
let source_size = size;
let size = format!("{}x{}", size.0, size.1);
@@ -983,7 +1005,7 @@ async fn read_encoder_with(
if aud.len() < 2 { break; }
let next = aud[1];
if next > MAX_ACCESS_UNIT { return Err("Encoder access unit exceeds limit".into()); }
let frame: Vec<u8> = pending.drain(..next).collect();
let frame: bytes::Bytes = pending.drain(..next).collect::<Vec<u8>>().into();
let sequence = sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed) + 1;
let permit=if wayland {Some(permits_rx.recv().await.ok_or("Capture producer stopped")?)} else {None};
gate.submit(&latest, Arc::new(CompleteFrame { source_generation: settings.source_generation, source_id: settings.source_id,
@@ -1196,6 +1218,8 @@ pub async fn stream_desktop_at(pc: Arc<RTCPeerConnection>, track: Arc<crate::vid
}
};
let mut reader = EncoderTask(tokio::spawn(open(size, live_selection, current)));
// The privacy screen swaps the portal stream to a virtual output that can have another size.
let mut portal_size = portal.as_ref().map(|p| p.size());
let mut previous = None;
let mut timeline = RtpTimeline { fps: u64::from(current.fps), ..Default::default() };
let mut settings_open = true;
@@ -1297,7 +1321,19 @@ pub async fn stream_desktop_at(pc: Arc<RTCPeerConnection>, track: Arc<crate::vid
}
return result;
},
_ = health.tick() => { if transport_closed(&pc) { return Ok(()); } },
_ = health.tick() => {
if transport_closed(&pc) { return Ok(()); }
let now = portal.as_ref().map(|p| p.size());
if now != portal_size {
log::info!("Portal stream size changed; restarting capture");
portal_size = now;
reader.0.abort();
let _ = (&mut reader.0).await;
while receiver.try_recv().is_ok() {}
idr.store(true, std::sync::atomic::Ordering::Relaxed);
reader.0 = tokio::spawn(open(size, live_selection, current));
}
},
changed = settings.changed(), if settings_open => {
if changed.is_err() { settings_open = false; }
continue;
@@ -1311,7 +1347,7 @@ pub async fn stream_desktop_at(pc: Arc<RTCPeerConnection>, track: Arc<crate::vid
max_age_ms = max_age_ms.max(frame.completed_at.elapsed().as_millis());
// Continue monitoring close even if the network send stalls.
let sample = Sample {
data: frame.data.clone().into(), duration, ..Default::default()
data: frame.data.clone(), duration, ..Default::default()
};
let extensions = [crate::rtp_metadata::capture_index(0), crate::rtp_metadata::new_frame()];
let sent_before=track.revision();
@@ -1461,7 +1497,7 @@ mod tests {
for sequence in 1..=2 {
let permit=budget.clone().acquire_owned().await.unwrap();
gate.submit(&tx,Arc::new(CompleteFrame { source_generation: 0, source_id: 0,codec:VideoCodec::H264,sequence,completed_at:Instant::now(),
data:vec![0,0,1,5,42],_permit:Some(permit)}));
data:vec![0,0,1,5,42].into(),_permit:Some(permit)}));
}
let sending=rx.recv().await.unwrap();
assert_eq!(budget.available_permits(),0);
@@ -1514,6 +1550,18 @@ mod tests {
}
}
#[test]
fn portal_native_pipeline_only_accepts_vaapi() {
assert!(!native_engine_eligible(Encoder::Cpu, NativeDisplayKind::Portal));
assert!(!native_engine_eligible(Encoder::Nvenc, NativeDisplayKind::Portal));
#[cfg(feature = "inproc-av")]
assert_eq!(native_engine_eligible(Encoder::Vaapi, NativeDisplayKind::Portal),
crate::inproc_encoder::selected(Encoder::Vaapi));
for kind in [NativeDisplayKind::Wayland, NativeDisplayKind::Kms, NativeDisplayKind::None] {
assert!(!native_engine_eligible(Encoder::Vaapi, kind));
}
}
#[test]
fn timing_probe_failure_keeps_modern_args() {
let modern = b" -fps_mode mode\n -enc_time_base ratio\n";
@@ -1611,7 +1659,7 @@ mod tests {
let (started_tx, started_rx) = tokio::sync::oneshot::channel();
let frame = |sequence, idr| Arc::new(CompleteFrame { source_generation: 0, source_id: 0, _permit: None,
sequence, codec: VideoCodec::H264, completed_at: Instant::now(),
data: vec![0, 0, 1, 9, 240, 0, 0, 1, if idr { 5 } else { 1 }, 42],
data: vec![0, 0, 1, 9, 240, 0, 0, 1, if idr { 5 } else { 1 }, 42].into(),
});
let mut reader = EncoderTask(tokio::spawn(async move {
let _stopped = MarkStopped(old_stopped);
@@ -1704,7 +1752,7 @@ mod tests {
async fn bounded_queue_never_sends_broken_prediction_chain_after_overload(){
let(tx,mut rx)=mpsc::channel(1);
let mut gate=DependencyGate::default();
let frame=|sequence,idr|Arc::new(CompleteFrame{source_generation:0,source_id:0,_permit:None,sequence,codec:VideoCodec::H264,completed_at:Instant::now(),data:vec![0,0,1,9,240,0,0,1,if idr{5}else{1},42]});
let frame=|sequence,idr|Arc::new(CompleteFrame{source_generation:0,source_id:0,_permit:None,sequence,codec:VideoCodec::H264,completed_at:Instant::now(),data:vec![0,0,1,9,240,0,0,1,if idr{5}else{1},42].into()});
gate.submit(&tx,frame(1,false));assert!(rx.try_recv().is_err()); // no IDR yet
gate.submit(&tx,frame(2,true));
gate.submit(&tx,frame(3,false)); // queue full: P3 lost
@@ -1777,7 +1825,7 @@ mod tests {
let (tx, mut rx) = mpsc::channel(1);
let mut gate = DependencyGate::default();
let frame = |sequence, irap| Arc::new(CompleteFrame { source_generation: 0, source_id: 0, _permit: None, codec: VideoCodec::H265,
sequence, completed_at: Instant::now(), data: vec![0,0,1,if irap { 38 } else { 2 },1,42] });
sequence, completed_at: Instant::now(), data: vec![0,0,1,if irap { 38 } else { 2 },1,42].into() });
gate.submit(&tx, frame(1, false));
assert!(rx.try_recv().is_err());
gate.submit(&tx, frame(2, true));
@@ -1824,7 +1872,7 @@ mod screen_frame_tests {
use super::*;
#[test]
fn source_restart_rejects_queued_frames_even_with_same_screen_and_codec() {
let frame=CompleteFrame {source_id:0,source_generation:7,codec:VideoCodec::H264,sequence:1,completed_at:Instant::now(),data:vec![],_permit:None};
let frame=CompleteFrame {source_id:0,source_generation:7,codec:VideoCodec::H264,sequence:1,completed_at:Instant::now(),data:vec![].into(),_permit:None};
let mut settings=VideoSettings {source_id:0,source_generation:7,..Default::default()};
assert!(frame.matches(&settings));
settings.source_generation=9;assert!(!frame.matches(&settings));
+1 -1
View File
@@ -57,7 +57,7 @@ impl VideoTrack {
// Leave room for the RTP header and negotiated UU extensions below the 1200 byte MTU.
let payloads = match codec {
VideoCodec::H264 => state.h264.payload(1160, &sample.data).map_err(Error::Rtp)?,
VideoCodec::H265 => crate::hevc::payload(1160, &sample.data).map_err(Error::new)?,
VideoCodec::H265 => crate::hevc::payload_bytes(1160, &sample.data).map_err(Error::new)?,
};
let count = payloads.len();
let mut complete = count > 0;
+1 -1
View File
@@ -31,7 +31,7 @@ pub(super) async fn encode(latest: mpsc::Sender<Arc<CompleteFrame>>, settings: V
let frame = Arc::new(CompleteFrame {
source_generation: settings.source_generation, source_id: settings.source_id,
codec: settings.codec, sequence: sequence.fetch_add(1, Ordering::Relaxed) + 1,
completed_at: Instant::now(), data: vec![0, 0, 1, 65, 1, 2], _permit: Some(permit),
completed_at: Instant::now(), data: vec![0, 0, 1, 65, 1, 2].into(), _permit: Some(permit),
});
if latest.send(frame).await.is_err() { return Ok(()); }
}
+135
View File
@@ -0,0 +1,135 @@
//! Session-scoped remote pointer shapes. Wire evidence is documented in src/cursor.rs.
use crate::protocol::{decode_wire,WireValue};
use std::sync::{Arc,Mutex};
const MAX_SIDE:u32=512;
const MAX_PNG:usize=1024*1024;
#[derive(Clone,Debug,PartialEq)]
pub struct Shape {pub width:u32,pub height:u32,pub hot_x:u32,pub hot_y:u32,pub scale_x:f64,pub scale_y:f64,pub png:Vec<u8>}
fn blob(data:&[u8],field:u32)->Option<&[u8]>{decode_wire(data).ok()?.into_iter().find_map(|f|match(f.number,f.value){(n,WireValue::Bytes(v))if n==field=>Some(v),_=>None})}
fn parse(data:&[u8])->Result<Option<Shape>,()> {
if data.len()>MAX_PNG+512{return Err(())}
let Some(change)=blob(data,15) else{return Ok(None)};
let Some(shape)=blob(change,2) else{return Ok(None)};
let fields=decode_wire(shape).map_err(|_|())?;
let uint=|n|fields.iter().find_map(|f|match(f.number,&f.value){(i,WireValue::Varint(v))if i==n=>Some(*v),_=>None}).unwrap_or(0);
let scale=|n|fields.iter().find_map(|f|match(f.number,&f.value){(i,WireValue::Fixed64(v))if i==n=>Some(f64::from_le_bytes(*v)),_=>None}).unwrap_or(1.);
let png=blob(shape,5).unwrap_or_default();
// Type-only/unsupported shapes restore the local arrow instead of leaving a stale resize cursor.
if png.is_empty(){return Ok(Some(Shape{width:0,height:0,hot_x:0,hot_y:0,scale_x:1.,scale_y:1.,png:Vec::new()}))}
let(width,height)=(u32::try_from(uint(3)).map_err(|_|())?,u32::try_from(uint(4)).map_err(|_|())?);
let(hot_x,hot_y)=(u32::try_from(uint(1)).map_err(|_|())?,u32::try_from(uint(2)).map_err(|_|())?);
let(scale_x,scale_y)=(scale(7),scale(8));
if width==0||height==0||width>MAX_SIDE||height>MAX_SIDE||hot_x>=width||hot_y>=height
|| ![scale_x,scale_y].iter().all(|v|v.is_finite()&&*v>0.&&*v<=16.) {return Err(())}
if png.len()<33||png.len()>MAX_PNG||!png.starts_with(b"\x89PNG\r\n\x1a\n")||&png[12..16]!=b"IHDR"{return Err(())}
let pw=u32::from_be_bytes(png[16..20].try_into().unwrap());let ph=u32::from_be_bytes(png[20..24].try_into().unwrap());
if pw==0||ph==0||pw>MAX_SIDE||ph>MAX_SIDE{return Err(())}
Ok(Some(Shape{width,height,hot_x,hot_y,scale_x,scale_y,png:png.to_vec()}))
}
#[derive(Default)] struct Latest {last:Option<Arc<Shape>>,pending:Option<Arc<Shape>>,count:u64}
#[derive(Clone,Default)] pub struct State(Arc<Mutex<Latest>>);
impl State {
pub fn receive(&self,data:&[u8]) {
let Ok(Some(shape))=parse(data) else{return};let mut state=self.0.lock().unwrap();
if state.last.as_deref()==Some(&shape){return}
state.count+=1;
if state.count<=3 || state.count%100==0 {log::info!("Viewer remote cursor: count={} size={}x{} png_bytes={}",state.count,shape.width,shape.height,shape.png.len());}
let shape=Arc::new(shape);state.last=Some(shape.clone());state.pending=Some(shape);
}
pub fn take(&self)->Option<Arc<Shape>>{self.0.lock().unwrap().pending.take()}
}
#[cfg(feature="viewer-sdl")]
mod display {
use super::*;
use sdl2::{mouse::{Cursor,SystemCursor},surface::Surface,pixels::PixelFormatEnum};
struct Image {shape:Arc<Shape>,width:u32,height:u32,rgba:Vec<u8>}
fn decode(shape:Arc<Shape>)->Result<Image,()> {
let mut decoder=png::Decoder::new_with_limits(std::io::Cursor::new(&shape.png),png::Limits{bytes:4*MAX_PNG});
decoder.set_ignore_text_chunk(true);decoder.set_ignore_iccp_chunk(true);
decoder.set_transformations(png::Transformations::EXPAND|png::Transformations::STRIP_16);
let mut reader=decoder.read_info().map_err(|_|())?;
let size=reader.output_buffer_size().filter(|v|*v<=MAX_SIDE as usize*MAX_SIDE as usize*4).ok_or(())?;
let mut data=vec![0;size];let info=reader.next_frame(&mut data).map_err(|_|())?;
if info.width==0||info.height==0||info.width>MAX_SIDE||info.height>MAX_SIDE{return Err(())}
data.truncate(info.buffer_size());let mut rgba=Vec::with_capacity(info.width as usize*info.height as usize*4);
match info.color_type {
png::ColorType::Rgba=>rgba=data,
png::ColorType::Rgb=>for p in data.chunks_exact(3){rgba.extend_from_slice(&[p[0],p[1],p[2],255]);},
png::ColorType::Grayscale=>for p in data {rgba.extend_from_slice(&[p,p,p,255]);},
png::ColorType::GrayscaleAlpha=>for p in data.chunks_exact(2){rgba.extend_from_slice(&[p[0],p[0],p[0],p[1]]);},
_=>return Err(()),
}
if rgba.len()!=info.width as usize*info.height as usize*4{return Err(())}
Ok(Image{shape,width:info.width,height:info.height,rgba})
}
fn geometry(s:&Shape)->(u32,u32,i32,i32) {
// Cursor width/hotspot are the host's cursor units. Video coordinate
// scales belong to pointer position mapping, not the local OS cursor.
// Keep the cursor readable when a large remote desktop is fitted down.
let w=s.width.clamp(1,256);let h=s.height.clamp(1,256);
let x=(s.hot_x as f64*w as f64/s.width as f64).round().clamp(0.,(w-1) as f64) as i32;
let y=(s.hot_y as f64*h as f64/s.height as f64).round().clamp(0.,(h-1) as f64) as i32;
(w,h,x,y)
}
pub struct Display {arrow:Option<Cursor>,remote:Option<Cursor>,image:Option<Image>,geometry:Option<(u32,u32,i32,i32)>,active:bool,applied:u64}
impl Display {
pub fn new()->Self {Self{arrow:Cursor::from_system(SystemCursor::Arrow).ok(),remote:None,image:None,geometry:None,active:false,applied:0}}
pub fn reset(&mut self){if let Some(cursor)=&self.arrow{cursor.set();}self.active=false;}
pub fn update(&mut self,shape:Option<Arc<Shape>>,active:bool){
if let Some(shape)=shape {
self.reset();self.remote=None;self.geometry=None;
self.image=if shape.png.is_empty(){None}else{match decode(shape){Ok(image)=>Some(image),Err(())=>{log::warn!("Viewer remote cursor PNG rejected");None}}};
}
if let Some(image)=self.image.as_mut(){
let size=geometry(&image.shape);
if self.geometry!=Some(size) {
let result=(||->Result<Cursor,String>{
let mut src=Surface::from_data(&mut image.rgba,image.width,image.height,image.width*4,PixelFormatEnum::RGBA32)?;
src.set_blend_mode(sdl2::render::BlendMode::None)?;
let mut target=Surface::new(size.0,size.1,PixelFormatEnum::RGBA32)?;
src.blit_scaled(None,&mut target,None)?;
Cursor::from_surface(&target,size.2,size.3)
})();
self.reset();self.remote=match result {Ok(cursor)=>{self.applied+=1;if self.applied<=3||self.applied%100==0{log::info!("Viewer cursor applied: count={} size={}x{}",self.applied,size.0,size.1);}Some(cursor)},Err(_)=>{log::warn!("Viewer remote cursor unavailable on this display");None}};self.geometry=Some(size);
}
}
let active=active&&self.remote.is_some();
if active!=self.active {
if active {self.remote.as_ref().unwrap().set();self.active=true;}else{self.reset();}
}
}
}
impl Drop for Display {fn drop(&mut self){self.reset();}}
#[cfg(test)] mod tests {
use super::*;
#[test] fn png_pixels_and_retina_hotspot_use_stable_cursor_units(){
let mut png=Vec::new();{
let mut encoder=png::Encoder::new(&mut png,4,4);encoder.set_color(png::ColorType::Rgba);encoder.set_depth(png::BitDepth::Eight);
encoder.write_header().unwrap().write_image_data(&[128;64]).unwrap();
}
let shape=Arc::new(Shape{width:2,height:2,hot_x:1,hot_y:1,scale_x:2.,scale_y:2.,png});
let image=decode(shape.clone()).unwrap();assert_eq!(image.rgba,vec![128;64]);
assert_eq!(geometry(&shape),(2,2,1,1));
let mut changed=(*shape).clone();changed.scale_x=0.25;changed.scale_y=0.25;assert_eq!(geometry(&changed),(2,2,1,1));
let mut bad=(*shape).clone();bad.png[40]^=255;assert!(decode(Arc::new(bad)).is_err());
}
}
}
#[cfg(feature="viewer-sdl")] pub use display::Display;
#[cfg(test)] mod tests {
use super::*;
fn packet(w:u64,hot:u64,scale:f64,png:&[u8])->Vec<u8>{
let mut shape=Vec::new();super::super::wire::int(3,w,&mut shape);super::super::wire::int(4,w,&mut shape);super::super::wire::int(1,hot,&mut shape);
super::super::wire::bytes(5,png,&mut shape);shape.push(7<<3|1);shape.extend_from_slice(&scale.to_le_bytes());
let mut change=Vec::new();super::super::wire::bytes(2,&shape,&mut change);super::super::wire::envelope(1,15,&change)
}
#[test] fn shape_bounds_and_latest_only_updates(){
let png=include_bytes!("../../tests/fixtures/clipboard-test.png");
let state=State::default();let valid=packet(16,2,1.,png);state.receive(&valid);state.receive(&valid);
assert_eq!(state.take().unwrap().width,16);assert!(state.take().is_none());
for bad in [packet(0,0,1.,png),packet(513,0,1.,png),packet(16,16,1.,png),packet(16,0,f64::NAN,png),packet(16,0,0.,png)] {assert!(parse(&bad).is_err());state.receive(&bad);assert!(state.take().is_none());}
state.receive(&packet(20,2,1.,png));state.receive(&packet(24,2,1.,png));assert_eq!(state.take().unwrap().width,24);
state.receive(&packet(0,0,1.,&[]));assert!(state.take().unwrap().png.is_empty());
assert!(parse(&vec![0;MAX_PNG+513]).is_err());
}
}
+135 -14
View File
@@ -3,7 +3,7 @@ use std::sync::{Arc, atomic::{AtomicBool,AtomicU32,Ordering}};
#[derive(Clone)]
pub struct Desktop { pub units:Latest<super::media::AccessUnit>, pub pli:Arc<AtomicBool>, pub reset:Arc<AtomicBool>, pub ssrc:Arc<AtomicU32> }
impl Default for Desktop {
fn default()->Self {Self{units:Latest::new(3),pli:Arc::new(AtomicBool::new(false)),reset:Arc::new(AtomicBool::new(false)),ssrc:Arc::new(AtomicU32::new(0))}}
fn default()->Self {Self{units:Latest::new(8),pli:Arc::new(AtomicBool::new(false)),reset:Arc::new(AtomicBool::new(false)),ssrc:Arc::new(AtomicU32::new(0))}}
}
/// `content` is the source picture size inside the (possibly padded) RGB canvas; None = full frame.
pub struct Frame { pub width:u32, pub height:u32, pub rgb:Vec<u8>, pub content:Option<(u32,u32)> }
@@ -51,12 +51,15 @@ impl KeyGate {
} else {false}
}
}
/// Shows the newest frame a decoder finished between access units.
pub fn drain(decoder:&mut dyn Decoder,sink:&mut dyn FrameSink)->Result<(),String> {
if let Some(frame)=decoder.poll().pop() {STATS[1].fetch_add(1,Ordering::Relaxed);sink.present(&frame)?;}
fn present(sink:&mut dyn FrameSink,frame:&Frame)->Result<(),String> {
sink.present(frame)?;
// Local acceptance aid: UU_VIEWER_DUMP_FRAME=path writes the 5th frame as PPM (owner's own screen).
if STATS[1].fetch_add(1,Ordering::Relaxed)==std::env::var("UU_VIEWER_DUMP_FRAME_INDEX").ok().and_then(|v|v.parse().ok()).unwrap_or(4u64) { if let Some(path)=std::env::var_os("UU_VIEWER_DUMP_FRAME") {
let mut ppm=format!("P6\n{} {}\n255\n",frame.width,frame.height).into_bytes();ppm.extend_from_slice(&frame.rgb);let _=std::fs::write(path,ppm);
}}
Ok(())
}
pub fn display(decoder:&mut dyn Decoder,sink:&mut dyn FrameSink,au:&[u8],codec:super::media::Codec,pli:&AtomicBool)->Result<(),String> {
fn decode(decoder:&mut dyn Decoder,au:&[u8],codec:super::media::Codec,pli:&AtomicBool)->Vec<Frame> {
let units=STATS[0].fetch_add(1,Ordering::Relaxed)+1;
// A later session can join a clean stream with no IDR in flight (#124): keep asking until a frame shows.
if wants_key_frame(units,STATS[1].load(Ordering::Relaxed)) {
@@ -68,16 +71,33 @@ pub fn display(decoder:&mut dyn Decoder,sink:&mut dyn FrameSink,au:&[u8],codec:s
use std::io::Write; if let Ok(mut f)=std::fs::OpenOptions::new().create(true).append(true).open(path){let _=f.write_all(au);}
}}
match decoder.decode(au) {
Ok(frames)=>{for frame in frames {
sink.present(&frame)?;
// Local acceptance aid: UU_VIEWER_DUMP_FRAME=path writes the 5th frame as PPM (owner's own screen).
if STATS[1].fetch_add(1,Ordering::Relaxed)==std::env::var("UU_VIEWER_DUMP_FRAME_INDEX").ok().and_then(|v|v.parse().ok()).unwrap_or(4u64) { if let Some(path)=std::env::var_os("UU_VIEWER_DUMP_FRAME") {
let mut ppm=format!("P6\n{} {}\n255\n",frame.width,frame.height).into_bytes();ppm.extend_from_slice(&frame.rgb);let _=std::fs::write(path,ppm);
}}
}Ok(())},
Err(_)=>{STATS[2].fetch_add(1,Ordering::Relaxed);decoder.reset();pli.store(true,Ordering::Release);Ok(())},
Ok(frames)=>frames,
Err(_)=>{STATS[2].fetch_add(1,Ordering::Relaxed);decoder.reset();pli.store(true,Ordering::Release);Vec::new()},
}
}
/// Feed reference-dependent units in FIFO order, but present only the newest decoded picture.
pub fn pump(desktop:&Desktop,decoder:&mut dyn Decoder,sink:&mut dyn FrameSink,gate:&mut KeyGate)->Result<Option<super::media::Codec>,String> {
let started=std::time::Instant::now();
pump_with_elapsed(desktop,decoder,sink,gate,||started.elapsed())
}
fn pump_with_elapsed(desktop:&Desktop,decoder:&mut dyn Decoder,sink:&mut dyn FrameSink,gate:&mut KeyGate,mut elapsed:impl FnMut()->std::time::Duration)->Result<Option<super::media::Codec>,String> {
let mut newest=None;let mut codec=None;
for _ in 0..8 {
let Some(au)=desktop.units.pop() else {break};
if desktop.reset.swap(false,Ordering::AcqRel) {decoder.reset();gate.arm();}
if !gate.admit(au.codec,&au.data) {desktop.pli.store(true,Ordering::Release);}
else {
decoder.set_codec(au.codec)?;codec=Some(au.codec);
if let Some(frame)=decode(decoder,&au.data,au.codec,&desktop.pli).pop() {newest=Some(frame);}
}
// A soft budget between calls: an in-progress decoder call cannot be interrupted.
if elapsed()>=std::time::Duration::from_millis(4) {break}
}
// Asynchronous decoders may finish a picture even when no new input has arrived.
if let Some(frame)=decoder.poll().pop() {newest=Some(frame);}
if let Some(frame)=newest {present(sink,&frame)?;}
Ok(codec)
}
#[cfg(test)] mod tests {
#[test] fn key_frames_by_nal_type(){
use crate::viewer::media::Codec;
@@ -106,5 +126,106 @@ pub fn display(decoder:&mut dyn Decoder,sink:&mut dyn FrameSink,au:&[u8],codec:s
assert_eq!((1..=90).filter(|&n|wants_key_frame(n,0)).count(),3);
assert!(!(1..=90).any(|n|wants_key_frame(n,1)));
}
#[test] fn decode_error_requests_pli_and_recovers(){let mut d=Mock(true);let mut s=Sink(0);let p=AtomicBool::new(false);display(&mut d,&mut s,&[],crate::viewer::media::Codec::H264,&p).unwrap();assert!(p.load(Ordering::Acquire));display(&mut d,&mut s,&[],crate::viewer::media::Codec::H264,&p).unwrap();assert_eq!(s.0,1);}
#[test] fn decode_error_requests_pli_and_recovers(){
let desktop=Desktop::default();let mut d=Mock(true);let mut s=Sink(0);let mut gate=KeyGate::new();
enqueue(&desktop,unit(0,false));
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();assert!(desktop.pli.load(Ordering::Acquire));assert_eq!(s.0,0);
enqueue(&desktop,unit(1,false));
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();assert_eq!(s.0,1);
}
use crate::viewer::media::{AccessUnit,Codec};
use std::time::Duration;
fn unit(id:u32,key:bool)->AccessUnit {
let mut data=vec![0,0,0,1,if key {0x65}else{0x41},0b1001_1000];
data.extend_from_slice(&id.to_le_bytes());AccessUnit{codec:Codec::H264,data}
}
fn picture(id:u32)->Frame {Frame{width:1,height:1,rgb:id.to_le_bytes()[..3].to_vec(),content:None}}
#[derive(Default)]
struct BatchDecoder {seen:Vec<u32>,resets:usize,pending:Vec<Frame>,extra_picture:bool}
impl Decoder for BatchDecoder {
fn set_codec(&mut self,_:Codec)->Result<(),String>{Ok(())}
fn decode(&mut self,au:&[u8])->Result<Vec<Frame>,String>{
let id=u32::from_le_bytes(au[6..].try_into().unwrap());self.seen.push(id);
let mut frames=vec![picture(id)];if self.extra_picture {frames.push(picture(id+100));}Ok(frames)
}
fn reset(&mut self){self.resets+=1;self.pending.clear();}
fn poll(&mut self)->Vec<Frame>{std::mem::take(&mut self.pending)}
}
#[derive(Default)]
struct Pictures(Vec<u32>);
impl FrameSink for Pictures {
fn present(&mut self,frame:&Frame)->Result<(),String>{assert_eq!(frame.rgb.len(),3);self.0.push(u32::from_le_bytes([frame.rgb[0],frame.rgb[1],frame.rgb[2],0]));Ok(())}
}
// Match the RTP reader's overflow signal without a network or wall-clock sleeps.
fn enqueue(desktop:&Desktop,au:AccessUnit)->bool {
let dropped=desktop.units.push(au);
if dropped {desktop.reset.store(true,Ordering::Release);desktop.pli.store(true,Ordering::Release);}
dropped
}
#[test] fn one_unit_per_tick_overflows_even_with_a_larger_queue(){
for capacity in [3,8] {
let q=Latest::new(capacity);let mut arrived=0;let mut dropped=0;
// 1,000 ticks at 125 Hz = 8 seconds; exactly 1,152 units arrive at 144 Hz.
for tick in 1..=1000 {
let due=tick*144/125;
while arrived<due {dropped+=usize::from(q.push(arrived));arrived+=1;}
assert!(q.pop().is_some());
}
assert_eq!(arrived,1152);assert_eq!(dropped,152-(capacity-1));
}
}
#[test] fn batches_keep_up_with_144_units_per_second_in_fifo_order(){
let desktop=Desktop::default();let mut d=BatchDecoder::default();let mut s=Pictures::default();let mut gate=KeyGate::new();let mut arrived=0;
for tick in 1..=1000 {
let due=tick*144/125;
while arrived<due {assert!(!enqueue(&desktop,unit(arrived,false)));arrived+=1;}
let before=s.0.len();
assert_eq!(pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap(),Some(Codec::H264));
assert_eq!(s.0.len(),before+1);assert_eq!(s.0.last(),Some(&(due-1)));
}
assert_eq!(arrived,1152);assert_eq!(d.seen,(0..1152).collect::<Vec<_>>());
assert_eq!(d.resets,0);assert!(desktop.units.pop().is_none());assert!(!desktop.reset.load(Ordering::Acquire));
}
#[test] fn batch_presents_only_the_latest_picture_and_polls_when_idle(){
let desktop=Desktop::default();let mut d=BatchDecoder{extra_picture:true,..Default::default()};let mut s=Pictures::default();let mut gate=KeyGate::new();
for id in 0..3 {assert!(!enqueue(&desktop,unit(id,false)));}
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();
assert_eq!(d.seen,vec![0,1,2]);assert_eq!(s.0,vec![102]);
d.pending=vec![picture(103),picture(104)];
assert_eq!(pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap(),None);
assert_eq!(s.0,vec![102,104]);
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();assert_eq!(s.0,vec![102,104]);
enqueue(&desktop,unit(105,false));d.pending=vec![picture(206)];
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();assert_eq!(s.0,vec![102,104,206]);
}
#[test] fn actual_queue_loss_still_resets_and_waits_for_a_key_frame(){
let desktop=Desktop::default();let mut d=BatchDecoder::default();let mut s=Pictures::default();let mut gate=KeyGate::new();
for id in 0..8 {assert!(!enqueue(&desktop,unit(id,false)));}
assert!(enqueue(&desktop,unit(8,false)));
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();
assert_eq!(d.resets,1);assert!(d.seen.is_empty());assert!(s.0.is_empty());assert!(desktop.pli.load(Ordering::Acquire));
enqueue(&desktop,unit(9,false));enqueue(&desktop,unit(10,true));enqueue(&desktop,unit(11,false));
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();
assert_eq!(d.resets,1);assert_eq!(d.seen,vec![10,11]);assert_eq!(s.0,vec![11]);
}
#[test] fn batch_count_limit_leaves_remaining_units_for_the_next_tick(){
let desktop=Desktop{units:Latest::new(12),..Default::default()};let mut d=BatchDecoder::default();let mut s=Pictures::default();let mut gate=KeyGate::new();
for id in 0..12 {assert!(!enqueue(&desktop,unit(id,false)));}
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();
assert_eq!(d.seen,(0..8).collect::<Vec<_>>());assert_eq!(s.0,vec![7]);
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();
assert_eq!(d.seen,(0..12).collect::<Vec<_>>());assert_eq!(s.0,vec![7,11]);
}
#[test] fn elapsed_budget_is_checked_between_calls_and_preserves_the_queue(){
let desktop=Desktop::default();let mut d=BatchDecoder::default();let mut s=Pictures::default();let mut gate=KeyGate::new();
for id in 0..4 {enqueue(&desktop,unit(id,false));}
let mut times=[Duration::from_millis(3),Duration::from_millis(4)].into_iter();
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||times.next().unwrap()).unwrap();
assert_eq!(d.seen,vec![0,1]);assert_eq!(s.0,vec![1]);
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::from_millis(20)).unwrap();
assert_eq!(d.seen,vec![0,1,2]);assert_eq!(s.0,vec![1,2]);
pump_with_elapsed(&desktop,&mut d,&mut s,&mut gate,||Duration::ZERO).unwrap();
assert_eq!(d.seen,vec![0,1,2,3]);assert_eq!(s.0,vec![1,2,3]);
}
}
+3
View File
@@ -21,8 +21,11 @@ pub mod thumbs;
#[cfg(uu_gtk)] pub mod host;
pub mod tools;
pub mod native_gamepad;
pub mod native_rumble;
pub mod clipboard;
pub mod cursor;
pub mod power;
pub mod secure_input;
pub mod type_ipc;
+141
View File
@@ -0,0 +1,141 @@
//! Opt-in official UU gamepad JSON, recovered from Windows 4.45.0.4318.
//! Evidence/RVAs and limits: docs/deckpad-native-gamepad.md. No port mapping or helper.
use serde_json::{json,Value};
use std::time::{Duration,Instant};
#[derive(Clone,Copy,Debug,Default,PartialEq,Eq)]
pub struct State {pub buttons:u16,pub lx:i16,pub ly:i16,pub rx:i16,pub ry:i16,pub lt:u8,pub rt:u8}
impl State {
pub fn json(self)->Value{json!({"action":"gpd_update","index":0,"buttons":self.buttons,
"left_trigger":self.lt,"right_trigger":self.rt,"left_thumb_x":self.lx,
"left_thumb_y":self.ly,"right_thumb_x":self.rx,"right_thumb_y":self.ry})}
fn released(self)->bool{self.buttons==0 && self.lt<8 && self.rt<8 &&
[self.lx,self.ly,self.rx,self.ry].iter().all(|v|i32::from(*v).abs()<5000)}
}
pub fn enabled()->bool{std::env::var("UU_VIEWER_NATIVE_GAMEPAD").as_deref()==Ok("1")}
pub fn connect()->Value{json!({"action":"gpd_connect","index":0})}
pub fn disconnect()->Value{json!({"action":"gpd_disconnect","index":0})}
fn y_axis(v:i16)->i16{(-i32::from(v)).clamp(-32768,32767) as i16}
fn trigger(v:i16)->u8{((i32::from(v).max(0)*255+16383)/32767) as u8}
/// Local state machine: focus loss sends neutral then detach; re-entry requires release.
/// The caller stops the session on any send failure rather than queueing old states.
#[derive(Default)]
struct Gate {connected:bool,armed:bool,last:Option<(State,Instant)>}
impl Gate {
fn close(&mut self)->Vec<Value>{
let out=if self.connected{vec![State::default().json(),disconnect()]}else{vec![]};
*self=Self::default();out
}
fn step(&mut self,state:Option<State>,active:bool,now:Instant)->Vec<Value>{
let Some(state)=state.filter(|_|active) else{return self.close()};
let mut out=Vec::new();
if !self.connected{out.push(connect());out.push(State::default().json());self.connected=true;}
if !self.armed {if state.released(){self.armed=true;}else{return out}}
if self.last.is_none_or(|(s,t)|s!=state||now.duration_since(t)>=Duration::from_millis(100)){
out.push(state.json());self.last=Some((state,now));
}
out
}
}
#[cfg(feature="viewer-sdl")]
pub struct NativeGamepad {sub:sdl2::GameControllerSubsystem,pad:Option<sdl2::controller::GameController>,gate:Gate,next_scan:Instant,paused:bool,chord:bool,
feedback:super::native_rumble::Feedback,rumble:super::native_rumble::Playback,rumble_enabled:bool,rumble_failed:bool,received_once:bool,applied_once:bool}
#[cfg(feature="viewer-sdl")]
impl NativeGamepad {
pub fn new(sdl:&sdl2::Sdl,feedback:super::native_rumble::Feedback)->Result<Self,String>{
let sub=sdl.game_controller()?;
eprintln!("DECKPAD_NATIVE_ENABLED");
let rumble_enabled=std::env::var("UU_VIEWER_NATIVE_RUMBLE").as_deref()!=Ok("0");
if rumble_enabled {eprintln!("DECKPAD_RUMBLE_ENABLED");}
Ok(Self{sub,pad:None,gate:Gate::default(),next_scan:Instant::now(),paused:false,chord:false,
feedback,rumble:Default::default(),rumble_enabled,rumble_failed:false,received_once:false,applied_once:false})
}
pub fn poll(&mut self,active:bool)->Vec<Value>{
use sdl2::controller::{Axis as A,Button as B};
let now=Instant::now();
if self.pad.as_ref().is_some_and(|p|!p.attached()) {
self.stop_feedback();
self.pad=None;self.chord=false;
// Detach before discovery, even if a replacement is already available.
return self.gate.close();
}
if self.pad.is_none() && now>=self.next_scan {
self.next_scan=now+Duration::from_secs(1);
if let Ok(n)=self.sub.num_joysticks(){
let ids:Vec<_>=(0..n).filter(|&i|self.sub.is_game_controller(i)).collect();
if ids.len()==1 {self.pad=self.sub.open(ids[0]).ok();if let Some(pad)=self.pad.as_ref(){
self.rumble_failed=false;self.received_once=false;self.applied_once=false;
eprintln!("DECKPAD_NATIVE_CONTROLLER_OPEN");
if self.rumble_enabled {eprintln!("{}",if pad.has_rumble(){"DECKPAD_RUMBLE_SUPPORTED"}else{"DECKPAD_RUMBLE_UNAVAILABLE"});}
}}
}
}
let state=self.pad.as_ref().map(|p|{
let mut buttons=0;
for (b,mask) in [(B::A,0x1000),(B::B,0x2000),(B::X,0x4000),(B::Y,0x8000),
(B::Back,0x20),(B::Start,0x10),(B::LeftStick,0x40),(B::RightStick,0x80),
(B::LeftShoulder,0x100),(B::RightShoulder,0x200),(B::DPadUp,1),(B::DPadDown,2),(B::DPadLeft,4),(B::DPadRight,8)] {
if p.button(b){buttons|=mask;}
}
State{buttons,lx:p.axis(A::LeftX),ly:y_axis(p.axis(A::LeftY)),rx:p.axis(A::RightX),ry:y_axis(p.axis(A::RightY)),lt:trigger(p.axis(A::TriggerLeft)),rt:trigger(p.axis(A::TriggerRight))}
});
let chord=state.is_some_and(|s|s.buttons&0x30==0x30);
if active && chord && !self.chord {self.paused=!self.paused;eprintln!("{}",if self.paused{"DECKPAD_NATIVE_PAUSED"}else{"DECKPAD_NATIVE_RESUMING"});}
self.chord=chord;
let connected=self.gate.connected;
let out=self.gate.step(state,active&&!self.paused&&!chord,now);
if self.gate.connected&&!connected {eprintln!("DECKPAD_NATIVE_CONNECT_QUEUED");}
if !self.gate.connected&&connected {eprintln!("DECKPAD_NATIVE_RELEASE_QUEUED");}
let feedback_active=self.gate.connected&&self.gate.armed&&self.rumble_enabled&&!self.rumble_failed;
self.feedback.set_active(feedback_active);
let incoming=self.feedback.take();
if incoming.is_some()&&!self.received_once {self.received_once=true;eprintln!("DECKPAD_RUMBLE_RECEIVED");}
if let Some(m)=self.rumble.step(incoming,feedback_active,now){
if let Some(pad)=self.pad.as_mut(){
if pad.set_rumble(m.left,m.right,super::native_rumble::EFFECT_MS).is_err(){
self.rumble_failed=true;self.feedback.set_active(false);self.rumble.stop();
let _=pad.set_rumble(0,0,0);eprintln!("DECKPAD_RUMBLE_OUTPUT_FAILED");
}else if m!=super::native_rumble::Motors::default()&&!self.applied_once{
self.applied_once=true;eprintln!("DECKPAD_RUMBLE_APPLIED");
}
}
}
out
}
fn stop_feedback(&mut self){
self.feedback.set_active(false);self.rumble.stop();
if let Some(pad)=self.pad.as_mut(){let _=pad.set_rumble(0,0,0);}
}
pub fn close(&mut self)->Vec<Value>{self.stop_feedback();self.gate.close()}
}
#[cfg(feature="viewer-sdl")]
impl Drop for NativeGamepad {fn drop(&mut self){self.stop_feedback();}}
#[cfg(test)] mod tests{
use super::*;
#[test] fn official_shape_and_axis_boundaries(){
assert_eq!(connect(),json!({"action":"gpd_connect","index":0}));
let s=State{buttons:0x1000,lx:-32768,ly:32767,rx:100,ry:-100,lt:128,rt:255}.json();
assert_eq!(s,json!({"action":"gpd_update","index":0,"buttons":4096,"left_trigger":128,"right_trigger":255,"left_thumb_x":-32768,"left_thumb_y":32767,"right_thumb_x":100,"right_thumb_y":-100}));
assert_eq!((y_axis(-32768),y_axis(32767)),(32767,-32767));
assert_eq!([trigger(-32768),trigger(0),trigger(16384),trigger(32767)],[0,0,128,255]);
}
#[test] fn held_on_entry_waits_for_release_then_focus_loss_detaches(){
let mut g=Gate::default();let t=Instant::now();let held=State{buttons:0x1000,..Default::default()};
assert_eq!(g.step(Some(held),true,t),vec![connect(),State::default().json()]);
assert!(g.step(Some(held),true,t).is_empty());
assert_eq!(g.step(Some(State::default()),true,t),vec![State::default().json()]);
assert_eq!(g.step(Some(held),true,t),vec![held.json()]);
assert_eq!(g.step(Some(held),false,t),vec![State::default().json(),disconnect()]);
assert!(g.close().is_empty());
assert_eq!(g.step(Some(held),true,t),vec![connect(),State::default().json()]);
}
#[test] fn unplug_neutral_and_idle_refresh(){
let mut g=Gate::default();let t=Instant::now();let z=State::default();g.step(Some(z),true,t);
assert!(g.step(Some(z),true,t+Duration::from_millis(50)).is_empty());
assert_eq!(g.step(Some(z),true,t+Duration::from_millis(100)),vec![z.json()]);
assert_eq!(g.step(None,true,t+Duration::from_millis(101)),vec![z.json(),disconnect()]);
}
}
+97
View File
@@ -0,0 +1,97 @@
//! Official Windows 4.45: gpd_vibration {index:u8,left_motor:u8,right_motor:u8}.
//! Server RVAs 0x5df5d0/0x5dfe80; viewer 0x10331a0. See protocol evidence doc.
use serde::Deserialize;
use std::{sync::{Arc,Mutex},time::{Duration,Instant}};
#[derive(Clone,Copy,Debug,Default,PartialEq,Eq)]
pub struct Motors {pub left:u16,pub right:u16}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct Message {action:String,index:u8,left_motor:u8,right_motor:u8}
pub fn decode(data:&[u8])->Option<Motors>{
if data.len()>512 {return None}
let m:Message=serde_json::from_slice(data).ok()?;
if m.action!="gpd_vibration" || m.index!=0 {return None}
Some(Motors{left:u16::from(m.left_motor)*257,right:u16::from(m.right_motor)*257})
}
#[derive(Default)]
struct Slot {active:bool,latest:Option<(Motors,Instant)>}
/// One slot per peer: bounded memory, latest update wins (including zero/stop).
/// Disabled while unfocused/unarmed; never replay feedback accumulated during pause.
#[derive(Clone,Default)]
pub struct Feedback(Arc<Mutex<Slot>>);
impl Feedback {
pub fn set_active(&self,active:bool){
let mut slot=self.0.lock().unwrap();
if slot.active!=active {slot.latest=None;slot.active=active;}
}
pub fn receive(&self,data:&[u8]){
let mut slot=self.0.lock().unwrap();
if slot.active {if let Some(m)=decode(data){slot.latest=Some((m,Instant::now()));}}
}
pub fn take(&self)->Option<(Motors,Instant)>{self.0.lock().unwrap().latest.take()}
}
/// Renew finite SDL effects while active; if the process stalls/dies, the hardware
/// effect expires. UU sends state changes, so a quiet network is NOT a stop message.
pub const EFFECT_MS:u32=1000;
const REFRESH:Duration=Duration::from_millis(250);
#[derive(Default)]
pub struct Playback {desired:Motors,next:Option<Instant>}
impl Playback {
pub fn step(&mut self,incoming:Option<(Motors,Instant)>,active:bool,now:Instant)->Option<Motors>{
if !active {return self.stop()}
let previous=self.desired;
if let Some((m,received))=incoming {
// Do not play a pulse left pending while decoding or scheduling stalled.
if m==Motors::default() || now.saturating_duration_since(received)<=Duration::from_millis(500){self.desired=m;}
}
let running=self.desired!=Motors::default();
if previous!=self.desired || (running&&self.next.is_none_or(|t|now>=t)) {
self.next=running.then_some(now+REFRESH);return Some(self.desired)
}
None
}
pub fn stop(&mut self)->Option<Motors>{
let running=self.desired!=Motors::default();*self=Self::default();
running.then_some(Motors::default())
}
}
#[cfg(test)] mod tests {
use super::*;
fn data(left:u8,right:u8)->Vec<u8>{format!(r#"{{"action":"gpd_vibration","index":0,"left_motor":{left},"right_motor":{right}}}"#).into_bytes()}
#[test] fn official_bytes_scale_to_full_sdl_range(){
assert_eq!(decode(&data(255,128)),Some(Motors{left:65535,right:32896}));
assert_eq!(decode(&data(0,0)),Some(Motors::default()));
}
#[test] fn reject_other_slots_malformed_ranges_duplicates_and_other_actions(){
let good=String::from_utf8(data(1,2)).unwrap();
for bad in [good.replace("\"index\":0","\"index\":1"),good.replace("vibration","update"),
good.replace("\"left_motor\":1","\"left_motor\":256"),good.replace("\"left_motor\":1","\"left_motor\":-1"),
good.replace("\"left_motor\":1","\"left_motor\":1.5"),good.replace("\"index\":0","\"index\":0,\"index\":0"),
good.replace(",\"right_motor\":2",""),"{}".into()," ".repeat(513)] {assert_eq!(decode(bad.as_bytes()),None);}
}
#[test] fn peer_isolation_pause_and_latest_stop_wins(){
let a=Feedback::default();let b=Feedback::default();
a.receive(&data(255,0));assert!(a.take().is_none());
a.set_active(true);b.set_active(true);
for _ in 0..1000 {a.receive(&data(255,255));}a.receive(&data(0,0));
assert_eq!(a.take().unwrap().0,Motors::default());assert!(b.take().is_none());
a.receive(&data(255,0));a.set_active(false);a.set_active(true);assert!(a.take().is_none());
}
#[test] fn sustained_effect_refresh_stop_focus_loss_and_stale_pulse(){
let t=Instant::now();let mut p=Playback::default();let m=Motors{left:100,right:200};
assert_eq!(p.step(Some((m,t)),true,t),Some(m));
assert_eq!(p.step(None,true,t+Duration::from_millis(249)),None);
assert_eq!(p.step(None,true,t+REFRESH),Some(m));
assert_eq!(p.step(Some((Motors::default(),t)),true,t+REFRESH),Some(Motors::default()));
assert_eq!(p.step(Some((m,t)),true,t),Some(m));
assert_eq!(p.step(None,false,t),Some(Motors::default()));
assert_eq!(p.step(None,true,t),None);
assert_eq!(p.step(Some((m,t)),true,t+Duration::from_millis(501)),None);
p.step(Some((m,t)),true,t);
assert_eq!(p.step(Some((Motors::default(),t)),true,t+Duration::from_secs(5)),Some(Motors::default()));
}
}
+12 -6
View File
@@ -44,6 +44,8 @@ pub struct Observed {
pub struct Peer {
clipboard:super::clipboard::Bridge,
pub tools:super::tools::Inbox,
pub rumble:super::native_rumble::Feedback,
pub cursor:super::cursor::State,
pub pc:Arc<RTCPeerConnection>,
pub channels:Vec<Arc<RTCDataChannel>>,
pub observed:Arc<Observed>,
@@ -78,6 +80,8 @@ impl Peer {
let api=APIBuilder::new().with_media_engine(engine).with_setting_engine(settings).with_interceptor_registry(registry).build();
let pc=Arc::new(api.new_peer_connection(config).await.map_err(|e|format!("Peer creation failed: {}",crate::auth::transport_error(&e)))?);
let tools:super::tools::Inbox=Arc::new(std::sync::Mutex::new(None));
let rumble=super::native_rumble::Feedback::default();
let cursor=super::cursor::State::default();
let inbox=tools.clone();
pc.on_peer_connection_state_change(Box::new(move |state|{
use webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState;
@@ -197,15 +201,17 @@ impl Peer {
}
})));
}
let closed=tools.clone();let state=observed.clone();
channel.on_close(Box::new(move ||{let closed=closed.clone();let state=state.clone();Box::pin(async move {
if index==0 {state.control_open.store(false,Ordering::Release);}
let closed=tools.clone();let state=observed.clone();let rumble_closed=rumble.clone();
channel.on_close(Box::new(move ||{let closed=closed.clone();let state=state.clone();let rumble_closed=rumble_closed.clone();Box::pin(async move {
if index==0 {state.control_open.store(false,Ordering::Release);rumble_closed.set_active(false);}
if [0,3,4].contains(&index){closed.lock().unwrap().take();}
})}));
let state=observed.clone();let inbox=tools.clone();let clipboard_tx=clipboard.sender();
let feedback=rumble.clone();let pointer=cursor.clone();
let control_for_echo=if index==0 {Arc::downgrade(&channel)} else {std::sync::Weak::new()};
channel.on_message(Box::new(move |message| {let state=state.clone();let inbox=inbox.clone();let control_for_echo=control_for_echo.clone();let clipboard_tx=clipboard_tx.clone();Box::pin(async move {
channel.on_message(Box::new(move |message| {let state=state.clone();let inbox=inbox.clone();let control_for_echo=control_for_echo.clone();let clipboard_tx=clipboard_tx.clone();let feedback=feedback.clone();let pointer=pointer.clone();Box::pin(async move {
if index==0 {
feedback.receive(&message.data);pointer.receive(&message.data);
let (codecs,chroma)=wire::media_control(&message.data);
if let Some(codecs)=codecs {state.encoder_codecs.store(codecs,Ordering::Release);}
if let Some(chroma)=chroma {
@@ -253,7 +259,7 @@ impl Peer {
Ok::<_,String>((channels,tools,clipboard))
}.await;
match result {
Ok((channels,tools,clipboard))=>Ok(Self{clipboard,tools,pc,channels,observed,desktop,audio,answered:false,early:Vec::new(),app_id:app_id.into(),ice_id:ice_id.into(),remote_client:remote_client.into()}),
Ok((channels,tools,clipboard))=>Ok(Self{clipboard,tools,rumble,cursor,pc,channels,observed,desktop,audio,answered:false,early:Vec::new(),app_id:app_id.into(),ice_id:ice_id.into(),remote_client:remote_client.into()}),
Err(e)=>{let _=pc.close().await;Err(e)},
}
}
@@ -329,7 +335,7 @@ impl Peer {
let rtt=(pair.current_round_trip_time>0.).then(||(pair.current_round_trip_time*1000.).round() as u32);
(rtt,format!("{} · {}",if tcp{"TCP"}else{"UDP"},if relay{"relay"}else{"direct"}))
}
pub async fn close(&self) {self.clipboard.stop();self.tools.lock().unwrap().take();let _=self.pc.close().await;}
pub async fn close(&self) {self.rumble.set_active(false);self.clipboard.stop();self.tools.lock().unwrap().take();let _=self.pc.close().await;}
}
fn answer_sdp(body:&Value)->Result<String,String> {
if let Some(s)=body.get("sdp").and_then(Value::as_str) {if s.len()<=1024*1024{return Ok(s.into())}}
+143 -15
View File
@@ -1,7 +1,7 @@
use super::{desktop::{Frame,FrameSink},input::{Input,Viewport},session::Session};
use sdl2::{event::{Event,WindowEvent},mouse::MouseButton,pixels::PixelFormatEnum,rect::Rect};
#[derive(Debug)] enum Command { Files, Type }
pub struct Window { canvas:sdl2::render::Canvas<sdl2::video::Window>, events:sdl2::EventPump, _sdl:sdl2::Sdl, frame:(u32,u32), focused:bool, files:bool, mac:bool,
pub struct Window {cursor:super::cursor::Display,canvas:sdl2::render::Canvas<sdl2::video::Window>, events:sdl2::EventPump, _sdl:sdl2::Sdl, frame:(u32,u32), focused:bool, files:bool, mac:bool,
clipboard:sdl2::clipboard::ClipboardUtil, clipboard_dirty:bool, clipboard_tx:tokio::sync::mpsc::Sender<super::clipboard::ClipboardRequest>, clipboard_requests:tokio::sync::mpsc::Receiver<super::clipboard::ClipboardRequest>,
pub last_frame:Option<Frame>, chrome:Chrome }
/// In-window chrome state (src/viewer/hud.rs): menu, network panel, loading screen.
@@ -19,6 +19,9 @@ impl Window {
let name=super::device_label(std::env::var("UU_VIEWER_DEVICE_NAME").ok().as_deref()).to_owned();
let window=video.window(&format!("{name} · {}",crate::i18n::s("UU 远程 Linux 控制端","UU Remote Linux viewer")),1280,720).position_centered().resizable().build().map_err(|_|"Window creation failed")?;
let mut canvas=window.into_canvas().build().map_err(|_|"Renderer creation failed")?;
// This window forwards scancodes, not SDL_TEXTINPUT. SDL enables text input by
// default; its X11 IME path can consume keys before KeyDown/KeyUp (#149).
video.text_input().stop();
// Wayland maps a toplevel only after its first buffer; without this the window stays
// invisible until the first decoded frame, which a stalled stream never delivers.
canvas.set_draw_color(LOADING_BG);canvas.clear();canvas.present();
@@ -29,10 +32,18 @@ impl Window {
title:crate::tr!("正在连接 {name}","Connecting to {name}"),stage:crate::i18n::s("正在连接远端设备…","Contacting the remote device…").into(),labels:Default::default(),menu_cache:None};
let events=sdl.event_pump()?;let clipboard=video.clipboard();
let(clipboard_tx,clipboard_requests)=tokio::sync::mpsc::channel(16);
Ok(Self{canvas,events,_sdl:sdl,frame:(1920,1080),focused:true,files:false,mac:false,clipboard,clipboard_dirty:true,clipboard_tx,clipboard_requests,last_frame:None,chrome})
Ok(Self{cursor:super::cursor::Display::new(),canvas,events,_sdl:sdl,frame:(1920,1080),focused:true,files:false,mac:false,clipboard,clipboard_dirty:true,clipboard_tx,clipboard_requests,last_frame:None,chrome})
}
pub fn clipboard_bridge(&self)->super::clipboard::Bridge{super::clipboard::Bridge::sdl(self.clipboard_tx.clone())}
pub fn set_mac(&mut self,mac:bool){self.mac=mac;}
fn sync_cursor(&mut self,state:&super::cursor::State){
let mouse=self.events.mouse_state();let(x,y)=(mouse.x() as f64,mouse.y() as f64);let v=self.viewport();
let tab=hud::tab_rect(self.chrome.font.as_ref(),self.canvas.window().size(),self.chrome.scale);
let active=self.focused&&self.canvas.window().has_mouse_focus()&&!self.chrome.menu.open
&&x>=v.x&&y>=v.y&&x<v.x+v.width&&y<v.y+v.height
&&!(self.tab_visible()&&tab.contains(x as f32,y as f32));
self.cursor.update(state.take(),active);
}
fn viewport(&self)->Viewport {
let window=self.canvas.window().size();
if !self.chrome.state.one_to_one {return Viewport::fit(window,self.frame)}
@@ -342,7 +353,13 @@ fn translate_actions(events:impl IntoIterator<Item=Event>,input:&mut Input,viewp
if !repeat{*files=true;messages.extend(input.release_all());}None
},
_ if !*focused || !input.enabled()=>None,
Event::KeyDown{scancode:Some(s),repeat:false,..}=>input.key(s as i32,true),
Event::KeyDown{scancode:Some(s),keymod,repeat:false,..}=>{
// FocusLost releases remote keys, while a modifier may remain physically held.
// SDL_Keysym.mod is the event-time snapshot: restore it before the next key,
// without querying the final state of a whole polled batch or typing text.
if !(224..=231).contains(&(s as i32)){messages.extend(sync_modifiers(input,keymod));}
input.key(s as i32,true)
},
Event::KeyUp{scancode:Some(s),..}=>input.key(s as i32,false),
Event::MouseMotion{x,y,..}=>viewport.motion(x as f64,y as f64),
Event::MouseButtonDown{mouse_btn,..}=>button(mouse_btn).and_then(|b|input.button(b,true)),
@@ -363,6 +380,18 @@ fn translate_actions(events:impl IntoIterator<Item=Event>,input:&mut Input,viewp
} (quit,messages)
}
fn sync_modifiers(input:&mut Input,keymod:sdl2::keyboard::Mod)->Vec<serde_json::Value>{
use sdl2::keyboard::Mod as M;
let modifiers=[(224,M::LCTRLMOD),(225,M::LSHIFTMOD),(226,M::LALTMOD),(227,M::LGUIMOD),
(228,M::RCTRLMOD),(229,M::RSHIFTMOD),(230,M::RALTMOD),(231,M::RGUIMOD)];
let mut out=Vec::new();
// Release stale modifiers before pressing new ones. Input deduplicates transitions.
// Caps/Num/Scroll Lock and MODE are not physical held modifiers.
for down in [false,true]{for (scan,flag) in modifiers{
if keymod.contains(flag)==down{out.extend(input.key(scan,down));}
}}out
}
fn needs_redraw(event:&Event)->bool{
matches!(event,Event::Window{win_event:WindowEvent::SizeChanged(..)|WindowEvent::Resized(..)|WindowEvent::Exposed|WindowEvent::Maximized|WindowEvent::Restored,..})
}
@@ -399,6 +428,10 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
}
Err(e)=>{ log::warn!("Type IPC not started: {e}"); None }
};
let mut native_gamepad=if super::native_gamepad::enabled(){
if window.mac{return Err(crate::i18n::s("原生手柄实验仅支持 Windows 被控端","Native gamepad experiment requires a Windows host").into())}
Some(super::native_gamepad::NativeGamepad::new(&window._sdl,session.peer.rumble.clone())?)
}else{None};
let mut command_open=true;let mut requested=false;let mut type_requested=false;let mut restored=false;
let mut type_job:Option<TypeJob>=None;
let mut terminate=tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()).map_err(|_|"Cannot watch termination")?;
@@ -471,6 +504,7 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
_=tick.tick()=>{
if let Some(playback)=audio.as_mut(){if playback.pump().is_err(){log::warn!("Viewer audio playback stopped");audio=None;}}
let (quit,mut messages)=window.poll(&mut input);
window.sync_cursor(&session.peer.cursor);
if !window.has_picture() {window.loading_frame(false);}
if !restored && session.peer.ready(super::rtc::ReadyPolicy::EchoOnly,false) {restored=true;window.restore_remote_settings();}
for command in window.take_commands() {
@@ -537,27 +571,28 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
type_job=None;
}
}
if let Some(pad)=native_gamepad.as_mut(){
let active=!quit&&window.focused&&input.enabled()&&!window.chrome.menu.open&&type_job.is_none()
&&session.peer.ready(super::rtc::ReadyPolicy::EchoOnly,false)
&&session.peer.observed.control_open.load(std::sync::atomic::Ordering::Acquire)
&&session.peer.pc.connection_state()==webrtc::peer_connection::peer_connection_state::RTCPeerConnectionState::Connected;
messages.extend(pad.poll(active));
}
if session.peer.ready(super::rtc::ReadyPolicy::EchoOnly,false){for m in messages{session.peer.send_input(&m).await?;}}
else {input.release_all();}
if quit{return Ok(())}
// At most one AU per iteration keeps local event polling responsive.
if let Some(au)=session.peer.desktop.units.pop(){
if session.peer.desktop.reset.swap(false,std::sync::atomic::Ordering::AcqRel){decoder.reset();key_gate.arm();}
if !key_gate.admit(au.codec,&au.data) {session.peer.desktop.pli.store(true,std::sync::atomic::Ordering::Release);super::desktop::drain(decoder,window)?;}
else {
decoder.set_codec(au.codec)?;
codec_name=if au.codec==super::media::Codec::H265 {"H.265"} else {"H.264"};
super::desktop::display(decoder,window,&au.data,au.codec,&session.peer.desktop.pli)?;
}}
// A picture can finish after its access unit was written; show it without waiting
// for the next one (a single keystroke may change the remote screen only once).
else {super::desktop::drain(decoder,window)?;}
if let Some(codec)=super::desktop::pump(&session.peer.desktop,decoder,window,&mut key_gate)? {
codec_name=if codec==super::media::Codec::H265 {"H.265"} else {"H.264"};
}
}
}}
}.await;
if let Some(frame)=window.last_frame.as_ref() {if let Err(e)=super::thumbs::save(device,frame){log::debug!("Viewer thumbnail not saved: {e}");}}
#[cfg(uu_gtk)] if let Some(f)=files {f.abort();let _=f.await;super::tools_ui::hide();session.peer.tools.lock().unwrap().take();}
if let Some(t)=type_ipc {t.abort();let _=t.await;}
if let Some(pad)=native_gamepad.as_mut(){for m in pad.close(){
let _=tokio::time::timeout(std::time::Duration::from_millis(300),session.peer.send_input(&m)).await;
}}
for m in input.release_all(){let _=session.peer.send_input(&m).await;}
result
}
@@ -701,8 +736,101 @@ async fn pump_type_job(job: &mut TypeJob, session: &mut Session, window: &mut Wi
}
}
#[cfg(test)] mod modifier_tests {
use super::*;
use sdl2::keyboard::{Scancode as S,Mod as M};
fn key(scan:S,down:bool,mods:M)->Event{
if down{Event::KeyDown{timestamp:0,window_id:1,keycode:None,scancode:Some(scan),keymod:mods,repeat:false}}
else{Event::KeyUp{timestamp:0,window_id:1,keycode:None,scancode:Some(scan),keymod:mods,repeat:false}}
}
fn focus(event:WindowEvent)->Event{Event::Window{timestamp:0,window_id:1,win_event:event}}
fn send(input:&mut Input,focused:&mut bool,events:impl IntoIterator<Item=Event>)->Vec<serde_json::Value>{
translate(events,input,Viewport::fit((800,600),(1920,1080)),focused).1
}
fn codes(messages:&[serde_json::Value])->Vec<(&str,i64)>{
messages.iter().map(|m|(m["action"].as_str().unwrap(),m["key"].as_i64().unwrap())).collect()
}
#[test] fn held_left_and_right_modifiers_recover_after_focus_return(){
for mac in [false,true]{for (scan,flag) in [(S::LCtrl,M::LCTRLMOD),(S::LShift,M::LSHIFTMOD),
(S::LAlt,M::LALTMOD),(S::LGui,M::LGUIMOD),(S::RCtrl,M::RCTRLMOD),(S::RShift,M::RSHIFTMOD),
(S::RAlt,M::RALTMOD),(S::RGui,M::RGUIMOD)]{
let code=|scan:S|i64::from(if mac{super::super::input::mac_keycode(scan as i32)}else{super::super::input::windows_vk(scan as i32)}.unwrap());
let mut input=Input::default();input.set_mac(mac);let mut focused=true;
let out=send(&mut input,&mut focused,[key(scan,true,flag),focus(WindowEvent::FocusLost)]);
assert_eq!(codes(&out),vec![("kbd_press",code(scan)),("kbd_release",code(scan))]);
assert!(!focused);
let out=send(&mut input,&mut focused,[focus(WindowEvent::FocusGained),key(S::Num2,true,flag),
key(S::Num2,false,flag),key(scan,false,M::NOMOD)]);
assert_eq!(codes(&out),vec![("kbd_press",code(scan)),("kbd_press",code(S::Num2)),
("kbd_release",code(S::Num2)),("kbd_release",code(scan))]);
assert!(input.release_all().is_empty());
}}
}
#[test] fn combined_snapshot_releases_stale_modifiers_before_new_chord(){
let mut input=Input::default();input.set_mac(true);let mut focused=true;
send(&mut input,&mut focused,[key(S::LShift,true,M::LSHIFTMOD),key(S::RGui,true,M::LSHIFTMOD|M::RGUIMOD)]);
let mods=M::RSHIFTMOD|M::LCTRLMOD|M::LALTMOD;
let out=send(&mut input,&mut focused,[key(S::A,true,mods),key(S::A,false,mods),
key(S::B,true,M::NOMOD),key(S::B,false,M::NOMOD)]);
assert_eq!(codes(&out),vec![("kbd_release",56),("kbd_release",54),
("kbd_press",59),("kbd_press",58),("kbd_press",60),("kbd_press",0),("kbd_release",0),
("kbd_release",59),("kbd_release",58),("kbd_release",60),("kbd_press",11),("kbd_release",11)]);
assert!(input.release_all().is_empty());
}
#[test] fn complete_chords_and_overlapping_letters_are_not_duplicated(){
let mut input=Input::default();input.set_mac(true);let mut focused=true;
let mods=M::LSHIFTMOD|M::RSHIFTMOD;
let out=send(&mut input,&mut focused,[key(S::LShift,true,M::LSHIFTMOD),key(S::RShift,true,mods),
key(S::A,true,mods),key(S::B,true,mods),key(S::A,false,mods),key(S::LShift,false,M::RSHIFTMOD),
key(S::B,false,M::RSHIFTMOD),key(S::RShift,false,M::NOMOD)]);
assert_eq!(codes(&out),vec![("kbd_press",56),("kbd_press",60),("kbd_press",0),("kbd_press",11),
("kbd_release",0),("kbd_release",56),("kbd_release",11),("kbd_release",60)]);
assert!(input.release_all().is_empty());
}
#[test] fn snapshot_is_event_time_and_does_not_create_lock_or_view_only_keys(){
let mut input=Input::default();let mut focused=true;
let out=send(&mut input,&mut focused,[key(S::Num2,true,M::LSHIFTMOD|M::CAPSMOD|M::NUMMOD|M::MODEMOD),
key(S::Num2,false,M::LSHIFTMOD),key(S::A,true,M::NOMOD),key(S::A,false,M::NOMOD)]);
assert_eq!(codes(&out),vec![("kbd_press",0xa0),("kbd_press",0x32),("kbd_release",0x32),
("kbd_release",0xa0),("kbd_press",0x41),("kbd_release",0x41)]);
for watch in [false,true]{
let mut input=Input::new(watch);let mut focused=false;
assert!(send(&mut input,&mut focused,[key(S::A,true,M::LSHIFTMOD)]).is_empty());
if watch{assert!(send(&mut input,&mut focused,[focus(WindowEvent::FocusGained),key(S::A,true,M::LSHIFTMOD)]).is_empty());}
assert!(input.release_all().is_empty());
}
}
}
#[cfg(test)] mod tests {
use super::*;
#[cfg_attr(target_os="macos",ignore)]
#[test] fn remote_window_disables_local_text_input_and_forwards_shift(){
if std::env::var_os("UU_VIEWER_IME_TEST_CHILD").is_none(){
let output=std::process::Command::new(std::env::current_exe().unwrap())
.args(["--exact","viewer::sdl::tests::remote_window_disables_local_text_input_and_forwards_shift","--test-threads=1"])
.env("SDL_VIDEODRIVER","dummy").env("UU_VIEWER_IME_TEST_CHILD","1").output().unwrap();
assert!(output.status.success(),"{}{}",String::from_utf8_lossy(&output.stdout),String::from_utf8_lossy(&output.stderr));return
}
let mut window=Window::new().unwrap();
assert!(!window.canvas.window().subsystem().text_input().is_active());
let id=window.canvas.window().id();
let key=|down,scan|if down {
Event::KeyDown{timestamp:0,window_id:id,keycode:None,scancode:Some(scan),keymod:sdl2::keyboard::Mod::NOMOD,repeat:false}
}else{
Event::KeyUp{timestamp:0,window_id:id,keycode:None,scancode:Some(scan),keymod:sdl2::keyboard::Mod::NOMOD,repeat:false}
};
let push=|event|window._sdl.event().unwrap().push_event(event).unwrap();
use sdl2::keyboard::Scancode as S;
for event in [key(true,S::LShift),key(false,S::LShift),key(true,S::A),key(false,S::A),
key(true,S::RShift),Event::Window{timestamp:0,window_id:id,win_event:WindowEvent::FocusLost},
Event::Window{timestamp:0,window_id:id,win_event:WindowEvent::FocusGained}] {push(event);}
let (_,messages)=window.poll(&mut Input::new(false));
let keys:Vec<_>=messages.iter().filter_map(|m|Some((m.get("action")?.as_str()?,m.get("key")?.as_i64()?))).collect();
assert_eq!(keys,vec![("kbd_press",0xa0),("kbd_release",0xa0),("kbd_press",0x41),("kbd_release",0x41),
("kbd_press",0xa1),("kbd_release",0xa1)]);
assert!(!window.canvas.window().subsystem().text_input().is_active());
}
// macOS: SDL video must start on the main thread, which the test harness does not use; CI runs it on Linux.
#[cfg_attr(target_os="macos",ignore)]
#[tokio::test] async fn clipboard_requests_use_existing_window(){
+20 -2
View File
@@ -250,12 +250,14 @@ async fn desktop_file_window_reattaches_without_replacing_peer(){
let mut engine=MediaEngine::default();engine.register_default_codecs().unwrap();
let host=Arc::new(APIBuilder::new().with_media_engine(engine).with_setting_engine(host_settings).build().new_peer_connection(RTCConfiguration::default()).await.unwrap());
let file:Arc<std::sync::Mutex<Option<Arc<webrtc::data_channel::RTCDataChannel>>>>=Default::default();
let control:Arc<std::sync::Mutex<Option<Arc<webrtc::data_channel::RTCDataChannel>>>>=Default::default();
let control_out=control.clone();
let(tx,mut received)=mpsc::channel(32);
let opened=Arc::new(AtomicUsize::new(0));let count=opened.clone();
host.on_data_channel(Box::new(move|channel|{let(tx,file,count)=(tx.clone(),file.clone(),count.clone());Box::pin(async move{
host.on_data_channel(Box::new(move|channel|{let(tx,file,count,control)=(tx.clone(),file.clone(),count.clone(),control.clone());Box::pin(async move{
count.fetch_add(1,Ordering::Relaxed);
if channel.label()==wire::CHANNELS[tools::FILE]{*file.lock().unwrap()=Some(channel.clone());}
if channel.label()==wire::CHANNELS[tools::CONTROL]{channel.on_message(Box::new(move|m|{
if channel.label()==wire::CHANNELS[tools::CONTROL]{*control.lock().unwrap()=Some(channel.clone());channel.on_message(Box::new(move|m|{
let(tx,file)=(tx.clone(),file.clone());Box::pin(async move{
if let Some(r)=tools::blob(&m.data,21){
if tools::blob(r,8).and_then(|b|tools::blob(b,10)).is_some(){
@@ -277,6 +279,7 @@ async fn desktop_file_window_reattaches_without_replacing_peer(){
peer.pc.set_remote_description(host.local_description().await.unwrap()).await.unwrap();
while opened.load(Ordering::Relaxed)!=5 || peer.channels.iter().any(|c|c.ready_state()!=webrtc::data_channel::data_channel_state::RTCDataChannelState::Open){tokio::time::sleep(Duration::from_millis(10)).await;}
let pc=peer.pc.clone();
peer.rumble.set_active(true);
for _ in 0..2{
let(io,rx)=tools::attach(&peer).unwrap();assert!(tools::attach(&peer).is_err());
let(f,_)=Files::new(io,rx);assert!(f.list_dir(":/").await.unwrap().is_empty());drop(f);
@@ -284,6 +287,21 @@ async fn desktop_file_window_reattaches_without_replacing_peer(){
assert!(Arc::ptr_eq(&pc,&peer.pc));
let heartbeat=super::input::Input::heartbeat();peer.send_input(&heartbeat).await.unwrap();
loop{if serde_json::from_slice::<Value>(&received.recv().await.unwrap()).ok()==Some(heartbeat.clone()){break}}
// Native gamepad shares CONTROL and must not open a new channel/peer.
use super::native_gamepad::{self,State};
for message in [native_gamepad::connect(),State{buttons:0x1000,..Default::default()}.json(),
State::default().json(),native_gamepad::disconnect()] {
peer.send_input(&message).await.unwrap();
loop {if serde_json::from_slice::<Value>(&received.recv().await.unwrap()).ok()==Some(message.clone()){break}}
}
// Host feedback shares the same peer/channel; file detach must not steal it.
let control=control_out.lock().unwrap().clone().unwrap();
for (left,right) in [(255u8,128u8),(0,0)] {
let feedback=json!({"action":"gpd_vibration","index":0,"left_motor":left,"right_motor":right});
control.send(&bytes::Bytes::from(feedback.to_string())).await.unwrap();
let received=loop {if let Some((m,_))=peer.rumble.take(){break m}tokio::time::sleep(Duration::from_millis(5)).await;};
assert_eq!(received,super::native_rumble::Motors{left:u16::from(left)*257,right:u16::from(right)*257});
}
}
assert_eq!(opened.load(Ordering::Relaxed),5);
peer.close().await;host.close().await.unwrap();router.lock().await.stop().await.unwrap();
+1 -1
View File
@@ -32,7 +32,7 @@ fn watch_session(mut child: tokio::process::Child, mut cancel: tokio::sync::ones
}
status = child.wait() => break status,
line = async { match lines.as_mut() { Some(l) => l.next_line().await, None => std::future::pending().await } } => match line {
Ok(Some(l)) => { if !l.starts_with('[') && !l.trim().is_empty() { last = l.chars().take(160).collect(); } }
Ok(Some(l)) => { if l.starts_with("DECKPAD_"){eprintln!("{l}");} else if !l.starts_with('[') && !l.trim().is_empty() { last = l.chars().take(160).collect(); } }
_ => lines = None,
},
}
+473
View File
@@ -0,0 +1,473 @@
//! Official device-card background reporting. Protocol evidence: docs/wallpaper-protocol.md.
use std::{path::PathBuf, sync::Arc, time::Duration};
use sha2::{Digest, Sha256};
use tokio::io::AsyncReadExt;
use crate::auth::UUAuthClient;
const LIMIT: usize = 10 * 1024 * 1024;
const TIMEOUT: Duration = Duration::from_secs(20);
pub fn start(auth: Arc<UUAuthClient>) -> tokio::task::AbortHandle {
tokio::spawn(async move {
if auth.creds.user_id.is_empty() || crate::desktop_backend::headless()
|| std::env::var("UU_WALLPAPER_UPLOAD").as_deref() == Ok("0") { return; }
let mut previous = None;
loop {
if let Some(path) = source().await {
match read_image(&path).await {
Ok(image) => {
let hash = Sha256::digest(&image).to_vec();
if previous.as_ref() != Some(&hash) {
match publish(&auth, image).await {
Ok(()) => { previous = Some(hash); log::info!("Device wallpaper synchronized"); }
Err(stage) => log::warn!("Device wallpaper synchronization failed: stage={stage}; will retry"),
}
}
}
Err(()) => log::debug!("Device wallpaper unavailable or unsupported"),
}
}
tokio::time::sleep(Duration::from_secs(60)).await;
}
}).abort_handle()
}
async fn command(program: &str, args: &[&str]) -> Option<String> {
let output = tokio::time::timeout(Duration::from_secs(3), tokio::process::Command::new(program)
.args(args).kill_on_drop(true).output()).await.ok()?.ok()?;
output.status.success().then(|| String::from_utf8(output.stdout).ok()).flatten()
}
async fn kde_config(programs: &[&str], args: &[&str]) -> Option<String> {
for program in programs {
if let Some(value) = command(program, args).await { return Some(value); }
}
None
}
async fn source() -> Option<PathBuf> {
if let Some(path) = std::env::var_os("UU_WALLPAPER") {
let path = PathBuf::from(path); return path.is_absolute().then_some(path);
}
let desktop = std::env::var("XDG_CURRENT_DESKTOP").unwrap_or_default().to_lowercase();
if desktop.split(':').any(|name| name == "hyprland") {
let home = std::env::var_os("HOME").map(PathBuf::from);
let xdg = |name, fallback| std::env::var_os(name).map(PathBuf::from)
.filter(|p| p.is_absolute()).or_else(|| home.as_ref().map(|p| p.join(fallback)));
return omarchy_background(xdg("XDG_STATE_HOME", ".local/state").as_deref(),
xdg("XDG_CONFIG_HOME", ".config").as_deref()).await;
}
if desktop.contains("gnome") || desktop.contains("unity") || desktop.contains("cinnamon") {
let schema = if desktop.contains("cinnamon") { "org.cinnamon.desktop.background" } else { "org.gnome.desktop.background" };
if schema == "org.gnome.desktop.background" && command("gsettings", &["get", "org.gnome.desktop.interface", "color-scheme"])
.await.is_some_and(|v| v.contains("prefer-dark")) {
if let Some(path) = command("gsettings", &["get", schema, "picture-uri-dark"]).await.and_then(|v| gsettings_path(&v)) { return Some(path); }
}
return command("gsettings", &["get", schema, "picture-uri"]).await.and_then(|v| gsettings_path(&v));
}
if desktop.contains("kde") {
let config = std::env::var_os("XDG_CONFIG_HOME").map(PathBuf::from)
.filter(|p| p.is_absolute()).or_else(|| std::env::var_os("HOME").map(|h| PathBuf::from(h).join(".config")))?;
let text = tokio::fs::read_to_string(config.join("plasma-org.kde.plasma.desktop-appletsrc")).await.unwrap_or_default();
if let Some(path) = kde_image(&text) { return package_image(path).await; }
// Plasma omits Image for the look-and-feel's default wallpaper.
if !kde_default_allowed(&text) { return None; }
let readers = ["kreadconfig6", "kreadconfig5"];
let theme = kde_config(&readers, &["--file", "kdeglobals", "--group", "KDE", "--key", "LookAndFeelPackage"])
.await.unwrap_or_default();
let theme = if theme.trim().is_empty() { "org.kde.breeze.desktop" } else { theme.trim() };
if theme.contains('/') || theme.contains("..") { return None; }
let defaults = format!("/usr/share/plasma/look-and-feel/{theme}/contents/defaults");
let image = kde_config(&readers, &["--file", &defaults, "--group", "Wallpaper", "--key", "Image"]).await?;
let image = image.trim();
if image.is_empty() || image.contains('/') || image.contains("..") { return None; }
return package_image(PathBuf::from("/usr/share/wallpapers").join(image)).await;
}
if desktop.contains("xfce") {
let text = command("xfconf-query", &["-c", "xfce4-desktop", "-lv"]).await?;
for line in text.lines() {
if let Some((key, value)) = line.trim().split_once(char::is_whitespace) {
if key.ends_with("/last-image") { if let Some(path) = local_path(value) { return Some(path); } }
}
}
}
None
}
// Omarchy maintains this link when changing wallpaper/theme. Prefer its current
// XDG state location, while supporting older installations using XDG config.
async fn omarchy_background(state: Option<&std::path::Path>, config: Option<&std::path::Path>) -> Option<PathBuf> {
for root in [state, config].into_iter().flatten() {
let path = root.join("omarchy/current/background");
if tokio::fs::metadata(&path).await.is_ok_and(|meta| meta.is_file()) { return Some(path); }
}
None
}
async fn package_image(path: PathBuf) -> Option<PathBuf> {
if tokio::fs::metadata(&path).await.ok()?.is_file() { return Some(path); }
let mut entries = tokio::fs::read_dir(path.join("contents/images")).await.ok()?;
let mut candidates = Vec::new();
while let Some(entry) = entries.next_entry().await.ok()? {
if !tokio::fs::metadata(entry.path()).await.is_ok_and(|meta| meta.is_file()) { continue; }
let path = entry.path();
let Some((w,h)) = path.file_stem().and_then(|s| s.to_str()).and_then(|s| s.split_once('x'))
.and_then(|(w,h)| Some((w.parse::<u32>().ok()?,h.parse::<u32>().ok()?))) else { continue; };
candidates.push(((w < h, u64::from(w) * u64::from(h)), path));
}
candidates.sort_by_key(|(score, _)| *score);
candidates.into_iter().next().map(|(_, path)| path)
}
fn kde_image(text: &str) -> Option<PathBuf> {
let plugins = kde_plugins(text);
let mut image_section = false;
for line in text.lines().map(str::trim) {
if line.starts_with('[') {
image_section = line.strip_prefix("[Containments][").and_then(|s| s.split_once(']'))
.is_some_and(|(id, section)| section == "[Wallpaper][org.kde.image][General]"
&& plugins.get(id).map_or(true, |plugin| *plugin == KdeWallpaper::Image));
}
if image_section { if let Some(value) = line.strip_prefix("Image=") { if let Some(path) = local_path(value) { return Some(path); } } }
}
None
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum KdeWallpaper { Image, Unsupported }
fn kde_plugins(text: &str) -> std::collections::HashMap<&str, KdeWallpaper> {
let mut containment = None;
let mut plugins = std::collections::HashMap::new();
let mut panels = Vec::new();
for line in text.lines().map(str::trim) {
if line.starts_with('[') {
containment = line.strip_prefix("[Containments][").and_then(|s| s.split_once(']'))
.filter(|(_, section)| section.is_empty()).map(|(id, _)| id);
}
if let Some(id) = containment {
plugins.entry(id).or_insert(KdeWallpaper::Image);
if line.strip_prefix("plugin=").is_some_and(|plugin| plugin.trim() == "org.kde.panel") { panels.push(id); }
if let Some(plugin) = line.strip_prefix("wallpaperplugin=") {
plugins.insert(id, if plugin.trim() == "org.kde.image" { KdeWallpaper::Image } else { KdeWallpaper::Unsupported });
}
}
}
// Panels can keep an image wallpaper setting, but do not supply a desktop background.
for id in panels { plugins.insert(id, KdeWallpaper::Unsupported); }
plugins
}
fn kde_default_allowed(text: &str) -> bool {
let plugins = kde_plugins(text);
if !plugins.is_empty() { return plugins.values().any(|plugin| *plugin == KdeWallpaper::Image); }
!text.contains("[Wallpaper][") || text.contains("[Wallpaper][org.kde.image]")
}
fn gsettings_path(value: &str) -> Option<PathBuf> {
// gsettings prints a GVariant string, with either quote style and C/Unicode escapes.
// https://docs.gtk.org/glib/gvariant-text-format.html#strings
let mut chars = value.trim().chars();
let quote = chars.next()?;
if quote != '\'' && quote != '"' { return None; }
let mut decoded = String::new();
while let Some(ch) = chars.next() {
if ch == quote { return chars.as_str().is_empty().then(|| local_path(&decoded)).flatten(); }
if ch != '\\' { decoded.push(ch); continue; }
let escaped = chars.next()?;
decoded.push(match escaped {
'a' => '\x07', 'b' => '\x08', 'f' => '\x0c', 'n' => '\n',
'r' => '\r', 't' => '\t', 'v' => '\x0b', '\\' => '\\', '\'' => '\'', '"' => '"',
'u' | 'U' => {
let mut code = 0u32;
for _ in 0..if escaped == 'u' { 4 } else { 8 } { code = u32::checked_add(code.checked_mul(16)?, chars.next()?.to_digit(16)?)?; }
char::from_u32(code).filter(|c| *c != '\0')?
}
'\n' => continue,
_ => escaped,
});
}
None
}
fn local_path(value: &str) -> Option<PathBuf> {
let value = value.trim();
let path = if value.starts_with("file:") {
let url = reqwest::Url::parse(value).ok()?;
if url.query().is_some() || url.fragment().is_some() { return None; }
url.to_file_path().ok()?
} else { PathBuf::from(value) };
path.is_absolute().then_some(path)
}
async fn read_image(path: &std::path::Path) -> Result<Vec<u8>, ()> {
if !tokio::fs::metadata(path).await.map_err(|_| ())?.is_file() { return Err(()); }
let file = tokio::fs::File::open(path).await.map_err(|_| ())?;
if !file.metadata().await.map_err(|_| ())?.is_file() { return Err(()); }
let mut image = Vec::new();
file.take((LIMIT + 1) as u64).read_to_end(&mut image).await.map_err(|_| ())?;
if image.len() > LIMIT || image_type(&image).is_none() { return Err(()); }
Ok(image)
}
fn image_type(image: &[u8]) -> Option<&'static str> {
if image.starts_with(b"\x89PNG\r\n\x1a\n") { Some("image/png") }
else if image.starts_with(b"\xff\xd8\xff") { Some("image/jpeg") }
else if image.starts_with(b"RIFF") && image.get(8..12) == Some(b"WEBP") { Some("image/webp") }
else { None }
}
fn api_data(status: u16, body: &serde_json::Value) -> Result<&serde_json::Value, ()> {
if status != 200 || body.get("code").and_then(|v| v.as_i64()) != Some(0) { return Err(()); }
body.get("data").ok_or(())
}
async fn publish(auth: &UUAuthClient, image: Vec<u8>) -> Result<(), &'static str> {
let http = crate::auth::http_client_builder().redirect(reqwest::redirect::Policy::none()).build().map_err(|_| "http-client")?;
publish_to(auth, image, crate::auth::BASE_URL, &http).await
}
async fn json(request: reqwest::RequestBuilder) -> Result<(u16, serde_json::Value), ()> {
let mut response = request.timeout(TIMEOUT).send().await.map_err(|_| ())?;
let status = response.status().as_u16();
let mut bytes = Vec::new();
while let Some(chunk) = response.chunk().await.map_err(|_| ())? {
if bytes.len() + chunk.len() > 65536 { return Err(()); }
bytes.extend_from_slice(&chunk);
}
Ok((status, serde_json::from_slice(&bytes).map_err(|_| ())?))
}
async fn publish_to(auth: &UUAuthClient, image: Vec<u8>, base: &str, http: &reqwest::Client) -> Result<(), &'static str> {
let path = "/api/v1/tool/fp/token?filetype=1";
let result = json(http.get(format!("{base}{path}")).headers(auth.build_headers("GET", path, ""))).await.map_err(|_| "token-request")?;
let data = api_data(result.0, &result.1).map_err(|_| "token-response")?;
let token = data.get("token").and_then(|v| v.as_str()).filter(|v| !v.is_empty()).ok_or("file-token")?;
let url = data.get("req_url").and_then(|v| v.as_str()).ok_or("upload-url")?;
let url = https_url(url).map_err(|_| "upload-url")?;
let max = data.get("max_size").and_then(|v| v.as_u64()).filter(|n| *n > 0).unwrap_or(LIMIT as u64);
if image.len() as u64 > max { return Err("file-size"); }
// Filepicker takes raw bytes and its own Authorization value, never account headers.
let response = json(http.post(url).header("Authorization", token)
.header("Content-Type", image_type(&image).ok_or("file-type")?).body(image)
).await.map_err(|_| "file-upload")?;
if response.0 != 200 { return Err("file-upload-status"); }
let url = response.1.get("url").and_then(|v| v.as_str()).ok_or("file-response")?;
https_url(url).map_err(|_| "file-response-url")?;
let path = "/api/v1/device/wallpaper";
let body = serde_json::json!({"wallpaper_url": url}).to_string();
let result = json(http.post(format!("{base}{path}")).headers(auth.build_headers("POST", path, &body)).body(body)).await.map_err(|_| "report-request")?;
if result.0 != 200 || result.1.get("code").and_then(|v| v.as_i64()) != Some(0) { return Err("report-response"); }
Ok(())
}
fn https_url(value: &str) -> Result<reqwest::Url, ()> {
let url = reqwest::Url::parse(value).map_err(|_| ())?;
if url.scheme() != "https" || url.host_str().is_none() || !url.username().is_empty() || url.password().is_some() { return Err(()); }
Ok(url)
}
#[cfg(test)]
mod tests {
use super::*;
use tokio::io::AsyncWriteExt;
#[tokio::test]
async fn kde_config_uses_plasma5_when_plasma6_reader_is_unavailable() {
use std::os::unix::fs::PermissionsExt;
let root = std::env::temp_dir().join(format!("uu-kreadconfig-test-{}-{}", std::process::id(), rand::random::<u64>()));
std::fs::create_dir(&root).unwrap();
let five = root.join("kreadconfig5"); let six = root.join("kreadconfig6");
std::fs::write(&five, "#!/bin/sh\ncase \"$*\" in *LookAndFeelPackage*) echo org.kde.breeze.desktop;; *Image*) echo Next;; esac\n").unwrap();
std::fs::set_permissions(&five, std::fs::Permissions::from_mode(0o700)).unwrap();
let readers = [six.to_str().unwrap(), five.to_str().unwrap()];
assert_eq!(kde_config(&readers, &["--key", "LookAndFeelPackage"]).await.as_deref(), Some("org.kde.breeze.desktop\n"));
assert_eq!(kde_config(&readers, &["--key", "Image"]).await.as_deref(), Some("Next\n"));
std::fs::write(&six, "#!/bin/sh\necho Plasma6\n").unwrap();
std::fs::set_permissions(&six, std::fs::Permissions::from_mode(0o700)).unwrap();
assert_eq!(kde_config(&readers, &["--key", "Image"]).await.as_deref(), Some("Plasma6\n"));
std::fs::remove_dir_all(root).unwrap();
}
#[tokio::test]
async fn omarchy_follows_current_wallpaper_links_and_supports_legacy_location() {
use std::os::unix::fs::symlink;
let root = std::env::temp_dir().join(format!("uu-omarchy-{}-{}", std::process::id(), rand::random::<u64>()));
let state = root.join("custom-state");
let config = root.join("custom-config");
for dir in [&state, &config] { std::fs::create_dir_all(dir.join("omarchy/current")).unwrap(); }
let current = state.join("omarchy/current/background");
let legacy = config.join("omarchy/current/background");
let first = root.join("first.png");
let second = root.join("second.jpg");
std::fs::write(&first, b"\x89PNG\r\n\x1a\n").unwrap();
std::fs::write(&second, b"\xff\xd8\xff").unwrap();
symlink(&second, &legacy).unwrap();
let detect = || omarchy_background(Some(&state), Some(&config));
assert_eq!(detect().await, Some(legacy.clone()));
symlink(&first, &current).unwrap();
assert_eq!(detect().await, Some(current.clone()));
assert_eq!(read_image(&detect().await.unwrap()).await.unwrap(), std::fs::read(&first).unwrap());
std::fs::remove_file(&current).unwrap(); symlink(&second, &current).unwrap();
assert_eq!(read_image(&detect().await.unwrap()).await.unwrap(), std::fs::read(&second).unwrap());
std::fs::remove_file(&current).unwrap(); symlink(root.join("missing"), &current).unwrap();
assert_eq!(detect().await, Some(legacy.clone()));
std::fs::remove_file(&current).unwrap(); symlink(&root, &current).unwrap();
assert_eq!(detect().await, Some(legacy.clone()));
std::fs::remove_file(&legacy).unwrap();
assert_eq!(detect().await, None);
std::fs::remove_dir_all(root).unwrap();
}
#[tokio::test]
async fn kde_packages_select_landscape_and_image_reads_are_bounded() {
let root = std::env::temp_dir().join(format!("uu-wallpaper-test-{}-{}", std::process::id(), rand::random::<u64>()));
let images = root.join("contents/images");
std::fs::create_dir_all(&images).unwrap();
for name in ["1440x2960.png", "5120x2880.png", "7680x2160.png"] {
std::fs::write(images.join(name), b"\x89PNG\r\n\x1a\n").unwrap();
}
let image = package_image(root.clone()).await.unwrap();
assert_eq!(image.file_name().unwrap(), "5120x2880.png");
assert_eq!(package_image(image.clone()).await, Some(image.clone()));
assert!(read_image(&image).await.is_ok());
std::fs::write(&image, b"private text is not an image").unwrap();
assert!(read_image(&image).await.is_err());
std::fs::OpenOptions::new().write(true).open(&image).unwrap().set_len((LIMIT + 1) as u64).unwrap();
assert!(read_image(&image).await.is_err());
assert!(read_image(&root).await.is_err());
std::fs::remove_dir_all(root).unwrap();
}
#[tokio::test]
async fn kde_packages_follow_image_symlinks_and_skip_invalid_targets() {
use std::os::unix::fs::symlink;
let root = std::env::temp_dir().join(format!("uu-wallpaper-links-test-{}-{}", std::process::id(), rand::random::<u64>()));
let images = root.join("contents/images");
std::fs::create_dir_all(&images).unwrap();
let target = root.join("shared.png");
std::fs::write(&target, b"\x89PNG\r\n\x1a\n").unwrap();
let image = images.join("1920x1080.png");
symlink("../../shared.png", &image).unwrap();
symlink("../../missing.png", images.join("640x480.png")).unwrap();
symlink(&root, images.join("800x600.png")).unwrap();
assert_eq!(package_image(root.clone()).await, Some(image.clone()));
assert!(read_image(&image).await.is_ok());
std::fs::remove_dir_all(root).unwrap();
}
#[tokio::test]
async fn reporting_protocol_keeps_file_token_separate_and_stops_on_failures() {
use tokio_rustls::{rustls, TlsAcceptor};
use rustls::pki_types::{CertificateDer, PrivateKeyDer, PrivatePkcs8KeyDer};
let cert = rcgen::generate_simple_self_signed(vec!["localhost".into()]).unwrap();
let der = cert.serialize_der().unwrap();
let http = reqwest::Client::builder().no_proxy().redirect(reqwest::redirect::Policy::none())
.add_root_certificate(reqwest::Certificate::from_der(&der).unwrap()).build().unwrap();
let config = rustls::ServerConfig::builder_with_provider(Arc::new(rustls::crypto::ring::default_provider()))
.with_safe_default_protocol_versions().unwrap().with_no_client_auth()
.with_single_cert(vec![CertificateDer::from(der)], PrivateKeyDer::Pkcs8(
PrivatePkcs8KeyDer::from(cert.serialize_private_key_der()))).unwrap();
let acceptor = TlsAcceptor::from(Arc::new(config));
let auth = UUAuthClient::new(crate::auth::Credentials {
token: "fixture-account-token".into(), csrf: "fixture-csrf".into(),
sign_key: "fixture-key".into(), ..Default::default()
});
for scenario in ["success", "token-failed", "too-large", "upload-failed", "report-failed"] {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let base = format!("https://localhost:{}", listener.local_addr().unwrap().port());
let server_base = base.clone(); let acceptor = acceptor.clone();
let steps = match scenario { "token-failed" | "too-large" => 1, "upload-failed" => 2, _ => 3 };
let server = tokio::spawn(async move {
for step in 0..steps {
let (socket, _) = listener.accept().await.unwrap();
let mut tls = acceptor.accept(socket).await.unwrap();
let mut bytes = Vec::new(); let mut byte = [0u8; 1];
while !bytes.ends_with(b"\r\n\r\n") {
tls.read_exact(&mut byte).await.unwrap(); bytes.push(byte[0]); assert!(bytes.len() < 16384);
}
let headers = String::from_utf8(bytes).unwrap().to_lowercase();
let length: usize = headers.lines().find_map(|l| l.strip_prefix("content-length:")
.and_then(|s| s.trim().parse().ok())).unwrap_or(0);
let mut body = vec![0; length]; tls.read_exact(&mut body).await.unwrap();
let (status, reply) = match step {
0 => {
assert!(headers.starts_with("get /api/v1/tool/fp/token?filetype=1 "));
assert!(headers.contains("authorization: bearer fixture-account-token\r\n"));
assert!(headers.contains("x-param-sign:")); assert!(body.is_empty());
(200, serde_json::json!({"code":if scenario=="token-failed" {1120}else{0},
"data":{"token":"fixture-file-token","req_url":format!("{server_base}/upload"),"ttl":60,
"max_size":if scenario=="too-large" {1}else{1024}}}))
}
1 => {
assert!(headers.starts_with("post /upload "));
assert!(headers.contains("authorization: fixture-file-token\r\n"));
for secret in ["fixture-account-token", "fixture-csrf", "cookie:", "x-param-"] { assert!(!headers.contains(secret)); }
assert_eq!(body, b"\x89PNG\r\n\x1a\n");
(if scenario=="upload-failed" {500}else{200}, serde_json::json!({"url":"https://example.invalid/wallpaper.png","fsize":8,"md5":"fixture","mime":"image/png"}))
}
_ => {
assert!(headers.starts_with("post /api/v1/device/wallpaper "));
assert!(headers.contains("authorization: bearer fixture-account-token\r\n"));
assert!(!headers.contains("fixture-file-token"));
assert_eq!(serde_json::from_slice::<serde_json::Value>(&body).unwrap(), serde_json::json!({"wallpaper_url":"https://example.invalid/wallpaper.png"}));
(200, serde_json::json!({"code":if scenario=="report-failed" {1120}else{0}}))
}
};
let reply = reply.to_string();
tls.write_all(format!("HTTP/1.1 {status} Fixture\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{reply}", reply.len()).as_bytes()).await.unwrap();
tls.shutdown().await.unwrap();
}
});
let result = tokio::time::timeout(Duration::from_secs(5), publish_to(&auth, b"\x89PNG\r\n\x1a\n".to_vec(), &base, &http)).await.unwrap();
assert_eq!(result.is_ok(), scenario == "success", "{scenario}");
tokio::time::timeout(Duration::from_secs(5), server).await.unwrap().unwrap();
}
}
#[test] fn wallpaper_sources_are_local_and_scoped() {
assert_eq!(gsettings_path("'file:///usr/share/a%20b.png'"), Some(PathBuf::from("/usr/share/a b.png")));
for value in ["", "relative.png", "https://example.com/a.png", "file://remote/a.png", "file:///tmp/a.png?token=secret"] { assert!(local_path(value).is_none()); }
assert_eq!(kde_image("[Other]\nImage=/wrong.png\n[Containments][2][Wallpaper][org.kde.image][General]\nImage=file:///right.png"), Some(PathBuf::from("/right.png")));
}
#[test] fn gsettings_decodes_quotes_backslashes_and_unicode() {
assert_eq!(gsettings_path("\"file:///tmp/it's.png\""), Some(PathBuf::from("/tmp/it's.png")));
assert_eq!(gsettings_path(r#"'file:///tmp/it\'s.png'"#), Some(PathBuf::from("/tmp/it's.png")));
assert_eq!(gsettings_path(r#"'/tmp/a\\b\t\u00e9\U0001f600.png'"#), Some(PathBuf::from("/tmp/a\\b\té😀.png")));
for value in ["'unterminated", "'/tmp/a' trailing", r#"'/tmp/\uD800'"#, r#"'/tmp/\Uffffffff'"#] { assert!(gsettings_path(value).is_none()); }
assert_eq!(gsettings_path(r#"'/tmp/\x41'"#), Some(PathBuf::from("/tmp/x41")));
assert_eq!(local_path("/tmp/it's.png"), Some(PathBuf::from("/tmp/it's.png")));
}
#[test] fn kde_default_survives_saved_image_settings_but_not_other_plugins() {
let image = "[Containments][1]\nwallpaperplugin=org.kde.image\n[Containments][1][Wallpaper][org.kde.image][General]\nFillMode=1\n";
assert!(kde_image(image).is_none()); assert!(kde_default_allowed(image));
assert!(kde_default_allowed("[Containments][1][Wallpaper][org.kde.image][General]\nFillMode=1"));
assert!(kde_default_allowed(""));
assert!(!kde_default_allowed(&image.replace("wallpaperplugin=org.kde.image", "wallpaperplugin=org.kde.slideshow")));
assert!(!kde_default_allowed("[Containments][1][Wallpaper][org.kde.slideshow][General]\nSlidePaths=/tmp"));
}
#[test] fn kde_stored_images_belong_to_the_same_active_image_containment() {
let stale = "[Containments][1]\nwallpaperplugin=org.kde.slideshow\n[Containments][1][Wallpaper][org.kde.image][General]\nImage=/tmp/previous.png\n";
assert!(kde_image(stale).is_none());
assert!(!kde_default_allowed(stale));
let mixed = format!("{stale}[Containments][2]\nwallpaperplugin=org.kde.image\n[Containments][2][Wallpaper][org.kde.image][General]\nImage=/tmp/current.png\n");
assert_eq!(kde_image(&mixed), Some(PathBuf::from("/tmp/current.png")));
assert_eq!(kde_image(&stale.replace("org.kde.slideshow", "org.kde.image")), Some(PathBuf::from("/tmp/previous.png")));
}
#[test] fn kde_panels_do_not_enable_default_wallpaper_or_supply_saved_images() {
let panel = "[Containments][2]\nwallpaperplugin=org.kde.image\nplugin=org.kde.panel\n[Containments][2][Wallpaper][org.kde.image][General]\nImage=/tmp/panel.png\n";
let slideshow = "[Containments][1]\nplugin=org.kde.plasma.folder\nwallpaperplugin=org.kde.slideshow\n";
assert!(!kde_default_allowed(slideshow));
assert!(!kde_default_allowed(&format!("{slideshow}{panel}")));
assert!(kde_image(&format!("{slideshow}{panel}")).is_none());
assert!(!kde_default_allowed(panel));
let desktop = "[Containments][1]\nplugin=org.kde.plasma.folder\n";
assert!(kde_default_allowed(&format!("{desktop}{panel}")));
}
#[test] fn only_supported_image_files_are_uploaded() {
assert_eq!(image_type(b"\x89PNG\r\n\x1a\n"), Some("image/png"));
assert_eq!(image_type(b"\xff\xd8\xff"), Some("image/jpeg"));
assert_eq!(image_type(b"RIFF1234WEBP"), Some("image/webp"));
assert_eq!(image_type(b"<wallpaper>private text</wallpaper>"), None);
}
#[test] fn failed_api_responses_and_unsafe_upload_urls_are_rejected() {
assert!(api_data(200, &serde_json::json!({"code":0,"data":{}})).is_ok());
assert!(api_data(422, &serde_json::json!({"code":1120})).is_err());
assert!(api_data(200, &serde_json::json!({"data":{}})).is_err());
for url in ["http://example.com", "file:///tmp/a", "https://[email protected]"] { assert!(https_url(url).is_err()); }
}
}
+1 -1
View File
@@ -261,7 +261,7 @@ fn portal_outputs()->Vec<Output> {
let mut outputs:Vec<Output>=monitors.iter().map(|m|Output {name:m.connector.clone(),width:m.width,height:m.height,fps,x:m.x,y:m.y}).collect();
// Screen 0 is the one opened first: the monitor whose consent is already saved, else the primary.
let dir=crate::portal::permissions_directory();
let granted=|name:&str|dir.as_deref().is_some_and(|d|d.join(crate::portal::monitor_key(name)).exists());
let granted=|name:&str|dir.as_deref().is_some_and(|d|crate::portal::permission_exists(d,&crate::portal::monitor_key(name)));
let primary=monitors.iter().find(|m|m.primary).map(|m|m.connector.clone()).unwrap_or_default();
outputs.sort_by_key(|o|(!granted(&o.name),o.name!=primary,o.x,o.y));
outputs.truncate(16);
+217 -99
View File
@@ -4,6 +4,9 @@ use crate::capture::ScreenCapture;
use crate::input::InputInjector;
use crate::signaling::SoacMessage;
#[path = "text_outbox.rs"]
mod text_outbox;
use base64::Engine;
use flate2::read::GzDecoder;
use std::io::Read;
@@ -137,6 +140,8 @@ fn track_session(end_pc: Arc<RTCPeerConnection>, actions: Arc<crate::system_acti
let closed = matches!(end_pc.connection_state(), State::Closed | State::Failed);
let ending = actions.clone();
let _ = tokio::task::spawn_blocking(move || ending.session_ended()).await;
// Strokes belong to the viewer that drew them: never leave them on the host screen.
crate::annotation::reset(crate::annotation::owner(&actions));
if closed { return; }
}
});
@@ -489,6 +494,11 @@ impl WebRtcSession {
let file_channel: Arc<std::sync::Mutex<Option<Arc<RTCDataChannel>>>> = Arc::new(std::sync::Mutex::new(None));
let (file_tx, mut file_rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
let peer_files = crate::file_trans::FileSession::new(file_tx, control_sequence.clone());
// Mac 4.43: streamerDidReceiveTextData (0x1001f56b4, arm64) reaches
// the metrics/RPC dispatcher at 0x1003a8560; CONTROL does not.
// Keep CONTROL metrics for other viewers; privacy replies use TEXT.
let (text_tx, text_rx) = text_outbox::channel();
let text_rx = Arc::new(tokio::sync::Mutex::new(Some(OutboundReceiver::Text(text_rx))));
// 端口映射 frames (Message 27) also travel on FILE_DATA_CHANNEL; one session per peer.
let port_mapping = crate::port_mapping::Session::new(file_channel.clone(), control_sequence.clone());
{
@@ -537,6 +547,8 @@ impl WebRtcSession {
let echo_seen = echo_seen.clone();
let channel_lock_state = channel_lock_state.clone();
let peer_files = peer_files.clone();
let text_out = text_tx.clone();
let text_rx = text_rx.clone();
let peer_port_mapping = port_mapping.clone();
let peer_video_settings = video_settings.clone();
let peer_video_track = control_video_track.clone();
@@ -565,12 +577,16 @@ impl WebRtcSession {
}
// Ordered outbound queue for protocol replies produced outside this callback.
// webrtc-rs announces the channel before handle_open (ready_state Connecting);
// send() returns ErrClosedPipe until Open. Draining CONTROL here would drop
// Message 25 and every later reply. Start CONTROL from the on_open below
// send() returns ErrClosedPipe until Open. Draining CONTROL/TEXT here would
// drop initial state and replies. Start them from the on_open below
// (one handler; a second on_open replaces it). Receiver taken once.
let mut control_drain: Option<Box<dyn (FnOnce() -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>>) + Send + Sync>> = None;
let (outbound, outbound_rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
let outbound_rx = Arc::new(tokio::sync::Mutex::new(Some(outbound_rx)));
let mut open_drain: Option<Box<dyn (FnOnce() -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>>) + Send + Sync>> = None;
let (outbound, outbound_rx) = if label == "TEXT_DATA_CHANNEL" {
(Outbound::Text(text_out.clone()), text_rx)
} else {
let (tx, rx) = tokio::sync::mpsc::unbounded_channel::<Vec<u8>>();
(Outbound::Other(tx), Arc::new(tokio::sync::Mutex::new(Some(OutboundReceiver::Other(rx)))))
};
if label == "CONTROL_DATA_CHANNEL" {
if let Some(mut chroma_sync_rx) = chroma_sync_rx.lock().unwrap().take() {
let sync_out = outbound.clone();
@@ -603,8 +619,8 @@ impl WebRtcSession {
});
}) as std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>>
};
if label != "CONTROL_DATA_CHANNEL" { tokio::spawn(start_drain()); }
else { control_drain = Some(Box::new(start_drain)); }
if !matches!(label.as_str(), "CONTROL_DATA_CHANNEL" | "TEXT_DATA_CHANNEL") { tokio::spawn(start_drain()); }
else { open_drain = Some(Box::new(start_drain)); }
}
let (capture_tx, mut capture_rx) = tokio::sync::mpsc::channel::<Vec<u8>>(16);
if matches!(label.as_str(),"CONTROL_DATA_CHANNEL"|"TEXT_DATA_CHANNEL") {
@@ -686,7 +702,7 @@ impl WebRtcSession {
};
let Some(active_screen) = active_screen else { continue; };
let input_size = if active_screen.init_error.is_none() {
(active_screen.width, active_screen.height)
active_screen.portal.as_ref().map_or((active_screen.width, active_screen.height), |p| p.size())
} else { (1920, 1080) };
let input_size=crate::wayland::input_size(input_size);
let source_changed=source_before!=crate::wayland::selected();
@@ -776,9 +792,10 @@ impl WebRtcSession {
Some(peer_files.clone())
} else { None };
// CT_TERMINAL: TERM frames and terminal RPCs (check_env/rename) on BINARY.
let terminal_conn = if label == "BINARY_DATA_CHANNEL" {
Some(Arc::new(crate::terminal::TerminalConn::new(outbound.clone())))
} else { None };
let terminal_conn = match (&outbound, label.as_str()) {
(Outbound::Other(tx), "BINARY_DATA_CHANNEL") => Some(Arc::new(crate::terminal::TerminalConn::new(tx.clone()))),
_ => None,
};
if label == "CONTROL_DATA_CHANNEL" || label == "TEXT_DATA_CHANNEL" {
let channel = d.clone();
let initial_sequence = out_sequence.clone();
@@ -795,8 +812,9 @@ impl WebRtcSession {
let open_role = channel_role.clone();
let open_screen = screen.clone();
let open_selection = peer_selection;
let open_text_out = text_out.clone();
d.on_open(Box::new(move || {
if let Some(start_drain) = control_drain { tokio::spawn(start_drain()); }
if let Some(start_drain) = open_drain { tokio::spawn(start_drain()); }
let init_actions = open_actions.clone();
let init_video = open_video.clone();
let init_track = open_track.clone();
@@ -810,6 +828,7 @@ impl WebRtcSession {
let owner = open_owner.clone();
let role = open_role.clone();
let pc = desktop_pc.upgrade();
let text_out = open_text_out.clone();
Box::pin(async move {
// Permission dialogs and first-frame waits must not occupy the
// channel-open callback or delay CONTROL message dispatch.
@@ -962,6 +981,7 @@ impl WebRtcSession {
let message = crate::initialization::envelope(
sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 13,
&init_actions.metrics_payload(desktop_sound, snapshot.permission(true)));
text_out.metrics(message.clone());
if channel.send(&bytes::Bytes::from(message)).await.is_err() { return; }
let mut updates = portal.subscribe();
match crate::desktop_session::wait_ready(&mut updates, &channel).await {
@@ -972,6 +992,7 @@ impl WebRtcSession {
let message = crate::initialization::envelope(
sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 13,
&init_actions.metrics_payload(desktop_sound, crate::system_metrics::Permission::Reject));
text_out.metrics(message.clone());
let _ = channel.send(&bytes::Bytes::from(message)).await;
}
return;
@@ -983,6 +1004,7 @@ impl WebRtcSession {
// Default file-transfer folder: the desktop user's home directory.
let home = std::env::var("HOME").unwrap_or_else(|_| "/".into());
let (mut desktop, mut promoted, mut lock_reported) = (desktop, false, desktop);
let mut privacy_reported = false;
let mut screen = screen;
loop {
loop {
@@ -1019,6 +1041,7 @@ impl WebRtcSession {
Ok(message) => message,
Err(e) => { log::error!("CONTROL initialization encode failed: {}", e); return; }
};
if field == 13 { text_out.metrics(message.clone()); }
if let Err(e) = channel.send(&bytes::Bytes::from(message)).await {
log::error!("CONTROL initialization field {} failed: {}", field, e);
return;
@@ -1037,6 +1060,41 @@ impl WebRtcSession {
lock_reported = true;
tokio::spawn(crate::session_lock::report_states(channel.clone(), sequence.clone(), crate::session_lock::watch_locked()));
}
// The viewer's menu only learns about a mode it did not ask for (an
// auto-enable) from this push, so desktop peers need it too, not only a
// tool peer promoted to desktop.
if !privacy_reported && crate::privacy_screen::supported() {
privacy_reported = true;
let (channel, sequence, actions) = (channel.clone(), sequence.clone(), init_actions.clone());
let portal = portal_desktop.clone();
let text_out = text_out.clone();
tokio::spawn(async move {
// 0 is not a wire type: the first tick must push the effective state.
// An auto-enable can land before this task starts, and the viewer
// never sent an RPC to learn the mode from a response.
let mut previous = 0u8;
let mut tick = tokio::time::interval(std::time::Duration::from_secs(1));
loop {
tick.tick().await;
if channel.ready_state() != webrtc::data_channel::data_channel_state::RTCDataChannelState::Open { return; }
let current = crate::privacy_screen::current_type();
if current == previous { continue; }
previous = current;
log::info!("Privacy state change pushed: type={current}");
let permission = portal.as_ref().map_or(crate::system_metrics::Permission::Allow, |p| p.snapshot().permission(true));
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let payload = actions.metrics_payload(desktop_sound, permission);
let message = crate::initialization::envelope(sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 13, &payload);
text_out.metrics(message.clone());
if channel.send(&bytes::Bytes::from(message)).await.is_err() { return; }
let state = crate::privacy_screen::state_message(sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts);
// Android 4.43.0 handles privacy replies on TEXT; CONTROL stays for
// viewers that only read the desktop channel.
let _ = text_out.send(state.clone());
if channel.send(&bytes::Bytes::from(state)).await.is_err() { return; }
}
});
}
// Mirror the Linux pointer shape; the video itself carries no pointer.
let mut shapes = crate::cursor::monitor(&screen.display);
let mut health = tokio::time::interval(std::time::Duration::from_millis(200));
@@ -1087,6 +1145,7 @@ impl WebRtcSession {
let message_role=channel_role.clone();
let terminal_worker = terminal_conn.clone();
let rpc_out = outbound.clone();
let text_out = text_out.clone();
let reply_chan = d_reply.clone();
let out_sequence = reply_sequence.clone();
let clipboard_sink = clipboard_input.clone();
@@ -1103,7 +1162,8 @@ impl WebRtcSession {
let capture_requests = capture_tx.clone();
Box::pin(async move {
let input_size = crate::wayland::input_size((screen.width, screen.height));
// The privacy screen can swap the portal stream to a virtual output of another size.
let input_size = crate::wayland::input_size(screen.portal.as_ref().map_or((screen.width, screen.height), |p| p.size()));
// After a RandR resize the stream restarts capture at the new size; map the pointer to it.
let live_x11 = screen.init_error.is_none() && screen.portal.is_none() && screen.backend == crate::desktop_backend::DesktopBackend::X11;
if let Some(term) = &terminal_worker {
@@ -1117,24 +1177,45 @@ impl WebRtcSession {
}
return;
}
if let Ok(fields) = crate::protocol::decode_wire(&msg.data) {
let proto_fields = crate::protocol::decode_wire(&msg.data).ok();
if let Some(fields) = proto_fields.as_deref() {
use crate::protocol::WireValue;
let rpc = fields.iter().find_map(|f| match (f.number, &f.value) { (21, WireValue::Bytes(b)) => Some(*b), _ => None });
let rpc_fields = rpc.and_then(|r| crate::protocol::decode_wire(r).ok());
if let Some(request) = rpc.filter(|_| rpc_fields.as_deref().is_some_and(crate::privacy_screen::is_request)) {
let (request, actions, chan, seq_out, rpc_out) = (request.to_vec(), actions.clone(), reply_chan.clone(), out_sequence.clone(), rpc_out.clone());
let settings_portal = portal_for_message.clone();
tokio::spawn(async move {
let response = tokio::task::spawn_blocking(move || crate::protocol::decode_wire(&request).ok()
.and_then(|r| crate::privacy_screen::rpc_response(&r))).await.ok().flatten();
let Some(response) = response else { return };
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let _ = rpc_out.send(crate::initialization::envelope(seq_out.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
// The 防窥 switch shows SettingMetric 4 like the other 安全 settings.
let permission = settings_portal.as_ref().map_or(crate::system_metrics::Permission::Allow, |manager| manager.snapshot().permission(desktop));
let message = crate::initialization::envelope(seq_out.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 13, &actions.metrics_payload(desktop_sound, permission));
if let Err(e) = chan.send(&bytes::Bytes::from(message)).await { log::warn!("Settings report failed: {}", e); }
});
if let Some(request) = rpc.filter(|_| rpc_fields.as_ref().is_some_and(|r| r.iter().any(|f| f.number == 7))) {
let Some((response, accepted)) = rpc_fields.as_deref().and_then(crate::privacy_screen::rpc_accept) else { return };
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let _ = text_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
let Some(accepted) = accepted else { return };
let failed = tokio::task::spawn_blocking(move || accepted.apply().is_err()).await.unwrap_or(true);
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);
if failed {
let report = crate::initialization::encode_report_error(next(), ts, crate::privacy_screen::REPORT_ERROR, "privacy screen failed");
let _ = reply_chan.send(&bytes::Bytes::from(report)).await;
}
let permission = portal_for_message.as_ref().map_or(crate::system_metrics::Permission::Allow, |p| p.snapshot().permission(desktop));
let metrics = actions.metrics_payload(desktop_sound, permission);
text_out.metrics(crate::initialization::envelope(next(), ts, 13, &metrics));
let _ = reply_chan.send(&bytes::Bytes::from(crate::initialization::envelope(next(), ts, 13, &metrics))).await;
let state = crate::privacy_screen::state_message(next(), ts);
let _ = reply_chan.send(&bytes::Bytes::from(state)).await;
log::info!("Privacy switch done: failed={failed} type={}", crate::privacy_screen::current_type());
return;
}
if let Some(response) = rpc_fields.as_deref().and_then(crate::privacy_screen::screensaver_response) {
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let _ = text_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
return;
}
if let Some((header, body)) = rpc_fields.as_deref().and_then(crate::annotation::draw_request) {
// A toggle waits for the X overlay to open: keep it off the async workers.
let owner = crate::annotation::owner(&actions);
let Ok(response) = tokio::task::spawn_blocking(move || crate::annotation::respond(owner, &header, &body)).await else { return };
// draw_req arrives on CONTROL, but a CONTROL reply timed out (9998) on Mac 4.42.0:
// answer on TEXT like the privacy RPCs above.
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
let _ = text_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
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))) {
@@ -1142,18 +1223,18 @@ impl WebRtcSession {
let _ = rpc_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
return;
}
if let Some(response) = rpc.and_then(|r| crate::protocol::decode_wire(r).ok()).and_then(|r| crate::terminal::rpc_response(&r)) {
if let Some(response) = rpc_fields.as_deref().and_then(crate::terminal::rpc_response) {
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));
return;
}
}
if let Ok(fields) = crate::protocol::decode_wire(&msg.data) {
if mapping.handle(&fields, &channel_name) { return; }
if let Some(fields) = proto_fields.as_deref() {
if mapping.handle(fields, &channel_name) { return; }
}
if let Some(files) = &file_worker {
if let Ok(fields) = crate::protocol::decode_wire(&msg.data) {
if files.handle(&fields) {
if let Some(fields) = proto_fields.as_deref() {
if files.handle(fields) {
static ROUTE: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
if ROUTE.fetch_add(1, std::sync::atomic::Ordering::Relaxed) < 20 {
log::info!("File transfer RPC received on {}", channel_name);
@@ -1179,16 +1260,16 @@ impl WebRtcSession {
}
}
shape(&value,0).to_string()
} else if let Ok(fields) = crate::protocol::decode_wire(&msg.data) {
} else if let Some(fields) = proto_fields.as_deref() {
format!("protobuf fields={:?}",fields.iter().map(|f|f.number).collect::<Vec<_>>())
} else { "opaque".to_string() };
log::info!("Clipboard channel schema: channel={} bytes={} schema={}",channel_name,msg.data.len(),shape);
}
}
if channel_name == "CONTROL_DATA_CHANNEL" || channel_name == "TEXT_DATA_CHANNEL" {
if let Ok(fields) = crate::protocol::decode_wire(&msg.data) {
if let Some(fields) = proto_fields.as_deref() {
use crate::protocol::WireValue;
for field in &fields {
for field in fields {
if let (22,WireValue::Bytes(payload))=(field.number,&field.value) {
let update=rich_incoming.lock().unwrap().response(payload);
match update {
@@ -1205,8 +1286,6 @@ impl WebRtcSession {
}
}
}
}
for field in &fields {
if let (21, WireValue::Bytes(payload)) = (field.number,&field.value) {
let ids=crate::clipboard_rich::format_ids(payload);
if !ids.is_empty(){log::info!("Clipboard offered format IDs: {:?}",ids);}
@@ -1244,8 +1323,6 @@ impl WebRtcSession {
Err(reason)=>log::warn!("Clipboard RPC rejected: {}",reason),
}
}
}
for field in &fields {
if let (17, WireValue::Bytes(payload)) = (field.number, &field.value) {
match clipboard_assembly.lock().unwrap().accept(payload) {
Ok(Some(text)) => {
@@ -1318,6 +1395,7 @@ impl WebRtcSession {
crate::control_protocol::simple_action_name(action).unwrap_or("?"), value, sa::args_shape(&args));
let (actions, input, chan, seq_out) = (actions.clone(), input_worker.clone(), reply_chan.clone(), out_sequence.clone());
let settings_portal = portal_for_message.clone();
let text_out = text_out.clone();
tokio::spawn(async move {
let worker = actions.clone();
let report = tokio::task::spawn_blocking(move || worker.handle(action, value, &args, || {
@@ -1331,6 +1409,7 @@ impl WebRtcSession {
crate::system_metrics::Permission::Allow,
|manager| manager.snapshot().permission(desktop));
let message = crate::initialization::envelope(seq_out.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 13, &actions.metrics_payload(desktop_sound, permission));
text_out.metrics(message.clone());
if let Err(e) = chan.send(&bytes::Bytes::from(message)).await { log::warn!("Settings report failed: {}", e); }
}
});
@@ -1370,68 +1449,87 @@ impl WebRtcSession {
}
if let Ok(txt) = std::str::from_utf8(&msg.data) {
log::debug!("DataChannel [{}] received UTF-8 data: {} bytes", channel_name, txt.len());
if let Ok(val) = serde_json::from_str::<serde_json::Value>(txt) {
if !channel_name.contains("CONTROL") {
// Input JSON on another channel (mobile input-method text was missing from CONTROL, #13/#46):
// record action names only, once per name, and accept text_input wherever it arrives.
if let Some(action) = val.get("action").and_then(serde_json::Value::as_str) {
static SEEN: std::sync::Mutex<Vec<String>> = std::sync::Mutex::new(Vec::new());
let mut seen = SEEN.lock().unwrap();
if seen.len() < 32 && action.len() <= 40 && action.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_') && !seen.iter().any(|s| s == action) {
seen.push(action.to_owned());
log::info!("JSON action on {} channel: action={}", if channel_name.contains("STREAMER") {"STREAMER"} else if channel_name.contains("TEXT") {"TEXT"} else {"other"}, action);
if channel_name.contains("CONTROL") {
match crate::control_protocol::decode_control(&msg.data) {
Ok(crate::control_protocol::ControlMessage::Input(event)) => {
// A ready compositor source remains controllable on its lock screen.
if screen.backend == crate::desktop_backend::DesktopBackend::Portal
&& (screen.init_error.is_some() || !desktop_ready) { return; }
if !crate::wayland::input_ready() {return;}
use crate::control_protocol::ControlInput;
// Separate receipt budgets keep motion floods from hiding clicks.
static RECEIPTS: [std::sync::atomic::AtomicUsize; 3] = [const { std::sync::atomic::AtomicUsize::new(0) }; 3];
let (slot, kind) = match &event {
ControlInput::MouseButton {..} | ControlInput::MouseClick {..} => (0, "button"),
ControlInput::Keyboard {..} | ControlInput::KeyboardClick {..} | ControlInput::TextInput {..} => (1, "keyboard"),
_ => (2, "motion"),
};
if RECEIPTS[slot].fetch_add(1, std::sync::atomic::Ordering::Relaxed) < 16 {
log::info!("CONTROL input received: kind={}", kind);
}
}
if let Ok(crate::control_protocol::ControlMessage::Input(crate::control_protocol::ControlInput::TextInput {text})) = crate::control_protocol::decode_control(&msg.data) {
if let Some(session)=message_input_session.as_ref() { session.with_input(|| {if crate::wayland::input_ready() {input_worker.text_input(&text);}}); }
if let Some(session)=message_input_session.as_ref() {
if matches!(&event, ControlInput::TextInput {..}) {
let (session, input, text) = match &event {
ControlInput::TextInput {text} => (session.clone(), input_worker.clone(), text.clone()),
_ => unreachable!(),
};
let _ = tokio::task::spawn_blocking(move || {
session.with_input(|| {
if crate::wayland::input_ready() { input.text_input(&text); }
});
}).await;
} else {
session.with_input(|| {
if !crate::wayland::input_ready() {return;}
match &event {
ControlInput::MouseAbsolute {x,y} => input_worker.mouse_absolute_normalized(*x,*y,crate::wayland::input_size(if live_x11 {crate::capture::x11_last_size().unwrap_or(input_size)} else {input_size})),
ControlInput::MouseRelative {dx,dy} => input_worker.mouse_relative(*dx,*dy),
ControlInput::MouseScroll {dx,dy} => input_worker.mouse_scroll(*dx,*dy),
ControlInput::Keyboard {key, pressed} => input_worker.windows_key_event(*key, *pressed),
ControlInput::KeyboardClick {key} => {input_worker.windows_key_event(*key, true);input_worker.windows_key_event(*key, false);},
ControlInput::MouseButton {button,pressed} => input_worker.wire_mouse_button(*button,*pressed),
ControlInput::MouseClick {button} => {input_worker.wire_mouse_button(*button,true);input_worker.wire_mouse_button(*button,false);},
_ => {}
}
});
}
}
},
Ok(crate::control_protocol::ControlMessage::Unsupported(v)) => {
// Action name and key names only, never values (an IME text event would carry typed text).
static UNSUPPORTED: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
if UNSUPPORTED.fetch_add(1, std::sync::atomic::Ordering::Relaxed) < 16 {
let action = v.get("action").and_then(serde_json::Value::as_str)
.filter(|a| a.len() <= 40 && a.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_')).unwrap_or("?");
let keys: Vec<&str> = v.as_object().map(|o| o.keys().map(String::as_str).take(12).collect()).unwrap_or_default();
log::info!("Unsupported CONTROL input: action={action} keys={keys:?}");
}
},
_ => {}
}
} else if let Ok(val) = serde_json::from_str::<serde_json::Value>(txt) {
// Input JSON on another channel (mobile input-method text was missing from CONTROL, #13/#46):
// record action names only, once per name, and accept text_input wherever it arrives.
if let Some(action) = val.get("action").and_then(serde_json::Value::as_str) {
static SEEN: std::sync::Mutex<Vec<String>> = std::sync::Mutex::new(Vec::new());
let mut seen = SEEN.lock().unwrap();
if seen.len() < 32 && action.len() <= 40 && action.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_') && !seen.iter().any(|s| s == action) {
seen.push(action.to_owned());
log::info!("JSON action on {} channel: action={}", if channel_name.contains("STREAMER") {"STREAMER"} else if channel_name.contains("TEXT") {"TEXT"} else {"other"}, action);
}
}
if channel_name.contains("CONTROL") {
match crate::control_protocol::decode_control(&msg.data) {
Ok(crate::control_protocol::ControlMessage::Input(event)) => {
if screen.backend == crate::desktop_backend::DesktopBackend::Portal
&& (screen.init_error.is_some() || !desktop_ready || *lock_for_message.borrow() != Some(false)) { return; }
if !crate::wayland::input_ready() {return;}
use crate::control_protocol::ControlInput;
// Separate receipt budgets keep motion floods from hiding clicks.
static RECEIPTS: [std::sync::atomic::AtomicUsize; 3] = [const { std::sync::atomic::AtomicUsize::new(0) }; 3];
let (slot, kind) = match &event {
ControlInput::MouseButton {..} | ControlInput::MouseClick {..} => (0, "button"),
ControlInput::Keyboard {..} | ControlInput::KeyboardClick {..} | ControlInput::TextInput {..} => (1, "keyboard"),
_ => (2, "motion"),
};
if RECEIPTS[slot].fetch_add(1, std::sync::atomic::Ordering::Relaxed) < 16 {
log::info!("CONTROL input received: kind={}", kind);
}
if let Some(session)=message_input_session.as_ref() {session.with_input(|| {
if !crate::wayland::input_ready() {return;}
match &event {
ControlInput::MouseAbsolute {x,y} => input_worker.mouse_absolute_normalized(*x,*y,crate::wayland::input_size(if live_x11 {crate::capture::x11_last_size().unwrap_or(input_size)} else {input_size})),
ControlInput::MouseRelative {dx,dy} => input_worker.mouse_relative(*dx,*dy),
ControlInput::MouseScroll {dx,dy} => input_worker.mouse_scroll(*dx,*dy),
ControlInput::Keyboard {key, pressed} => input_worker.windows_key_event(*key, *pressed),
ControlInput::TextInput {text} => input_worker.text_input(text),
ControlInput::KeyboardClick {key} => {input_worker.windows_key_event(*key, true);input_worker.windows_key_event(*key, false);},
ControlInput::MouseButton {button,pressed} => input_worker.wire_mouse_button(*button,*pressed),
ControlInput::MouseClick {button} => {input_worker.wire_mouse_button(*button,true);input_worker.wire_mouse_button(*button,false);},
_ => {}
}
});}
},
Ok(crate::control_protocol::ControlMessage::Unsupported(v)) => {
// Action name and key names only, never values (an IME text event would carry typed text).
static UNSUPPORTED: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
if UNSUPPORTED.fetch_add(1, std::sync::atomic::Ordering::Relaxed) < 16 {
let action = v.get("action").and_then(serde_json::Value::as_str)
.filter(|a| a.len() <= 40 && a.bytes().all(|b| b.is_ascii_alphanumeric() || b == b'_')).unwrap_or("?");
let keys: Vec<&str> = v.as_object().map(|o| o.keys().map(String::as_str).take(12).collect()).unwrap_or_default();
log::info!("Unsupported CONTROL input: action={action} keys={keys:?}");
}
},
_ => {}
if let Ok(crate::control_protocol::ControlMessage::Input(crate::control_protocol::ControlInput::TextInput {text})) = crate::control_protocol::decode_control(&msg.data) {
if let Some(session)=message_input_session.as_ref() {
let (session, input) = (session.clone(), input_worker.clone());
let _ = tokio::task::spawn_blocking(move || {
session.with_input(|| {
if crate::wayland::input_ready() { input.text_input(&text); }
});
}).await;
}
} else if channel_name.contains("STREAMER") {
}
if channel_name.contains("STREAMER") {
log::debug!("STREAMER channel JSON received");
if let Some(event)=val.get("connection_period_stats_event") {
let nums=crate::viewer_metrics::collect(event);
@@ -1684,8 +1782,28 @@ fn negotiated_bundle_media(sdp: &str) -> Option<(String, u16)> {
None
}
#[derive(Clone)]
enum Outbound {
Text(text_outbox::Sender),
Other(tokio::sync::mpsc::UnboundedSender<Vec<u8>>),
}
impl Outbound {
fn send(&self, message: Vec<u8>) -> Result<(), tokio::sync::mpsc::error::SendError<Vec<u8>>> {
match self { Self::Text(tx) => tx.send(message), Self::Other(tx) => tx.send(message) }
}
}
enum OutboundReceiver {
Text(text_outbox::Receiver),
Other(tokio::sync::mpsc::UnboundedReceiver<Vec<u8>>),
}
impl OutboundReceiver {
async fn recv(&mut self) -> Option<Vec<u8>> {
match self { Self::Text(rx) => rx.recv().await, Self::Other(rx) => rx.recv().await }
}
}
/// First drain owns the outbound receiver; a later open must not start another.
async fn take_outbound_once<T>(slot: &tokio::sync::Mutex<Option<tokio::sync::mpsc::UnboundedReceiver<T>>>) -> Option<tokio::sync::mpsc::UnboundedReceiver<T>> {
async fn take_outbound_once<T>(slot: &tokio::sync::Mutex<Option<T>>) -> Option<T> {
slot.lock().await.take()
}
Binary file not shown.

After

Width:  |  Height:  |  Size: 68 B

+37
View File
@@ -0,0 +1,37 @@
#!/bin/sh
# Requires a C compiler, GTK3/X11 development headers, Xvfb and xauth.
# Run: xvfb-run -a -s '-screen 0 1600x1200x24' sh tests/gtk-ui-smoke.sh /tmp/gtk-ui-previews
# Optional output directory retains synthetic main/settings screenshots; no account or QR is used.
# Checks 5 window types in Chinese/English with System/Light/Dark and settings persistence.
set -eu
cd "$(dirname "$0")/.."
work=$(mktemp -d)
trap 'rm -rf "$work"' EXIT HUP INT TERM
out=${1:-"$work/previews"}
mkdir -p "$out" "$work/config/gtk-3.0" "$work/config/uuremote" "$work/home/Documents"
export HOME="$work/home"
export XDG_CONFIG_HOME="$work/config"
export GSETTINGS_BACKEND=memory
export G_DEBUG=fatal-warnings
export GDK_BACKEND=x11
export GDK_SCALE=1
export GDK_DPI_SCALE=1
export NO_AT_BRIDGE=1
unset GTK_THEME
printf '[Settings]\ngtk-theme-name=Adwaita\ngtk-application-prefer-dark-theme=false\n' > "$XDG_CONFIG_HOME/gtk-3.0/settings.ini"
for ui in HOST VIEWER TOOLS; do
# pkg-config output is intentionally split into compiler arguments.
cc -std=gnu11 -Wall -Wextra -Werror -Wno-deprecated-declarations \
-D"UI_$ui" tests/gtk_ui_smoke.c c_engine/ui_theme.c \
$(pkg-config --cflags --libs gtk+-3.0) -ldl -lpthread -o "$work/$ui"
for lang in en zh; do
for theme in light dark system; do
case $theme in light) mode=1;; dark) mode=2;; system) mode=0;; esac
for kind in $(if [ "$ui" = TOOLS ]; then printf 'files portmap terminal'; else printf 'main'; fi); do
printf '%s' "$theme" > "$XDG_CONFIG_HOME/uuremote/theme"
UU_LANG=$lang "$work/$ui" "$out/$ui-$kind-$lang-$theme.png" "$mode" "$kind"
done
done
done
done
printf 'GTK UI smoke checks passed (host, viewer, files, port mapping, terminal; English/Chinese; light/dark/system).\n'
+177
View File
@@ -0,0 +1,177 @@
// Offline fixtures only: no account, QR, cloud, or desktop capture is used.
#include <gtk/gtk.h>
#include <gdk/gdkx.h>
#include <cairo-xlib.h>
#include <string.h>
#include <stdlib.h>
int uu_i18n_english(void) { return g_strcmp0(g_getenv("UU_LANG"), "zh") != 0; }
int uu_i18n_save(int english) { (void)english; return 1; }
#if defined(UI_HOST)
#include "../c_engine/assist_window.c"
#elif defined(UI_VIEWER)
#include "../c_engine/viewer_window.c"
#else
#include <unistd.h>
static int fixture_hostname(char *name, size_t len) { g_strlcpy(name, "Local workstation", len); return 0; }
#define gethostname fixture_hostname
#include "../c_engine/viewer_tools.c"
#endif
static GtkWidget *appearance_combo(GtkWidget *w) {
if (GTK_IS_COMBO_BOX(w) && !g_strcmp0(atk_object_get_name(gtk_widget_get_accessible(w)), L("外观", "Appearance"))) return w;
if (!GTK_IS_CONTAINER(w)) return NULL;
GList *children = gtk_container_get_children(GTK_CONTAINER(w));
GtkWidget *found = NULL;
for (GList *c = children; c && !found; c = c->next) found = appearance_combo(c->data);
g_list_free(children);
return found;
}
#if !defined(UI_VIEWER)
static GtkWidget *settings_button(GtkWidget *w) {
if (GTK_IS_BUTTON(w) && !g_strcmp0(atk_object_get_name(gtk_widget_get_accessible(w)), L("设置", "Settings"))) return w;
if (!GTK_IS_CONTAINER(w)) return NULL;
GList *children = gtk_container_get_children(GTK_CONTAINER(w));
GtkWidget *found = NULL;
for (GList *c = children; c && !found; c = c->next) found = settings_button(c->data);
g_list_free(children);
return found;
}
#endif
static gboolean snapshot(GtkWidget *w, const char *path) {
static int attempts;
int width = gtk_widget_get_allocated_width(w), height = gtk_widget_get_allocated_height(w);
GdkWindow *native = gtk_widget_get_window(w);
int x, y;
gdk_window_get_origin(native, &x, &y);
g_assert_cmpint(x + width, <=, gdk_screen_width());
g_assert_cmpint(y + height, <=, gdk_screen_height());
gdk_window_process_updates(native, TRUE);
gdk_display_sync(gtk_widget_get_display(w));
// GTK 3.24.33's get_from_window marks its cached surface dirty without flushing;
// Cairo 1.16 can abort on attached MIME data. Read through a fresh X11 surface.
cairo_surface_t *surface = cairo_xlib_surface_create(GDK_WINDOW_XDISPLAY(native),
GDK_WINDOW_XID(native), GDK_VISUAL_XVISUAL(gdk_window_get_visual(native)), width, height);
g_assert_cmpint(cairo_surface_status(surface), ==, CAIRO_STATUS_SUCCESS);
GdkPixbuf *shot = gdk_pixbuf_get_from_surface(surface, 0, 0, width, height);
cairo_surface_destroy(surface);
g_assert_nonnull(shot);
const guchar *pixels = gdk_pixbuf_read_pixels(shot);
int low = 255, high = 0;
for (int row = 0; row < height; row++) {
for (int col = 0; col < width; col++) {
int v = pixels[row * gdk_pixbuf_get_rowstride(shot) + col * gdk_pixbuf_get_n_channels(shot)];
low = MIN(low, v); high = MAX(high, v);
}
}
if (high - low <= 80) {
// A loaded CI runner may not have painted yet; retry through the main loop, with a bound.
g_object_unref(shot);
g_assert_cmpint(++attempts, <, 10);
return FALSE;
}
attempts = 0;
g_assert_true(gdk_pixbuf_save(shot, path, "png", NULL, NULL));
g_object_unref(shot);
return TRUE;
}
static const char *output;
static int expected_mode, stage;
#if defined(UI_VIEWER)
static void verify_badge(void) {
for (int i = 0; i < 2; i++) {
show_device(i); // Fixture 0 is online, fixture 1 is offline.
GtkStyleContext *ctx = gtk_widget_get_style_context(badge);
GdkRGBA actual, expected;
g_assert_cmpint(gtk_style_context_has_class(ctx, "off"), ==, i == 1);
g_assert_true(gtk_style_context_lookup_color(ctx, i ? "uu_muted" : "uu_success", &expected));
gtk_style_context_get_color(ctx, GTK_STATE_FLAG_NORMAL, &actual);
g_assert_cmpfloat_with_epsilon(actual.red, expected.red, 0.005);
g_assert_cmpfloat_with_epsilon(actual.green, expected.green, 0.005);
g_assert_cmpfloat_with_epsilon(actual.blue, expected.blue, 0.005);
}
}
#endif
static gboolean verify(gpointer unused) {
(void)unused;
if (!stage) {
g_assert_null(appearance_combo(window)); // Appearance belongs in Settings.
if (!snapshot(window, output)) return G_SOURCE_CONTINUE;
#if defined(UI_VIEWER)
open_settings();
#else
GtkWidget *button = settings_button(window);
g_assert_nonnull(button);
gtk_button_clicked(GTK_BUTTON(button));
#endif
stage++;
return G_SOURCE_CONTINUE;
}
GList *windows = gtk_window_list_toplevels();
GtkWidget *combo = NULL, *settings = NULL;
for (GList *w = windows; w && !combo; w = w->next) {
combo = appearance_combo(w->data);
if (combo) settings = w->data;
}
g_list_free(windows);
g_assert_nonnull(combo);
g_assert_cmpint(gtk_combo_box_get_active(GTK_COMBO_BOX(combo)), ==, expected_mode);
if (stage == 1) {
char *path = g_strconcat(output, ".settings.png", NULL);
gboolean painted = snapshot(settings, path); g_free(path);
if (!painted) return G_SOURCE_CONTINUE;
#if defined(UI_VIEWER)
verify_badge();
#endif
expected_mode = expected_mode == 2 ? 1 : 2;
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), expected_mode);
stage++;
return G_SOURCE_CONTINUE;
}
gboolean dark = FALSE;
g_object_get(gtk_settings_get_default(), "gtk-application-prefer-dark-theme", &dark, NULL);
g_assert_cmpint(dark, ==, expected_mode == 2);
#if defined(UI_VIEWER)
verify_badge();
#endif
char *path = g_build_filename(g_get_user_config_dir(), "uuremote", "theme", NULL), *saved = NULL;
g_assert_true(g_file_get_contents(path, &saved, NULL, NULL));
g_assert_cmpstr(saved, ==, expected_mode == 2 ? "dark" : "light");
g_free(path); g_free(saved);
// System must release the application override and restore the test desktop's light default.
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0);
g_object_get(gtk_settings_get_default(), "gtk-application-prefer-dark-theme", &dark, NULL);
g_assert_false(dark);
gtk_main_quit();
return G_SOURCE_REMOVE;
}
int main(int argc, char **argv) {
g_assert_cmpint(argc, >=, 3);
output = argv[1]; expected_mode = atoi(argv[2]);
gtk_init(NULL, NULL);
g_object_set(gtk_settings_get_default(), "gtk-enable-animations", FALSE, NULL);
g_timeout_add(400, verify, NULL);
#if defined(UI_HOST)
show_account = 1;
build_window();
gtk_main();
#elif defined(UI_VIEWER)
uu_viewer_ui_set_devices("demo-workstation\tWorkstation\t1\t1\t0\ndemo-laptop\tLaptop\t4\t0\t0\n");
logged_in = 1;
g_idle_add(apply_devices, NULL);
g_idle_add(apply_login, NULL);
run(NULL);
#else
g_strlcpy(remote_name, "Workstation", sizeof remote_name);
if (argc > 3 && !strcmp(argv[3], "terminal")) build_terminal();
else if (argc > 3 && !strcmp(argv[3], "portmap")) build_portmap();
else build_files();
gtk_widget_show_all(window);
gtk_main();
#endif
return 0;
}
+189
View File
@@ -0,0 +1,189 @@
#define _GNU_SOURCE
#include <assert.h>
#include <pipewire/pipewire.h>
#include <spa/param/video/format-utils.h>
static struct pw_buffer *incoming[8], *returned[32];
static unsigned input_count, input_next, return_count, loop_depth, updates;
static int requested_dma;
static struct pw_buffer *test_dequeue(struct pw_stream *stream) {
(void)stream;
assert(loop_depth == 1);
return input_next < input_count ? incoming[input_next++] : NULL;
}
static int test_queue(struct pw_stream *stream, struct pw_buffer *buffer) {
(void)stream;
assert(loop_depth == 1 && return_count < 32);
returned[return_count++] = buffer;
return 0;
}
static void test_loop_lock(struct pw_thread_loop *loop) { (void)loop; assert(loop_depth++ == 0); }
static void test_loop_unlock(struct pw_thread_loop *loop) { (void)loop; assert(loop_depth-- == 1); }
static int test_update(struct pw_stream *stream, const struct spa_pod **params, uint32_t count) {
(void)stream;
assert(loop_depth == 1);
if (count == 1) { updates++; return 0; } /* Negotiated buffer requirements. */
assert(count == 2 || count == 3);
requested_dma = count == 3;
assert(!!spa_pod_find_prop(params[0], NULL, SPA_FORMAT_VIDEO_modifier) == requested_dma);
if (requested_dma) assert(!spa_pod_find_prop(params[1], NULL, SPA_FORMAT_VIDEO_modifier));
updates++;
return 0;
}
#define pw_stream_dequeue_buffer test_dequeue
#define pw_stream_queue_buffer test_queue
#define pw_stream_update_params test_update
#define pw_thread_loop_lock test_loop_lock
#define pw_thread_loop_unlock test_loop_unlock
#include "../c_engine/portal_engine.c"
static struct uu_portal *make_portal(void) {
struct uu_portal *p = calloc(1, sizeof(*p));
assert(p);
pthread_mutex_init(&p->lock, NULL);
pthread_cond_init(&p->changed, NULL);
p->width=2; p->height=2; p->format=SPA_VIDEO_FORMAT_BGRA; p->format_valid=1;
p->frame_length=16; p->frame=malloc(16); assert(p->frame); memset(p->frame, 99, 16);
p->pw_loop=(struct pw_thread_loop *)1; p->stream=(struct pw_stream *)1;
input_count=input_next=return_count=updates=loop_depth=0;
return p;
}
static void close_portal(struct uu_portal *p) {
assert(!loop_depth);
p->stream=NULL; p->pw_loop=NULL;
uu_portal_close(p);
}
static void process(struct uu_portal *p, struct pw_buffer *buffer) {
input_count=1; input_next=0; incoming[0]=buffer;
test_loop_lock(p->pw_loop); stream_process(p); test_loop_unlock(p->pw_loop);
}
static void descriptor_bounds(void) {
struct uu_portal *p=make_portal();
struct spa_chunk chunk={.offset=8, .size=24, .stride=16};
struct spa_data data={.type=SPA_DATA_DmaBuf, .fd=5, .mapoffset=4, .maxsize=64, .chunk=&chunk};
struct spa_buffer buffer={.n_datas=1, .datas=&data};
UuDmaFrame frame;
assert(describe_dma_buffer(p,&buffer,&frame)==0);
assert(frame.offset==12 && frame.size==68 && frame.stride==16 && frame.fourcc==0x34325241);
chunk.size=23; assert(describe_dma_buffer(p,&buffer,&frame)==10); chunk.size=24;
data.maxsize=31; assert(describe_dma_buffer(p,&buffer,&frame)==14); data.maxsize=64;
data.mapoffset=UINT32_MAX; assert(describe_dma_buffer(p,&buffer,&frame)==14); data.mapoffset=4;
chunk.stride=7; assert(describe_dma_buffer(p,&buffer,&frame)==14); chunk.stride=16;
data.fd=-1; assert(describe_dma_buffer(p,&buffer,&frame)==14); data.fd=5;
data.type=SPA_DATA_MemFd; assert(describe_dma_buffer(p,&buffer,&frame)==14); data.type=SPA_DATA_DmaBuf;
buffer.n_datas=2; assert(describe_dma_buffer(p,&buffer,&frame)==14); buffer.n_datas=1;
p->modifier=1; assert(describe_dma_buffer(p,&buffer,&frame)==19); p->modifier=0;
chunk.flags=SPA_CHUNK_FLAG_CORRUPTED; assert(describe_dma_buffer(p,&buffer,&frame)==10);
chunk.flags=SPA_CHUNK_FLAG_EMPTY; assert(describe_dma_buffer(p,&buffer,&frame)==15); chunk.flags=0;
struct spa_meta_header header={.flags=SPA_META_HEADER_FLAG_CORRUPTED};
struct spa_meta meta={.type=SPA_META_Header,.size=sizeof(header),.data=&header};
buffer.n_metas=1; buffer.metas=&meta; assert(describe_dma_buffer(p,&buffer,&frame)==10);
struct spa_meta_region crop={.region=SPA_REGION(1,0,2,2)};
meta=(struct spa_meta){.type=SPA_META_VideoCrop,.size=sizeof(crop),.data=&crop};
assert(describe_dma_buffer(p,&buffer,&frame)==14);
#if PW_CHECK_VERSION(1, 2, 0)
struct spa_meta_sync_timeline sync={0};
meta=(struct spa_meta){.type=SPA_META_SyncTimeline,.size=sizeof(sync),.data=&sync};
assert(describe_dma_buffer(p,&buffer,&frame)==18);
#endif
close_portal(p);
}
static void ownership_and_reset(void) {
struct uu_portal *p=make_portal();
p->dma_requested=p->dma_negotiated=p->dma_format=1;
struct spa_chunk chunk={.size=16,.stride=8};
/* Invalid CPU address: the DMA path must never dereference or copy pixels. */
struct spa_data data={.type=SPA_DATA_DmaBuf,.fd=5,.maxsize=16,.data=(void *)1,.chunk=&chunk};
struct spa_buffer spa={.n_datas=1,.datas=&data};
struct pw_buffer a={.buffer=&spa}, b={.buffer=&spa}, c={.buffer=&spa};
UuDmaFrame frame; uint64_t revision=0;
process(p,&a);
assert(p->dma_pending==&a && !return_count && p->frame[0]==99);
assert(uu_portal_dmabuf_acquire(p,&frame,&revision)==0 && loop_depth==1);
assert(p->dma_current==&a && !p->dma_pending && !return_count);
uu_portal_dmabuf_release(p); assert(!loop_depth && !return_count);
process(p,&b); process(p,&c);
assert(return_count==1 && returned[0]==&b && p->dma_current==&a && p->dma_pending==&c);
assert(uu_portal_dmabuf_acquire(p,&frame,&revision)==0);
assert(return_count==2 && returned[1]==&a && p->dma_current==&c);
uu_portal_dmabuf_release(p);
assert(uu_portal_dmabuf_acquire(p,&frame,&revision)==12);
uu_portal_dmabuf_release(p);
assert(return_count==2);
uu_portal_reset_frame(p);
assert(return_count==3 && returned[2]==&c && !p->dma_current && !p->dma_pending && !p->sequence);
for (unsigned i=0;i<16;i++) assert(!p->frame[i]);
process(p,&a);
stream_remove_buffer(p,&a);
assert(!p->dma_pending);
process(p,&b);
uu_portal_dmabuf_disable(p);
assert(p->dma_blocked && !requested_dma && !p->dma_pending && !p->dma_current);
assert(return_count==4 && returned[3]==&b);
assert(uu_portal_dmabuf_acquire(p,&frame,&revision)==14 && !loop_depth);
close_portal(p);
}
static void negotiation_and_black(void) {
struct uu_portal *p=make_portal();
UuDmaFrame frame; uint64_t revision=0;
assert(uu_portal_dmabuf_acquire(p,&frame,&revision)==10 && !loop_depth);
assert(requested_dma && updates==1);
p->dma_negotiated=1; p->dma_format=1;
p->dma_requested_at=g_get_monotonic_time()-3*G_TIME_SPAN_SECOND;
assert(uu_portal_dmabuf_acquire(p,&frame,&revision)==17 && !loop_depth);
struct spa_chunk chunk={.flags=SPA_CHUNK_FLAG_EMPTY};
struct spa_data data={.type=SPA_DATA_DmaBuf,.fd=5,.chunk=&chunk};
struct spa_buffer spa={.n_datas=1,.datas=&data};
struct pw_buffer buffer={.buffer=&spa};
process(p,&buffer);
assert(uu_portal_dmabuf_acquire(p,&frame,&revision)==15 && !loop_depth);
p->dma_neutral=0; p->dma_format=0;
assert(uu_portal_dmabuf_acquire(p,&frame,&revision)==16 && !loop_depth);
uu_portal_dmabuf_disable(p);
assert(!requested_dma && updates==2);
close_portal(p);
}
static void initial_dma_transport(void) {
struct uu_portal *p=make_portal();
uint8_t storage[2048];
const struct spa_pod *params[3];
struct spa_pod_builder builder=SPA_POD_BUILDER_INIT(storage,sizeof(storage));
p->width=p->height=0;
assert(capture_formats(p,&builder,params,0)==2);
assert(!spa_pod_find_prop(params[0],NULL,SPA_FORMAT_VIDEO_modifier));
builder=(struct spa_pod_builder)SPA_POD_BUILDER_INIT(storage,sizeof(storage));
assert(capture_formats(p,&builder,params,1)==3);
assert(spa_pod_find_prop(params[0],NULL,SPA_FORMAT_VIDEO_modifier));
assert(!spa_pod_find_prop(params[1],NULL,SPA_FORMAT_VIDEO_modifier));
/* Recovery must request DMA before the first buffer: opening in CPU mode and
* switching later drops a compositor's already-negotiated DMA first frame. */
p->dma_requested=1;
p->dma_bad=18;
assert(wait_for_first_frame(p)==14); /* Reject unsupported startup buffers without a 10 s stall. */
p->dma_bad=0;
builder=(struct spa_pod_builder)SPA_POD_BUILDER_INIT(storage,sizeof(storage));
const struct spa_pod *format=spa_format_video_raw_build(&builder,SPA_PARAM_Format,
&SPA_VIDEO_INFO_RAW_INIT(.format=SPA_VIDEO_FORMAT_BGRA,.size=SPA_RECTANGLE(2,2),
.flags=SPA_VIDEO_FLAG_MODIFIER,.modifier=0,.framerate=SPA_FRACTION(60,1)));
test_loop_lock(p->pw_loop);
stream_format(p,SPA_PARAM_Format,format);
test_loop_unlock(p->pw_loop);
struct spa_chunk chunk={.size=16,.stride=8};
struct spa_data data={.type=SPA_DATA_DmaBuf,.fd=5,.maxsize=16,.data=(void *)1,.chunk=&chunk};
struct spa_buffer spa={.n_datas=1,.datas=&data};
struct pw_buffer buffer={.buffer=&spa};
process(p,&buffer);
assert(wait_for_first_frame(p)==0 && p->dma_pending==&buffer && p->frame[0]==99);
UuDmaFrame frame; uint64_t revision=0;
assert(uu_portal_dmabuf_acquire(p,&frame,&revision)==0);
uu_portal_dmabuf_release(p);
uu_portal_reset_frame(p);
close_portal(p);
}
int main(void) {
descriptor_bounds();
ownership_and_reset();
negotiation_and_black();
initial_dma_transport();
return 0;
}
+17
View File
@@ -419,7 +419,24 @@ static void authorization_still_required(void) {
g_variant_unref(reply);
}
}
static void saved_token_with_position(const char *token, void *data, int has_position, int32_t x, int32_t y) {
int *calls = data;
assert(!strcmp(token, "synthetic-grant"));
assert(has_position && x == 25 && y == 50);
(*calls)++;
}
static void rotated_token_callback(void) {
struct uu_portal p = {0};
int calls = 0;
save_restore_token(&p, NULL, saved_token_with_position, &calls);
assert(calls == 0);
p.restore_token = "synthetic-grant";
p.has_position = 1; p.position_x = 25; p.position_y = 50;
save_restore_token(&p, NULL, saved_token_with_position, &calls);
assert(calls == 1);
}
int main(void) {
rotated_token_callback();
portal_renegotiation_timeout();
portal_renegotiation_recovery();
portal_renegotiation_event_order_and_healthy_states();
+48
View File
@@ -0,0 +1,48 @@
/* Read-only live-keymap regression: cc tests/uinput_keymap.c -o /tmp/uu-keymap-test -lX11
* Requires DISPLAY (X11 or XWayland). Never injects keys or changes the server keymap. */
#include <assert.h>
#include <stdio.h>
#include "../c_engine/uinput_keymap.c"
int main(void) {
Display *display=XOpenDisplay(NULL);
assert(display);
XkbDescPtr map=XkbGetMap(display,XkbAllClientInfoMask,XkbUseCoreKbd);
assert(map && XkbGetNames(display,XkbKeyNamesMask,map)==Success);
XkbStateRec state={0};
XkbStateRec actual;
assert(XkbGetState(display,XkbUseCoreKbd,&actual)==Success);
state.group=actual.group;
uint8_t characters[97];
for (unsigned i=0;i<95;i++) characters[i]=0x20+i;
characters[95]='\t'; characters[96]='\n';
UuTextKey plan[97];
for (unsigned locks=0;locks<3;locks++) {
state.locked_mods=locks==0 ? 0 : locks==1 ? LockMask : Mod2Mask;
assert(text_plan(map,&state,characters,sizeof(characters),plan,97)==97);
for (unsigned i=0;i<97;i++) {
KeySym symbol=NoSymbol; unsigned consumed=0;
unsigned modifiers=XkbBuildCoreState(state.locked_mods | (plan[i].shift ? ShiftMask : 0),state.group);
assert(XkbTranslateKeyCode(map,plan[i].code+8,modifiers,&consumed,&symbol));
assert(symbol==(characters[i]=='\n' ? XK_Return : characters[i]=='\t' ? XK_Tab : characters[i]));
assert(plan[i].code>=1 && plan[i].code<=248 && plan[i].shift<=248);
}
}
state.locked_mods=0;
const uint8_t mixed[]={'a','b',0xc3,0xa9};
assert(text_plan(map,&state,mixed,sizeof(mixed),plan,97)==2);
assert(text_plan(map,&state,characters,sizeof(characters),plan,2)==2);
state.base_mods=ControlMask;
assert(text_plan(map,&state,characters,sizeof(characters),plan,97)==0);
state.base_mods=0; state.latched_mods=ShiftMask;
assert(text_plan(map,&state,characters,sizeof(characters),plan,97)==0);
state.latched_mods=0;
XkbKeyNameRec previous=map->names->keys[38];
memcpy(map->names->keys[38].name,"NONE",4);
assert(text_plan(map,&state,characters,sizeof(characters),plan,97)==0);
map->names->keys[38]=previous;
XkbFreeKeyboard(map,XkbAllComponentsMask,True);
XCloseDisplay(display);
puts("PASS: ASCII, shift/lock modifiers, partial prefixes and keycode validation");
return 0;
}
+67
View File
@@ -0,0 +1,67 @@
/* Hardware regression: cc tests/vaapi_dmabuf.c -o /tmp/vaapi-dma -lgbm -ldl
* Requires a VAAPI render node. stdout is synthetic H.264: red DMA-BUF, then black host upload.
* No desktop capture or account credentials are used. */
#include <assert.h>
#include <gbm.h>
#include <fcntl.h>
#include <linux/dma-buf.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include "../c_engine/vaapi_engine.c"
static void assert_color(struct gbm_bo *bo, int write_red) {
uint32_t stride=gbm_bo_get_stride(bo);
int fd=gbm_bo_get_fd(bo);
assert(fd>=0);
size_t size=(size_t)stride*720;
uint8_t *pixels=mmap(NULL,size,PROT_READ | PROT_WRITE,MAP_SHARED,fd,0);
assert(pixels!=MAP_FAILED);
struct dma_buf_sync sync={.flags=DMA_BUF_SYNC_START | DMA_BUF_SYNC_RW};
assert(ioctl(fd,DMA_BUF_IOCTL_SYNC,&sync)==0);
for (unsigned y=0; y<720; y++) {
for (unsigned x=0; x<1280; x++) {
uint8_t *pixel=pixels+y*stride+x*4;
if (write_red) { pixel[0]=0; pixel[1]=0; pixel[2]=255; pixel[3]=255; }
else assert(pixel[0]==0 && pixel[1]==0 && pixel[2]==255 && pixel[3]==255);
}
}
sync.flags=DMA_BUF_SYNC_END | DMA_BUF_SYNC_RW;
assert(ioctl(fd,DMA_BUF_IOCTL_SYNC,&sync)==0);
munmap(pixels,size); close(fd);
}
static void encode(VaapiEngine *engine) {
const uint8_t *data=NULL;
uint32_t size=0;
assert(vaapi_encode_frame(engine, 1, &data, &size)==0 && data && size);
assert(fwrite(data, 1, size, stdout)==size);
}
int main(void) {
const char *device=getenv("UU_VAAPI_DEVICE");
if (!device) device="/dev/dri/renderD128";
int fd=open(device, O_RDWR | O_CLOEXEC);
assert(fd>=0);
struct gbm_device *gbm=gbm_create_device(fd);
assert(gbm);
const uint64_t modifier=0;
struct gbm_bo *bo=gbm_bo_create_with_modifiers2(gbm,1280,720,GBM_FORMAT_ARGB8888,&modifier,1,GBM_BO_USE_RENDERING);
assert(bo && gbm_bo_get_modifier(bo)==0);
assert_color(bo,1);
int dma=gbm_bo_get_fd(bo);
assert(dma>=0);
UuDmaFrame frame={.fd=dma,.fourcc=GBM_FORMAT_ARGB8888,.width=1280,.height=720,
.stride=gbm_bo_get_stride(bo),.size=gbm_bo_get_stride(bo)*720,.modifier=0};
VaapiConfig config={.width=1280,.height=720,.cap_width=1280,.cap_height=720,.fps=30,.gop=30,
.target_bps=1000000,.max_bps=2000000,.buffer_bits=500000,.device=device};
VaapiEngine *engine=vaapi_create(&config);
assert(engine && vaapi_import_frame(engine,&frame)==0);
encode(engine);
uint8_t *black=calloc(1280*720,4);
assert(black && vaapi_upload_host_buffer(engine,black,1280*4)==0);
encode(engine);
/* Host fallback must allocate its own surface, never overwrite the leased compositor buffer. */
assert_color(bo,0);
free(black);
vaapi_destroy(engine);
close(dma); gbm_bo_destroy(bo); gbm_device_destroy(gbm); close(fd);
return 0;
}