Compare commits

..
95 Commits
Author SHA1 Message Date
VallierDevandClaude Opus 5.5 13a40f9733 docs: note NVENC API mismatch on Pascal with FFmpeg 9 (#230)
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-14 20:19:40 +08:00
VallierDevandClaude Opus 5.5 5f28047a34 release: v0.2.59
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-14 13:15:56 +08:00
Mr. Error 661263fe37 fix(portal): capture the lock screen on locked cold connections (#229)
* fix(portal): capture the lock screen on locked cold connections

KWin keeps the Portal screencast alive while the session is locked, but maintain() refused to open a session until unlock, so a cold connection only received synthetic black frames. Allow capture during lock on KDE and keep the black-frame fallback for compositors that close the session. A consent failure behind the lock screen and auto privacy now wait for the local unlock.

* docs: document the KDE lock-screen capture default

Cover the new default, the UU_LOCKED_CAPTURE opt-out and the desktop-detection fallback in both READMEs, as requested in #229.
2026-11-14 14:14:42 +09:00
ff2bd9c582 build: copy engine plugins to the profile dir under Cargo's newer build-dir layout (#226)
Rust 1.100 CI places OUT_DIR one level deeper, so ancestors().nth(3) no longer
reached target/<profile> and the release feature-set checks lost libuu-wayland.so.

Co-authored-by: VallierDev <[email protected]>
Co-authored-by: Claude Opus 5.5 <[email protected]>
2026-11-13 13:40:01 +09:00
VallierDevandClaude Opus 5.5 0e1e935fb4 release: v0.2.58
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-12 19:20:09 +08:00
Onekkiandzhuwangqi 4649149ff5 viewer: pick a CJK-capable font for the HUD (#219)
The HUD rasterizes text with a single font and has no per-character
fallback. On systems where fontconfig strongly prefers a Latin-only
sans-serif (e.g. Liberation Sans on Omarchy), 'sans-serif:lang=zh-cn'
resolves to a face without Han glyphs and the Chinese labels render as
empty boxes.

Require U+63A7 (控, from 控制中心) in the fc-match pattern so coverage
influences selection while still respecting the system's font families.

Co-authored-by: zhuwangqi <[email protected]>
2026-11-12 18:17:13 +08:00
阿夜 50a7447b7b 使用 logind D-Bus 监听锁屏变化,减少进程轮询和审计噪声 (#218)
* fix: monitor logind lock state over D-Bus instead of spawning loginctl

* docs: add redacted lock-monitor audit evidence and validation

* fix: retain logind subscription without a graphical session
2026-11-12 17:14:51 +08:00
Kitlee0252 890c46e280 test: keep waiting for the listed session's LIST_RESP on the binary channel (#216)
locked_control_unlock_requests_and_tools_work_without_a_video_frame broke
out of its wait loop on the first BINARY_DATA_CHANNEL message and unwrapped
terminal::decode on it. The process-global terminal change watch also sends
the field-28 list-invalidated notification on that channel
(terminal::changed_message, an initialization::envelope with an empty field
28), which is not a TERM frame, so decode returns None. Any concurrently
running test that opens, kills or reconciles a terminal session can
broadcast it inside this test's wait window, and the suite panics at
desktop_control_tests.rs:302.

Skip messages that do not decode and keep waiting until the LIST_RESP of the
session being listed (71, then 72) arrives, following the sibling terminal
test in webrtc_lifecycle_tests.rs. Test-only change.
2026-11-12 13:08:51 +08:00
Xianjie ZhanandClaude Sonnet 5.5 fe052cdca7 wol: send inner_ip when registering as wake helper (#209)
The helper registration (POST /api/v1/device/wake_on_lan/info) was rejected
with HTTP 422 / code 1001, so the cloud reported 'no helper online' and never
forwarded wake_on_lan pushes. The official macOS client sends inner_ip, ip,
mac and subnet_mask; adding inner_ip makes the server accept the helper.

Verified end to end: headless Linux host in Docker on a NAS, UU_WOL_HELPER=1,
official iOS controller. Registration returns 200 / code 0, the cloud pushes
wake_on_lan, the host sends the magic packet and the Windows PC boots.

Co-authored-by: Claude Sonnet 5.5 <[email protected]>
2026-11-09 22:10:47 +08:00
VallierDevandClaude Opus 5.5 b84e6e4543 release: v0.2.57
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-09 18:48:41 +08:00
Juck Zhang bfbbe2f677 feat: add opt-in controller microphone input (#207)
* feat: add opt-in controller microphone input

* fix: address microphone CI and review feedback
2026-11-09 17:47:07 +08:00
VallierDevandClaude Opus 5.5 f437328ad1 file_trans: reject send_request without a path instead of walking /
Refs #208

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-09 14:45:18 +08:00
VallierDevandClaude Opus 5.5 0308498097 release: v0.2.56
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-09 09:42:48 +08:00
Cr d8e3025fb3 video: size the NVENC VBV buffer like libx264 so keyframes stop blurring (#103) (#205)
The 100-500 kbit NVENC default squeezes every IDR of a high-resolution desktop
into a blur that sharpens over the GOP: at 3840x2160 hevc_nvenc CQ18 / 30M the
IDR frame lost 29-31 dB Y-PSNR against the frame before it, and the following
P-frames spent 15-18 Mbit/s re-sharpening a static desktop.

NVENC now takes one second of the bitrate cap within 500-8000 kbit, the rule
libx264 already uses (#8). UU_NVENC_BUFFER_MS still overrides it, so a small
value brings back the low-latency buffer. VAAPI is unchanged.
2026-11-09 08:37:00 +08:00
Mr. Error 21e9e690ae feat(portal): follow the viewer's mouse mode with the embedded cursor (#203)
* feat(portal): follow the viewer's mouse mode with the embedded cursor

The portal stream hides the compositor cursor. A viewer that drives the pointer
with relative motion (UU's controlled-end mouse, also the Mac trackpad mode)
has no absolute position to draw its own pointer at, and the game's cursor
never reaches the picture, so the mouse can be moved and clicked but not seen.

Request cursor_mode=embedded while relative motion arrives, and keep it hidden
while absolute motion arrives: there the viewer draws its own pointer and an
embedded copy would trail it. The portal reads cursor_mode only when the
session is created, so switch by rebuilding the session with the saved consent,
the same path the privacy screen uses. A run has to last five events and 200 ms
before it counts, so a burst at connect or an alternating controller does not
rebuild; a failed rebuild backs off for five seconds.

The rebuilt session is checked against the monitor the previous one captured,
so a restored consent cannot silently move the share. The engine keeps the mode
for later opens (recovery, privacy, monitor switches) and skips the switch when
an older libuu-portal.so lacks uu_portal_set_cursor_mode.

UU_PORTAL_CURSOR_MODE=embedded sets the startup default.

* fix(portal): keep the cursor rebuild off locks and held input

Do not rebuild while the desktop is locked, and cancel an open that is already
waiting when it locks: GNOME closes the portal session on lock, so the request
would wait for consent that cannot be answered while holding `recovery`
against the post-unlock recovery.

Keys and buttons held through the portal input path are dropped when the
session is replaced, so wait for their release. Monitor selection takes the
same `recovery` lock, so it cannot install a stale source over the cursor
rebuild or the other way round, and the rebuilt session is revalidated against
the source it started from.

* fix(portal): carry the clipboard across cursor rebuilds

The engine keeps the viewer's text only in the session that provided it, and
the host re-sends it only for a new viewer update. A replacement session
therefore had no clipboard ownership, so changing the mouse mode made
previously synchronized text unpasteable until the viewer sent it again.

Offer the text to the replacement before the old session closes, but only
while that session still owns the selection: a local copy that has taken the
clipboard since is left alone. Touch consent upgrades replace the handle too,
so they take the same `recovery` lock as recovery, monitor selection and the
cursor rebuild and cannot install a handle opened under an older cursor mode.

* fix(portal): serialize clipboard writes with the cursor swap

The clipboard bridge calls clipboard_set from its own thread. Installing the
replacement handle and then carrying the old text over left a window where an
update could land on the new session and be overwritten by the older text,
with no pending update left to restore it.

Take a clipboard write lock before the handle is installed and hold it until
the carry-over finishes; clipboard_set takes the same lock. A write that
starts before the swap is included in the text carried over, a write that
starts after waits and wins.

* fix(portal): cancel a waiting rebuild when the desktop ends

The desktop ends its share when the last controller leaves (end_idle), but an
open that is still waiting for consent is not the installed handle, so it
survived that shutdown and installed a live share afterwards.

Bump an end generation in Session::end(), snapshot it before the open, and
cancel the request when it moves. The generation is checked again under the
handle lock before installing, so an end that races the swap either aborts
the rebuild or ends the handle it just installed.

* fix(portal): keep session swaps consistent with the viewer's state

Addresses the ownership race reported on the previous commit and the paths
that share its failure mode.

uu_portal_clipboard_set publishes the new text before SetSelection so a
transfer during the call serves it, restores the old text when the call fails,
and ignores a stale revision so a newer owner wins. The engine reports the
cursor mode it actually requested and the modes the backend advertised; the
host follows that instead of assuming the request was applied and stops
retrying where an embedded cursor is unavailable. The end generation is
sampled before the rebuild queues for `recovery`, a rebuild refuses to start
while the session is no longer alive, and cancellation now covers virtual
output opens.

Portal-bound keys and buttons are tracked separately, so an input held through
the portal defers the swap on every routing path, and the check is repeated
after the open. Every handle replacement (privacy screen, monitor switch,
touch consent, recovery after lock or stream loss) carries the viewer's
clipboard under the clipboard write lock, and the rebuilt session is checked
against the captured geometry.

* fix(portal): stop the swap bookkeeping from outliving a deferred rebuild

open_inner publishes the replacement's cursor mode before the swap. When held
input defers the rebuild, that session is never installed, so the host belief
described the discarded handle and later motion looked like it already matched.
Restore the belief from the installed session on every abort path.

The extra portal releases in release_held now stop at the first failure like
the sweep above; with a dead portal bus each remaining input waited out the
three-second timeout while the input and desktop-owner locks were held.

* fix(portal): invalidate clipboard ownership when a session ends

A closed session stops receiving owner changes, so a cached clipboard_owns
survived into the recovery paths and could republish old viewer text over a
newer local copy. Clear the claim in uu_portal_end and the Closed handler, and
let uu_portal_clipboard_copy refuse a source that is no longer alive.

Mark the embedded cursor unavailable when the engine did not apply it: with
AvailableCursorModes unreadable the session opens hidden, and retrying on every
motion run rebuilt it every 200 ms without changing the mode.

* fix(portal): retire held portal input when the devices are replaced

A key or button held through the native portal path is recorded when its
injection succeeds. If the session dies first, the key-up fails and the record
survives; recovery then installs new devices while the tracker still says an
input is held, so pointer-mode detection keeps deferring.

Keep the tracker in module state and clear it whenever the portal replaces or
ends its devices: the rebuild, both recovery paths and Session::end.

* fix(portal): scope held-input retirement to the retired handle

A press delivered to the replacement after the swap could be recorded while
the old handle was still being retired, and the unconditional reset then
deleted it. Hold the recording lock from before the swap until the reset
finishes, so only inputs sent to the retired devices are dropped.

A portal touchscreen contact was not tracked at all: the swap retired the
active contact while TouchDrag stayed down, so the following move reached a
session that never saw the press. Track contact down/up and include it in the
deferral state.

* fix(portal): serialize touch injection with handle replacement

inject_touch wrote the contact state outside the recording lock the handle
swap holds, so a contact delivered to the replacement between the swap and the
reset could be cleared, and the following phase-1 would fail on new devices
that never saw the press. Take the same lock across the injection and the
state update.

* fix(portal): decide the swap under the held-input lock

The final held-input check ran before install_replacement() took the serial
lock, so an input could be injected and recorded against the old handle while
the install waited for the clipboard lock. The install then retired the
records and swapped, destroying a contact the new devices never saw. Repeat
the check under the serial lock that recording uses, and defer the rebuild
when it hits.

* fix(portal): hold the input lock across native injection, refresh privacy geometry

inject_button and inject_key injected through the portal and only took the
recording lock afterwards, so a swap could take the lock, see no held input
and replace the devices that had just received the press. Take the serial lock
across the injection and its record, as the touch path does; the record
helpers no longer take it themselves.

A cursor rebuild that replaces the privacy virtual output invalidates the
cached pointer region: recompute it from the settled layout so absolute input
keeps landing inside the captured share.
2026-11-09 08:36:37 +08:00
Mr. Error c489f3056f fix(privacy): keep new windows and desktop pets on the virtual output (#201) 2026-11-08 20:16:35 +08:00
Mr. Error 101123797a fix(privacy): accept the Windows viewer's enable=0 encoding (#202) 2026-11-08 20:15:37 +08:00
VallierDevandClaude Opus 5.5 ac9606b872 release: v0.2.55
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-08 00:50:08 +08:00
max2787andmax2787 4e91126561 fix(clipboard): omit format name for predefined Windows Unicode text (#200)
Co-authored-by: max2787 <[email protected]>
2026-11-08 00:48:59 +08:00
VallierDevandClaude Opus 5.5 10825c1fe0 release: v0.2.54
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-11-07 19:43:17 +08:00
cnetstandCodex 36fd51a9d6 Fix terminal session termination, ownership and list updates (#197)
Co-authored-by: Codex <codex@localhost>
2026-11-07 19:42:15 +08:00
Mr. Error 9271904be6 fix(privacy): accept the iOS screen-off encoding (#199)
The iOS viewer sends PrivateScreenSettingRequest{enable=0, privacy_type=3}
when the user turns the display off: its enable bit is the picture-mode
switch and the explicit type carries the intent. The host treated enable=0
as off, so the screen was restored instead of turned off.

Normalize that combination for iOS controllers only. Android 4.43.0 was
verified with the field-1 semantics, so keep Android and desktop viewers
unchanged. Record the platform after a desktop session is created, update
it on capture_desktop promotion, and cancel a pending UU_PRIVACY_AUTO even
when the switch is refused.
2026-11-07 18:40:49 +08:00
cnetstandCodex 1004806035 Resolve the iOS default upload directory alias (#198)
Co-authored-by: Codex <codex@localhost>
2026-11-07 11:21:56 +08:00
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
tingfeng347 6bf05a6361 修复 niri 主控端控制官方 Windows 时的双向文本剪贴板同步 (#138)
Fixes #139.
2026-10-30 13:43:36 +08:00
VallierDevandClaude Opus 5.5 d9c43897c7 Release v0.2.41
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-29 23:46:34 +08:00
9fe1351de1 控制端:重置后关键帧等待接受 I 片/恢复点 SEI 并 1.5 秒超时放行 (#136) (#137)
v0.2.40 在本地重置后只接受 IDR,Mac 被控端对 PLI 不回 IDR 时画面一直空白。
现在 H.264 的 I 片和恢复点 SEI 也算重启点,等待超过 1.5 秒照常解码;
丢弃单元时也取走解码器已完成的画面。

Co-authored-by: VallierDev <[email protected]>
Co-authored-by: Claude Opus 5.5 <[email protected]>
2026-10-29 23:43:34 +08:00
Its.spixy c0b0ca6afb GNOME Portal:手机控制端拖动滚动、按住选中、短按点击 (#134)
Replayed as touch, a phone drag scrolled in browsers but still selected
text in VTE terminals (Ptyxis, GNOME Terminal), as on a real touchscreen.
By default on the portal backend the host now decides per press: moving
past 12 px within 450 ms scrolls smoothly (NotifyPointerAxis or EIS
scroll, content follows the finger, `finish` on release so clients may
coast), holding still selects with button 1 down, and a short press
clicks. This works in terminals too and needs no touchscreen consent.
UU_TOUCH_INPUT=touch keeps the touchscreen replay (with its one-time
consent upgrade); UU_TOUCH_INPUT=0 keeps plain mouse drags.
2026-10-29 23:34:30 +08:00
Its.spixy 11097b5847 GNOME Portal:手机触控模式拖动按触摸屏重放,输入法 ASCII 直接按键输入 (#131)
* portal: mobile touch-mode drags become touch, consent asks once for it

In touch mode the Android viewer sends a finger as a left-button drag at
absolute positions (observed: press, mouse_move_absolute stream, release),
which on GNOME selects text instead of scrolling. SelectDevices now also
asks for the touchscreen type where AvailableDeviceTypes offers it, and a
drag from an Android/iOS controller (controller_platform 2/3) that follows
absolute motion is replayed as one finger through NotifyTouch* or EIS
touch, so the desktop scrolls and taps as on a touch screen. Relative
motion (the trackpad mode) and every other viewer keep mouse buttons.

A consent saved before this restores keyboard and pointer only. The first
mobile drag then asks the host once per run in the background (GNOME's
share dialog, also visible on the phone; the consent timeout closes it)
and swaps the new session in only when it grants the touchscreen for the
same monitor and size. The saved consent is never removed beforehand.
UU_TOUCH_INPUT=0 keeps mouse drags and never asks.

* input: type mobile IME text as portal keysyms on Latin GNOME layouts

Each mobile text_input was set as the clipboard and pasted with
Shift+Insert, which VTE terminals bind to the PRIMARY selection: text
typed from the phone into a terminal pasted whatever was last selected
(observed: a selected line of box-drawing characters for every letter).
When GNOME's active input source (first of mru-sources) is a Latin xkb
layout, printable ASCII, newline and tab now go through
NotifyKeyboardKeysym, where Mutter picks the key and Shift level of the
active layout. Other text, IBus engines, KDE and EIS sessions keep the
clipboard paste, which no longer replaces the clipboard for plain typing.

* portal test: accept libei before 1.3 rejecting a touch outside one of two regions

libei 1.2 (Ubuntu 24.04, CI) accepts a touch only inside every region of the
device; 1.3.0 checks any region. The harness device also carries a region for
another screen, so the older library rejects the touch with a client-bug
diagnostic. A real one-stream session has one region.
2026-10-29 19:49:15 +08:00
Its.spixy 6a0cd5bda6 控制端:跨会话记住画质、帧率和真彩设置 (#133)
The host starts every session at the official defaults (Auto, 60 fps,
4:2:0), so a choice made for a slow link was lost on reconnect. Save them
in viewer.json with the other preferences and send the ones that differ
once CONTROL answers the echo.
2026-10-29 18:48:30 +08:00
VallierDevandClaude Opus 5.5 4cfdd563f7 Release v0.2.40
TURN TCP: report an inspecting proxy that answers with HTTP inside the relay stream.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-29 11:46:02 +08:00
Its.spixyandClaude Opus 5.5 0cbfc5b4f1 控制端:原生分辨率、中英文界面、控制中心、实测 RTT 与稳定性修复 (#129)
* viewer: decode at the host's native size and filter window scaling

Every frame was scaled into a fixed 1920x1080 canvas and SDL then stretched it
to the window with nearest-neighbour sampling, so remote text looked uneven and
blurry. Decode at the native size (read from ffmpeg's verbose scaler line),
restart the decoder when the host resolution changes, and use linear render
scaling. UU_VIEWER_SIZE keeps the fixed canvas, now resampled with Lanczos.

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

* Add Chinese/English UI language

All GTK windows (viewer launcher, tool windows, host main window and QR login)
and viewer messages are available in Chinese and English. The language comes
from UU_LANG, the choice saved in Settings -> General, then the locale.
README: document the fork's changes and language selection.

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

* Host main window: add the language selector

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

* viewer: control center, network status, loading screen, device previews

In-window chrome drawn on the SDL canvas with a fontconfig font (ab_glyph):
- loading animation with the connection stage instead of a black window
- control center (Ctrl+Alt+M or the top tab): quality, fps, true color,
  resolution, fit/1:1, volume, auto lock and host mute (SimpleAction 19,
  14/18/16), system shortcut grab, file transfer, watch mode, full screen,
  disconnect
- network status panel (Ctrl+Alt+G): time, route, fps, bitrate, RTT, loss
- launcher device previews from the last remote picture (local 0600 cache)
- viewer sign-in keeps the local host user service running, so this
  computer joins the account's device list; the settings switch controls it

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

* viewer: compact cascading control center

Narrow category list with an options card beside the selected row, sized to
its content; opaque cards with a hairline border and soft shadow, so the
remote picture no longer shows through.

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

* viewer: keep the control center responsive; resync on a key frame

The menu was rasterized on every mouse event just to hit-test it; hit testing
now uses the layout alone and the drawn menu is cached until what it shows
changes. A stalled UI overflowed the access-unit queue, and the reset decoder
then smeared P-frames into blocks; after a reset it now waits for an IDR/IRAP
while requesting key frames. The tab icon is drawn, since fonts without U+2630
showed a box.

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

* viewer: measured RTT, no crash on closing tool windows, account card

webrtc-ice never measured the round trip, so the network panel always read
'RTT --'. Binding responses now record it on their pair, and the selected
pair is pinged when the sample is older than the keepalive interval, since
a streaming pair never idles (vendor/webrtc-ice/PATCHES.md).

On Wayland, libdecor's GTK plugin drew SDL's title bar with GTK3 from SDL's
thread while the file window ran gtk_main on its own; closing that window
crashed in GTK's style code. GTK builds now offer libdecor only the cairo
plugin unless LIBDECOR_PLUGIN_DIR is set.

Settings > General gets an Account card with the signed-in user and Sign out.

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

* README: keep the language section, without the fork notes

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

* viewer: English server errors in the English UI; stable type_ipc tests

UU servers answer in Chinese only. The English UI now translates the known
messages (2002 target already controlled, assistance refusals) and shows the
code for unknown ones instead of Chinese text.

type_ipc tests shared one temp directory per process and read
XDG_RUNTIME_DIR while another test pointed it at a planted directory; each
call now gets its own directory and socket tests hold the environment lock.

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

* viewer launcher: switching the language restarts the launcher

The choice was saved but took effect only on the next start, so the window
seemed to ignore it. The launcher now re-executes itself in place; session
windows are separate processes and stay connected.

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

* viewer: show pictures as soon as decoded; coalesce mouse motion

The raw-stream parser closed an access unit only when the next began, and
frames were collected only when another one arrived, so a single remote
change (a typed letter) waited for the next one. An access unit delimiter
now follows each unit and the loop drains finished frames between units.

Motions within one 8 ms poll collapse to the newest position (click order
kept), so a drag no longer queues behind itself on a relayed path.

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

* viewer launcher: hosting is opt-in

Signing in to the viewer no longer installs or enables uuremote-native.service.
Only the Settings switch enables or disables it, and the unit's enabled state is
the saved choice, so turning it off survives a restart. A new sign-in restarts the
host only when the user turned it on and it is running.

PATCHES.md: the RTT keepalive also runs on the host; checked with the official
Android client controlling a Linux host.

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

* viewer: drop SDL event types sdl2 0.37 does not define

sdl2 0.37 transmutes every event type into SDL_EventType. sdl2-compat on SDL3
delivers types SDL 2 does not define (0x207), which is undefined behaviour and
aborts with debug checks (clipboard_requests_use_existing_window on Fedora 44).
Poll raw events and skip those types before the crate converts them.

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

* Keep the package version at 0.2.39

The maintainer sets the version at release time.

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

---------

Co-authored-by: Claude Opus 5.5 <[email protected]>
2026-10-29 10:45:11 +08:00
Its.spixyandClaude Opus 5.5 47c7728822 GNOME Portal:多显示器切换、精确触控、断开后停止共享 (#128)
* portal: switch monitors on GNOME, precise touch, stop sharing when idle

GNOME grants one monitor per portal consent and refuses multi-select, so
each Mutter monitor gets its own saved consent (gnome@<connector>). The
monitors are advertised as screens; a switch opens that monitor's session
(silently once consented, GNOME asks on the host the first time) and swaps
it into the shared PortalSession, whose frame size follows the monitor.

Absolute motion and clicks go through the portal session: a uinput tablet
spans every monitor, and clicks on the separate uinput queue could land
before the compositor moved the pointer.

An idle watch ends the portal session (screen-share indicator off) once no
desktop controller is left for two checks; the next one reopens it with the
saved consent.

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

* portal: stop screen sharing as soon as the last controller leaves

The idle watch stays as the fallback for controllers that vanish without
a release event.

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

* portal test: accept the runtime-engine message in portal builds

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

---------

Co-authored-by: Claude Opus 5.5 <[email protected]>
2026-10-29 10:44:30 +08:00
Its.spixy e503041dac 登录:跨进程串行化设备注册 (#127)
主机扫码窗口与控制端登录可能各自调用 device/windows/init,导致账号绑定一台设备而 config.json 保存另一台(主机显示离线的幽灵设备)。现在在 config.json 旁的排他文件锁下注册设备,取锁后重读配置,第二个流程复用已注册设备。

感谢 @spixyy7 的贡献。

🤖 Generated with [Claude Code](https://claude.com/claude-code)
2026-10-29 04:40:52 +08:00
Sile Liu 835bfa2319 Fix niri monitor switching, rotated input and mobile text (#71)
niri 实验性支持:三屏切换、90°/180°/270° 旋转输出的采集与指针映射、手机中文文本输入,全部 gated 在 NIRI_SOCKET,不影响 Hyprland/X11 路径。新增 wayland_transform.h 及其 ASAN 单测。

感谢 @WALKERKILLER 的贡献与 CachyOS + niri 实机验收。

🤖 Generated with [Claude Code](https://claude.com/claude-code)
2026-10-29 01:39:01 +08:00
VallierDevandClaude Opus 5.5 482c01a85d viewer tests: accept the video track RPC in the loopback session
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 20:45:43 +08:00
VallierDevandClaude Opus 5.5 7f6cf6e092 Release v0.2.39
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 20:39:58 +08:00
VallierDevandClaude Opus 5.5 c0c04a2c98 viewer: request the desktop video track like the official viewer (#124)
The official iPhone viewer sends RpcRequest case 15 SendVideoTrackReq (no
fields) right after CONTROL opens. Without it a second session only joins the
stream already encoded for another viewer: no SPS/PPS/IDR, so it stays black.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 20:37:43 +08:00
VallierDevandClaude Opus 5.5 b636f1b278 Release v0.2.38
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 20:22:03 +08:00
VallierDevandClaude Opus 5.5 64d2ffbdd3 ICE: trust the system certificate store for TURN over TLS
A TLS-inspecting HTTP proxy re-signs the TURN certificate with a CA that the
host's administrator installed in the system store; OpenSSL accepts it while
the bundled Mozilla roots alone fail with UnknownIssuer.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 20:21:37 +08:00
VallierDevandClaude Opus 5.5 5656f33d86 Release v0.2.37
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 19:35:12 +08:00
VallierDevandClaude Opus 5.5 6a633e1bc4 ICE: gather TURN relays over TCP/TLS through the HTTP proxy with UU_USE_PROXY=1
Upstream webrtc-ice only gathers UDP relays. Forced-relay sessions also offer
turns:<ip>:<port>?transport=tcp, the only media path on hosts whose UDP cannot
reach the TURN servers but whose TCP goes through an HTTP proxy. Vendor
webrtc-ice 0.10.1 with a TCP/TLS dialer (optional HTTP CONNECT) that frames
STUN/ChannelData for the unchanged turn client. Certificates are chain-verified;
a name mismatch is accepted only for IP-literal TURN URLs. Enabled only with
UU_USE_PROXY=1; default UDP gathering is unchanged.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 19:34:24 +08:00
VallierDevandClaude Opus 5.5 ab137a1b20 Release v0.2.36
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 17:27:17 +08:00
VallierDevandClaude Opus 5.5 092ea713f8 X11: fall back to XGetImage when MIT-SHM attach is refused
XShmAttach fails asynchronously with BadAccess when the X server cannot reach
the segment (for example a server in another container); Xlib's default error
handler exited the host before the existing XGetImage fallback could run.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 17:26:01 +08:00
VallierDevandClaude Opus 5.5 53d5f0e144 viewer: request key frames until the first frame is shown (#124)
A session that joins a host already streaming to another viewer can receive a
clean stream with no IDR in flight, so the loss-driven PLI never fired. Ask
every 30 access units until something is presented, and warn after 300.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 16:36:35 +08:00
VallierDevandClaude Opus 5.5 6b5216df35 Release v0.2.35
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 15:21:34 +08:00
VallierDevandClaude Opus 5.5 d66937a01c Signaling: honor the REST client's opt-in HTTP proxy policy (#123)
Route host and viewer WebSocket signaling through the shared reqwest client so UU_USE_PROXY=1 applies to signaling as well (HTTP/HTTPS proxies only, no direct fallback, no redirects, strict upgrade validation). ICE/WebRTC media is not proxied.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 14:42:12 +08:00
VallierDevandClaude Opus 5.5 825f964f7d doctor: warn about extra host instances; README: never share config.json (#122)
Count only top-level hosts (helpers such as the Wayland capture process and
the login window are children) and explain that two instances with one
identity kick each other out of the room.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 14:32:37 +08:00
VallierDevandClaude Opus 5.5 3f2da6f587 doctor: count re-executed host processes by executable (#122)
The host re-execs through /proc/self/exe, so its process name becomes "exe"
and pgrep -x uuremote-server missed duplicate hosts.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 14:26:34 +08:00
VallierDevandClaude Opus 5.5 027abba44d Signaling: log the shape of cloud room leaves without a peer id (#122)
Keys, value types and lengths only, as for SOAC offers.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 14:02:10 +08:00
VallierDevandClaude Opus 5.5 ef86019b39 Login: distinguish QR polling failures from expiry with safe diagnostics (#121)
Classify QR request failures (timeout/connect/decode/body/request) with phase, elapsed time and HTTP/API status only; never print tickets, URLs or server content. Extract and test the polling decisions; keep the 60 s timeout and official refresh behaviour.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-28 13:28:50 +08:00
shofukantktsandshofukantkts 003da254a6 Wayland: type mobile text_input via clipboard paste on Portal and compositors without spare keycodes (#119)
* Wayland: type mobile text_input via clipboard paste on Portal and compositors without spare keycodes

* Wayland: address review comments for mobile text_input clipboard fallback

- Guard external clipboard commands in unit tests to eliminate desktop side effects
- Narrow paste fallback to Wayland and Portal backends only
- Document clipboard override and two-way sync behavior in README (both zh and en)
- Unify disable switch via UU_WAYLAND_TEXT=0

---------

Co-authored-by: shofukantkts <[email protected]>
2026-10-27 22:14:56 +08:00
VallierDevandClaude Opus 5.5 7a86fab340 Release v0.2.34
Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-27 13:10:49 +08:00
VallierDevandClaude Opus 5.5 d631849f1d Viewer: map the desktop window before the first decoded frame (#118)
Wayland shows a toplevel only after its first buffer, so a stream that never
yields a picture left no window at all. Present a black buffer on creation and
on resize/expose while no frame has arrived.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-27 12:10:35 +08:00
VallierDevandClaude Opus 5.5 d04d241411 Viewer: repaint the last frame after a compositor resize (#118)
Tiling or maximizing the SDL viewer resized the surface, but nothing was
drawn until the next decoded frame, so a static remote desktop stayed blank.
Repaint the last frame on SizeChanged/Resized/Exposed/Maximized/Restored.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-27 11:10:53 +08:00
VallierDevandClaude Opus 5.5 2eece30287 Signaling: bound the WebSocket handshake so reconnect retries after a stall (#115)
After a network change the DNS/TCP/TLS/upgrade could stall forever after
room credentials were acquired; the reconnect loop never retried. The
handshake now fails after 20s and the existing 5s retry takes over.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-26 20:03:54 +08:00
217 changed files with 29143 additions and 947 deletions

No files matched your search

+21 -3
View File
@@ -25,10 +25,19 @@ jobs:
sudo apt-get update sudo apt-get update
sudo apt-get install -y build-essential pkg-config \ sudo apt-get install -y build-essential pkg-config \
libx11-dev libxext-dev libxtst-dev libxfixes-dev libgtk-3-dev \ 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: dtolnay/rust-toolchain@stable
- uses: Swatinem/rust-cache@v2 - uses: Swatinem/rust-cache@v2
- run: cargo test --locked - 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 # 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). # the portal plugin is skipped with a warning (release builds it on 24.04).
- name: Release feature set - name: Release feature set
@@ -97,7 +106,7 @@ jobs:
ASAN_OPTIONS: detect_leaks=1 ASAN_OPTIONS: detect_leaks=1
UBSAN_OPTIONS: halt_on_error=1 UBSAN_OPTIONS: halt_on_error=1
run: | run: |
for source in tests/portal_engine.c tests/portal_input.c tests/portal_eis.c tests/desktop_power.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)" target="/tmp/$(basename "$source" .c)"
cc -O1 -g -fsanitize=address,undefined -fno-omit-frame-pointer \ cc -O1 -g -fsanitize=address,undefined -fno-omit-frame-pointer \
-Wall -Wextra -Wno-unused-parameter "$source" -o "$target" \ -Wall -Wextra -Wno-unused-parameter "$source" -o "$target" \
@@ -114,10 +123,19 @@ jobs:
sudo apt-get update sudo apt-get update
sudo apt-get install -y build-essential pkg-config \ sudo apt-get install -y build-essential pkg-config \
libx11-dev libxext-dev libxtst-dev libxfixes-dev libgtk-3-dev \ 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: dtolnay/rust-toolchain@stable
- uses: Swatinem/rust-cache@v2 - 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
- run: cargo test --locked --features inproc-av,wayland,portal
test-linux-arm64: test-linux-arm64:
# aarch64 hosts (Ampere A1, arm64 VMs, Apple-silicon VMs) build from source, so keep that # aarch64 hosts (Ampere A1, arm64 VMs, Apple-silicon VMs) build from source, so keep that
+12 -3
View File
@@ -29,7 +29,10 @@ This file is written for large language model agents (Claude Code, Codex, Cursor
the config file / environment. The only built-in default is the public client signing key in `src/auth.rs`. the config file / environment. The only built-in default is the public client signing key in `src/auth.rs`.
6. **Don't break other tools.** The desktop, file-transfer, terminal and port-mapping tools each open their own 6. **Don't break other tools.** The desktop, file-transfer, terminal and port-mapping tools each open their own
peer connection; a new offer must never close other peers. peer connection; a new offer must never close other peers.
7. Keep changes small and tested; match the surrounding code style (dense, comment only the non-obvious). 7. **UI text is bilingual.** Every user-facing string has Chinese and English: `L("中文", "English")` in C
(`c_engine/i18n.h`), `crate::i18n::s(..)` / `crate::tr!(..)` in Rust (`src/i18n.rs`; `UU_LANG`, saved choice, locale).
Logs stay English.
8. Keep changes small and tested; match the surrounding code style (dense, comment only the non-obvious).
## 3. Build and test ## 3. Build and test
@@ -122,7 +125,9 @@ viewer does not reconnect them automatically.
| `UU_X11_MULTISCREEN=1`, `UU_X11_OUTPUT` | X11: advertise each RandR monitor (`xrandr --listmonitors`, read once at start; primary or `UU_X11_OUTPUT` is id 0) through the same screen-switch path as `UU_WAYLAND_MULTISCREEN` (`wayland::outputs`/`select`). x11grab reads `display+x,y` at the monitor size, XTest/uinput absolute input adds the monitor offset, the in-process engine and `desktop_mode` resize are skipped (分辨率 scales). Needs two or more monitors | | `UU_X11_MULTISCREEN=1`, `UU_X11_OUTPUT` | X11: advertise each RandR monitor (`xrandr --listmonitors`, read once at start; primary or `UU_X11_OUTPUT` is id 0) through the same screen-switch path as `UU_WAYLAND_MULTISCREEN` (`wayland::outputs`/`select`). x11grab reads `display+x,y` at the monitor size, XTest/uinput absolute input adds the monitor offset, the in-process engine and `desktop_mode` resize are skipped (分辨率 scales). Needs two or more monitors |
| `UU_DESKTOP_RESIZE=0` | X11: the viewer's 分辨率 choice scales the encoded stream instead of changing the display mode. Default: `src/desktop_mode.rs` switches the primary output via xrandr (adds a CVT-RB mode when missing, re-applies once if mutter resets it), restores the original mode for resolution_type 3 and 2 s after the last desktop stream ends | | `UU_DESKTOP_RESIZE=0` | X11: the viewer's 分辨率 choice scales the encoded stream instead of changing the display mode. Default: `src/desktop_mode.rs` switches the primary output via xrandr (adds a CVT-RB mode when missing, re-applies once if mutter resets it), restores the original mode for resolution_type 3 and 2 s after the last desktop stream ends |
| `UU_NVENC_RGB=0` / `=1` | NVENC 4:2:0 without scaling takes packed BGRA/BGR0 directly (no CPU swscale). Default: on, except when a connected DRM connector belongs to an nvidia-bound card (desktop composited on the encoding GPU; #16 measured 82.6 vs 98 fps at 4K). `0` forces CPU conversion, `1` forces the direct path | | `UU_NVENC_RGB=0` / `=1` | NVENC 4:2:0 without scaling takes packed BGRA/BGR0 directly (no CPU swscale). Default: on, except when a connected DRM connector belongs to an nvidia-bound card (desktop composited on the encoding GPU; #16 measured 82.6 vs 98 fps at 4K). `0` forces CPU conversion, `1` forces the direct path |
| `UU_TOUCH_INPUT` | Android/iOS controllers (connect header `controller_platform` 2/3) send a finger as a left-button drag at absolute positions. Default on the portal backend (gesture): per press, moving past 12 px within 450 ms scrolls (`NotifyPointerAxis` / EIS scroll, content follows the finger, `finish` on release), holding still selects with button 1 down, a short press clicks; needs no touchscreen consent. `touch`: replay as one finger on the portal touchscreen (`NotifyTouch*` / EIS touch; requested where `AvailableDeviceTypes` offers it; consents saved before touch support restore keyboard+pointer only, so the first mobile drag asks once per run in the background via `PortalSession::upgrade_touch`, swapped in only with the touchscreen granted for the same monitor; the saved consent is never removed first). `0`: plain mouse drags |
| `UU_INPUT_BACKEND` | `auto` (uinput on Wayland/portal when `/dev/uinput` is accessible, udev `uaccess` rule in README) / `uinput` / `native`. X11 keeps XTest (held-key autorepeat handling) | | `UU_INPUT_BACKEND` | `auto` (uinput on Wayland/portal when `/dev/uinput` is accessible, udev `uaccess` rule in README) / `uinput` / `native`. X11 keeps XTest (held-key autorepeat handling) |
| `UU_PORTAL_CURSOR_MODE` | portal capture startup cursor mode: `embedded` draws the compositor pointer into the stream, default hidden. `input::inject_move` reports relative/absolute motion; `portal::note_pointer_motion` flips the mode after a 200 ms run of one kind and rebuilds the session via `Session::set_cursor_embedded`, because the portal only reads `cursor_mode` in `SelectSources`. Relative motion gives the viewer no position to draw its own pointer at, so the stream must carry one; absolute motion means the viewer draws its own and an embedded copy would trail it |
| Mac viewer Cmd | With 「使用 macOS 快捷键」 off the Mac viewer sends Cmd=VK_LWIN 0x5B, Option=0xA4, Ctrl=0xA2; connect header `controller_platform`=4 is macOS. For Mac controllers Cmd is held back: Cmd+C/V/A/F/X/Z → Ctrl+key (terminal: Cmd+C/V → Ctrl+Shift+C/V), other combos/alone → Super | | Mac viewer Cmd | With 「使用 macOS 快捷键」 off the Mac viewer sends Cmd=VK_LWIN 0x5B, Option=0xA4, Ctrl=0xA2; connect header `controller_platform`=4 is macOS. For Mac controllers Cmd is held back: Cmd+C/V/A/F/X/Z → Ctrl+key (terminal: Cmd+C/V → Ctrl+Shift+C/V), other combos/alone → Super |
| `UU_TERMINAL_SHORTCUTS=0` | disable Ctrl+V → Ctrl+Shift+V in focused X11 terminals (Mac Cmd and Ctrl both arrive as VK_LCONTROL) | | `UU_TERMINAL_SHORTCUTS=0` | disable Ctrl+V → Ctrl+Shift+V in focused X11 terminals (Mac Cmd and Ctrl both arrive as VK_LCONTROL) |
| `contrib/virtual-desktop/` | Xvfb + session (`UU_VIRTUAL_SESSION`, `UU_VIRTUAL_BUS=user|private`) for monitorless hosts; serve it with `DISPLAY=:99` | | `contrib/virtual-desktop/` | Xvfb + session (`UU_VIRTUAL_SESSION`, `UU_VIRTUAL_BUS=user|private`) for monitorless hosts; serve it with `DISPLAY=:99` |
@@ -133,7 +138,7 @@ viewer does not reconnect them automatically.
| `UU_LOGIN_WINDOW=0` | don't auto-open the login window | | `UU_LOGIN_WINDOW=0` | don't auto-open the login window |
| `UU_ENGINE_DIR` | directory holding `libuu-wayland.so` / `libuu-portal.so` (`--features engine-plugins`, used by release packages: engines are dlopen'ed only on Wayland sessions; also searched next to the binary, `../lib/uu-remote-linux`, `~/.local/lib/uu-remote-linux`, `/usr/lib/uu-remote-linux`) | | `UU_ENGINE_DIR` | directory holding `libuu-wayland.so` / `libuu-portal.so` (`--features engine-plugins`, used by release packages: engines are dlopen'ed only on Wayland sessions; also searched next to the binary, `../lib/uu-remote-linux`, `~/.local/lib/uu-remote-linux`, `/usr/lib/uu-remote-linux`) |
| `UU_WOL_HELPER=1` | experimental: report LAN info (`api-ipv4…/api/v1/device/wake_on_lan/info` {mac, ip, subnet_mask}) after sign-in and answer `wake_on_lan` pushes (`target_device` {mac, ip, subnet_mask}) with a magic packet, like the official Windows host (field names from its log strings; not verified end to end). `wake_on_lan` push key names are always logged | | `UU_WOL_HELPER=1` | experimental: report LAN info (`api-ipv4…/api/v1/device/wake_on_lan/info` {mac, ip, subnet_mask}) after sign-in and answer `wake_on_lan` pushes (`target_device` {mac, ip, subnet_mask}) with a magic packet, like the official Windows host (field names from its log strings; not verified end to end). `wake_on_lan` push key names are always logged |
| `UU_USE_PROXY=1` | honor HTTP/SOCKS proxy env vars; cloud API clients bypass env proxies by default | | `UU_USE_PROXY=1` | honor HTTP/HTTPS proxy env vars for REST and WebSocket signaling, and also gather TURN relays over TCP/TLS through that proxy (`vendor/webrtc-ice/PATCHES.md`; chain-verified, name mismatch tolerated for IP TURN URLs); clients bypass env proxies by default |
| `UU_REMOTE_ASSIST=0`, `UU_ASSIST_ALLOW=1`, `UU_ASSIST_UI=tty`, `UU_ASSIST_DEBUG=1` | disable assistance / allow at start / terminal UI for `assist` / include the server's short error message in assist errors | | `UU_REMOTE_ASSIST=0`, `UU_ASSIST_ALLOW=1`, `UU_ASSIST_UI=tty`, `UU_ASSIST_DEBUG=1` | disable assistance / allow at start / terminal UI for `assist` / include the server's short error message in assist errors |
Token has no expiry field; API code 1120 (HTTP 422) means invalid/expired → re-login. `config.json` is parsed once Token has no expiry field; API code 1120 (HTTP 422) means invalid/expired → re-login. `config.json` is parsed once
@@ -156,8 +161,10 @@ for a new QR login.
| `src/clipboard*.rs` | text clipboard bridge and protocol | | `src/clipboard*.rs` | text clipboard bridge and protocol |
| `src/file_trans.rs` | FileTransferFtp RPC | | `src/file_trans.rs` | FileTransferFtp RPC |
| `src/terminal.rs` | TERM frames + PTY sessions | | `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/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/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/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/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 | | `src/desktop_backend.rs`, `src/wayland.rs`, `src/portal*.rs` | backend selection, Hyprland, GNOME/KDE portal |
@@ -168,6 +175,8 @@ for a new QR login.
| `src/assist.rs`, `c_engine/assist_window.c` | remote assistance (guest + account) and the unified GTK main window (assist + account/QR card) | | `src/assist.rs`, `c_engine/assist_window.c` | remote assistance (guest + account) and the unified GTK main window (assist + account/QR card) |
| `src/viewer_main.rs`, `src/viewer/` | experimental viewer (`--features native-viewer,viewer-sdl`): cloud join, WebRTC offer side, SDL desktop window (ffmpeg CLI decode), files/terminal/portmap/power/assist tools, device removal (`POST /api/v1/device/{id}/unbind`, verified live; shared devices use `/api/v1/device/share/{id}/unbind`, strings only), GTK launcher | | `src/viewer_main.rs`, `src/viewer/` | experimental viewer (`--features native-viewer,viewer-sdl`): cloud join, WebRTC offer side, SDL desktop window (ffmpeg CLI decode), files/terminal/portmap/power/assist tools, device removal (`POST /api/v1/device/{id}/unbind`, verified live; shared devices use `/api/v1/device/share/{id}/unbind`, strings only), GTK launcher |
| `c_engine/viewer_window.c`, `c_engine/viewer_tools.c` | viewer GTK launcher and tool windows (files, port mapping, terminal list) | | `c_engine/viewer_window.c`, `c_engine/viewer_tools.c` | viewer GTK launcher and tool windows (files, port mapping, terminal list) |
| `src/viewer/hud.rs` | in-window chrome drawn on the SDL canvas: loading screen, control center (Ctrl+Alt+M; capture settings RPC 2 and SimpleActions 14/16/18/19 as the official viewer sends them), network-status panel (Ctrl+Alt+G); fontconfig font via ab_glyph |
| `src/viewer/thumbs.rs`, `src/viewer/host.rs` | launcher device previews (last picture, local 0600 cache); viewer sign-in keeps the local host user service running so the machine joins the account's device list |
Diagnostic subcommands: `doctor` (paste-safe report: session, selected backend, engine plugins, uinput, encoder and codec with source, sign-in/service state; booleans and names only), `set-encoder auto|cpu|vaapi|nvenc` and `set-codec auto|h264|h265` (both notify a running host with SIGUSR2; live encoder switch, negotiated codec unchanged, codec preference on the next desktop stream; illegal values exit 2), `login [--no-gui]`, `unlock-check` (password on stdin, prints only accepted/rejected), Diagnostic subcommands: `doctor` (paste-safe report: session, selected backend, engine plugins, uinput, encoder and codec with source, sign-in/service state; booleans and names only), `set-encoder auto|cpu|vaapi|nvenc` and `set-codec auto|h264|h265` (both notify a running host with SIGUSR2; live encoder switch, negotiated codec unchanged, codec preference on the next desktop stream; illegal values exit 2), `login [--no-gui]`, `unlock-check` (password on stdin, prints only accepted/rejected),
`desktop-probe [new.png]`, `desktop-video-probe` (`UU_PROBE_FPS`, `UU_PROBE_FRAMES`, `UU_PROBE_QUALITY` 1-5 = viewer bitrate preset, 5 auto; `UU_PROBE_CHROMA=444` 真彩; `UU_PROBE_INPUT` fixed video/image sequence, `UU_PROBE_LOOP=1` repeats), `wayland-input-probe`, `clipboard-acceptance`, `desktop-probe [new.png]`, `desktop-video-probe` (`UU_PROBE_FPS`, `UU_PROBE_FRAMES`, `UU_PROBE_QUALITY` 1-5 = viewer bitrate preset, 5 auto; `UU_PROBE_CHROMA=444` 真彩; `UU_PROBE_INPUT` fixed video/image sequence, `UU_PROBE_LOOP=1` repeats), `wayland-input-probe`, `clipboard-acceptance`,
@@ -187,7 +196,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 - 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, `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, 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 - 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), 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). 5 Auto, 6 Custom. Resolution: 16/17 pixel size or 5/6, 10 resolution_type (3 = follow remote).
Generated
+413 -5
View File
@@ -2,6 +2,22 @@
# It is not intended for manual editing. # It is not intended for manual editing.
version = 4 version = 4
[[package]]
name = "ab_glyph"
version = "0.2.32"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "01c0457472c38ea5bd1c3b5ada5e368271cb550be7a4ca4a0b4634e9913f6cc2"
dependencies = [
"ab_glyph_rasterizer",
"owned_ttf_parser",
]
[[package]]
name = "ab_glyph_rasterizer"
version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "366ffbaa4442f4684d91e2cd7c5ea7c4ed8add41959a31447066e279e432b618"
[[package]] [[package]]
name = "adler2" name = "adler2"
version = "2.0.1" version = "2.0.1"
@@ -156,6 +172,29 @@ dependencies = [
"syn 1.0.109", "syn 1.0.109",
] ]
[[package]]
name = "async-broadcast"
version = "0.7.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "435a87a52755b8f27fcf321ac4f04b2802e337c8c4872923137471ec39c37532"
dependencies = [
"event-listener",
"event-listener-strategy",
"futures-core",
"pin-project-lite",
]
[[package]]
name = "async-recursion"
version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4f8abc12baad266b1c8cec146854c195b5864b4221d4b2ca7296a7ae82d9e451"
dependencies = [
"proc-macro2",
"quote",
"syn 3.0.9",
]
[[package]] [[package]]
name = "async-trait" name = "async-trait"
version = "0.1.92" version = "0.1.92"
@@ -624,6 +663,33 @@ dependencies = [
"zeroize", "zeroize",
] ]
[[package]]
name = "endi"
version = "1.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099"
[[package]]
name = "enumflags2"
version = "0.7.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1027f7680c853e056ebcec683615fb6fbbc07dbaa13b4d5d9442b146ded4ecef"
dependencies = [
"enumflags2_derive",
"serde",
]
[[package]]
name = "enumflags2_derive"
version = "0.7.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.119",
]
[[package]] [[package]]
name = "env_filter" name = "env_filter"
version = "2.0.0" version = "2.0.0"
@@ -647,6 +713,12 @@ dependencies = [
"log", "log",
] ]
[[package]]
name = "equivalent"
version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "00d174d5400e5e8fd687ad1049e2f578285fa914201b1af7e8b112a4546bd826"
[[package]] [[package]]
name = "errno" name = "errno"
version = "0.3.14" version = "0.3.14"
@@ -657,6 +729,41 @@ dependencies = [
"windows-sys 0.61.2", "windows-sys 0.61.2",
] ]
[[package]]
name = "event-listener"
version = "5.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5a23add41df1562121a9393cb065eab5146a1242410f23a644851e90cfd669d2"
dependencies = [
"parking",
"pin-project-lite",
]
[[package]]
name = "event-listener-strategy"
version = "0.5.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
dependencies = [
"event-listener",
"pin-project-lite",
]
[[package]]
name = "fastrand"
version = "2.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"
[[package]]
name = "fdeflate"
version = "0.3.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
dependencies = [
"simd-adler32",
]
[[package]] [[package]]
name = "ff" name = "ff"
version = "0.13.1" version = "0.13.1"
@@ -711,7 +818,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb" checksum = "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb"
dependencies = [ dependencies = [
"crc32fast", "crc32fast",
"miniz_oxide", "miniz_oxide 0.9.1",
"zlib-rs", "zlib-rs",
] ]
@@ -772,6 +879,19 @@ version = "0.3.34"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "53c0fa8157de1303bfffdaa1cc2a673bfffb60102f76b0ef4441659124373fed" checksum = "53c0fa8157de1303bfffdaa1cc2a673bfffb60102f76b0ef4441659124373fed"
[[package]]
name = "futures-lite"
version = "2.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"
dependencies = [
"fastrand",
"futures-core",
"futures-io",
"parking",
"pin-project-lite",
]
[[package]] [[package]]
name = "futures-macro" name = "futures-macro"
version = "0.3.34" version = "0.3.34"
@@ -887,6 +1007,12 @@ dependencies = [
"subtle", "subtle",
] ]
[[package]]
name = "hashbrown"
version = "0.17.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
[[package]] [[package]]
name = "hermit-abi" name = "hermit-abi"
version = "0.5.3" version = "0.5.3"
@@ -1120,6 +1246,16 @@ dependencies = [
"icu_properties", "icu_properties",
] ]
[[package]]
name = "indexmap"
version = "2.14.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855"
dependencies = [
"equivalent",
"hashbrown",
]
[[package]] [[package]]
name = "inout" name = "inout"
version = "0.1.4" version = "0.1.4"
@@ -1301,12 +1437,31 @@ dependencies = [
"autocfg", "autocfg",
] ]
[[package]]
name = "memoffset"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
dependencies = [
"autocfg",
]
[[package]] [[package]]
name = "minimal-lexical" name = "minimal-lexical"
version = "0.2.1" version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" 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]] [[package]]
name = "miniz_oxide" name = "miniz_oxide"
version = "0.9.1" version = "0.9.1"
@@ -1337,7 +1492,7 @@ dependencies = [
"bitflags 1.3.2", "bitflags 1.3.2",
"cfg-if", "cfg-if",
"libc", "libc",
"memoffset", "memoffset 0.7.1",
"pin-utils", "pin-utils",
] ]
@@ -1440,6 +1595,25 @@ version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe" checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
[[package]]
name = "ordered-stream"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9aa2b01e1d916879f73a53d01d1d6cee68adbb31d6d9177a8cfce093cced1d50"
dependencies = [
"futures-core",
"pin-project-lite",
]
[[package]]
name = "owned_ttf_parser"
version = "0.25.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "36820e9051aca1014ddc75770aab4d68bc1e9e632f0f5627c4086bc216fb583b"
dependencies = [
"ttf-parser",
]
[[package]] [[package]]
name = "p256" name = "p256"
version = "0.13.2" version = "0.13.2"
@@ -1464,6 +1638,12 @@ dependencies = [
"sha2", "sha2",
] ]
[[package]]
name = "parking"
version = "2.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
[[package]] [[package]]
name = "parking_lot" name = "parking_lot"
version = "0.12.5" version = "0.12.5"
@@ -1546,6 +1726,19 @@ version = "0.3.34"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548" 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]] [[package]]
name = "polyval" name = "polyval"
version = "0.6.2" version = "0.6.2"
@@ -1606,6 +1799,15 @@ dependencies = [
"elliptic-curve", "elliptic-curve",
] ]
[[package]]
name = "proc-macro-crate"
version = "3.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f"
dependencies = [
"toml_edit",
]
[[package]] [[package]]
name = "proc-macro2" name = "proc-macro2"
version = "1.0.107" version = "1.0.107"
@@ -2172,6 +2374,17 @@ dependencies = [
"zmij", "zmij",
] ]
[[package]]
name = "serde_repr"
version = "0.1.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8d3b1629de253c70a0508c3899572da79ca359fdab27c7920ff00406df418906"
dependencies = [
"proc-macro2",
"quote",
"syn 3.0.9",
]
[[package]] [[package]]
name = "serde_urlencoded" name = "serde_urlencoded"
version = "0.7.1" version = "0.7.1"
@@ -2406,6 +2619,19 @@ dependencies = [
"syn 3.0.9", "syn 3.0.9",
] ]
[[package]]
name = "tempfile"
version = "3.27.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
dependencies = [
"fastrand",
"getrandom 0.4.3",
"once_cell",
"rustix",
"windows-sys 0.61.2",
]
[[package]] [[package]]
name = "thiserror" name = "thiserror"
version = "1.0.69" version = "1.0.69"
@@ -2506,6 +2732,7 @@ dependencies = [
"signal-hook-registry", "signal-hook-registry",
"socket2 0.6.5", "socket2 0.6.5",
"tokio-macros", "tokio-macros",
"tracing",
"windows-sys 0.61.2", "windows-sys 0.61.2",
] ]
@@ -2559,6 +2786,36 @@ dependencies = [
"tokio", "tokio",
] ]
[[package]]
name = "toml_datetime"
version = "1.1.3+spec-1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "173f25c883cd2176a2d8212155638c0a60d484a9d84546d270866f40f56b6e49"
dependencies = [
"serde_core",
]
[[package]]
name = "toml_edit"
version = "0.25.19+spec-1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dd43688c4858d7264ae1cf9a9f874a67c3feb74a883b1cd7bebd6a4ea8307218"
dependencies = [
"indexmap",
"toml_datetime",
"toml_parser",
"winnow",
]
[[package]]
name = "toml_parser"
version = "1.1.5+spec-1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baa693a8032d7e1cada7d0041e96126df243179ff061456783ac7f12bda4744c"
dependencies = [
"winnow",
]
[[package]] [[package]]
name = "tower" name = "tower"
version = "0.5.3" version = "0.5.3"
@@ -2611,9 +2868,21 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
dependencies = [ dependencies = [
"pin-project-lite", "pin-project-lite",
"tracing-attributes",
"tracing-core", "tracing-core",
] ]
[[package]]
name = "tracing-attributes"
version = "0.1.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.119",
]
[[package]] [[package]]
name = "tracing-core" name = "tracing-core"
version = "0.1.36" version = "0.1.36"
@@ -2629,6 +2898,12 @@ version = "0.2.5"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b" checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
[[package]]
name = "ttf-parser"
version = "0.25.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d2df906b07856748fa3f6e0ad0cbaa047052d4a7dd609e231c4f72cee8c36f31"
[[package]] [[package]]
name = "tungstenite" name = "tungstenite"
version = "0.23.0" version = "0.23.0"
@@ -2675,6 +2950,17 @@ version = "1.20.1"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20" checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
[[package]]
name = "uds_windows"
version = "1.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f2f6fb2847f6742cd76af783a2a2c49e9375d0a111c7bef6f71cd9e738c72d6e"
dependencies = [
"memoffset 0.9.1",
"tempfile",
"windows-sys 0.61.2",
]
[[package]] [[package]]
name = "unicode-ident" name = "unicode-ident"
version = "1.0.27" version = "1.0.27"
@@ -2741,8 +3027,9 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
[[package]] [[package]]
name = "uu-remote-linux" name = "uu-remote-linux"
version = "0.2.33" version = "0.2.59"
dependencies = [ dependencies = [
"ab_glyph",
"async-trait", "async-trait",
"base64 0.22.1", "base64 0.22.1",
"bytes", "bytes",
@@ -2756,17 +3043,21 @@ dependencies = [
"libc", "libc",
"log", "log",
"nix 0.29.0", "nix 0.29.0",
"png",
"qrcode", "qrcode",
"rand 0.8.8", "rand 0.8.8",
"rcgen",
"reqwest", "reqwest",
"sdl2", "sdl2",
"serde", "serde",
"serde_json", "serde_json",
"sha2", "sha2",
"tokio", "tokio",
"tokio-rustls",
"tokio-tungstenite", "tokio-tungstenite",
"webrtc", "webrtc",
"x11rb", "x11rb",
"zbus",
] ]
[[package]] [[package]]
@@ -2777,6 +3068,7 @@ checksum = "7cc1186384beb7dd8eedea376413fd654937285ea6c9cfbb928dc3043ea4b606"
dependencies = [ dependencies = [
"getrandom 0.4.3", "getrandom 0.4.3",
"js-sys", "js-sys",
"serde_core",
"wasm-bindgen", "wasm-bindgen",
] ]
@@ -3008,23 +3300,24 @@ dependencies = [
[[package]] [[package]]
name = "webrtc-ice" name = "webrtc-ice"
version = "0.10.1" version = "0.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a1bbd6b3dea22cc6e961e22b012e843d8869e2ac8e76b96e54d4a25e311857ad"
dependencies = [ dependencies = [
"arc-swap", "arc-swap",
"async-trait", "async-trait",
"crc", "crc",
"log", "log",
"rand 0.8.8", "rand 0.8.8",
"rustls-native-certs",
"serde", "serde",
"serde_json", "serde_json",
"stun", "stun",
"thiserror 1.0.69", "thiserror 1.0.69",
"tokio", "tokio",
"tokio-rustls",
"turn", "turn",
"url", "url",
"uuid", "uuid",
"waitgroup", "waitgroup",
"webpki-roots 1.0.9",
"webrtc-mdns", "webrtc-mdns",
"webrtc-util", "webrtc-util",
] ]
@@ -3223,6 +3516,15 @@ version = "0.52.6"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
[[package]]
name = "winnow"
version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8c3b93199df0ab874cdf0c6a94f0a0dc3423fe41f1cafb62b8bd7b1deb277aef"
dependencies = [
"memchr",
]
[[package]] [[package]]
name = "writeable" name = "writeable"
version = "0.6.4" version = "0.6.4"
@@ -3310,6 +3612,71 @@ dependencies = [
"synstructure 0.14.0", "synstructure 0.14.0",
] ]
[[package]]
name = "zbus"
version = "5.19.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5db4be7c075cb421e4b7ee645541604239bd243ba7c357511f4ff3a74b555907"
dependencies = [
"async-broadcast",
"async-recursion",
"async-trait",
"enumflags2",
"event-listener",
"futures-core",
"futures-lite",
"hex",
"libc",
"ordered-stream",
"rustix",
"serde",
"serde_repr",
"tokio",
"tracing",
"uds_windows",
"uuid",
"windows-sys 0.61.2",
"winnow",
"zbus_macros",
"zbus_names",
"zvariant",
]
[[package]]
name = "zbus_macros"
version = "5.19.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2990635d09ade6df1868f72f8cac69a876a90981e8bd3c40b1be413f8dc88f40"
dependencies = [
"proc-macro-crate",
"proc-macro2",
"quote",
"syn 3.0.9",
"zbus_names",
"zvariant",
"zvariant_utils",
]
[[package]]
name = "zbus_names"
version = "4.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "812a12be4ead7a59e18ea8f047d08add0066b73bc62fc1467066a2472ae088dd"
dependencies = [
"serde",
"winnow",
"zvariant",
]
[[package]]
name = "zcheapstr"
version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "939f186d9ecebe044315a5cb6d6f78568bbc21152adc954d5a0c2f58bdbc9920"
dependencies = [
"serde",
]
[[package]] [[package]]
name = "zerocopy" name = "zerocopy"
version = "0.8.62" version = "0.8.62"
@@ -3415,3 +3782,44 @@ name = "zmij"
version = "1.0.23" version = "1.0.23"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
[[package]]
name = "zvariant"
version = "5.15.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "80bf6d6cd6a4b601acb64cfb8284cdc643fcfa75ef26ae3c46ec8aa4e8a1fbb7"
dependencies = [
"endi",
"enumflags2",
"serde",
"winnow",
"zcheapstr",
"zvariant_derive",
"zvariant_utils",
]
[[package]]
name = "zvariant_derive"
version = "5.15.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ef2672456ba1cb54b5eaec136e63135b3c7495fb938e53b28a62e633496d486d"
dependencies = [
"proc-macro-crate",
"proc-macro2",
"quote",
"syn 3.0.9",
"zvariant_utils",
]
[[package]]
name = "zvariant_utils"
version = "4.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bad0294361a320b694a328460dc73add56c306150f5cb6bfafc44446120008a3"
dependencies = [
"proc-macro2",
"quote",
"serde",
"syn 3.0.9",
"winnow",
]
+13 -2
View File
@@ -1,6 +1,6 @@
[package] [package]
name = "uu-remote-linux" name = "uu-remote-linux"
version = "0.2.33" version = "0.2.59"
edition = "2021" edition = "2021"
default-run = "uuremote-server" default-run = "uuremote-server"
authors = ["uu-remote-linux contributors"] authors = ["uu-remote-linux contributors"]
@@ -23,7 +23,7 @@ required-features = ["native-viewer"]
default = [] default = []
native-viewer = [] native-viewer = []
viewer-ffmpeg = ["native-viewer", "dep:ffmpeg-next"] viewer-ffmpeg = ["native-viewer", "dep:ffmpeg-next"]
viewer-sdl = ["native-viewer", "dep:sdl2"] viewer-sdl = ["native-viewer", "dep:sdl2", "dep:ab_glyph", "dep:png"]
wayland = [] wayland = []
# Experimental direct linear framebuffer capture; never enabled in release builds. # Experimental direct linear framebuffer capture; never enabled in release builds.
kms = [] kms = []
@@ -38,6 +38,7 @@ inproc-av = ["dep:x11rb"]
tokio = { version = "1", features = ["full"] } tokio = { version = "1", features = ["full"] }
tokio-tungstenite = { version = "0.23", features = ["rustls-tls-webpki-roots"] } tokio-tungstenite = { version = "0.23", features = ["rustls-tls-webpki-roots"] }
futures-util = "0.3" futures-util = "0.3"
zbus = { version = "5", default-features = false, features = ["tokio"] }
serde = { version = "1.0", features = ["derive"] } serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0" serde_json = "1.0"
reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls", "rustls-tls-native-roots"] } reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls", "rustls-tls-native-roots"] }
@@ -59,6 +60,14 @@ ffmpeg-next = { version = "6.1", optional = true, default-features = false, feat
x11rb = { version = "0.13", features = ["damage", "shm", "allow-unsafe-code"], optional = true } x11rb = { version = "0.13", features = ["damage", "shm", "allow-unsafe-code"], optional = true }
sdl2 = { version = "0.37", optional = true, features = ["use-pkgconfig"] } 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"] }
[build-dependencies] [build-dependencies]
cc = "1.0" cc = "1.0"
@@ -69,6 +78,8 @@ webrtc-srtp = { path = "vendor/webrtc-srtp" }
webrtc-dtls = { path = "vendor/webrtc-dtls" } webrtc-dtls = { path = "vendor/webrtc-dtls" }
# Larger data-channel receive buffer (see vendor/webrtc/src/data_channel/mod.rs). # Larger data-channel receive buffer (see vendor/webrtc/src/data_channel/mod.rs).
webrtc = { path = "vendor/webrtc" } webrtc = { path = "vendor/webrtc" }
# TURN over TCP/TLS through an HTTP CONNECT proxy (vendor/webrtc-ice/PATCHES.md).
webrtc-ice = { path = "vendor/webrtc-ice" }
[[bench]] [[bench]]
name = "nvenc_pipeline_bench" name = "nvenc_pipeline_bench"
+93 -13
View File
@@ -21,7 +21,38 @@
<p align="center"><sub>Linux viewer: device list (device names redacted)</sub></p> <p align="center"><sub>Linux viewer: device list (device names redacted)</sub></p>
<p align="center"><img src="docs/images/main-window.png" width="620" alt="Host main window: remote assistance and account"></p> <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 in Chinese, like the official app.</sub></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:
1. `UU_LANG=en` or `UU_LANG=zh`;
2. the choice saved in the viewer's **Settings → General → 语言 / Language**
or the host main window's 语言 / Language row; stored as `~/.config/uuremote/language`, applies after a restart);
3. the locale: `LC_ALL` / `LC_MESSAGES` / `LANG` starting with `zh` → Chinese, anything else → English.
```sh
UU_LANG=en uuremote-viewer ui
UU_LANG=zh uuremote-server
```
Protocol strings and messages that come from the UU servers are shown as the server sends them.
<!-- Screenshot placeholder: the Linux desktop controlled from the official client. Take your own <!-- Screenshot placeholder: the Linux desktop controlled from the official client. Take your own
screenshot, remove account/device details and NetEase logos, save it as docs/images/remote-desktop.png screenshot, remove account/device details and NetEase logos, save it as docs/images/remote-desktop.png
@@ -45,11 +76,12 @@
| Mouse / keyboard | Absolute and relative motion, clicks, wheel, keys; no spurious key repeat on high-latency links; optional uinput virtual devices on Wayland (layout independent, see below) | | Mouse / keyboard | Absolute and relative motion, clicks, wheel, keys; no spurious key repeat on high-latency links; optional uinput virtual devices on Wayland (layout independent, see below) |
| 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) | | 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) | | Pointer shape | Remote cursor shape is mirrored to the viewer (X11) |
| Clipboard | Two-way text sync | | 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 | | 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 | | Sound | System audio captured from PulseAudio / PipeWire and sent as Opus |
| File transfer | Upload, download (including folders), create folder, rename, delete | | File transfer | Upload, download (including folders), create folder, rename, delete; iOS quick uploads use the default receive directory (the current user’s home) |
| Terminal | The official "Terminal" tool, PTY sessions, multiple sessions, rename | | Terminal | The official "Terminal" tool, PTY sessions, multiple sessions, rename, termination and automatic list refresh; input and detach messages from an old connection cannot affect a reattached session |
| Lock state and auto unlock | Lock state is reported to the viewer; with "auto unlock" enabled in the client, the password is verified with PAM and the session is unlocked | | Lock state and auto unlock | Lock state is reported to the viewer; with "auto unlock" enabled in the client, the password is verified with PAM and the session is unlocked |
| Lock after remote session | Stored on the host, so it still applies after reconnecting | | Lock after remote session | Stored on the host, so it still applies after reconnecting |
| Mute host while controlled | Host speakers are muted while the viewer still hears the sound; the previous mute state is restored afterwards | | Mute host while controlled | Host speakers are muted while the viewer still hears the sound; the previous mute state is restored afterwards |
@@ -73,7 +105,7 @@ authorized session. Independent file/terminal tool peers do not reset input.
| Xfce | X11 | ✅ Tested in a VM | default | | Xfce | X11 | ✅ Tested in a VM | default |
| Cinnamon / MATE | X11 | ✅ Tested in a VM | default | | Cinnamon / MATE | X11 | ✅ Tested in a VM | default |
| Hyprland | Wayland (native wlroots protocols) | 🧪 Experimental, tested in a VM (some features limited, see below) | `--features wayland` | | Hyprland | Wayland (native wlroots protocols) | 🧪 Experimental, tested in a VM (some features limited, see below) | `--features wayland` |
| niri | Wayland (native wlroots protocols) | 🧪 Experimental; protocol support confirmed from niri sources, not yet tested on hardware (#55) | `--features wayland` | | niri | Wayland (native wlroots protocols) | 🧪 Experimental; capture, text input and portrait switching hardware-tested; other features pending (#55) | `--features wayland` |
| GNOME / KDE Plasma | Wayland (xdg-desktop-portal) | 🧪 Experimental; validation scope and limits below | `--features wayland,portal` | | GNOME / KDE Plasma | Wayland (xdg-desktop-portal) | 🧪 Experimental; validation scope and limits below | `--features wayland,portal` |
The GNOME Wayland Portal/EIS path has been checked for video and mouse/keyboard input on Ubuntu 26.04, GNOME 50, with one 4K screen at 200% scale; auto unlock after a cold locked connection is verified with the official Mac and iPhone 4.42.0 viewers, while other lock recovery and reconnection still need hardware acceptance testing. Apart from that path and GNOME on X11, desktop testing has primarily used virtual machines. If something goes wrong on The GNOME Wayland Portal/EIS path has been checked for video and mouse/keyboard input on Ubuntu 26.04, GNOME 50, with one 4K screen at 200% scale; auto unlock after a cold locked connection is verified with the official Mac and iPhone 4.42.0 viewers, while other lock recovery and reconnection still need hardware acceptance testing. Apart from that path and GNOME on X11, desktop testing has primarily used virtual machines. If something goes wrong on
@@ -84,13 +116,21 @@ plugins, permissions and encoders only, no account data, tokens or addresses) an
Wayland limits: captures one screen by default; Hyprland can enable monitor switching as described below. Resolution is fixed. The native Hyprland backend now pipelines two shm screencopy buffers and passes the viewer's requested fps to both capture pacing and the encoder. Actual fps remains limited by the compositor, rendering and readback (the old serial path measured about 16–22 fps at 2560x1600; the pipeline is VM-measured only, not a hardware guarantee). The portal backend does not support dynamic resolution; see below for GNOME wake and lock recovery; the clipboard syncs while the viewer's remote window has focus. On the first connection the desktop asks for "Remote Desktop / Screen Sharing" Wayland limits: captures one screen by default; Hyprland can enable monitor switching as described below. Resolution is fixed. The native Hyprland backend now pipelines two shm screencopy buffers and passes the viewer's requested fps to both capture pacing and the encoder. Actual fps remains limited by the compositor, rendering and readback (the old serial path measured about 16–22 fps at 2560x1600; the pipeline is VM-measured only, not a hardware guarantee). The portal backend does not support dynamic resolution; see below for GNOME wake and lock recovery; the clipboard syncs while the viewer's remote window has focus. On the first connection the desktop asks for "Remote Desktop / Screen Sharing"
permission; the permission is remembered once granted. permission; the permission is remembered once granted.
**Touch from mobile viewers (GNOME)**: in touch mode the Android/iOS viewers send a finger as a left-button drag, which on a desktop selects text. On the portal backend the host decides per press: a finger that moves more than a few pixels within 0.45 s scrolls smoothly (`NotifyPointerAxis`; the content follows the finger, also in terminals, and the last event lets clients coast), one held still selects like a mouse drag, and a short press clicks. This needs no touchscreen consent. `UU_TOUCH_INPUT=touch` instead replays drags as one finger on the portal touchscreen, which the host requests where the portal offers it; a consent saved before touch support restores keyboard and pointer only, so the first drag then asks the host once more in the background (the GNOME share dialog, which the phone also sees; it closes after the consent timeout), and an approval for the same monitor switches to touch without reconnecting. The saved consent is never removed beforehand, and the host asks at most once per run. `UU_TOUCH_INPUT=0` keeps mouse drags.
**Mobile IME typing and clipboard on Wayland**: Mobile IME text (`text_input`) on Wayland is typed through spare keycodes on wlroots compositors. On GNOME (Portal) printable ASCII is typed as keysyms when the active input source is a Latin xkb layout (Mutter picks the key and Shift level); other text, KDE and compositors where keycodes are exhausted fall back to "system clipboard write + `Shift+Insert` (or `UU_WAYLAND_PASTE_KEY=ctrl_v`)". VTE terminals paste the PRIMARY selection on `Shift+Insert`, which is why ASCII is typed instead. **Note**: This fallback replaces the host's existing clipboard contents and may echo back to the viewer's clipboard via two-way sync; set `UU_WAYLAND_TEXT=0` to completely disable Wayland mobile text input and clipboard paste fallback.
Scaled GNOME desktops using native Portal input use EIS on the same authorized session when `ConnectToEIS` and a screen `mapping_id` are available. Each axis is mapped using the matched region and actual frame dimensions, with no fixed resolution or scale factor. This avoids scaled-coordinate rejection by `NotifyPointerMotionAbsolute`. Portal builds require libei >= 1.1. Missing EIS support retains the legacy input path and its existing scaling limitations; other initialization failures are reported and trigger session recovery. After a successful EIS connection, all input uses EIS. Capture alone and uinput do not initialize EIS; missing optional logical dimensions do not block capture. Keyboard input uses the existing Windows VK to evdev mapping. Recovery keeps the encoder frame dimensions fixed but accepts logical-size changes after scaling. On GNOME, a display-change notification enables earlier recovery when previously streaming Portal capture remains paused without a valid format for a 200 ms grace after both conditions are present. Healthy renegotiation cancels the early check; repeated notifications do not postpone the same interruption. The five-second fallback remains without a related notification. Static video and valid-format pauses do not trigger recovery. Tested while connected on Ubuntu 26.04, GNOME Wayland, one 3840x2160 display: 200% -> 166.67% -> 200%, with continuously updating video and full-screen pointer control after recovery. Switching briefly freezes and goes black before recovering; five seconds is the fallback threshold, not total recovery time. See [#35](../../pull/35) for timing measurements and validation limits. Lock recovery still needs hardware acceptance testing; multi-monitor support, live resolution changes, and rotation/reflection transforms are outside this fix's scope. Capture settings remain at protocol version 4: advertised resolutions use pixel coordinates and DPR 1; Portal logical dimensions are used only for local input mapping. Scaled GNOME desktops using native Portal input use EIS on the same authorized session when `ConnectToEIS` and a screen `mapping_id` are available. Each axis is mapped using the matched region and actual frame dimensions, with no fixed resolution or scale factor. This avoids scaled-coordinate rejection by `NotifyPointerMotionAbsolute`. Portal builds require libei >= 1.1. Missing EIS support retains the legacy input path and its existing scaling limitations; other initialization failures are reported and trigger session recovery. After a successful EIS connection, all input uses EIS. Capture alone and uinput do not initialize EIS; missing optional logical dimensions do not block capture. Keyboard input uses the existing Windows VK to evdev mapping. Recovery keeps the encoder frame dimensions fixed but accepts logical-size changes after scaling. On GNOME, a display-change notification enables earlier recovery when previously streaming Portal capture remains paused without a valid format for a 200 ms grace after both conditions are present. Healthy renegotiation cancels the early check; repeated notifications do not postpone the same interruption. The five-second fallback remains without a related notification. Static video and valid-format pauses do not trigger recovery. Tested while connected on Ubuntu 26.04, GNOME Wayland, one 3840x2160 display: 200% -> 166.67% -> 200%, with continuously updating video and full-screen pointer control after recovery. Switching briefly freezes and goes black before recovering; five seconds is the fallback threshold, not total recovery time. See [#35](../../pull/35) for timing measurements and validation limits. Lock recovery still needs hardware acceptance testing; multi-monitor support, live resolution changes, and rotation/reflection transforms are outside this fix's scope. Capture settings remain at protocol version 4: advertised resolutions use pixel coordinates and DPR 1; Portal logical dimensions are used only for local input mapping.
GNOME Portal CONTROL no longer waits for a consent dialog or the first video frame. It announces the selected desktop before reporting secure-desktop state and receiving the official viewer's “auto unlock host” request. The official Android viewer requires this desktop selection before entering its auto-unlock flow, so the notification must precede capture readiness; actual screen dimensions, codec information and capture permissions still follow their real readiness state. Enable auto unlock in the viewer and use the current Linux user's login password. The host verifies it with PAM, unlocks the existing GNOME session, requests display wake, and restores capture, input and clipboard through the shared Portal session. Initial consent or revoked permissions still require local approval. Reconnect if physical or logical dimensions change. GNOME Portal CONTROL no longer waits for a consent dialog or the first video frame. It announces the selected desktop before reporting secure-desktop state and receiving the official viewer's “auto unlock host” request. The official Android viewer requires this desktop selection before entering its auto-unlock flow, so the notification must precede capture readiness; actual screen dimensions, codec information and capture permissions still follow their real readiness state. Enable auto unlock in the viewer and use the current Linux user's login password. The host verifies it with PAM, unlocks the existing GNOME session, requests display wake, and restores capture, input and clipboard through the shared Portal session. Initial consent or revoked permissions still require local approval. Reconnect if physical or logical dimensions change.
The host also accepts a desktop connection while GNOME is locked with no Portal session yet (a cold connection): it reports lock state and accepts auto unlock, then restores picture, input and clipboard after unlock. While Portal is pending, the host sends generated black video once per second on the negotiated track by default, allowing the official iPhone viewer to enter its auto-unlock flow without extra configuration. Verified on Ubuntu GNOME Wayland with the official Mac viewer; iPhone 4.42.0 with H.265 completed a same-executable control experiment: black video ON succeeded, OFF failed, and ON succeeded again ([#29](../../issues/29)). **Limitation**: this is synthetic black video, not the GNOME lock screen, and it does not enable native mouse/keyboard input while locked. Enable 「自动解锁被控端」 in the UU client under 控制中心 → 安全 and enter the password. Without saved Portal permission, local consent is still required after unlock before the real desktop can appear. The host also accepts a desktop connection while GNOME is locked with no Portal session yet (a cold connection): it reports lock state and accepts auto unlock, then restores picture, input and clipboard after unlock. While Portal is pending, the host sends generated black video once per second on the negotiated track by default, allowing the official iPhone viewer to enter its auto-unlock flow without extra configuration. Verified on Ubuntu GNOME Wayland with the official Mac viewer; iPhone 4.42.0 with H.265 completed a same-executable control experiment: black video ON succeeded, OFF failed, and ON succeeded again ([#29](../../issues/29)). **Limitation**: this is synthetic black video, not the GNOME lock screen, and it does not enable native mouse/keyboard input while locked. Enable 「自动解锁被控端」 in the UU client under 控制中心 → 安全 and enter the password. Without saved Portal permission, local consent is still required after unlock before the real desktop can appear.
Existing screen-off and lock settings remain unchanged. Only capture recovery in an unlocked session temporarily holds a GNOME idle inhibitor; the first frame, lock, disconnect or initialization failure releases it. An idle viewer still allows the normal screen-off and lock timeout, and manual lock remains effective. Desktop input is blocked and real video is hidden while locked or when lock state is unknown. Independent terminal, file-transfer and port-mapping peers do not wait for video initialization and survive desktop reconnection. Automated protocol and lifecycle regression tests cover this path; auto unlock and capture recovery after a cold locked connection are verified on GNOME hardware with the official Mac and iPhone 4.42.0 viewers, while screen-off and the other scenarios still need acceptance testing. Waking a fully suspended or hibernating machine is outside this CONTROL path. On KDE Plasma (KWin), the Portal screencast stays alive after the session locks. The host now opens capture while locked by default, so a cold connection shows the real lock screen and the password can be entered with the remote keyboard instead of receiving black video ([#227](../../issues/227), [#229](../../pull/229)). Set `UU_LOCKED_CAPTURE=0` to disable this and return to the black-video and auto-unlock path. Detection requires `XDG_CURRENT_DESKTOP` or `XDG_SESSION_DESKTOP` in the systemd user environment. Without either the host falls back to black video, and `UU_LOCKED_CAPTURE=1` forces the new behavior. Portal pointer input remains blocked while locked, and the keyboard uses uinput and can enter the password. This does not apply to GNOME: Mutter closes the Portal session on lock, so the black-video and auto-unlock behavior above is unchanged.
Existing screen-off and lock settings remain unchanged. Only capture recovery in an unlocked session temporarily holds a GNOME idle inhibitor; the first frame, lock, disconnect or initialization failure releases it. An idle viewer still allows the normal screen-off and lock timeout, and manual lock remains effective. Portal input is blocked while locked. KDE keeps sending the real lock screen, while GNOME hides real video and uses black video. Independent terminal, file-transfer and port-mapping peers do not wait for video initialization and survive desktop reconnection. Automated protocol and lifecycle regression tests cover this path; auto unlock and capture recovery after a cold locked connection are verified on GNOME hardware with the official Mac and iPhone 4.42.0 viewers, while screen-off and the other scenarios still need acceptance testing. Waking a fully suspended or hibernating machine is outside this CONTROL path.
Lock monitoring reads logind `LockedHint` over the system D-Bus and subscribes to changes instead of spawning `loginctl` every second. Without a graphical session it stays subscribed with unknown state, so login signals trigger a fresh read. It reconciles the session over D-Bus every 30 seconds; if D-Bus fails, it retries with a bounded `loginctl` fallback every 30 seconds, resolving the executable path once. Notifications may be delayed during fallback; unreadable state remains unknown. The locker must still report its state to logind. Suspend, locking and remote connection policies are unchanged.
Locked black video requires FFmpeg's libx264/libx265 encoder for the negotiated H.264/H.265 codec; hardware encoding support alone does not satisfy this dependency. Encoder failures are logged explicitly. Synthetic video does not change capture permissions or advertised monitor dimensions. It pauses on unlock or unknown lock state, ends when capture is ready/rejected or the connection closes, and then hands the same video track to real capture. See [#29](../../issues/29) and [#34](../../pull/34) for the controlled experiment and validation scope. Locked black video requires FFmpeg's libx264/libx265 encoder for the negotiated H.264/H.265 codec; hardware encoding support alone does not satisfy this dependency. Encoder failures are logged explicitly. Synthetic video does not change capture permissions or advertised monitor dimensions. It pauses on unlock or unknown lock state, ends when capture is ready/rejected or the connection closes, and then hands the same video track to real capture. See [#29](../../issues/29) and [#34](../../pull/34) for the controlled experiment and validation scope.
@@ -114,16 +154,18 @@ X11 sessions send all monitors as one combined picture by default. With `UU_X11_
Switching reuses one video track and pauses input until the new source sends a frame. Capture/encoder failure or a first-frame timeout requests restoration of the previous source. The inventory uses `hyprctl` and supports unrotated outputs; restart the host after monitor hotplug or layout changes. Phone-side switching and clicks were tested on Omarchy / Hyprland with 2560×1440 at 125% and 1920×1080 at 133.33%. Switching reuses one video track and pauses input until the new source sends a frame. Capture/encoder failure or a first-frame timeout requests restoration of the previous source. The inventory uses `hyprctl` and supports unrotated outputs; restart the host after monitor hotplug or layout changes. Phone-side switching and clicks were tested on Omarchy / Hyprland with 2560×1440 at 125% and 1920×1080 at 133.33%.
On niri, `niri msg --json outputs` enumerates enabled monitors. Normal and 90/180/270-degree capture and pointer transforms are enabled only with `NIRI_SOCKET`; reflected transforms are excluded. Three-output switching, 90-degree portrait capture/click alignment, and mobile Chinese input into Codex were hardware-tested on CachyOS + niri. Other compositors retain their existing text path and reject rotated outputs. Restart after layout changes. The temporary printable-key text keyboard is niri-only; the Hyprland fast path and pristine-keymap restoration are unchanged.
## Not implemented / not supported ## Not implemented / not supported
| Feature | Status | | Feature | Status |
|---|---| |---|---|
| Switching between multiple monitors | Experimental on native Hyprland Wayland and on X11 (`UU_X11_MULTISCREEN=1`); see above | | Switching between multiple monitors | Experimental on native niri / Hyprland Wayland and on X11 (`UU_X11_MULTISCREEN=1`); see above |
| 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 | | 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 | | HDR | Not implemented |
| Super screen / virtual display | Not implemented | | Super screen / virtual display | Not implemented |
| Privacy screen on the host | Not implemented | | Privacy screen on the host | Experimental, KDE Plasma Wayland (portal) only; off, picture and screen-off status labels verified with Mac 4.43.0; `UU_PRIVACY_AUTO=picture` / `screen-off` enables it automatically on desktop connect; see [docs/privacy-screen.md](docs/privacy-screen.md) |
| Microphone (viewer audio played on the host) | Not implemented (needs a virtual sound card) | | Microphone (viewer audio played on the host) | Experimental: Opus to a virtual input with `UU_MICROPHONE=1`; supports PulseAudio / PipeWire-pulse, see [notes](docs/remote-microphone.md) |
| Plugins such as the WoW queue notifier | Not supported; the client is told that no plugins exist | | 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 | | Linux login screen | The system login screen (before anyone logs in to the Linux desktop) cannot be controlled yet; use headless mode or a virtual desktop (see below). This is about the Linux login: **without a UU account** the host can now be used through remote assistance |
| Relay connections on restrictive networks | Uses the ICE servers provided by the UU cloud; complex network setups are not thoroughly tested | | Relay connections on restrictive networks | Uses the ICE servers provided by the UU cloud; complex network setups are not thoroughly tested |
@@ -181,12 +223,15 @@ sudo apt install libwayland-dev libxkbcommon-dev wl-clipboard
sudo apt install libglib2.0-dev libpipewire-0.3-dev libei-dev 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) # 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 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>). - A Rust toolchain is required (<https://rustup.rs>).
- `libgtk-3-dev` is optional. Without GTK, login works with a QR code in the terminal (`UU_NO_GTK=1` disables - `libgtk-3-dev` is optional. Without GTK, login works with a QR code in the terminal (`UU_NO_GTK=1` disables
the login window explicitly). the login window explicitly).
- On NVIDIA GPUs use an FFmpeg build with `h264_nvenc`; otherwise the CPU encoder (libx264) is used. - On NVIDIA GPUs use an FFmpeg build with `h264_nvenc`; otherwise the CPU encoder (libx264) is used.
- The NVENC API version FFmpeg requires comes from the nv-codec-headers it was built against. For example, Arch's FFmpeg 9 is built against nv-codec-headers 13.1 and needs driver 610 or newer; Pascal (GTX 10 series) tops out at driver 580 with NVENC API 13.0, so the log shows `Driver does not support the required nvenc API version` and encoding falls back to the CPU. Build a separate FFmpeg against nv-codec-headers 13.0 into its own prefix and point `ffmpeg_root` in `config.json` at it (#230).
### 2. Build ### 2. Build
@@ -199,6 +244,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 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. 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 ### 3. Log in
Run inside your graphical session: Run inside your graphical session:
@@ -210,6 +258,10 @@ Run inside your graphical session:
Scan the code with the **NetEase UU Remote mobile app** and confirm. Credentials are stored only on this Scan the code with the **NetEase UU Remote mobile app** and confirm. Credentials are stored only on this
machine, in `~/.config/uuremote/config.json` (mode 0600). machine, in `~/.config/uuremote/config.json` (mode 0600).
A failed status query or the 60-second request timeout does not prove that the QR expired or that the phone confirmed login. The official-client refresh policy is unchanged: after a query error, click Refresh QR (Enter in a terminal; refresh after 60 seconds with neither a window nor a terminal). QR request diagnostics contain only the request phase, error category, elapsed time, HTTP/API status and last known scan state—not tickets, URLs or response content. A `connect` category alone does not identify a DNS, TLS or proxy cause.
The same file holds this machine's device identity (`device_id`, `client_id`, `system_id`), which reinstalls and new QR logins keep. **Do not copy `config.json` between machines or clone a second host from a snapshot/disk that includes the home directory**: two host instances with one identity, on the same or different machines, kick each other out of the room. The log then shows `Cloud room leave without peer identifier` every few seconds with reconnects, and viewers disconnect right after connecting. On a cloned or copied machine, stop the service, remove those three keys plus `token`, `csrf` and `user_id`, and run `uuremote-server login` to register a new device. A leftover instance on the same machine (for example an old `~/.local/bin/uuremote-server` started by hand) has the same effect; `uuremote-server doctor` warns when more than one host instance is running.
### 4. Run as a user service ### 4. Run as a user service
`~/.config/systemd/user/uuremote-native.service`: `~/.config/systemd/user/uuremote-native.service`:
@@ -259,6 +311,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. `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. 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) ## 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 As in the official client, this host shows a **device ID** and a **verification code**; whoever you give them to can
@@ -345,18 +399,24 @@ Common environment variables:
| `UU_X11_OUTPUT` | Initial X11 monitor name (`xrandr --listmonitors`); default: the primary | | `UU_X11_OUTPUT` | Initial X11 monitor name (`xrandr --listmonitors`); default: the primary |
| `UU_WAYLAND_NO_VIRTUAL_KEYBOARD=1` | Native Wayland skips the virtual keyboard (e.g. Denial reserves it for its input method); keys go through uinput. Without wlr-virtual-pointer the pointer also uses uinput (#72) | | `UU_WAYLAND_NO_VIRTUAL_KEYBOARD=1` | Native Wayland skips the virtual keyboard (e.g. Denial reserves it for its input method); keys go through uinput. Without wlr-virtual-pointer the pointer also uses uinput (#72) |
| `UU_INPUT_BACKEND` | `auto` (default: uinput on Wayland when accessible) / `uinput` / `native` | | `UU_INPUT_BACKEND` | `auto` (default: uinput on Wayland when accessible) / `uinput` / `native` |
| `UU_PORTAL_CURSOR_MODE` | Startup cursor mode: `embedded` draws the compositor pointer into the stream; hidden by default. The host switches at runtime as the viewer sends relative or absolute motion. A switch rebuilds the portal session and interrupts picture and input for a moment |
| `UU_TERMINAL_SHORTCUTS=0` | Disable the Ctrl+V paste rewrite in terminal windows | | `UU_TERMINAL_SHORTCUTS=0` | Disable the Ctrl+V paste rewrite in terminal windows |
| `UU_VIDEO_ENCODER` | `cpu`: libx264; `vaapi`: opt-in Intel/AMD; `nvenc`: force NVENC; unset or `auto`: a background probe (one synthetic IDR per candidate, 3 s each). With an NVIDIA driver the order is NVENC then CPU; without one the only candidate is CPU and the probe is skipped. A session that starts before the probe finishes uses the previous rule (NVENC if NVIDIA is present, else CPU). On a self-built `--features inproc-av` binary, a process-only failure of NVENC when the in-process engine would try it first on X11 is logged `native_unprobed` and keeps the previous NVENC choice (Wayland, portal, and KMS fall back to CPU). The skipped CPU-only probe is logged `not probed (only candidate)`. A successful probe and that CPU-only skip stay cached while NVIDIA presence matches the report. A later desktop connection whose presence differs starts one background re-probe and still uses the cached encoder until the new result is stored. A hardware-candidate failure (NVENC failed, CPU chosen) is kept for 10 minutes; the next desktop connection after that starts the same re-probe and still uses the cached encoder until the new result is stored. Explicit `cpu` / `vaapi` / `nvenc` does not start the probe. Another failure restarts the 10 minutes. `native_unprobed` is not a temporary failure. A non-`auto` `video_encoder` in `host_settings.json` wins. VAAPI stays out of auto until #33 | | `UU_VIDEO_ENCODER` | `cpu`: libx264; `vaapi`: opt-in Intel/AMD; `nvenc`: force NVENC; unset or `auto`: a background probe (one synthetic IDR per candidate, 3 s each). With an NVIDIA driver the order is NVENC then CPU; without one the only candidate is CPU and the probe is skipped. A session that starts before the probe finishes uses the previous rule (NVENC if NVIDIA is present, else CPU). On a self-built `--features inproc-av` binary, a process-only failure of NVENC when the in-process engine would try it first on X11 is logged `native_unprobed` and keeps the previous NVENC choice (Wayland, portal, and KMS fall back to CPU). The skipped CPU-only probe is logged `not probed (only candidate)`. A successful probe and that CPU-only skip stay cached while NVIDIA presence matches the report. A later desktop connection whose presence differs starts one background re-probe and still uses the cached encoder until the new result is stored. A hardware-candidate failure (NVENC failed, CPU chosen) is kept for 10 minutes; the next desktop connection after that starts the same re-probe and still uses the cached encoder until the new result is stored. Explicit `cpu` / `vaapi` / `nvenc` does not start the probe. Another failure restarts the 10 minutes. `native_unprobed` is not a temporary failure. A non-`auto` `video_encoder` in `host_settings.json` wins. VAAPI stays out of auto until #33 |
| `UU_VAAPI_BUFFER_MS` | VAAPI VBV buffer in ms (10-1000, VAAPI only); raise it when keyframes are squeezed into a blur at high resolution | | `UU_VAAPI_BUFFER_MS` | VAAPI VBV buffer in ms (10-1000, VAAPI only); raise it when keyframes are squeezed into a blur at high resolution |
| `UU_NVENC_BUFFER_MS` | NVENC VBV buffer in ms (10-1000, NVENC only, including the in-process engine); the default is 100-500 kbit, set `1000` when high-resolution keyframes blur and flicker once per GOP (#103) | | `UU_NVENC_BUFFER_MS` | NVENC VBV buffer in ms (10-1000, NVENC only, including the in-process engine); the default matches libx264, one second of the bitrate cap within 500-8000 kbit, so high-resolution keyframes no longer blur and flicker once per GOP (#103). Set a small value (e.g. `50`) for a smaller low-latency buffer on a weak link |
| `UU_FFMPEG_ROOT` | Use FFmpeg from this prefix | | `UU_FFMPEG_ROOT` | Use FFmpeg from this prefix |
| `UU_AUDIO=0` | Disable sound; `UU_AUDIO_SOURCE` picks the PulseAudio source | | `UU_AUDIO=0` | Disable sound; `UU_AUDIO_SOURCE` picks the PulseAudio source |
| `UU_REMOTE_ASSIST=0` | Disable remote assistance (no guest assistance before sign-in either) | | `UU_REMOTE_ASSIST=0` | Disable remote assistance (no guest assistance before sign-in either) |
| `UU_ASSIST_ALLOW=1` | Allow remote assistance at start (overrides the saved switch) | | `UU_ASSIST_ALLOW=1` | Allow remote assistance at start (overrides the saved switch) |
| `UU_LOGIN_WINDOW=0` | Do not open the login window automatically when credentials are missing | | `UU_LOGIN_WINDOW=0` | Do not open the login window automatically when credentials are missing |
| `UU_PORT_MAPPING=0` | Disable port mapping (the official host's controlled-side switch) | | `UU_PORT_MAPPING=0` | Disable port mapping (the official host's controlled-side switch) |
| `UU_WOL_HELPER=1` | Experimental: act as a remote-boot helper like the official Windows host — report this host's LAN info after sign-in and send a magic packet to the LAN when the cloud asks to wake a PC (not verified end to end) | | `UU_WOL_HELPER=1` | Experimental: act as a remote-boot helper like the official Windows host — report this host's LAN info after sign-in and send a magic packet to the LAN when the cloud asks to wake a PC (verified end to end with a headless Linux host on a NAS and the official iOS controller) |
| `UU_USE_PROXY=1` | Honor HTTP/SOCKS proxy environment variables; by default proxies are ignored and NetEase servers are reached directly | | `UU_USE_PROXY=1` | Share environment HTTP/HTTPS proxy policy between REST and host/viewer WebSocket signaling; proxies are ignored by default |
`UU_USE_PROXY=1` uses only proxy settings already available to the current process. `HTTP_PROXY` / `HTTPS_PROXY` / `ALL_PROXY` (and lowercase forms) and `NO_PROXY` follow reqwest's standard selection, with uppercase taking precedence. Signaling rejects invalid/unsupported values in the selected variables (HTTP/HTTPS only, not SOCKS), proxy URLs with paths/queries/fragments, and CGI environments that would ignore proxies; this validation is intentionally stricter than silently ignoring bad values. No matching proxy or a `NO_PROXY` match still means direct access; a selected proxy failing does not trigger direct fallback. Certificate verification remains enabled and redirects are not followed, so room authentication is not forwarded to a redirect target.
With it the host also reaches the cloud TURN relays over TCP/TLS (CONNECT through the unauthenticated `http://` proxy in `HTTPS_PROXY`/`ALL_PROXY`, or directly without one), for hosts whose UDP cannot reach the TURN servers but whose TCP/proxy can. TURN certificates are chain-verified; a name mismatch is tolerated only when the cloud-supplied TURN address is an IP (media itself is end-to-end DTLS-SRTP). Without the setting only UDP relays are used, as before. **This creates no new network access**: login, signaling and media each still need an allowed network path. Connector errors expose only fixed categories/HTTP status; do not enable dependency TRACE logs that may record URLs or authentication information.
Host settings such as "lock after remote session" and "mute host" are stored in Host settings such as "lock after remote session" and "mute host" are stored in
`~/.config/uuremote/host_settings.json`. The same file stores `video_encoder` `~/.config/uuremote/host_settings.json`. The same file stores `video_encoder`
@@ -413,6 +473,7 @@ flowchart LR
## Security and privacy ## 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. - 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 - 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. once with PAM; it is never written to disk or logs.
@@ -548,6 +609,8 @@ No official "no desktop" error code was found for headless desktop offers, so th
## Experimental native viewer (uuremote-viewer) ## 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 `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 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. separate from the host `uuremote-server`; the default host build and behaviour are unchanged.
@@ -557,8 +620,13 @@ 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 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`. `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). SDL clipboard access reuses the desktop window to avoid temporary-window Dock churn on GNOME Wayland (#37).
Synchronization runs only while that window is focused and keeps the 30 KiB text limit. Selections without a supported 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
text format are skipped; empty-text detection depends on the SDL2 backend. Builds without SDL retain the command backend. text format are skipped; empty-text detection depends on the SDL2 backend. Builds without SDL retain the command backend.
SDL2 reads selections synchronously, so a slow selection owner can temporarily block the window; the bridge timeout cannot interrupt it. SDL2 reads selections synchronously, so a slow selection owner can temporarily block the window; the bridge timeout cannot interrupt it.
GNOME-to-official-Mac bidirectional clipboard synchronization is still unverified; this change does not resolve host compatibility. GNOME-to-official-Mac bidirectional clipboard synchronization is still unverified; this change does not resolve host compatibility.
@@ -589,6 +657,10 @@ GNOME-to-official-Mac bidirectional clipboard synchronization is still unverifie
- Desktop offers H.264 / H.265; the host chooses the codec. `UU_VIEWER_CODEC=h264` limits both SDP and decoder capabilities to H.264. - Desktop offers H.264 / H.265; the host chooses the codec. `UU_VIEWER_CODEC=h264` limits both SDP and decoder capabilities to H.264.
The default request stays 4:2:0; `UU_VIEWER_CHROMA=444` requests true color (4:4:4) after CONTROL opens. The host may fall back to The default request stays 4:2:0; `UU_VIEWER_CHROMA=444` requests true color (4:4:4) after CONTROL opens. The host may fall back to
4:2:0, as reported by CaptureSettingSync. FFmpeg converts either chroma format to RGB24 for display. 4:2:0, as reported by CaptureSettingSync. FFmpeg converts either chroma format to RGB24 for display.
- 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 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 automatically translating Ctrl to Command; on a Mac target the PC Super / Windows key acts as Command. Only verified target
@@ -614,3 +686,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 "—" = 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. 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).
+88 -14
View File
@@ -19,6 +19,32 @@
<p align="center"><img src="docs/images/main-window.png" width="620" alt="Linux 主机主窗口:远程协助与账号"></p> <p align="center"><img src="docs/images/main-window.png" width="620" alt="Linux 主机主窗口:远程协助与账号"></p>
<p align="center"><sub>Linux 被控端主窗口:远程协助与账号(设备 ID、验证码和账号已打码)</sub></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
启动时按以下顺序确定界面语言:
1. `UU_LANG=zh` 或 `UU_LANG=en`;
2. 控制端 **设置 → 常规 → 语言 / Language** 或主机主窗口底部「语言 / Language」中保存的选择(保存在 `~/.config/uuremote/language`,重启后生效);
3. 系统区域设置:`LC_ALL` / `LC_MESSAGES` / `LANG` 以 `zh` 开头为中文,其余为英文。
```sh
UU_LANG=zh uuremote-viewer ui
UU_LANG=en uuremote-server
```
协议字段以及 UU 服务器返回的提示按服务器原文显示。
<!-- 截图占位:在官方客户端里远控 Linux 桌面的效果图。请自行截图并去掉账号、设备名等信息后放到 <!-- 截图占位:在官方客户端里远控 Linux 桌面的效果图。请自行截图并去掉账号、设备名等信息后放到
docs/images/remote-desktop.png,再取消下面这行的注释。注意不要截入网易的图标和品牌素材。 --> docs/images/remote-desktop.png,再取消下面这行的注释。注意不要截入网易的图标和品牌素材。 -->
<!-- <p align="center"><img src="docs/images/remote-desktop.png" width="720" alt="用官方 Mac 客户端远控 Linux 桌面"></p> --> <!-- <p align="center"><img src="docs/images/remote-desktop.png" width="720" alt="用官方 Mac 客户端远控 Linux 桌面"></p> -->
@@ -39,11 +65,12 @@
| 鼠标 / 键盘 | 绝对/相对移动、点击、滚轮、按键;修复了网络延迟导致的按键连发;Wayland 下可用 uinput 虚拟键鼠(不依赖键盘布局,见下文) | | 鼠标 / 键盘 | 绝对/相对移动、点击、滚轮、按键;修复了网络延迟导致的按键连发;Wayland 下可用 uinput 虚拟键鼠(不依赖键盘布局,见下文) |
| 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) | | 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) | | 鼠标指针样式 | 远端指针形状实时同步(X11) |
| 剪贴板 | 双向文本同步 | | 剪贴板 | 双向文本同步;Wayland 手机输入法输入通过剪贴板兜底粘贴,见下文 |
| 观看模式批注 | 控制端观看模式下开启「批注」后画的笔迹显示在 Linux 屏幕上,并随画面传回控制端(X11,需要合成器;覆盖层不拦截鼠标);关闭批注或断开连接时清除。已用 Mac 控制端 4.42.0 实测,手机控制端未测 |
| 画质 / 帧率 / 分辨率 | 自动、原画 20M、超清 8M、高清 2M、自定义;30/60/90/144 帧;X11 下切换分辨率会像官方 Windows 被控端一样真正修改桌面分辨率(xrandr,缺少该模式时自动添加;选「原始」或断开后恢复),`UU_DESKTOP_RESIZE=0` 改为仅由编码器缩放;Wayland 仍由编码器缩放 | | 画质 / 帧率 / 分辨率 | 自动、原画 20M、超清 8M、高清 2M、自定义;30/60/90/144 帧;X11 下切换分辨率会像官方 Windows 被控端一样真正修改桌面分辨率(xrandr,缺少该模式时自动添加;选「原始」或断开后恢复),`UU_DESKTOP_RESIZE=0` 改为仅由编码器缩放;Wayland 仍由编码器缩放 |
| 声音 | 采集系统声音(PulseAudio / PipeWire),Opus 编码传到控制端 | | 声音 | 采集系统声音(PulseAudio / PipeWire),Opus 编码传到控制端 |
| 文件传输 | 上传、下载(含文件夹)、新建文件夹、重命名、删除 | | 文件传输 | 上传、下载(含文件夹)、新建文件夹、重命名、删除;iOS 直接上传使用默认接收目录(当前用户的主目录) |
| 终端 | 官方「终端」工具,PTY 会话,支持多会话和重命名 | | 终端 | 官方「终端」工具,PTY 会话,支持多会话、重命名、结束会话和列表自动刷新;重连后旧连接的输入和断开消息不会影响当前会话 |
| 锁屏与自动解锁 | 向控制端上报锁屏状态;开启「自动解锁被控端」后,通过 PAM 校验密码并解锁当前会话 | | 锁屏与自动解锁 | 向控制端上报锁屏状态;开启「自动解锁被控端」后,通过 PAM 校验密码并解锁当前会话 |
| 远程结束后自动锁屏 | 设置保存在本机,重连后依然生效 | | 远程结束后自动锁屏 | 设置保存在本机,重连后依然生效 |
| 被控端静音运行 | 主机扬声器静音,控制端照常能听到声音;结束后恢复原来的音量设置 | | 被控端静音运行 | 主机扬声器静音,控制端照常能听到声音;结束后恢复原来的音量设置 |
@@ -65,7 +92,7 @@ Portal 仅作用于本服务获授权的会话。文件传输、终端等独立
| Xfce | X11 | ✅ 虚拟机测试通过 | 默认 | | Xfce | X11 | ✅ 虚拟机测试通过 | 默认 |
| Cinnamon / MATE | X11 | ✅ 虚拟机测试通过 | 默认 | | Cinnamon / MATE | X11 | ✅ 虚拟机测试通过 | 默认 |
| Hyprland | Wayland(wlroots 原生协议) | 🧪 实验性,虚拟机测试(部分功能受限,见下) | `--features wayland` | | Hyprland | Wayland(wlroots 原生协议) | 🧪 实验性,虚拟机测试(部分功能受限,见下) | `--features wayland` |
| niri | Wayland(wlroots 原生协议) | 🧪 实验性,协议支持已按 niri 源码确认,尚未实机验收(#55) | `--features wayland` | | niri | Wayland(wlroots 原生协议) | 🧪 实验性,采集、文字输入及竖屏切换已实机验收,其余待验证(#55) | `--features wayland` |
| GNOME / KDE Plasma | Wayland(xdg-desktop-portal) | 🧪 实验性,验证范围与限制见下 | `--features wayland,portal` | | GNOME / KDE Plasma | Wayland(xdg-desktop-portal) | 🧪 实验性,验证范围与限制见下 | `--features wayland,portal` |
最后一列是源码编译方式;Release 预编译包已包含全部后端,直接使用即可(见[安装](#0-直接用-release-预编译包推荐x86_64))。 最后一列是源码编译方式;Release 预编译包已包含全部后端,直接使用即可(见[安装](#0-直接用-release-预编译包推荐x86_64))。
@@ -75,13 +102,21 @@ GNOME Wayland 的 Portal/EIS 路径已在 Ubuntu 26.04、GNOME 50、单屏 4K/20
Wayland 下的限制:默认采集单屏,Hyprland 可按上文启用切屏;分辨率固定;Hyprland 原生后端默认使用双缓冲流水线 shm screencopy,控制端帧率设置会同步到采集节拍和编码器,但实际帧率仍受合成器、渲染和读回速度限制(旧串行路径在 2560x1600 曾测得约 16~22 帧;流水线只在虚拟机里测量过,不代表实机保证);portal 后端暂不支持动态分辨率;GNOME 的屏幕唤醒与锁屏恢复见下;剪贴板只在控制端的远控窗口处于前台时同步。 Wayland 下的限制:默认采集单屏,Hyprland 可按上文启用切屏;分辨率固定;Hyprland 原生后端默认使用双缓冲流水线 shm screencopy,控制端帧率设置会同步到采集节拍和编码器,但实际帧率仍受合成器、渲染和读回速度限制(旧串行路径在 2560x1600 曾测得约 16~22 帧;流水线只在虚拟机里测量过,不代表实机保证);portal 后端暂不支持动态分辨率;GNOME 的屏幕唤醒与锁屏恢复见下;剪贴板只在控制端的远控窗口处于前台时同步。
**手机控制端触控(GNOME)**:Android/iOS 控制端在触控模式下把手指当作左键拖动发送,在桌面上会选中文字。Portal 后端下被控端按每次按下判断:0.45 秒内移动超过几个像素即平滑滚动(`NotifyPointerAxis`,内容跟随手指,终端里同样有效,最后一个事件让客户端可以惯性滑动);按住不动则像鼠标拖动一样选中;短按为点击。此模式无需触摸屏授权。`UU_TOUCH_INPUT=touch` 改为把拖动按单指触控在 Portal 触摸屏上重放,门户提供触摸屏设备类型时被控端会一并申请;此前保存的授权只恢复键盘和指针,因此第一次拖动时会在后台再申请一次(GNOME 共享对话框,手机画面中也能看到,授权超时后自动关闭),同意同一显示器后无需重连即切换为触控。不会预先删除已保存的授权,每次运行最多申请一次。`UU_TOUCH_INPUT=0` 保持鼠标拖动。
**Wayland 手机输入法打字与剪贴板**:Wayland 下手机端输入法提交的文字(`text_input`)优先通过虚拟键盘空闲键码上屏;GNOME(Portal)下,当前输入源为拉丁 xkb 布局时,可打印 ASCII 直接以 keysym 输入(由 Mutter 选择按键和 Shift 层级);其他文字、KDE 以及键码耗尽的环境自动通过「写系统剪贴板 + 触发 `Shift+Insert`(或 `UU_WAYLAND_PASTE_KEY=ctrl_v`)」兜底粘贴。VTE 终端的 `Shift+Insert` 粘贴的是 PRIMARY 选区,因此 ASCII 改为直接输入。**注意**:此兜底过程会覆盖被控端原有的剪贴板内容,且会被双向同步回传到控制端剪贴板;设置 `UU_WAYLAND_TEXT=0` 可完全关闭 Wayland 文字输入及该粘贴兜底。
GNOME 缩放桌面在使用 Portal 原生键鼠时,若支持 `ConnectToEIS` 和屏幕 `mapping_id`,通过同一授权会话的 EIS 接口注入输入,按匹配的区域与实际帧尺寸分别映射横纵坐标,没有固定分辨率或缩放倍率,可避免 `NotifyPointerMotionAbsolute` 在缩放时拒绝坐标。Portal 构建需要 libei ≥ 1.1。缺少 EIS 支持时保留旧输入路径及其既有缩放限制;其他初始化错误会明确报告并触发会话恢复。EIS 连接成功后全部输入统一使用 EIS。只采集画面或使用 uinput 时不会初始化 EIS;缺少可选的逻辑尺寸也不阻断采集。键盘沿用项目现有的 Windows VK → evdev 映射。恢复时保持编码器的采集帧尺寸不变,允许缩放后的逻辑尺寸变化。GNOME 显示配置变化后,已推流的 Portal 采集若持续「暂停且无有效格式」,会在关联通知后的 200 毫秒宽限结束后提前进入现有恢复流程;正常重协商恢复会取消提前判定,连续通知不会推迟同次异常的判定。未收到相关通知时保留五秒兜底;静态画面或有效格式下的暂停不会触发恢复。Ubuntu 26.04、GNOME Wayland 单屏 3840×2160 已实测保持连接切换 200%→166.67%→200%,恢复后画面持续更新且鼠标可控制全屏;切换期间会短暂停顿、黑屏后恢复,五秒是兜底判定阈值,并非总恢复时间。提前恢复的测量结果和验证范围见 [#35](../../pull/35)。此路径仍需实机验证锁屏恢复;多屏、连接中改变分辨率及旋转/镜像变换不属于本次修复范围。 捕获设置协议仍为版本 4:对客户端上报的分辨率统一使用像素坐标、DPR 为 1;Portal 逻辑尺寸仅用于本地输入映射。 GNOME 缩放桌面在使用 Portal 原生键鼠时,若支持 `ConnectToEIS` 和屏幕 `mapping_id`,通过同一授权会话的 EIS 接口注入输入,按匹配的区域与实际帧尺寸分别映射横纵坐标,没有固定分辨率或缩放倍率,可避免 `NotifyPointerMotionAbsolute` 在缩放时拒绝坐标。Portal 构建需要 libei ≥ 1.1。缺少 EIS 支持时保留旧输入路径及其既有缩放限制;其他初始化错误会明确报告并触发会话恢复。EIS 连接成功后全部输入统一使用 EIS。只采集画面或使用 uinput 时不会初始化 EIS;缺少可选的逻辑尺寸也不阻断采集。键盘沿用项目现有的 Windows VK → evdev 映射。恢复时保持编码器的采集帧尺寸不变,允许缩放后的逻辑尺寸变化。GNOME 显示配置变化后,已推流的 Portal 采集若持续「暂停且无有效格式」,会在关联通知后的 200 毫秒宽限结束后提前进入现有恢复流程;正常重协商恢复会取消提前判定,连续通知不会推迟同次异常的判定。未收到相关通知时保留五秒兜底;静态画面或有效格式下的暂停不会触发恢复。Ubuntu 26.04、GNOME Wayland 单屏 3840×2160 已实测保持连接切换 200%→166.67%→200%,恢复后画面持续更新且鼠标可控制全屏;切换期间会短暂停顿、黑屏后恢复,五秒是兜底判定阈值,并非总恢复时间。提前恢复的测量结果和验证范围见 [#35](../../pull/35)。此路径仍需实机验证锁屏恢复;多屏、连接中改变分辨率及旋转/镜像变换不属于本次修复范围。 捕获设置协议仍为版本 4:对客户端上报的分辨率统一使用像素坐标、DPR 为 1;Portal 逻辑尺寸仅用于本地输入映射。
GNOME Portal 的控制通道不再等待授权窗口或第一帧画面:先通知客户端当前选择桌面,再上报锁屏状态、接收官方客户端的「自动解锁被控端」请求。官方 Android 客户端需要桌面目标通知才会进入自动解锁流程,因此该通知不能等待采集就绪;真实屏幕尺寸、编码信息及采集权限仍按实际就绪状态上报。请在客户端启用自动解锁,使用当前 Linux 用户的登录密码;主机通过 PAM 验证后解锁当前 GNOME 会话、请求点亮屏幕,并恢复同一 Portal 会话中的画面、键鼠和剪贴板。首次授权或权限被撤销时仍需本机确认。物理或逻辑分辨率变化后需要重连。 GNOME Portal 的控制通道不再等待授权窗口或第一帧画面:先通知客户端当前选择桌面,再上报锁屏状态、接收官方客户端的「自动解锁被控端」请求。官方 Android 客户端需要桌面目标通知才会进入自动解锁流程,因此该通知不能等待采集就绪;真实屏幕尺寸、编码信息及采集权限仍按实际就绪状态上报。请在客户端启用自动解锁,使用当前 Linux 用户的登录密码;主机通过 PAM 验证后解锁当前 GNOME 会话、请求点亮屏幕,并恢复同一 Portal 会话中的画面、键鼠和剪贴板。首次授权或权限被撤销时仍需本机确认。物理或逻辑分辨率变化后需要重连。
桌面锁屏且尚未建立 Portal 时(冷连接),主机也会建立控制通道:上报锁屏状态并接受自动解锁,解锁后再恢复画面、键鼠和剪贴板。Portal 等待就绪期间,主机默认通过已协商的视频轨每秒发送一帧生成的纯黑画面,让官方 iPhone 客户端进入自动解锁流程,无需额外配置。Ubuntu GNOME Wayland 上已用官方 Mac 客户端验证;iPhone 4.42.0 的 H.265 冷连接完成了同一实验二进制「开启黑帧成功 → 关闭失败 → 再开成功」对照([#29](../../issues/29))。**局限**:黑帧不是真实 GNOME 锁屏画面,也不支持在锁屏界面操作原生键鼠;需要在 UU 客户端 控制中心 → 安全 → 自动解锁被控端 中启用自动解锁并输入密码。若本机没有已保存的 Portal 授权,解锁后仍需本机确认授权才能显示真实桌面。 桌面锁屏且尚未建立 Portal 时(冷连接),主机也会建立控制通道:上报锁屏状态并接受自动解锁,解锁后再恢复画面、键鼠和剪贴板。Portal 等待就绪期间,主机默认通过已协商的视频轨每秒发送一帧生成的纯黑画面,让官方 iPhone 客户端进入自动解锁流程,无需额外配置。Ubuntu GNOME Wayland 上已用官方 Mac 客户端验证;iPhone 4.42.0 的 H.265 冷连接完成了同一实验二进制「开启黑帧成功 → 关闭失败 → 再开成功」对照([#29](../../issues/29))。**局限**:黑帧不是真实 GNOME 锁屏画面,也不支持在锁屏界面操作原生键鼠;需要在 UU 客户端 控制中心 → 安全 → 自动解锁被控端 中启用自动解锁并输入密码。若本机没有已保存的 Portal 授权,解锁后仍需本机确认授权才能显示真实桌面。
无需修改现有熄屏和锁屏设置。主机仅在会话已解锁的采集恢复期间临时申请 GNOME 的 idle 抑制,拿到首帧后立即释放;锁屏、断开或初始化失败也会释放。远控窗口空闲时仍按原策略熄屏和锁屏,手动锁屏也继续生效。锁屏及锁状态未知时停止桌面输入并隐藏真实画面;独立终端、文件传输和端口映射连接不依赖画面初始化,也不会因桌面重连被关闭。这一恢复路径已覆盖自动化协议与生命周期回归测试,锁屏冷连接后的自动解锁与采集恢复已用官方 Mac 和 iPhone 4.42.0 客户端在 GNOME 实机验证,熄屏等其余场景仍待验收;不支持从整机挂起或休眠状态通过现有控制通道唤醒。 KDE Plasma(KWin)的 Portal 采集在锁屏后仍会继续。主机默认在锁屏时也打开采集,冷连接可以直接看到真实锁屏界面,并用远程键盘输入密码,不再只发黑帧([#227](../../issues/227)、[#229](../../pull/229))。`UU_LOCKED_CAPTURE=0` 关闭这一行为,回到黑帧和自动解锁的路径。KDE 判断依赖 systemd 用户环境里的 `XDG_CURRENT_DESKTOP` 或 `XDG_SESSION_DESKTOP`,两者都没有时回落到黑帧行为,可以手动设 `UU_LOCKED_CAPTURE=1` 开启。锁屏时 Portal 指针输入仍会被拦截,键盘通过 uinput 注入,可以输入密码。GNOME 不适用这一段,Mutter 在锁屏时关闭 Portal 会话,仍走上面的黑帧和自动解锁。
无需修改现有熄屏和锁屏设置。主机仅在会话已解锁的采集恢复期间临时申请 GNOME 的 idle 抑制,拿到首帧后立即释放;锁屏、断开或初始化失败也会释放。远控窗口空闲时仍按原策略熄屏和锁屏,手动锁屏也继续生效。锁屏时停止 Portal 输入。KDE 下继续传输真实锁屏画面,GNOME 下隐藏真实画面并发黑帧。独立终端、文件传输和端口映射连接不依赖画面初始化,也不会因桌面重连被关闭。这一恢复路径已覆盖自动化协议与生命周期回归测试,锁屏冷连接后的自动解锁与采集恢复已用官方 Mac 和 iPhone 4.42.0 客户端在 GNOME 实机验证,熄屏等其余场景仍待验收;不支持从整机挂起或休眠状态通过现有控制通道唤醒。
锁屏状态优先通过系统 D-Bus 读取 logind 的 `LockedHint` 并监听变化,正常监测不按秒启动 `loginctl`。尚无图形会话时保持未知并继续监听,登录后由信号触发重新读取。每 30 秒通过 D-Bus 校验会话;D-Bus 异常时每 30 秒重试并使用带超时的 `loginctl` 回退查询,命令路径只解析一次。回退期间状态通知可能延迟;无法读取时保持未知。锁屏程序仍需正确上报 logind 状态,这不改变睡眠、锁屏或远程连接策略。
锁屏黑帧使用 FFmpeg 的 libx264/libx265 编码器(按已协商的 H.264/H.265 选择),硬件编码器可用并不代表这些软件编码器已安装。编码失败会明确记录日志。黑帧不改变采集权限或上报的真实屏幕尺寸;解锁或锁状态未知时暂停,采集就绪、拒绝或连接关闭时结束,再由真实视频接续同一条视频轨。对照实验与验证范围见 [#29](../../issues/29)、[#34](../../pull/34)。 锁屏黑帧使用 FFmpeg 的 libx264/libx265 编码器(按已协商的 H.264/H.265 选择),硬件编码器可用并不代表这些软件编码器已安装。编码失败会明确记录日志。黑帧不改变采集权限或上报的真实屏幕尺寸;解锁或锁状态未知时暂停,采集就绪、拒绝或连接关闭时结束,再由真实视频接续同一条视频轨。对照实验与验证范围见 [#29](../../issues/29)、[#34](../../pull/34)。
@@ -98,18 +133,20 @@ GNOME Portal 的控制通道不再等待授权窗口或第一帧画面:先通
X11 会话默认把所有显示器拼成一张画面。设置 `UU_X11_MULTISCREEN=1` 后,主机按 `xrandr --listmonitors` 列出各个显示器,控制端可选择其中一块,只采集该区域,绝对鼠标坐标加上该屏幕在桌面中的偏移;默认屏幕为主显示器,`UU_X11_OUTPUT` 可指定其他屏幕(如 `HDMI-1`)。显示器布局在主机启动时读取,改动后需重启服务。此模式下控制端的「分辨率」改为缩放画面,不再修改显示模式。实验性:目前只有单元测试与 Xvfb 虚拟显示器实测,尚未经官方客户端实机验收。 X11 会话默认把所有显示器拼成一张画面。设置 `UU_X11_MULTISCREEN=1` 后,主机按 `xrandr --listmonitors` 列出各个显示器,控制端可选择其中一块,只采集该区域,绝对鼠标坐标加上该屏幕在桌面中的偏移;默认屏幕为主显示器,`UU_X11_OUTPUT` 可指定其他屏幕(如 `HDMI-1`)。显示器布局在主机启动时读取,改动后需重启服务。此模式下控制端的「分辨率」改为缩放画面,不再修改显示模式。实验性:目前只有单元测试与 Xvfb 虚拟显示器实测,尚未经官方客户端实机验收。
切屏复用同一条视频轨道,过渡期间暂停输入,发送新屏首帧后恢复;采集或编码失败、等待首帧超时会请求恢复原屏。当前通过 `hyprctl` 枚举未旋转的显示器,显示器插拔或布局变化后需重启服务。已在 Omarchy / Hyprland 上用官方手机客户端实测 2560×1440(125%)与 1920×1080(133.33%)双屏切换及点击。 切屏复用同一条视频轨道,过渡期间暂停输入,发送新屏首帧后恢复;采集或编码失败、等待首帧超时会请求恢复原屏。Hyprland 通过 `hyprctl` 枚举未旋转的显示器,显示器插拔或布局变化后需重启服务。已在 Omarchy / Hyprland 上用官方手机客户端实测 2560×1440(125%)与 1920×1080(133.33%)双屏切换及点击。
niri 会话通过 `niri msg --json outputs` 枚举已启用的显示器。普通及 90°/180°/270° 旋转输出仅在 `NIRI_SOCKET` 存在时启用;镜像变换暂不支持。三屏切换、90° 竖屏画面与点击,以及手机向 Codex 输入中文已在 CachyOS + niri 实测。其他合成器继续拒绝旋转输出,保留原有文本输入路径。显示器布局变化后需重启服务。
## 尚未实现 / 不支持 ## 尚未实现 / 不支持
| 功能 | 状态 | | 功能 | 状态 |
|---|---| |---|---|
| 多显示器切换 | Hyprland 原生 Wayland 后端与 X11(`UU_X11_MULTISCREEN=1`)实验性支持,见上文 | | 多显示器切换 | niri / Hyprland 原生 Wayland 后端与 X11(`UU_X11_MULTISCREEN=1`)实验性支持,见上文 |
| 真彩(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,并如实回报给客户端 | | 真彩(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 | 未实现 | | HDR | 未实现 |
| 超级屏 / 虚拟显示器 | 未实现 | | 超级屏 / 虚拟显示器 | 未实现 |
| 被控端防窥模式 | 未实现 | | 被控端防窥模式 | 实验性,仅 KDE Plasma Wayland(portal);Mac 4.43.0 已验证不启用、隐私屏保、关闭显示屏三种状态回显;`UU_PRIVACY_AUTO=picture` / `screen-off` 可在桌面连接时自动开启,见 [docs/privacy-screen.md](docs/privacy-screen.md) |
| 麦克风(控制端声音传到被控端) | 未实现(需要虚拟声卡) | | 麦克风(控制端声音传到被控端) | 实验性:Opus → 虚拟麦克风,需 `UU_MICROPHONE=1`;支持 PulseAudio / PipeWire-pulse,见 [说明](docs/remote-microphone.md) |
| 魔兽世界排队提醒等插件 | 不支持,会明确告诉客户端「无插件」 | | 魔兽世界排队提醒等插件 | 不支持,会明确告诉客户端「无插件」 |
| Linux 系统登录界面 | 还不支持控制开机后的系统登录界面(还没有人登录 Linux 桌面时);这种情况可以用无头模式或虚拟桌面(见下文)。注意:这里说的是 Linux 系统登录,**不登录 UU 账号**现在可以通过「远程协助」使用 | | Linux 系统登录界面 | 还不支持控制开机后的系统登录界面(还没有人登录 Linux 桌面时);这种情况可以用无头模式或虚拟桌面(见下文)。注意:这里说的是 Linux 系统登录,**不登录 UU 账号**现在可以通过「远程协助」使用 |
| 跨运营商 / 受限网络的中继连接 | 已接入官方下发的 ICE 服务器,但复杂网络环境未充分测试 | | 跨运营商 / 受限网络的中继连接 | 已接入官方下发的 ICE 服务器,但复杂网络环境未充分测试 |
@@ -165,11 +202,14 @@ sudo apt install libwayland-dev libxkbcommon-dev wl-clipboard
sudo apt install libglib2.0-dev libpipewire-0.3-dev libei-dev sudo apt install libglib2.0-dev libpipewire-0.3-dev libei-dev
# 可选:inproc-av 的 VAAPI/DRI3 引擎编译所需(libva 本体运行时加载) # 可选:inproc-av 的 VAAPI/DRI3 引擎编译所需(libva 本体运行时加载)
sudo apt install libva-dev libgbm-dev libx11-xcb-dev libxcb-dri3-dev libxcb-damage0-dev 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>)。 - 需要 Rust 工具链(<https://rustup.rs>)。
- `libgtk-3-dev` 是可选的:没有 GTK 时只能在终端里扫码登录(也可以设置 `UU_NO_GTK=1` 主动关闭登录窗口)。 - `libgtk-3-dev` 是可选的:没有 GTK 时只能在终端里扫码登录(也可以设置 `UU_NO_GTK=1` 主动关闭登录窗口)。
- NVIDIA 显卡用户需要使用带 `h264_nvenc` 的 FFmpeg,否则自动回落到 CPU 编码(libx264)。 - NVIDIA 显卡用户需要使用带 `h264_nvenc` 的 FFmpeg,否则自动回落到 CPU 编码(libx264)。
- FFmpeg 要求的 NVENC API 版本由编译时的 nv-codec-headers 决定。例如 Arch 的 FFmpeg 9 对着 nv-codec-headers 13.1 编译,需要 610 及以上驱动;Pascal(GTX 10 系)驱动最高 580,只有 NVENC API 13.0,日志会出现 `Driver does not support the required nvenc API version`,于是回落 CPU。可对着 nv-codec-headers 13.0 另编一份 FFmpeg 装到独立目录,在 `config.json` 里用 `ffmpeg_root` 指向它(#230)。
### 2. 编译 ### 2. 编译
@@ -182,6 +222,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)。 控制端的 `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。默认构建和预编译包都不需要该特性。 服务端可选的 `--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. 登录 ### 3. 登录
在图形桌面里运行: 在图形桌面里运行:
@@ -193,6 +236,10 @@ cargo build --release --features wayland,portal # + GNOME/KDE Wayland
用手机上的 **网易 UU 远程 App** 扫码并确认即可。登录信息只保存在本机的 用手机上的 **网易 UU 远程 App** 扫码并确认即可。登录信息只保存在本机的
`~/.config/uuremote/config.json`(权限 0600)里。 `~/.config/uuremote/config.json`(权限 0600)里。
登录状态查询失败或达到 60 秒请求超时不代表二维码已过期,也不代表手机已经确认。程序保留官方客户端的刷新策略:查询出错后点击「刷新二维码」(终端按回车;无窗口且无终端时 60 秒后刷新)。二维码请求诊断只包含请求阶段、错误类别、耗时、HTTP/API 状态及最后已知扫码状态,不输出票据、URL 或响应内容;`connect` 类别本身不能确定是 DNS、TLS 还是代理问题。
这个文件里还有本机的设备身份(`device_id`、`client_id`、`system_id`),重装软件和重新扫码登录都会沿用它。**不要在机器之间拷贝 `config.json`,也不要从带着家目录的快照/数据盘克隆出第二台主机**:同一身份的两个主机实例(不论在同一台还是不同机器上)会互相把对方踢出房间,日志表现为每隔几秒出现 `Cloud room leave without peer identifier` 并反复重连,控制端一连就断。克隆或拷贝出来的机器先停掉服务,删掉配置里这三个键和 `token`、`csrf`、`user_id`,再运行 `uuremote-server login` 注册为新设备。同一台机器上残留的旧实例(例如以前手动启动的 `~/.local/bin/uuremote-server`)也会这样,`uuremote-server doctor` 发现多个主机实例时会提示。
### 4. 作为用户服务常驻 ### 4. 作为用户服务常驻
`~/.config/systemd/user/uuremote-native.service`: `~/.config/systemd/user/uuremote-native.service`:
@@ -240,6 +287,8 @@ sudo udevadm control --reload && sudo udevadm trigger --name-match=uinput
`uaccess` 只把权限给当前坐在这台机器前的登录用户。`UU_INPUT_BACKEND=uinput|native` 可以强制指定后端。 `uaccess` 只把权限给当前坐在这台机器前的登录用户。`UU_INPUT_BACKEND=uinput|native` 可以强制指定后端。
X11 默认继续用 XTest,因为它能正确处理网络延迟下按住不放的按键。 X11 默认继续用 XTest,因为它能正确处理网络延迟下按住不放的按键。
uinput 的 ASCII 文本映射依赖 X11/XWayland XKB;不可映射的文字保留原有文字输入/剪贴板路径。
## 远程协助与主窗口(实验性) ## 远程协助与主窗口(实验性)
和官方客户端的「远程协助」一样:本机显示**设备 ID** 和**验证码**,把它们发给信任的人,对方在 UU 远程的「开始协助」里输入即可控制本机。 和官方客户端的「远程协助」一样:本机显示**设备 ID** 和**验证码**,把它们发给信任的人,对方在 UU 远程的「开始协助」里输入即可控制本机。
@@ -307,24 +356,30 @@ systemctl --user restart uuremote-native.service
| `UU_DESKTOP_BACKEND` | `auto` / `x11` / `wayland` / `portal` / `kms`(实验性特性) / `none`(无头模式) | | `UU_DESKTOP_BACKEND` | `auto` / `x11` / `wayland` / `portal` / `kms`(实验性特性) / `none`(无头模式) |
| `UU_DESKTOP_RESIZE=0` | X11 下控制端切换分辨率时不改桌面分辨率,只缩放编码画面 | | `UU_DESKTOP_RESIZE=0` | X11 下控制端切换分辨率时不改桌面分辨率,只缩放编码画面 |
| `UU_NVENC_RGB=0` / `=1` | NVENC 直接编码 BGRA(省 CPU)。显示器接在 NVIDIA 卡上时默认关闭(同卡合成时直吃反而更慢),`0` 强制关,`1` 强制开 | | `UU_NVENC_RGB=0` / `=1` | NVENC 直接编码 BGRA(省 CPU)。显示器接在 NVIDIA 卡上时默认关闭(同卡合成时直吃反而更慢),`0` 强制关,`1` 强制开 |
| `UU_WAYLAND_MULTISCREEN=1` | 启用 Hyprland 物理显示器切换(默认关闭) | | `UU_WAYLAND_MULTISCREEN=1` | 启用 Hyprland / niri 物理显示器切换(默认关闭) |
| `UU_WAYLAND_OUTPUT` | 原生 Wayland 默认采集输出名称,例如 `HDMI-A-1` | | `UU_WAYLAND_OUTPUT` | 原生 Wayland 默认采集输出名称,例如 `HDMI-A-1` |
| `UU_X11_MULTISCREEN=1` | X11 下按显示器分别选择和采集(实验性,默认关闭,需要 `xrandr`) | | `UU_X11_MULTISCREEN=1` | X11 下按显示器分别选择和采集(实验性,默认关闭,需要 `xrandr`) |
| `UU_X11_OUTPUT` | X11 默认采集的显示器名称(`xrandr --listmonitors`),默认主显示器 | | `UU_X11_OUTPUT` | X11 默认采集的显示器名称(`xrandr --listmonitors`),默认主显示器 |
| `UU_WAYLAND_NO_VIRTUAL_KEYBOARD=1` | 原生 Wayland 不创建虚拟键盘(如 Denial 只把它给自己的输入法),键盘改走 uinput。合成器没有 wlr-virtual-pointer 时鼠标也自动改走 uinput(#72) | | `UU_WAYLAND_NO_VIRTUAL_KEYBOARD=1` | 原生 Wayland 不创建虚拟键盘(如 Denial 只把它给自己的输入法),键盘改走 uinput。合成器没有 wlr-virtual-pointer 时鼠标也自动改走 uinput(#72) |
| `UU_INPUT_BACKEND` | `auto`(默认,Wayland 下可用时用 uinput)/ `uinput` / `native` | | `UU_INPUT_BACKEND` | `auto`(默认,Wayland 下可用时用 uinput)/ `uinput` / `native` |
| `UU_PORTAL_CURSOR_MODE` | 启动时的光标模式:`embedded` 让合成器把指针画进抓屏流,默认隐藏。运行中按客户端发来的相对/绝对位移自动切换;每次切换重建一次 portal 会话,画面和输入短暂中断 |
| `UU_TERMINAL_SHORTCUTS=0` | 关闭终端窗口里的 Ctrl+V 粘贴转换 | | `UU_TERMINAL_SHORTCUTS=0` | 关闭终端窗口里的 Ctrl+V 粘贴转换 |
| `UU_VIDEO_ENCODER` | `cpu` 强制 CPU;`vaapi` 显式启用 Intel/AMD 硬编;`nvenc` 强制 NVENC;未设置或 `auto` 时后台探测(每个候选编码一帧,限时 3 秒)。有 NVIDIA 驱动时顺序是 NVENC → CPU;没有 NVIDIA 时只有 CPU,不探测。探测未完成就建流则沿用旧规则(有 NVIDIA 用 NVENC,否则 CPU)。自行编译的 `--features inproc-av` 上,仅 X11 会先走进程内引擎:外部 FFmpeg 探测失败时记为 `native_unprobed`,沿用旧规则(NVENC);Wayland、portal、KMS 回退 CPU。只有 CPU 时跳过探测,记为 `not probed (only candidate)`。探测成功和这种只含 CPU 的跳过会缓存到 NVIDIA 是否存在发生变化为止(`/proc/driver/nvidia/version` 或 `/dev/nvidia0`)。之后的桌面连接在后台再探测一次(不挡住这一路,仍用缓存的编码器)。NVENC 探测失败、选用 CPU 时只缓存 10 分钟;到期后下一次桌面连接同样在后台再探测一次,再次失败则重新计 10 分钟。显式 `cpu` / `vaapi` / `nvenc` 不启动探测。`native_unprobed` 不算失败缓存。优先级低于 `host_settings.json` 里非 `auto` 的 `video_encoder`。VAAPI 要等 #33 解决后才会进入 auto | | `UU_VIDEO_ENCODER` | `cpu` 强制 CPU;`vaapi` 显式启用 Intel/AMD 硬编;`nvenc` 强制 NVENC;未设置或 `auto` 时后台探测(每个候选编码一帧,限时 3 秒)。有 NVIDIA 驱动时顺序是 NVENC → CPU;没有 NVIDIA 时只有 CPU,不探测。探测未完成就建流则沿用旧规则(有 NVIDIA 用 NVENC,否则 CPU)。自行编译的 `--features inproc-av` 上,仅 X11 会先走进程内引擎:外部 FFmpeg 探测失败时记为 `native_unprobed`,沿用旧规则(NVENC);Wayland、portal、KMS 回退 CPU。只有 CPU 时跳过探测,记为 `not probed (only candidate)`。探测成功和这种只含 CPU 的跳过会缓存到 NVIDIA 是否存在发生变化为止(`/proc/driver/nvidia/version` 或 `/dev/nvidia0`)。之后的桌面连接在后台再探测一次(不挡住这一路,仍用缓存的编码器)。NVENC 探测失败、选用 CPU 时只缓存 10 分钟;到期后下一次桌面连接同样在后台再探测一次,再次失败则重新计 10 分钟。显式 `cpu` / `vaapi` / `nvenc` 不启动探测。`native_unprobed` 不算失败缓存。优先级低于 `host_settings.json` 里非 `auto` 的 `video_encoder`。VAAPI 要等 #33 解决后才会进入 auto |
| `UU_VAAPI_BUFFER_MS` | VAAPI 的 VBV 缓冲(10–1000 ms,仅 `UU_VIDEO_ENCODER=vaapi` 时生效);高分辨率下关键帧被压糊时用它换稳定画质 | | `UU_VAAPI_BUFFER_MS` | VAAPI 的 VBV 缓冲(10–1000 ms,仅 `UU_VIDEO_ENCODER=vaapi` 时生效);高分辨率下关键帧被压糊时用它换稳定画质 |
| `UU_NVENC_BUFFER_MS` | NVENC 的 VBV 缓冲(10–1000 ms,仅 NVENC 生效,含进程内引擎);默认 100–500 kbit,1440p 等高分辨率下关键帧被压糊、按 GOP 周期闪烁时设 `1000`(#103) | | `UU_NVENC_BUFFER_MS` | NVENC 的 VBV 缓冲(10–1000 ms,仅 NVENC 生效,含进程内引擎);默认与 libx264 相同,取 1 秒码率上限并限制在 500–8000 kbit,高分辨率关键帧不再被压糊、按 GOP 周期闪烁(#103)。弱网下想要更小的低延迟缓冲可设小值(如 `50`) |
| `UU_FFMPEG_ROOT` | 使用指定目录下的 FFmpeg | | `UU_FFMPEG_ROOT` | 使用指定目录下的 FFmpeg |
| `UU_AUDIO=0` | 关闭声音转发;`UU_AUDIO_SOURCE` 指定 PulseAudio 采集源 | | `UU_AUDIO=0` | 关闭声音转发;`UU_AUDIO_SOURCE` 指定 PulseAudio 采集源 |
| `UU_LOGIN_WINDOW=0` | 凭证缺失时不自动弹出登录窗口 | | `UU_LOGIN_WINDOW=0` | 凭证缺失时不自动弹出登录窗口 |
| `UU_REMOTE_ASSIST=0` | 关闭远程协助(未登录时也不再以访客身份提供协助) | | `UU_REMOTE_ASSIST=0` | 关闭远程协助(未登录时也不再以访客身份提供协助) |
| `UU_ASSIST_ALLOW=1` | 启动时就允许他人远程协助(覆盖窗口里保存的开关状态) | | `UU_ASSIST_ALLOW=1` | 启动时就允许他人远程协助(覆盖窗口里保存的开关状态) |
| `UU_PORT_MAPPING=0` | 关闭端口映射(对应官方被控端的开关) | | `UU_PORT_MAPPING=0` | 关闭端口映射(对应官方被控端的开关) |
| `UU_WOL_HELPER=1` | 实验性:让这台主机像官方 Windows 被控端一样充当「远程开机」辅助设备——登录后向网易上报本机局域网信息,收到云端唤醒请求时向同一局域网发送唤醒包(未经端到端验证) | | `UU_WOL_HELPER=1` | 实验性:让这台主机像官方 Windows 被控端一样充当「远程开机」辅助设备——登录后向网易上报本机局域网信息,收到云端唤醒请求时向同一局域网发送唤醒包(已在 NAS 上的无头 Linux 主机配合官方 iOS 控制端实测可远程开机) |
| `UU_USE_PROXY=1` | 使用环境变量里的 HTTP/SOCKS 代理;默认忽略代理、直连网易服务器 | | `UU_USE_PROXY=1` | REST API 与 host/viewer WebSocket 信令共用环境 HTTP/HTTPS 代理策略;默认忽略代理、直连 |
`UU_USE_PROXY=1` 仅使用当前进程已有的代理配置;`HTTP_PROXY` / `HTTPS_PROXY` / `ALL_PROXY`(及小写形式)和 `NO_PROXY` 按 reqwest 的标准规则选择,大写优先。信令拒绝选定变量中的无效/不支持的代理 URL(仅 HTTP/HTTPS;不支持 SOCKS)、带路径/查询/片段的代理 URL,以及会忽略代理的 CGI 环境;此校验比 reqwest 默默忽略坏值更严格。未配置匹配代理或命中 `NO_PROXY` 时仍正常直连,选中代理后连接失败不会改为直连。信令保留 TLS 证书校验,不跟随重定向,也不转发认证头到重定向目标。
开启后主机还会经 TCP/TLS 连接云端 TURN 中继(使用 `HTTPS_PROXY`/`ALL_PROXY` 里的无认证 `http://` 代理做 CONNECT,没有代理则直连),适用于 UDP 到不了 TURN 服务器、只有 TCP/代理能出网的主机;TURN 证书按 CA 链校验,云端下发的 TURN 地址是 IP 时容忍名称不匹配(媒体本身由 DTLS-SRTP 端到端加密)。默认(不开代理)只用 UDP 中继,行为不变。**这不创建任何新的网络出口**:登录、信令和媒体仍需各自有允许使用的网络路径。连接器只返回固定错误类别/HTTP 状态;不要为诊断开启会记录 URL/认证信息的依赖库 TRACE 日志。
「远程结束后自动锁屏」「静音运行」等设置保存在 `~/.config/uuremote/host_settings.json`。同一文件里的 `video_encoder`(`auto`/`cpu`/`vaapi`/`nvenc`)和 `video_codec`(`auto`/`h264`/`h265`)用 `uuremote-server set-encoder`、`uuremote-server set-codec` 写入(非法参数退出码 2)。非 `auto` 的值优先于 `UU_VIDEO_ENCODER` / `UU_VIDEO_CODEC`;`auto` 或留空则落到环境变量,再落到 auto(有 NVIDIA 时 NVENC 优先,失败再 CPU;没有 NVIDIA 时就是 CPU,不探测;codec 仍是硬件优先 H.265、CPU 用 H.264)。探测在启动时后台进行,不挡住第一路出图。成功结果缓存到进程退出,但 NVIDIA 是否存在(`/proc/driver/nvidia/version` 或 `/dev/nvidia0`)与报告不一致时,下一次桌面连接会在后台再探测一次(`warm_auto_probe`),这一路仍用缓存的编码器,直到新结果写入。NVENC 失败只缓存 10 分钟,到期后的桌面连接同样在后台再探测一次,这一路仍用当前结果。`set-encoder` 和 `set-codec` 写完后若 `host.pid` 指向正在运行的本程序,都会发 `SIGUSR2`:编码器变化时进行中的桌面流立刻换编码器(不断开,沿用本会话已协商的 codec;新编码器起不来时按进程内 → FFmpeg 进程 → CPU 回退)。手改文件后可 `kill -USR2 $(cat ~/.config/uuremote/host.pid)`。`SIGUSR2` 不重新探测。codec 偏好仍在下次建立桌面连接时生效(运行中的 host 只记日志,不重开编码)。显式 `vaapi` 请求真彩时仍用 VAAPI、编码 4:2:0,并在 CaptureSettingSync 的 field 3 回报 4:2:0。所选编码器在本机不可用时,建流回退 CPU 并记 warning。VAAPI 进入 auto 要等 #33。 「远程结束后自动锁屏」「静音运行」等设置保存在 `~/.config/uuremote/host_settings.json`。同一文件里的 `video_encoder`(`auto`/`cpu`/`vaapi`/`nvenc`)和 `video_codec`(`auto`/`h264`/`h265`)用 `uuremote-server set-encoder`、`uuremote-server set-codec` 写入(非法参数退出码 2)。非 `auto` 的值优先于 `UU_VIDEO_ENCODER` / `UU_VIDEO_CODEC`;`auto` 或留空则落到环境变量,再落到 auto(有 NVIDIA 时 NVENC 优先,失败再 CPU;没有 NVIDIA 时就是 CPU,不探测;codec 仍是硬件优先 H.265、CPU 用 H.264)。探测在启动时后台进行,不挡住第一路出图。成功结果缓存到进程退出,但 NVIDIA 是否存在(`/proc/driver/nvidia/version` 或 `/dev/nvidia0`)与报告不一致时,下一次桌面连接会在后台再探测一次(`warm_auto_probe`),这一路仍用缓存的编码器,直到新结果写入。NVENC 失败只缓存 10 分钟,到期后的桌面连接同样在后台再探测一次,这一路仍用当前结果。`set-encoder` 和 `set-codec` 写完后若 `host.pid` 指向正在运行的本程序,都会发 `SIGUSR2`:编码器变化时进行中的桌面流立刻换编码器(不断开,沿用本会话已协商的 codec;新编码器起不来时按进程内 → FFmpeg 进程 → CPU 回退)。手改文件后可 `kill -USR2 $(cat ~/.config/uuremote/host.pid)`。`SIGUSR2` 不重新探测。codec 偏好仍在下次建立桌面连接时生效(运行中的 host 只记日志,不重开编码)。显式 `vaapi` 请求真彩时仍用 VAAPI、编码 4:2:0,并在 CaptureSettingSync 的 field 3 回报 4:2:0。所选编码器在本机不可用时,建流回退 CPU 并记 warning。VAAPI 进入 auto 要等 #33。
@@ -358,6 +413,7 @@ flowchart LR
## 安全与隐私 ## 安全与隐私
- 已登录的图形主机默认会将当前壁纸图片上传到 UU 的文件服务,供设备卡片显示背景;可用 `UU_WALLPAPER_UPLOAD=0` 关闭上传。
- 日志不记录键盘输入、终端内容、剪贴板内容、文件内容、密码和令牌。 - 日志不记录键盘输入、终端内容、剪贴板内容、文件内容、密码和令牌。
- 自动解锁的密码保存在**控制端**(官方客户端)里,被控端只拿来做一次 PAM 校验,不落盘、不写日志。 - 自动解锁的密码保存在**控制端**(官方客户端)里,被控端只拿来做一次 PAM 校验,不落盘、不写日志。
- 能连上这台机器的,只有登录了同一个 UU 账号的设备。请保管好你的 UU 账号。 - 能连上这台机器的,只有登录了同一个 UU 账号的设备。请保管好你的 UU 账号。
@@ -477,6 +533,8 @@ xfce4-session xfce4-panel xfdesktop xfwm4 gnome-terminal`。
## 实验性原生控制端(uuremote-viewer) ## 实验性原生控制端(uuremote-viewer)
[SDL 控制端视频调度说明](docs/viewer-video-scheduling.md)。
`uuremote-viewer` 是 Linux 上的**控制端**:用你的 UU 账号连接并控制其他设备(官方 Windows / Mac 被控端,或本项目的 Linux 主机), `uuremote-viewer` 是 Linux 上的**控制端**:用你的 UU 账号连接并控制其他设备(官方 Windows / Mac 被控端,或本项目的 Linux 主机),
也可以凭对方的设备 ID 和验证码发起远程协助。它是实验性功能,与主机 `uuremote-server` 相互独立,默认主机构建和行为不变。 也可以凭对方的设备 ID 和验证码发起远程协助。它是实验性功能,与主机 `uuremote-server` 相互独立,默认主机构建和行为不变。
@@ -484,7 +542,12 @@ xfce4-session xfce4-panel xfdesktop xfwm4 gnome-terminal`。
`ffmpeg` 命令;SDL 桌面窗口直接同步文本剪贴板(Wayland/X11),无需额外剪贴板工具;终端功能需要本机终端程序(可用 `TERMINAL` 指定)。 `ffmpeg` 命令;SDL 桌面窗口直接同步文本剪贴板(Wayland/X11),无需额外剪贴板工具;终端功能需要本机终端程序(可用 `TERMINAL` 指定)。
从源码构建:`sudo apt install libsdl2-dev`,然后 `cargo build --release --locked --features native-viewer,viewer-sdl --bin uuremote-viewer`。 从源码构建:`sudo apt install libsdl2-dev`,然后 `cargo build --release --locked --features native-viewer,viewer-sdl --bin uuremote-viewer`。
SDL 剪贴板复用桌面窗口,避免 GNOME Wayland 上临时窗口引起的 Dock 跳动(#37)。仅在桌面窗口获得焦点时同步, 组合键使用 SDL 按键事件携带的左右修饰键状态;窗口失焦时释放远端按键,重新聚焦后的下一次普通按键会恢复仍按住的 Shift/Ctrl/Alt/Win(Mac 为 Command)。此行为内置,无需适配库或开关。
控制端会同步远端以 PNG 发送的指针形状(如文本光标和窗口缩放箭头),并保留正确热点。离开远控画面或打开本地菜单时恢复本机箭头。
SDL 剪贴板复用桌面窗口,避免 GNOME Wayland 上临时窗口引起的 Dock 跳动(#37)。niri 改用支持 data-control 的
`wl-clipboard`,不需要桌面窗口保持焦点;其他 SDL 后端仅在桌面窗口获得焦点时同步。
保留 30 KiB 文本上限;跳过不含支持的文本格式的本地选择,空文本的识别取决于 SDL2 后端。不带 SDL 的构建保留命令后端。 保留 30 KiB 文本上限;跳过不含支持的文本格式的本地选择,空文本的识别取决于 SDL2 后端。不带 SDL 的构建保留命令后端。
SDL2 同步读取选择内容,慢速的剪贴板提供者可能暂时阻塞窗口,桥接超时无法中断该原生调用。 SDL2 同步读取选择内容,慢速的剪贴板提供者可能暂时阻塞窗口,桥接超时无法中断该原生调用。
GNOME 与官方 Mac 被控端的双向剪贴板尚未验证通过;此修改不解决被控端兼容问题。 GNOME 与官方 Mac 被控端的双向剪贴板尚未验证通过;此修改不解决被控端兼容问题。
@@ -514,6 +577,9 @@ GNOME 与官方 Mac 被控端的双向剪贴板尚未验证通过;此修改不
- 桌面同时提供 H.264 / H.265,由主机协商选择;`UU_VIEWER_CODEC=h264` 将 SDP 和解码能力限制为 H.264。 - 桌面同时提供 H.264 / H.265,由主机协商选择;`UU_VIEWER_CODEC=h264` 将 SDP 和解码能力限制为 H.264。
默认请求 4:2:0;`UU_VIEWER_CHROMA=444` 在 CONTROL 打开后请求真彩(4:4:4)。主机可能回落到 4:2:0, 默认请求 4:2:0;`UU_VIEWER_CHROMA=444` 在 CONTROL 打开后请求真彩(4:4:4)。主机可能回落到 4:2:0,
以 CaptureSettingSync 回报为准。两种色度均由 FFmpeg 转为 RGB24 显示。 以 CaptureSettingSync 回报为准。两种色度均由 FFmpeg 转为 RGB24 显示。
- 按被控端原始分辨率解码,窗口缩放使用线性过滤;被控端分辨率变化时自动重启解码器。`UU_VIEWER_SIZE=WxH` 可改为固定的留黑边画布。
SDL 远程画面窗口关闭本地输入法的文本组合,按物理键转发;输入中文时请使用被控端的输入法及其中英切换键(例如 Shift)。
Mac 目标使用 macOS 原生键码,Windows / Linux 目标保留 Windows VK。键盘按物理键位置转发,不自动把 Ctrl 改成 Command; Mac 目标使用 macOS 原生键码,Windows / Linux 目标保留 Windows VK。键盘按物理键位置转发,不自动把 Ctrl 改成 Command;
控制 Mac 时,PC 键盘的 Super / Win 键对应 Command。仅接受已验证的目标平台值 1(Windows / 本项目 Linux 主机)和 4(Mac), 控制 Mac 时,PC 键盘的 Super / Win 键对应 Command。仅接受已验证的目标平台值 1(Windows / 本项目 Linux 主机)和 4(Mac),
@@ -536,3 +602,11 @@ Mac 目标使用 macOS 原生键码,Windows / Linux 目标保留 Windows VK。
| Wayland 下的桌面窗口与剪贴板 | — | — | ✅ Hyprland、KDE;GNOME 窗口正常,剪贴板已于 v0.2.3 改为 SDL 直连(#37,最终版本未重新实机验收) | | Wayland 下的桌面窗口与剪贴板 | — | — | ✅ Hyprland、KDE;GNOME 窗口正常,剪贴板已于 v0.2.3 改为 SDL 直连(#37,最终版本未重新实机验收) |
「—」表示尚未测试。重启/关机只应在可以重启的机器上使用。**未实测**:官方被控端的 H.265 / 4:4:4、多显示器。日志只记录字段号、大小和状态,不记录键盘、剪贴板、文件内容、验证码或凭据。 「—」表示尚未测试。重启/关机只应在可以重启的机器上使用。**未实测**:官方被控端的 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)。
+32 -4
View File
@@ -1,14 +1,22 @@
fn main() { 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/portal_clipboard.inc");
println!("cargo:rerun-if-changed=c_engine/x11_engine.c"); 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.c");
println!("cargo:rerun-if-changed=c_engine/nvenc_engine.h"); 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/dynlink_cuda.h");
println!("cargo:rerun-if-changed=vendor/ffnvcodec/ffnvcodec/nvEncodeAPI.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/clipboard.c");
println!("cargo:rerun-if-changed=c_engine/assist_window.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_window.c");
println!("cargo:rerun-if-changed=c_engine/viewer_tools.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-changed=c_engine/pam_check.c");
println!("cargo:rerun-if-env-changed=UU_NO_GTK"); println!("cargo:rerun-if-env-changed=UU_NO_GTK");
println!("cargo:rustc-check-cfg=cfg(uu_gtk)"); println!("cargo:rustc-check-cfg=cfg(uu_gtk)");
@@ -27,9 +35,17 @@ fn main() {
} }
let mut x11_build = cc::Build::new(); let mut x11_build = cc::Build::new();
x11_build.file("c_engine/x11_engine.c") 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/clipboard.c")
.file("c_engine/pam_check.c"); .file("c_engine/pam_check.c");
if std::env::var_os("CARGO_FEATURE_INPROC_AV").is_some() { 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/nvenc_engine.c");
x11_build.file("c_engine/vaapi_engine.c"); x11_build.file("c_engine/vaapi_engine.c");
x11_build.file("c_engine/dri3_capture.c"); x11_build.file("c_engine/dri3_capture.c");
@@ -37,15 +53,22 @@ fn main() {
println!("cargo:rerun-if-changed={f}"); println!("cargo:rerun-if-changed={f}");
} }
x11_build.include("vendor/ffnvcodec"); x11_build.include("vendor/ffnvcodec");
}
x11_build.compile("x11_engine");
// libva/libva-drm are dlopen'ed at runtime (like NVENC's libcuda); these are // 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. // 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=gbm");
println!("cargo:rustc-link-lib=X11-xcb"); println!("cargo:rustc-link-lib=X11-xcb");
println!("cargo:rustc-link-lib=xcb"); println!("cargo:rustc-link-lib=xcb");
println!("cargo:rustc-link-lib=xcb-dri3"); println!("cargo:rustc-link-lib=xcb-dri3");
println!("cargo:rustc-link-lib=xcb-damage"); println!("cargo:rustc-link-lib=xcb-damage");
} }
x11_build.compile("x11_engine");
println!("cargo:rustc-link-lib=X11"); println!("cargo:rustc-link-lib=X11");
println!("cargo:rustc-link-lib=Xext"); println!("cargo:rustc-link-lib=Xext");
@@ -58,7 +81,7 @@ fn main() {
match (std::env::var_os("UU_NO_GTK").is_none()).then(|| gtk("--cflags").zip(gtk("--libs"))).flatten() { match (std::env::var_os("UU_NO_GTK").is_none()).then(|| gtk("--cflags").zip(gtk("--libs"))).flatten() {
Some((cflags, libs)) => { Some((cflags, libs)) => {
let mut build = cc::Build::new(); 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); } for flag in cflags.split_whitespace() { build.flag(flag); }
build.compile("uu_login_window"); build.compile("uu_login_window");
for flag in libs.split_whitespace() { for flag in libs.split_whitespace() {
@@ -150,6 +173,11 @@ fn shared_engine(name: &str, sources: &[&str], includes: &[&std::path::Path], cf
command.args(cflags.split_whitespace()).args(sources).args(libs.split_whitespace()).arg("-lpthread"); command.args(cflags.split_whitespace()).args(sources).args(libs.split_whitespace()).arg("-lpthread");
let status = command.status().expect("C compiler for the engine plugin"); let status = command.status().expect("C compiler for the engine plugin");
assert!(status.success(), "building {name} failed"); assert!(status.success(), "building {name} failed");
// OUT_DIR = target/<profile>/build/<package>-<hash>/out // OUT_DIR = target/<profile>/build/<package>-<hash>/out, or target/<profile>/build/<package>/<hash>/out with
if let Some(profile) = out.ancestors().nth(3) { std::fs::copy(&library, profile.join(name)).expect("copy engine plugin"); } // the newer Cargo build-dir layout (Rust 1.100 CI): the profile dir is the parent of the `build` component.
let profile = out.ancestors().find(|dir| dir.file_name().is_some_and(|n| n == "build")).and_then(|dir| dir.parent());
match profile {
Some(profile) => { std::fs::copy(&library, profile.join(name)).expect("copy engine plugin"); }
None => println!("cargo:warning={name} built in {} but no target/<profile> dir found to copy it to", out.display()),
}
} }
+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);
}
+74 -81
View File
@@ -8,25 +8,9 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <dlfcn.h> #include <dlfcn.h>
#include "i18n.h"
static const char *CSS = #include "ui_theme.h"
"window { background-color: #f5f6f8; }\n" static void on_language(GtkComboBox *c, gpointer note);
"* { 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 { 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 }; enum { VERIFY_TEMPORARY = 0, VERIFY_CUSTOM = 1, VERIFY_BOTH = 2 };
@@ -96,9 +80,9 @@ static void on_custom_changed(GtkEditable *e, gpointer ok) {
// Returns 1 when a new custom code was entered and posted. // Returns 1 when a new custom code was entered and posted.
static int ask_custom_code(void) { static int ask_custom_code(void) {
GtkWidget *d = gtk_dialog_new_with_buttons("设置自定义验证码", GTK_WINDOW(window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GtkWidget *d = gtk_dialog_new_with_buttons(L("设置自定义验证码", "Set custom code"), GTK_WINDOW(window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
"取消", GTK_RESPONSE_CANCEL, NULL); L("取消", "Cancel"), GTK_RESPONSE_CANCEL, NULL);
GtkWidget *ok = gtk_dialog_add_button(GTK_DIALOG(d), "确定", GTK_RESPONSE_OK); GtkWidget *ok = gtk_dialog_add_button(GTK_DIALOG(d), L("确定", "OK"), GTK_RESPONSE_OK);
gtk_widget_set_sensitive(ok, FALSE); gtk_widget_set_sensitive(ok, FALSE);
GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(d)); GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(d));
gtk_container_set_border_width(GTK_CONTAINER(area), 16); gtk_container_set_border_width(GTK_CONTAINER(area), 16);
@@ -106,10 +90,10 @@ static int ask_custom_code(void) {
GtkWidget *entry = gtk_entry_new(); GtkWidget *entry = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(entry), 16); gtk_entry_set_max_length(GTK_ENTRY(entry), 16);
gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE); gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE);
gtk_entry_set_placeholder_text(GTK_ENTRY(entry), "请输入自定义验证码"); gtk_entry_set_placeholder_text(GTK_ENTRY(entry), L("请输入自定义验证码", "Enter custom code"));
g_signal_connect(entry, "changed", G_CALLBACK(on_custom_changed), ok); g_signal_connect(entry, "changed", G_CALLBACK(on_custom_changed), ok);
gtk_box_pack_start(GTK_BOX(area), entry, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(area), entry, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(area), label("8-16 位,需同时包含字母和数字;不会自动刷新,请妥善保管", "note"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(area), label(L("8-16 位,需同时包含字母和数字;不会自动刷新,请妥善保管", "8-16 characters with both letters and digits; never refreshed automatically, keep it safe"), "note"), FALSE, FALSE, 0);
gtk_widget_show_all(d); gtk_widget_show_all(d);
int done = 0; int done = 0;
if (gtk_dialog_run(GTK_DIALOG(d)) == GTK_RESPONSE_OK) { if (gtk_dialog_run(GTK_DIALOG(d)) == GTK_RESPONSE_OK) {
@@ -140,12 +124,12 @@ static void on_refresh_item(GtkCheckMenuItem *item, gpointer data) {
} }
static void on_refresh_now(GtkMenuItem *i, gpointer d) { (void)i; (void)d; post(CMD_RESET); } static void on_refresh_now(GtkMenuItem *i, gpointer d) { (void)i; (void)d; post(CMD_RESET); }
static const char *REFRESH_NOTES[5] = { "每次远控结束刷新", "每小时自动刷新", "每 12 小时自动刷新", "每 24 小时自动刷新", "不自动刷新" }; static const char *refresh_note(int i) { const char *notes[5] = { L("每次远控结束刷新", "Refreshed after every remote session"), L("每小时自动刷新", "Refreshed every hour"), L("每 12 小时自动刷新", "Refreshed every 12 hours"), L("每 24 小时自动刷新", "Refreshed every 24 hours"), L("不自动刷新", "Never refreshed automatically") }; return notes[i >= 0 && i < 5 ? i : 0]; }
static void render_code(void) { static void render_code(void) {
if (!code_label) return; if (!code_label) return;
gtk_label_set_text(GTK_LABEL(code_label), current_code[0] ? (code_visible ? current_code : "********") : "--------"); gtk_label_set_text(GTK_LABEL(code_label), current_code[0] ? (code_visible ? current_code : "********") : "--------");
gtk_button_set_label(GTK_BUTTON(eye_button), code_visible ? "隐藏" : "显示"); gtk_button_set_label(GTK_BUTTON(eye_button), code_visible ? L("隐藏", "Hide") : L("显示", "Show"));
} }
static void copy_text(const char *text, const char *hint) { static void copy_text(const char *text, const char *hint) {
@@ -159,19 +143,19 @@ static void on_copy_id(GtkButton *b, gpointer d) {
char digits[64]; size_t n = 0; char digits[64]; size_t n = 0;
for (const char *p = current_id; *p && n + 1 < sizeof digits; p++) if (*p != ' ') digits[n++] = *p; for (const char *p = current_id; *p && n + 1 < sizeof digits; p++) if (*p != ' ') digits[n++] = *p;
digits[n] = 0; digits[n] = 0;
copy_text(digits, "已复制设备 ID"); copy_text(digits, L("已复制设备 ID", "Device ID copied"));
} }
static void on_copy_code(GtkButton *b, gpointer d) { (void)b; (void)d; copy_text(current_code, "已复制验证码,请只发给信任的人"); } static void on_copy_code(GtkButton *b, gpointer d) { (void)b; (void)d; copy_text(current_code, L("已复制验证码,请只发给信任的人", "Code copied. Only share it with people you trust")); }
static void on_eye(GtkButton *b, gpointer d) { (void)b; (void)d; code_visible = !code_visible; render_code(); } static void on_eye(GtkButton *b, gpointer d) { (void)b; (void)d; code_visible = !code_visible; render_code(); }
static void on_share(GtkButton *b, gpointer d) { static void on_share(GtkButton *b, gpointer d) {
(void)b; (void)d; (void)b; (void)d;
if (!current_id[0] || !current_code[0]) return; if (!current_id[0] || !current_code[0]) return;
char *text = g_strdup_printf("UU 远程协助\n设备 ID:%s\n验证码:%s", current_id, current_code); char *text = g_strdup_printf(L("UU 远程协助\n设备 ID:%s\n验证码:%s", "UU Remote assistance\nDevice ID: %s\nCode: %s"), current_id, current_code);
gtk_clipboard_set_text(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD), text, -1); gtk_clipboard_set_text(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD), text, -1);
g_free(text); g_free(text);
gtk_label_set_text(GTK_LABEL(hint_label), "已复制设备 ID 和验证码,请只发给信任的人"); gtk_label_set_text(GTK_LABEL(hint_label), L("已复制设备 ID 和验证码,请只发给信任的人", "Device ID and code copied. Only share them with people you trust"));
} }
static gboolean on_switch(GtkSwitch *s, gboolean state, gpointer d) { static gboolean on_switch(GtkSwitch *s, gboolean state, gpointer d) {
@@ -213,10 +197,10 @@ static gboolean draw_avatar(GtkWidget *w, cairo_t *cr, gpointer d) {
static void on_logout(GtkButton *b, gpointer d) { static void on_logout(GtkButton *b, gpointer d) {
(void)b; (void)d; (void)b; (void)d;
GtkWidget *dlg = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_OK_CANCEL, GtkWidget *dlg = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_OK_CANCEL,
"退出登录后,本机将从你的设备列表中下线,远程协助会改用访客身份。确定退出吗?"); L("退出登录后,本机将从你的设备列表中下线,远程协助会改用访客身份。确定退出吗?", "After signing out this computer leaves your device list and assistance switches to guest mode. Sign out?"));
if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_OK) { if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_OK) {
post(CMD_LOGOUT); post(CMD_LOGOUT);
gtk_label_set_text(GTK_LABEL(user_label), "正在退出登录…"); gtk_label_set_text(GTK_LABEL(user_label), L("正在退出登录…", "Signing out…"));
} }
gtk_widget_destroy(dlg); gtk_widget_destroy(dlg);
} }
@@ -226,7 +210,7 @@ static GtkWidget *build_account_card(void) {
gtk_style_context_add_class(gtk_widget_get_style_context(card), "card"); gtk_style_context_add_class(gtk_widget_get_style_context(card), "card");
GtkWidget *header = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10); GtkWidget *header = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10);
gtk_container_set_border_width(GTK_CONTAINER(header), 20); gtk_container_set_border_width(GTK_CONTAINER(header), 20);
gtk_box_pack_start(GTK_BOX(header), label("账号", "heading"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(header), label(L("账号", "Account"), "heading"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(card), header, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(card), header, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(card), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(card), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0);
account_stack = gtk_stack_new(); account_stack = gtk_stack_new();
@@ -243,21 +227,21 @@ static GtkWidget *build_account_card(void) {
GtkWidget *spinner = gtk_spinner_new(); GtkWidget *spinner = gtk_spinner_new();
gtk_spinner_start(GTK_SPINNER(spinner)); gtk_spinner_start(GTK_SPINNER(spinner));
gtk_box_pack_start(GTK_BOX(loading), spinner, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(loading), spinner, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(loading), label("正在获取二维码…", "note"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(loading), label(L("正在获取二维码…", "Loading QR code…"), "note"), FALSE, FALSE, 0);
gtk_stack_add_named(GTK_STACK(qr_stack), loading, "loading"); gtk_stack_add_named(GTK_STACK(qr_stack), loading, "loading");
qr_image = gtk_image_new(); qr_image = gtk_image_new();
gtk_stack_add_named(GTK_STACK(qr_stack), qr_image, "qr"); gtk_stack_add_named(GTK_STACK(qr_stack), qr_image, "qr");
gtk_box_pack_start(GTK_BOX(qr_page), qr_stack, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(qr_page), qr_stack, FALSE, FALSE, 0);
GtkWidget *qr_text = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8); GtkWidget *qr_text = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8);
gtk_widget_set_valign(qr_text, GTK_ALIGN_CENTER); gtk_widget_set_valign(qr_text, GTK_ALIGN_CENTER);
gtk_box_pack_start(GTK_BOX(qr_text), label("扫码登录", "heading"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(qr_text), label(L("扫码登录", "Scan to sign in"), "heading"), FALSE, FALSE, 0);
GtkWidget *cap = label("请使用网易 UU 远程 App 扫一扫登录。\n登录后本机会出现在你的设备列表中,可直接远程控制;\n远程协助在登录前后都可以使用。", "hint"); GtkWidget *cap = label(L("请使用网易 UU 远程 App 扫一扫登录。\n登录后本机会出现在你的设备列表中,可直接远程控制;\n远程协助在登录前后都可以使用。", "Scan with the NetEase UU Remote app to sign in.\nAfter sign-in this computer appears in your device list and can be controlled directly;\nremote assistance works whether you are signed in or not."), "hint");
gtk_label_set_xalign(GTK_LABEL(cap), 0); gtk_label_set_xalign(GTK_LABEL(cap), 0);
gtk_box_pack_start(GTK_BOX(qr_text), cap, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(qr_text), cap, FALSE, FALSE, 0);
login_status = label("", "status"); login_status = label("", "status");
gtk_label_set_line_wrap(GTK_LABEL(login_status), TRUE); gtk_label_set_line_wrap(GTK_LABEL(login_status), TRUE);
gtk_box_pack_start(GTK_BOX(qr_text), login_status, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(qr_text), login_status, FALSE, FALSE, 0);
qr_refresh = gtk_button_new_with_label("刷新二维码"); qr_refresh = gtk_button_new_with_label(L("刷新二维码", "Refresh QR code"));
gtk_widget_set_halign(qr_refresh, GTK_ALIGN_START); gtk_widget_set_halign(qr_refresh, GTK_ALIGN_START);
gtk_widget_set_no_show_all(qr_refresh, TRUE); gtk_widget_set_no_show_all(qr_refresh, TRUE);
g_signal_connect(qr_refresh, "clicked", G_CALLBACK(on_qr_refresh), NULL); g_signal_connect(qr_refresh, "clicked", G_CALLBACK(on_qr_refresh), NULL);
@@ -277,9 +261,9 @@ static GtkWidget *build_account_card(void) {
gtk_widget_set_valign(user_text, GTK_ALIGN_CENTER); gtk_widget_set_valign(user_text, GTK_ALIGN_CENTER);
user_label = label("", "user"); user_label = label("", "user");
gtk_box_pack_start(GTK_BOX(user_text), user_label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(user_text), user_label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(user_text), label("已登录 · 本机已出现在你的设备列表中", "hint"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(user_text), label(L("已登录 · 本机已出现在你的设备列表中", "Signed in · this computer is in your device list"), "hint"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(user_page), user_text, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(user_page), user_text, TRUE, TRUE, 0);
GtkWidget *logout = gtk_button_new_with_label("退出登录"); GtkWidget *logout = gtk_button_new_with_label(L("退出登录", "Sign out"));
gtk_style_context_add_class(gtk_widget_get_style_context(logout), "share"); gtk_style_context_add_class(gtk_widget_get_style_context(logout), "share");
gtk_widget_set_valign(logout, GTK_ALIGN_CENTER); gtk_widget_set_valign(logout, GTK_ALIGN_CENTER);
g_signal_connect(logout, "clicked", G_CALLBACK(on_logout), NULL); g_signal_connect(logout, "clicked", G_CALLBACK(on_logout), NULL);
@@ -299,8 +283,8 @@ static void on_tray_allow(GtkCheckMenuItem *i, gpointer d) {
static void on_tray_quit(GtkMenuItem *i, gpointer d) { static void on_tray_quit(GtkMenuItem *i, gpointer d) {
(void)i; (void)d; (void)i; (void)d;
GtkWidget *dlg = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_OK_CANCEL, GtkWidget *dlg = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_OK_CANCEL,
"退出后本机将下线:设备列表和远程协助都无法连接,直到再次启动。确定退出吗?"); L("退出后本机将下线:设备列表和远程协助都无法连接,直到再次启动。确定退出吗?", "Quitting takes this computer offline: neither the device list nor remote assistance can connect until it starts again. Quit?"));
gtk_window_set_title(GTK_WINDOW(dlg), "UU 远程 Linux 主机"); gtk_window_set_title(GTK_WINDOW(dlg), L("UU 远程 Linux 主机", "UU Remote Linux host"));
if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_OK) post(CMD_QUIT); if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_OK) post(CMD_QUIT);
gtk_widget_destroy(dlg); gtk_widget_destroy(dlg);
} }
@@ -337,11 +321,11 @@ static gchar *write_tray_icon(void) {
} }
static void build_tray(void) { static void build_tray(void) {
tray_menu = gtk_menu_new(); tray_menu = gtk_menu_new();
GtkWidget *open = gtk_menu_item_new_with_label("打开主窗口"); GtkWidget *open = gtk_menu_item_new_with_label(L("打开主窗口", "Open main window"));
g_signal_connect(open, "activate", G_CALLBACK(on_tray_open), NULL); g_signal_connect(open, "activate", G_CALLBACK(on_tray_open), NULL);
tray_allow = gtk_check_menu_item_new_with_label("允许他人远程协助"); tray_allow = gtk_check_menu_item_new_with_label(L("允许他人远程协助", "Allow remote assistance"));
g_signal_connect(tray_allow, "toggled", G_CALLBACK(on_tray_allow), NULL); g_signal_connect(tray_allow, "toggled", G_CALLBACK(on_tray_allow), NULL);
GtkWidget *quit = gtk_menu_item_new_with_label("退出"); GtkWidget *quit = gtk_menu_item_new_with_label(L("退出", "Quit"));
g_signal_connect(quit, "activate", G_CALLBACK(on_tray_quit), NULL); g_signal_connect(quit, "activate", G_CALLBACK(on_tray_quit), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), open); gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), open);
gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), tray_allow); gtk_menu_shell_append(GTK_MENU_SHELL(tray_menu), tray_allow);
@@ -367,7 +351,7 @@ static void build_tray(void) {
// Without a theme path the panel cannot find the cached icon; keep the installed one. // Without a theme path the panel cannot find the cached icon; keep the installed one.
void *ind = ind_new("uu-remote-linux", set_theme_path ? icon : fallback, 0 /* APPLICATION_STATUS */); void *ind = ind_new("uu-remote-linux", set_theme_path ? icon : fallback, 0 /* APPLICATION_STATUS */);
if (icon_path && set_theme_path) set_theme_path(ind, icon_path); if (icon_path && set_theme_path) set_theme_path(ind, icon_path);
if (set_title) set_title(ind, "UU 远程 Linux 主机"); if (set_title) set_title(ind, L("UU 远程 Linux 主机", "UU Remote Linux host"));
set_menu(ind, GTK_MENU(tray_menu)); set_menu(ind, GTK_MENU(tray_menu));
set_status(ind, 1 /* ACTIVE */); set_status(ind, 1 /* ACTIVE */);
return; // keep the library loaded for the indicator's lifetime return; // keep the library loaded for the indicator's lifetime
@@ -377,23 +361,19 @@ static void build_tray(void) {
// XEmbed system tray (Xfce, Cinnamon, MATE...). // XEmbed system tray (Xfce, Cinnamon, MATE...).
G_GNUC_BEGIN_IGNORE_DEPRECATIONS G_GNUC_BEGIN_IGNORE_DEPRECATIONS
GtkStatusIcon *status = gtk_status_icon_new_from_icon_name(icon); GtkStatusIcon *status = gtk_status_icon_new_from_icon_name(icon);
gtk_status_icon_set_tooltip_text(status, "UU 远程 Linux 主机"); gtk_status_icon_set_tooltip_text(status, L("UU 远程 Linux 主机", "UU Remote Linux host"));
gtk_status_icon_set_title(status, "UU 远程 Linux 主机"); gtk_status_icon_set_title(status, L("UU 远程 Linux 主机", "UU Remote Linux host"));
g_signal_connect(status, "activate", G_CALLBACK(on_status_activate), NULL); g_signal_connect(status, "activate", G_CALLBACK(on_status_activate), NULL);
g_signal_connect(status, "popup-menu", G_CALLBACK(on_status_menu), NULL); g_signal_connect(status, "popup-menu", G_CALLBACK(on_status_menu), NULL);
G_GNUC_END_IGNORE_DEPRECATIONS G_GNUC_END_IGNORE_DEPRECATIONS
} }
static void build_window(void) { static void build_window(void) {
GtkCssProvider *css = gtk_css_provider_new(); uu_theme_init();
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);
gtk_window_set_default_icon_name("uu-remote-linux"); // contrib/desktop icon, when installed gtk_window_set_default_icon_name("uu-remote-linux"); // contrib/desktop icon, when installed
window = gtk_window_new(GTK_WINDOW_TOPLEVEL); window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "UU 远程 Linux 主机(非官方)"); gtk_window_set_title(GTK_WINDOW(window), L("UU 远程 Linux 主机(非官方)", "UU Remote Linux host (unofficial)"));
gtk_window_set_default_size(GTK_WINDOW(window), 760, -1); gtk_window_set_default_size(GTK_WINDOW(window), 760, -1);
gtk_window_set_resizable(GTK_WINDOW(window), FALSE); gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
@@ -417,12 +397,12 @@ static void build_window(void) {
// Header: 本设备 ... 允许他人远程协助 [switch] // Header: 本设备 ... 允许他人远程协助 [switch]
GtkWidget *header = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10); GtkWidget *header = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10);
gtk_container_set_border_width(GTK_CONTAINER(header), 20); gtk_container_set_border_width(GTK_CONTAINER(header), 20);
gtk_box_pack_start(GTK_BOX(header), label("本设备", "heading"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(header), label(L("本设备", "This device"), "heading"), FALSE, FALSE, 0);
allow_switch = gtk_switch_new(); allow_switch = gtk_switch_new();
gtk_widget_set_valign(allow_switch, GTK_ALIGN_CENTER); gtk_widget_set_valign(allow_switch, GTK_ALIGN_CENTER);
g_signal_connect(allow_switch, "state-set", G_CALLBACK(on_switch), NULL); g_signal_connect(allow_switch, "state-set", G_CALLBACK(on_switch), NULL);
gtk_box_pack_end(GTK_BOX(header), allow_switch, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(header), allow_switch, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(header), label("允许他人远程协助", "key"), FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(header), label(L("允许他人远程协助", "Allow remote assistance"), "key"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(card), header, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(card), header, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(card), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(card), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0);
@@ -431,12 +411,12 @@ static void build_window(void) {
gtk_container_set_border_width(GTK_CONTAINER(body), 20); gtk_container_set_border_width(GTK_CONTAINER(body), 20);
gtk_grid_set_column_spacing(GTK_GRID(body), 48); gtk_grid_set_column_spacing(GTK_GRID(body), 48);
gtk_grid_set_row_spacing(GTK_GRID(body), 6); gtk_grid_set_row_spacing(GTK_GRID(body), 6);
gtk_grid_attach(GTK_GRID(body), label("本设备 ID", "key"), 0, 0, 1, 1); gtk_grid_attach(GTK_GRID(body), label(L("本设备 ID", "This device's ID"), "key"), 0, 0, 1, 1);
GtkWidget *id_row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8); GtkWidget *id_row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
id_label = label("获取中…", "big"); id_label = label(L("获取中…", "Loading…"), "big");
gtk_label_set_selectable(GTK_LABEL(id_label), TRUE); gtk_label_set_selectable(GTK_LABEL(id_label), TRUE);
gtk_box_pack_start(GTK_BOX(id_row), id_label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(id_row), id_label, FALSE, FALSE, 0);
GtkWidget *copy_id = gtk_button_new_with_label("复制"); GtkWidget *copy_id = gtk_button_new_with_label(L("复制", "Copy"));
gtk_style_context_add_class(gtk_widget_get_style_context(copy_id), "flat"); gtk_style_context_add_class(gtk_widget_get_style_context(copy_id), "flat");
gtk_widget_set_valign(copy_id, GTK_ALIGN_CENTER); gtk_widget_set_valign(copy_id, GTK_ALIGN_CENTER);
g_signal_connect(copy_id, "clicked", G_CALLBACK(on_copy_id), NULL); g_signal_connect(copy_id, "clicked", G_CALLBACK(on_copy_id), NULL);
@@ -444,11 +424,11 @@ static void build_window(void) {
gtk_grid_attach(GTK_GRID(body), id_row, 0, 1, 1, 1); gtk_grid_attach(GTK_GRID(body), id_row, 0, 1, 1, 1);
GtkWidget *verify_row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6); GtkWidget *verify_row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start(GTK_BOX(verify_row), label("验证方式:", "key"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(verify_row), label(L("验证方式:", "Verification:"), "key"), FALSE, FALSE, 0);
verify_combo = gtk_combo_box_text_new(); verify_combo = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(verify_combo), "仅使用临时验证码"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(verify_combo), L("仅使用临时验证码", "Temporary code only"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(verify_combo), "仅使用自定义验证码"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(verify_combo), L("仅使用自定义验证码", "Custom code only"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(verify_combo), "同时使用两种验证码"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(verify_combo), L("同时使用两种验证码", "Use both codes"));
gtk_combo_box_set_active(GTK_COMBO_BOX(verify_combo), 0); gtk_combo_box_set_active(GTK_COMBO_BOX(verify_combo), 0);
g_signal_connect(verify_combo, "changed", G_CALLBACK(on_verify_changed), NULL); g_signal_connect(verify_combo, "changed", G_CALLBACK(on_verify_changed), NULL);
gtk_box_pack_start(GTK_BOX(verify_row), verify_combo, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(verify_row), verify_combo, FALSE, FALSE, 0);
@@ -456,17 +436,17 @@ static void build_window(void) {
GtkWidget *code_row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8); GtkWidget *code_row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
code_label = label("--------", "big"); code_label = label("--------", "big");
gtk_box_pack_start(GTK_BOX(code_row), code_label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(code_row), code_label, FALSE, FALSE, 0);
eye_button = gtk_button_new_with_label("隐藏"); eye_button = gtk_button_new_with_label(L("隐藏", "Hide"));
gtk_style_context_add_class(gtk_widget_get_style_context(eye_button), "flat"); gtk_style_context_add_class(gtk_widget_get_style_context(eye_button), "flat");
g_signal_connect(eye_button, "clicked", G_CALLBACK(on_eye), NULL); g_signal_connect(eye_button, "clicked", G_CALLBACK(on_eye), NULL);
// Gear menu: 立即刷新 / 自动刷新 ▸ (每次远控结束, 每小时, 每 12 小时, 每 24 小时, 关闭) / 设置自定义验证码 // Gear menu: 立即刷新 / 自动刷新 ▸ (每次远控结束, 每小时, 每 12 小时, 每 24 小时, 关闭) / 设置自定义验证码
GtkWidget *menu = gtk_menu_new(); GtkWidget *menu = gtk_menu_new();
GtkWidget *now = gtk_menu_item_new_with_label("立即刷新"); GtkWidget *now = gtk_menu_item_new_with_label(L("立即刷新", "Refresh now"));
g_signal_connect(now, "activate", G_CALLBACK(on_refresh_now), NULL); g_signal_connect(now, "activate", G_CALLBACK(on_refresh_now), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), now); gtk_menu_shell_append(GTK_MENU_SHELL(menu), now);
GtkWidget *auto_item = gtk_menu_item_new_with_label("自动刷新"); GtkWidget *auto_item = gtk_menu_item_new_with_label(L("自动刷新", "Auto refresh"));
GtkWidget *sub = gtk_menu_new(); GtkWidget *sub = gtk_menu_new();
const char *names[5] = { "每次远控结束", "每小时", "每 12 小时", "每 24 小时", "关闭" }; const char *names[5] = { L("每次远控结束", "After every remote session"), L("每小时", "Every hour"), L("每 12 小时", "Every 12 hours"), L("每 24 小时", "Every 24 hours"), L("关闭", "Close") };
GSList *group = NULL; GSList *group = NULL;
for (int i = 0; i < 5; i++) { for (int i = 0; i < 5; i++) {
refresh_items[i] = gtk_radio_menu_item_new_with_label(group, names[i]); refresh_items[i] = gtk_radio_menu_item_new_with_label(group, names[i]);
@@ -476,15 +456,15 @@ static void build_window(void) {
} }
gtk_menu_item_set_submenu(GTK_MENU_ITEM(auto_item), sub); gtk_menu_item_set_submenu(GTK_MENU_ITEM(auto_item), sub);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), auto_item); gtk_menu_shell_append(GTK_MENU_SHELL(menu), auto_item);
GtkWidget *custom_item = gtk_menu_item_new_with_label("设置自定义验证码…"); GtkWidget *custom_item = gtk_menu_item_new_with_label(L("设置自定义验证码…", "Set custom code…"));
g_signal_connect(custom_item, "activate", G_CALLBACK(on_set_custom), NULL); g_signal_connect(custom_item, "activate", G_CALLBACK(on_set_custom), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), custom_item); gtk_menu_shell_append(GTK_MENU_SHELL(menu), custom_item);
gtk_widget_show_all(menu); gtk_widget_show_all(menu);
GtkWidget *gear = gtk_menu_button_new(); GtkWidget *gear = gtk_menu_button_new();
gtk_button_set_image(GTK_BUTTON(gear), gtk_image_new_from_icon_name("emblem-system-symbolic", GTK_ICON_SIZE_BUTTON)); gtk_button_set_image(GTK_BUTTON(gear), gtk_image_new_from_icon_name("emblem-system-symbolic", GTK_ICON_SIZE_BUTTON));
gtk_widget_set_tooltip_text(gear, "刷新设置"); gtk_widget_set_tooltip_text(gear, L("刷新设置", "Refresh settings"));
gtk_menu_button_set_popup(GTK_MENU_BUTTON(gear), menu); gtk_menu_button_set_popup(GTK_MENU_BUTTON(gear), menu);
GtkWidget *copy_code = gtk_button_new_with_label("复制"); GtkWidget *copy_code = gtk_button_new_with_label(L("复制", "Copy"));
gtk_style_context_add_class(gtk_widget_get_style_context(copy_code), "flat"); gtk_style_context_add_class(gtk_widget_get_style_context(copy_code), "flat");
gtk_widget_set_valign(copy_code, GTK_ALIGN_CENTER); gtk_widget_set_valign(copy_code, GTK_ALIGN_CENTER);
g_signal_connect(copy_code, "clicked", G_CALLBACK(on_copy_code), NULL); g_signal_connect(copy_code, "clicked", G_CALLBACK(on_copy_code), NULL);
@@ -494,10 +474,10 @@ static void build_window(void) {
gtk_box_pack_start(GTK_BOX(code_row), eye_button, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(code_row), eye_button, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(code_row), gear, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(code_row), gear, FALSE, FALSE, 0);
gtk_grid_attach(GTK_GRID(body), code_row, 1, 1, 1, 1); gtk_grid_attach(GTK_GRID(body), code_row, 1, 1, 1, 1);
note_label = label(REFRESH_NOTES[0], "note"); note_label = label(refresh_note(0), "note");
gtk_grid_attach(GTK_GRID(body), note_label, 1, 2, 1, 1); gtk_grid_attach(GTK_GRID(body), note_label, 1, 2, 1, 1);
share_button = gtk_button_new_with_label("复制并分享"); share_button = gtk_button_new_with_label(L("复制并分享", "Copy and share"));
gtk_style_context_add_class(gtk_widget_get_style_context(share_button), "share"); gtk_style_context_add_class(gtk_widget_get_style_context(share_button), "share");
gtk_widget_set_valign(share_button, GTK_ALIGN_CENTER); gtk_widget_set_valign(share_button, GTK_ALIGN_CENTER);
g_signal_connect(share_button, "clicked", G_CALLBACK(on_share), NULL); g_signal_connect(share_button, "clicked", G_CALLBACK(on_share), NULL);
@@ -509,9 +489,19 @@ static void build_window(void) {
account_card = build_account_card(); account_card = build_account_card();
gtk_widget_set_margin_top(account_card, 6); gtk_widget_set_margin_top(account_card, 6);
gtk_box_pack_start(GTK_BOX(root), account_card, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(root), account_card, FALSE, FALSE, 0);
footer_label = label("开源 Linux 被控端 · 非网易官方客户端 · 关闭窗口即停止远程协助", "footer"); footer_label = label(L("开源 Linux 被控端 · 非网易官方客户端 · 关闭窗口即停止远程协助", "Open-source Linux host · not an official NetEase client · closing the window stops remote assistance"), "footer");
gtk_box_pack_end(GTK_BOX(root), footer_label, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(root), footer_label, FALSE, FALSE, 0);
if (close_hides) gtk_label_set_text(GTK_LABEL(footer_label), "开源 Linux 被控端 · 非网易官方客户端 · 关闭窗口后远程协助仍在后台运行"); GtkWidget *lang_row = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8), *lang_note = label("", "note");
GtkWidget *lang = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(lang), "中文"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(lang), "English");
gtk_combo_box_set_active(GTK_COMBO_BOX(lang), uu_i18n_english());
g_signal_connect(lang, "changed", G_CALLBACK(on_language), lang_note);
gtk_box_pack_start(GTK_BOX(lang_row), label("语言 / Language", "key"), FALSE, FALSE, 0);
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(); render_code();
if (close_hides) build_tray(); if (close_hides) build_tray();
gtk_widget_show_all(gtk_bin_get_child(GTK_BIN(window))); gtk_widget_show_all(gtk_bin_get_child(GTK_BIN(window)));
@@ -525,11 +515,14 @@ static void build_window(void) {
if (!start_hidden) gtk_widget_show(window); if (!start_hidden) gtk_widget_show(window);
} }
static void on_language(GtkComboBox *c, gpointer note) {
int english = gtk_combo_box_get_active(c) == 1;
gtk_label_set_text(GTK_LABEL(note), english == uu_i18n_english() ? "" : !uu_i18n_save(english) ? L("无法保存语言设置", "Could not save the language")
: english ? "Restart uuremote-server to switch to English" : "重新启动 uuremote-server 后切换为中文");
}
static void *ui_main(void *arg) { static void *ui_main(void *arg) {
(void)arg; (void)arg;
int ok = gtk_init_check(NULL, NULL); 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(); if (ok) build_window();
pthread_mutex_lock(&init_lock); pthread_mutex_lock(&init_lock);
init_state = ok ? 1 : -1; init_state = ok ? 1 : -1;
@@ -582,7 +575,7 @@ static gboolean apply_state(gpointer data) {
if (window) { if (window) {
g_strlcpy(current_id, s->id, sizeof current_id); g_strlcpy(current_id, s->id, sizeof current_id);
g_strlcpy(current_code, s->code, sizeof current_code); g_strlcpy(current_code, s->code, sizeof current_code);
gtk_label_set_text(GTK_LABEL(id_label), current_id[0] ? current_id : "获取中…"); gtk_label_set_text(GTK_LABEL(id_label), current_id[0] ? current_id : L("获取中…", "Loading…"));
render_code(); render_code();
suppress_switch = 1; suppress_switch = 1;
gtk_switch_set_active(GTK_SWITCH(allow_switch), s->allowed); gtk_switch_set_active(GTK_SWITCH(allow_switch), s->allowed);
@@ -593,12 +586,12 @@ static gboolean apply_state(gpointer data) {
if (s->refresh >= 0 && s->refresh < 5) { if (s->refresh >= 0 && s->refresh < 5) {
suppress_refresh = 1; gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(refresh_items[s->refresh]), TRUE); suppress_refresh = 0; suppress_refresh = 1; gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(refresh_items[s->refresh]), TRUE); suppress_refresh = 0;
} }
gtk_label_set_text(GTK_LABEL(note_label), s->verify == VERIFY_CUSTOM ? "自定义验证码不会自动刷新" gtk_label_set_text(GTK_LABEL(note_label), s->verify == VERIFY_CUSTOM ? L("自定义验证码不会自动刷新", "Custom code is never refreshed automatically")
: s->verify == VERIFY_BOTH ? "也可使用自定义验证码连接" : REFRESH_NOTES[s->refresh >= 0 && s->refresh < 5 ? s->refresh : 0]); : s->verify == VERIFY_BOTH ? L("也可使用自定义验证码连接", "The custom code also works") : refresh_note(s->refresh));
gtk_widget_set_sensitive(share_button, current_id[0] && current_code[0]); gtk_widget_set_sensitive(share_button, current_id[0] && current_code[0]);
gtk_label_set_text(GTK_LABEL(hint_label), s->allowed gtk_label_set_text(GTK_LABEL(hint_label), s->allowed
? "对方在 UU 远程「开始协助」中输入设备 ID 和验证码即可连接" ? L("对方在 UU 远程「开始协助」中输入设备 ID 和验证码即可连接", "Your partner enters the device ID and code under \"Start assistance\" in UU Remote to connect")
: "已关闭:他人暂时无法远程协助本机,打开右上角开关后才能连接"); : L("已关闭:他人暂时无法远程协助本机,打开右上角开关后才能连接", "Off: nobody can assist this computer until you turn on the switch at the top right"));
} }
g_free(s->id); g_free(s->code); g_free(s); g_free(s->id); g_free(s->code); g_free(s);
return G_SOURCE_REMOVE; return G_SOURCE_REMOVE;
@@ -725,7 +718,7 @@ static int notify_desktop(const char *summary, const char *body) {
g_variant_builder_add(&hints, "{sv}", "urgency", g_variant_new_byte(2)); // critical: stays until dismissed g_variant_builder_add(&hints, "{sv}", "urgency", g_variant_new_byte(2)); // critical: stays until dismissed
GVariant *reply = g_dbus_connection_call_sync(bus, "org.freedesktop.Notifications", "/org/freedesktop/Notifications", GVariant *reply = g_dbus_connection_call_sync(bus, "org.freedesktop.Notifications", "/org/freedesktop/Notifications",
"org.freedesktop.Notifications", "Notify", "org.freedesktop.Notifications", "Notify",
g_variant_new("(susssasa{sv}i)", "UU 远程 Linux 主机", 0u, "uu-remote-linux", summary, body, &actions, &hints, -1), g_variant_new("(susssasa{sv}i)", L("UU 远程 Linux 主机", "UU Remote Linux host"), 0u, "uu-remote-linux", summary, body, &actions, &hints, -1),
G_VARIANT_TYPE("(u)"), G_DBUS_CALL_FLAGS_NONE, 3000, NULL, NULL); G_VARIANT_TYPE("(u)"), G_DBUS_CALL_FLAGS_NONE, 3000, NULL, NULL);
g_object_unref(bus); g_object_unref(bus);
if (!reply) return -1; if (!reply) return -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
+8
View File
@@ -0,0 +1,8 @@
// Chinese / English UI text. The language is decided once on the Rust side (src/i18n.rs: UU_LANG, the
// choice saved in settings, then the locale) so the GTK windows and Rust messages always agree.
#ifndef UU_I18N_H
#define UU_I18N_H
int uu_i18n_english(void);
int uu_i18n_save(int english);
#define L(zh, en) (uu_i18n_english() ? (en) : (zh))
#endif
+35 -4
View File
@@ -67,6 +67,7 @@ static void selection_owner(GDBusConnection *bus,const gchar *sender,const gchar
pthread_mutex_lock(&p->lock); pthread_mutex_lock(&p->lock);
g_free(p->clipboard_mime); p->clipboard_mime=selected; g_free(p->clipboard_mime); p->clipboard_mime=selected;
p->clipboard_changed=!owner && selected!=NULL; p->clipboard_revision++; p->clipboard_changed=!owner && selected!=NULL; p->clipboard_revision++;
p->clipboard_owns=owner?1:0;
pthread_mutex_unlock(&p->lock); pthread_mutex_unlock(&p->lock);
if (types) g_variant_unref(types); if (types) g_variant_unref(types);
} }
@@ -100,16 +101,46 @@ int uu_portal_clipboard_set(struct uu_portal *p,const uint8_t *text,size_t lengt
if (!uu_portal_clipboard_ready(p) || length>CLIP_LIMIT || !g_utf8_validate((const char *)text,(gssize)length,NULL)) return -1; if (!uu_portal_clipboard_ready(p) || length>CLIP_LIMIT || !g_utf8_validate((const char *)text,(gssize)length,NULL)) return -1;
char *copy=g_malloc(length+1); memcpy(copy,text,length); copy[length]=0; char *copy=g_malloc(length+1); memcpy(copy,text,length); copy[length]=0;
pthread_mutex_lock(&p->lock); pthread_mutex_lock(&p->lock);
g_free(p->clipboard_text); p->clipboard_text=copy; p->clipboard_length=length; /* Serve the new text while the portal announces it, and restore the old one on failure. */
p->clipboard_changed=0; char *old_text=p->clipboard_text; size_t old_length=p->clipboard_length;
uint64_t revision=p->clipboard_revision;
p->clipboard_text=copy; p->clipboard_length=length; p->clipboard_changed=0;
pthread_mutex_unlock(&p->lock); pthread_mutex_unlock(&p->lock);
const char *types[]={"text/plain;charset=utf-8","text/plain",NULL}; const char *types[]={"text/plain;charset=utf-8","text/plain",NULL};
GVariantBuilder options; g_variant_builder_init(&options,G_VARIANT_TYPE_VARDICT); GVariantBuilder options; g_variant_builder_init(&options,G_VARIANT_TYPE_VARDICT);
g_variant_builder_add(&options,"{sv}","mime_types",g_variant_new_strv(types,-1)); g_variant_builder_add(&options,"{sv}","mime_types",g_variant_new_strv(types,-1));
GVariant *reply=g_dbus_connection_call_sync(p->bus,DEST,PATH,CLIPBOARD,"SetSelection", GVariant *reply=g_dbus_connection_call_sync(p->bus,DEST,PATH,CLIPBOARD,"SetSelection",
g_variant_new("(o@a{sv})",p->session,g_variant_builder_end(&options)),NULL,G_DBUS_CALL_FLAGS_NONE,2000,NULL,NULL); g_variant_new("(o@a{sv})",p->session,g_variant_builder_end(&options)),NULL,G_DBUS_CALL_FLAGS_NONE,2000,NULL,NULL);
if (!reply) return -1; if (!reply) {
g_variant_unref(reply); return 0; pthread_mutex_lock(&p->lock);
g_free(p->clipboard_text);
p->clipboard_text=old_text; p->clipboard_length=old_length;
pthread_mutex_unlock(&p->lock);
return -1;
}
g_variant_unref(reply);
g_free(old_text);
pthread_mutex_lock(&p->lock);
/* Another owner may have been reported meanwhile; its newer state must win. */
if (p->clipboard_revision==revision) p->clipboard_owns=1;
pthread_mutex_unlock(&p->lock);
return 0;
}
/* Hand the text this session is providing to a replacement session, so a session swap (cursor
* mode, privacy screen, monitor switch) does not drop the viewer's clipboard. Transfers only
* while this session still owns the selection. Returns 0 transferred, 1 nothing to transfer. */
int uu_portal_clipboard_copy(struct uu_portal *from, struct uu_portal *to) {
if (!from || !to) return -1;
/* A session that ended cannot know whether a newer owner took the selection since. */
if (!uu_portal_alive(from)) return 1;
pthread_mutex_lock(&from->lock);
char *copy=(from->clipboard_owns && from->clipboard_text)?g_memdup2(from->clipboard_text,from->clipboard_length+1):NULL;
size_t length=from->clipboard_length;
pthread_mutex_unlock(&from->lock);
if (!copy) return 1;
int result=uu_portal_clipboard_set(to,(const uint8_t *)copy,length);
g_free(copy);
return result==0?0:-1;
} }
int uu_portal_clipboard_poll(struct uu_portal *p,uint8_t *out,size_t capacity) { int uu_portal_clipboard_poll(struct uu_portal *p,uint8_t *out,size_t capacity) {
if (!out || !uu_portal_clipboard_ready(p) || capacity<CLIP_LIMIT) return -1; if (!out || !uu_portal_clipboard_ready(p) || capacity<CLIP_LIMIT) return -1;
+39 -3
View File
@@ -17,7 +17,7 @@ static int portal_eis_dispatch(struct uu_portal *p) {
case EI_EVENT_SEAT_ADDED: case EI_EVENT_SEAT_ADDED:
ei_seat_bind_capabilities(ei_event_get_seat(event), ei_seat_bind_capabilities(ei_event_get_seat(event),
EI_DEVICE_CAP_POINTER, EI_DEVICE_CAP_POINTER_ABSOLUTE, EI_DEVICE_CAP_POINTER, EI_DEVICE_CAP_POINTER_ABSOLUTE,
EI_DEVICE_CAP_BUTTON, EI_DEVICE_CAP_SCROLL, EI_DEVICE_CAP_KEYBOARD, NULL); EI_DEVICE_CAP_BUTTON, EI_DEVICE_CAP_SCROLL, EI_DEVICE_CAP_KEYBOARD, EI_DEVICE_CAP_TOUCH, NULL);
break; break;
case EI_EVENT_DEVICE_RESUMED: case EI_EVENT_DEVICE_RESUMED:
if (!g_list_find(p->ei_devices, device)) { if (!g_list_find(p->ei_devices, device)) {
@@ -55,15 +55,19 @@ static struct ei_region *portal_eis_region(struct uu_portal *p, struct ei_device
ei_region_get_width(region) && ei_region_get_height(region)) return region; ei_region_get_width(region) && ei_region_get_height(region)) return region;
} }
} }
static struct ei_device *portal_eis_absolute(struct uu_portal *p, struct ei_region **region) { static struct ei_device *portal_eis_mapped(struct uu_portal *p, enum ei_device_capability capability, struct ei_region **region) {
for (GList *item = p->ei_devices; item; item = item->next) { for (GList *item = p->ei_devices; item; item = item->next) {
struct ei_device *device = item->data; struct ei_device *device = item->data;
if (ei_device_has_capability(device, EI_DEVICE_CAP_POINTER_ABSOLUTE) && if (ei_device_has_capability(device, capability) &&
(*region = portal_eis_region(p, device))) return device; (*region = portal_eis_region(p, device))) return device;
} }
return NULL; return NULL;
} }
static struct ei_device *portal_eis_absolute(struct uu_portal *p, struct ei_region **region) {
return portal_eis_mapped(p, EI_DEVICE_CAP_POINTER_ABSOLUTE, region);
}
static void portal_eis_close(struct uu_portal *p) { static void portal_eis_close(struct uu_portal *p) {
if (p->ei_touch) p->ei_touch = ei_touch_unref(p->ei_touch);
for (GList *item = p->ei_devices; item; item = item->next) ei_device_unref(item->data); for (GList *item = p->ei_devices; item; item = item->next) ei_device_unref(item->data);
g_list_free(p->ei_devices); p->ei_devices = NULL; g_list_free(p->ei_devices); p->ei_devices = NULL;
if (p->ei) p->ei = ei_unref(p->ei); if (p->ei) p->ei = ei_unref(p->ei);
@@ -157,6 +161,38 @@ static int portal_eis_button(struct uu_portal *p, int button, int pressed) {
ei_device_button_button(device, code, !!pressed); ei_device_button_button(device, code, !!pressed);
return portal_eis_frame(p, device); return portal_eis_frame(p, device);
} }
static int portal_eis_scroll(struct uu_portal *p, double dx, double dy, int finish) {
if (portal_eis_available(p)) return 9;
struct ei_device *device = portal_eis_device(p, EI_DEVICE_CAP_SCROLL);
if (!device) return 9;
if (dx != 0 || dy != 0) ei_device_scroll_delta(device, dx, dy);
if (finish) ei_device_scroll_stop(device, true, true);
return portal_eis_frame(p, device);
}
static int portal_eis_touch(struct uu_portal *p, int phase, double x, double y) {
if (portal_eis_available(p)) return 9;
if (phase == 2) {
if (!p->ei_touch) return 0;
struct ei_device *device = ei_touch_get_device(p->ei_touch);
ei_touch_up(p->ei_touch);
p->ei_touch = ei_touch_unref(p->ei_touch);
return portal_eis_frame(p, device);
}
struct ei_region *region = NULL;
struct ei_device *device = portal_eis_mapped(p, EI_DEVICE_CAP_TOUCH, &region);
if (!device) return 9;
double target_x = ei_region_get_x(region) + x * ei_region_get_width(region) / p->width;
double target_y = ei_region_get_y(region) + y * ei_region_get_height(region) / p->height;
if (phase == 0) {
if (p->ei_touch) { ei_touch_up(p->ei_touch); p->ei_touch = ei_touch_unref(p->ei_touch); }
if (!(p->ei_touch = ei_device_touch_new(device))) return 9;
ei_touch_down(p->ei_touch, target_x, target_y);
} else {
if (!p->ei_touch) return 11;
ei_touch_motion(p->ei_touch, target_x, target_y);
}
return portal_eis_frame(p, device);
}
static int portal_eis_key(struct uu_portal *p, int code, int pressed) { static int portal_eis_key(struct uu_portal *p, int code, int pressed) {
if (code < 0 || code > 0x2ff) return 11; if (code < 0 || code > 0x2ff) return 11;
if (portal_eis_available(p)) return 9; if (portal_eis_available(p)) return 9;
+432 -37
View File
@@ -16,6 +16,7 @@
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <limits.h>
#define DEST "org.freedesktop.portal.Desktop" #define DEST "org.freedesktop.portal.Desktop"
#define PATH "/org/freedesktop/portal/desktop" #define PATH "/org/freedesktop/portal/desktop"
@@ -37,7 +38,8 @@ struct uu_portal {
char *session; char *session;
char *restore_token; char *restore_token;
guint closed_subscription, clipboard_owner_subscription, clipboard_transfer_subscription, display_subscription; guint closed_subscription, clipboard_owner_subscription, clipboard_transfer_subscription, display_subscription;
int clipboard_enabled, clipboard_changed; int clipboard_enabled, clipboard_changed, clipboard_owns;
int cursor_available, cursor_applied;
char *clipboard_text, *clipboard_mime; char *clipboard_text, *clipboard_mime;
size_t clipboard_length; size_t clipboard_length;
uint64_t clipboard_revision; uint64_t clipboard_revision;
@@ -56,10 +58,12 @@ struct uu_portal {
int format_valid, stream_started; int format_valid, stream_started;
gint64 interrupted_at, display_changed_at; gint64 interrupted_at, display_changed_at;
uint32_t node, width, height; uint32_t node, width, height;
int logical_width, logical_height; int logical_width, logical_height, position_x, position_y, has_position;
int absolute_stream_pixels; int absolute_stream_pixels;
uint32_t devices, available;
struct ei *ei; struct ei *ei;
GList *ei_devices; GList *ei_devices;
struct ei_touch *ei_touch;
char *mapping_id; char *mapping_id;
uint32_t ei_sequence; uint32_t ei_sequence;
atomic_int ei_failed; atomic_int ei_failed;
@@ -69,11 +73,23 @@ struct uu_portal {
size_t frame_length; size_t frame_length;
uint64_t sequence; uint64_t sequence;
uint64_t revision; 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" #include "portal_clipboard.inc"
static pthread_once_t pw_once = PTHREAD_ONCE_INIT; static pthread_once_t pw_once = PTHREAD_ONCE_INIT;
static atomic_uint token_sequence = 1; static atomic_uint token_sequence = 1;
/* Cursor preference for sessions opened from now on; -1 defers to UU_PORTAL_CURSOR_MODE. */
static atomic_int cursor_mode_override = -1;
void uu_portal_set_cursor_mode(int mode) { atomic_store(&cursor_mode_override, mode); }
/* Cursor mode the last session actually requested: 1 hidden, 2 embedded, 0 when unavailable. */
int uu_portal_cursor_mode(struct uu_portal *p) { return p ? p->cursor_applied : 0; }
/* Cursor modes the backend advertised for the last session; 0 when the property was unreadable. */
int uu_portal_cursor_modes(struct uu_portal *p) { return p ? p->cursor_available : 0; }
static void initialize_pipewire(void) { pw_init(NULL, NULL); } static void initialize_pipewire(void) { pw_init(NULL, NULL); }
static GVariant *empty_options(void) { return g_variant_new_array(G_VARIANT_TYPE("{sv}"), NULL, 0); } static GVariant *empty_options(void) { return g_variant_new_array(G_VARIANT_TYPE("{sv}"), NULL, 0); }
static int open_cancelled(struct uu_portal *p) { static int open_cancelled(struct uu_portal *p) {
@@ -81,6 +97,23 @@ static int open_cancelled(struct uu_portal *p) {
} }
static int wait_for_first_frame(struct uu_portal *p); static int wait_for_first_frame(struct uu_portal *p);
#include "portal_eis.inc" #include "portal_eis.inc"
/* A uint32 portal property; 0 when unreadable. */
static guint interface_property(struct uu_portal *p, const char *interface, const char *name) {
GVariant *reply = g_dbus_connection_call_sync(p->bus, DEST, PATH,
"org.freedesktop.DBus.Properties", "Get", g_variant_new("(ss)", interface, name),
G_VARIANT_TYPE("(v)"), G_DBUS_CALL_FLAGS_NONE, 3000, NULL, NULL);
guint result = 0;
if (reply) {
GVariant *value; g_variant_get(reply, "(v)", &value);
if (g_variant_is_of_type(value, G_VARIANT_TYPE_UINT32)) result = g_variant_get_uint32(value);
g_variant_unref(value); g_variant_unref(reply);
}
return result;
}
/* A uint32 RemoteDesktop property (version, AvailableDeviceTypes). */
static guint remote_property(struct uu_portal *p, const char *name) {
return interface_property(p, REMOTE, name);
}
static void fail(struct uu_portal *p, int error) { static void fail(struct uu_portal *p, int error) {
pthread_mutex_lock(&p->lock); pthread_mutex_lock(&p->lock);
if (!p->error) p->error = error; if (!p->error) p->error = error;
@@ -158,6 +191,8 @@ static void session_closed(GDBusConnection *bus, const gchar *sender, const gcha
const gchar *interface, const gchar *signal, GVariant *parameters, gpointer data) { const gchar *interface, const gchar *signal, GVariant *parameters, gpointer data) {
(void)bus; (void)sender; (void)path; (void)interface; (void)signal; (void)parameters; (void)bus; (void)sender; (void)path; (void)interface; (void)signal; (void)parameters;
struct uu_portal *p = data; struct uu_portal *p = data;
/* A closed session no longer tracks owner changes, so its cached claim is stale. */
pthread_mutex_lock(&p->lock); p->clipboard_owns=0; pthread_mutex_unlock(&p->lock);
atomic_store(&p->closed, 1); fail(p, 9); atomic_store(&p->closed, 1); fail(p, 9);
} }
static void *run_dbus(void *data) { static void *run_dbus(void *data) {
@@ -208,11 +243,17 @@ static void stream_state(void *data, enum pw_stream_state old, enum pw_stream_st
pthread_mutex_unlock(&p->lock); pthread_mutex_unlock(&p->lock);
if (state == PW_STREAM_STATE_ERROR || state == PW_STREAM_STATE_UNCONNECTED) fail(data, 9); 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) { static void stream_format(void *data, uint32_t id, const struct spa_pod *param) {
struct uu_portal *p = data; struct uu_portal *p = data;
if (id != SPA_PARAM_Format) return; if (id != SPA_PARAM_Format) return;
if (!param) { if (!param) {
pthread_mutex_lock(&p->lock); 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; p->format_valid = 0;
update_interruption(p); update_interruption(p);
pthread_mutex_unlock(&p->lock); pthread_mutex_unlock(&p->lock);
@@ -224,6 +265,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_BGRA && info.format != SPA_VIDEO_FORMAT_BGRx &&
info.format != SPA_VIDEO_FORMAT_RGBA && info.format != SPA_VIDEO_FORMAT_RGBx)) { fail(p, 8); return; } info.format != SPA_VIDEO_FORMAT_RGBA && info.format != SPA_VIDEO_FORMAT_RGBx)) { fail(p, 8); return; }
pthread_mutex_lock(&p->lock); 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)) { 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; p->error = 8; pthread_cond_broadcast(&p->changed); pthread_mutex_unlock(&p->lock); return;
} }
@@ -231,12 +277,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->frame = malloc(length);
if (!p->frame) { p->error = 8; pthread_mutex_unlock(&p->lock); return; } 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->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->frame_length = length;
p->format_valid = 1; p->format_valid = 1;
p->display_changed_at = 0; p->display_changed_at = 0;
update_interruption(p); update_interruption(p);
pthread_cond_broadcast(&p->changed); pthread_cond_broadcast(&p->changed);
pthread_mutex_unlock(&p->lock); 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; /* Called with the frame mutex held. Invalid transient chunks are discarded;
* allocation capacity is not evidence that valid pixels have been supplied. */ * allocation capacity is not evidence that valid pixels have been supplied. */
@@ -286,14 +390,131 @@ static void stream_process(void *data) {
} }
if (!newest) return; if (!newest) return;
pthread_mutex_lock(&p->lock); 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_cond_broadcast(&p->changed);
pthread_mutex_unlock(&p->lock); 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 = { 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) { static int connect_pipewire(struct uu_portal *p) {
if (open_cancelled(p)) return 13; if (open_cancelled(p)) return 13;
GUnixFDList *fds = NULL; GUnixFDList *fds = NULL;
@@ -322,36 +543,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)); PW_KEY_MEDIA_TYPE, "Video", PW_KEY_MEDIA_CATEGORY, "Capture", PW_KEY_MEDIA_ROLE, "Screen", NULL));
if (!p->stream) return 7; if (!p->stream) return 7;
pw_stream_add_listener(p->stream, &p->stream_listener, &stream_events, p); 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)); uint8_t storage[2048]; struct spa_pod_builder builder = SPA_POD_BUILDER_INIT(storage, sizeof(storage));
const struct spa_pod *params[2]; const struct spa_pod *params[3];
params[0] = spa_pod_builder_add_object(&builder, SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat, unsigned param_count = capture_formats(p, &builder, params, p->dma_requested);
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_video), SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw), p->dma_requested_at = g_get_monotonic_time();
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)));
/* Node ID belongs to this portal's restricted remote. Do not put it into /* 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. */ * target.object, whose numeric value means object.serial on modern PW. */
if (pw_stream_connect(p->stream, PW_DIRECTION_INPUT, p->node, 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; 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) { static int wait_for_first_frame(struct uu_portal *p) {
struct timespec until; struct timespec until;
gint64 deadline = g_get_monotonic_time() + 10 * G_TIME_SPAN_SECOND; gint64 deadline = g_get_monotonic_time() + 10 * G_TIME_SPAN_SECOND;
pthread_mutex_lock(&p->lock); 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(); gint64 remaining = deadline - g_get_monotonic_time();
if (remaining <= 0) break; if (remaining <= 0) break;
clock_gettime(CLOCK_REALTIME, &until); clock_gettime(CLOCK_MONOTONIC, &until);
gint64 wait_us = MIN(100000, remaining); gint64 wait_us = MIN(100000, remaining);
until.tv_nsec += wait_us * 1000; until.tv_nsec += wait_us * 1000;
if (until.tv_nsec >= 1000000000) { until.tv_sec++; until.tv_nsec -= 1000000000; } if (until.tv_nsec >= 1000000000) { until.tv_sec++; until.tv_nsec -= 1000000000; }
pthread_cond_timedwait(&p->changed, &p->lock, &until); 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); pthread_mutex_unlock(&p->lock);
return result; return result;
} }
@@ -365,10 +595,12 @@ static int read_stream_result(struct uu_portal *p, GVariant *results) {
if (!has_devices || (devices & 3) != 3 || !streams || g_variant_n_children(streams) != 1) { if (!has_devices || (devices & 3) != 3 || !streams || g_variant_n_children(streams) != 1) {
error = 6; error = 6;
} else { } else {
p->devices = devices;
GVariant *entry = g_variant_get_child_value(streams, 0), *properties; GVariant *entry = g_variant_get_child_value(streams, 0), *properties;
g_variant_get(entry, "(u@a{sv})", &p->node, &properties); g_variant_get(entry, "(u@a{sv})", &p->node, &properties);
/* Optional 'size' is compositor logical coordinates, not frame pixels. */ /* Optional 'size' is compositor logical coordinates, not frame pixels. */
g_variant_lookup(properties, "size", "(ii)", &p->logical_width, &p->logical_height); g_variant_lookup(properties, "size", "(ii)", &p->logical_width, &p->logical_height);
p->has_position = g_variant_lookup(properties, "position", "(ii)", &p->position_x, &p->position_y);
const char *mapping_id = NULL; const char *mapping_id = NULL;
if (g_variant_lookup(properties, "mapping_id", "&s", &mapping_id)) p->mapping_id = g_strdup(mapping_id); if (g_variant_lookup(properties, "mapping_id", "&s", &mapping_id)) p->mapping_id = g_strdup(mapping_id);
g_variant_unref(properties); g_variant_unref(entry); g_variant_unref(properties); g_variant_unref(entry);
@@ -376,14 +608,21 @@ static int read_stream_result(struct uu_portal *p, GVariant *results) {
if (streams) g_variant_unref(streams); if (streams) g_variant_unref(streams);
return error; 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 *), 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, uu_portal_save_detailed_fn save_detailed, void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data,
int *error, uint32_t *width, uint32_t *height) { int prefer_dmabuf, int *error, uint32_t *width, uint32_t *height, uint32_t source_types) {
*error = 0; *width = *height = 0; *error = 0; *width = *height = 0;
struct uu_portal *p = calloc(1, sizeof(*p)); struct uu_portal *p = calloc(1, sizeof(*p));
if (!p) { *error = 8; return NULL; } if (!p) { *error = 8; return NULL; }
p->cancelled = cancelled; p->cancelled = cancelled;
p->cancel_data = cancel_data; p->cancel_data = cancel_data;
p->dma_requested = !!prefer_dmabuf;
/* GNOME forwards NotifyPointerMotionAbsolute into Mutter's stream-to-stage /* GNOME forwards NotifyPointerMotionAbsolute into Mutter's stream-to-stage
* transform. It expects stream pixels, unlike the compositor-sized KDE path. * transform. It expects stream pixels, unlike the compositor-sized KDE path.
* Do not apply the compositor scale twice on fractional-scale displays. */ * Do not apply the compositor scale twice on fractional-scale displays. */
@@ -391,7 +630,12 @@ static struct uu_portal *open_persist(const char *restore, void (*save_token)(co
for (gchar **desktop = desktops; *desktop; desktop++) for (gchar **desktop = desktops; *desktop; desktop++)
if (!g_ascii_strcasecmp(*desktop, "GNOME")) p->absolute_stream_pixels = 1; if (!g_ascii_strcasecmp(*desktop, "GNOME")) p->absolute_stream_pixels = 1;
g_strfreev(desktops); 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->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); p->bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
if (!p->bus) { *error = 1; goto done; } if (!p->bus) { *error = 1; goto done; }
@@ -412,16 +656,10 @@ static struct uu_portal *open_persist(const char *restore, void (*save_token)(co
p->closed_subscription = g_dbus_connection_signal_subscribe(p->bus, DEST, SESSION, "Closed", p->session, p->closed_subscription = g_dbus_connection_signal_subscribe(p->bus, DEST, SESSION, "Closed", p->session,
NULL, G_DBUS_SIGNAL_FLAGS_NONE, session_closed, p, NULL); NULL, G_DBUS_SIGNAL_FLAGS_NONE, session_closed, p, NULL);
g_variant_builder_init(&options, G_VARIANT_TYPE_VARDICT); g_variant_builder_init(&options, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add(&options, "{sv}", "types", g_variant_new_uint32(3)); /* Keyboard and pointer, plus the touchscreen (4) where the portal offers one (mobile viewers). */
GVariant *version_reply = g_dbus_connection_call_sync(p->bus, DEST, PATH, p->available = remote_property(p, "AvailableDeviceTypes");
"org.freedesktop.DBus.Properties", "Get", g_variant_new("(ss)", REMOTE, "version"), g_variant_builder_add(&options, "{sv}", "types", g_variant_new_uint32(3 | (p->available & 4)));
G_VARIANT_TYPE("(v)"), G_DBUS_CALL_FLAGS_NONE, 3000, NULL, NULL); guint version = remote_property(p, "version");
guint version = 0;
if (version_reply) {
GVariant *value; g_variant_get(version_reply, "(v)", &value);
if (g_variant_is_of_type(value, G_VARIANT_TYPE_UINT32)) version = g_variant_get_uint32(value);
g_variant_unref(value); g_variant_unref(version_reply);
}
if (version >= 2) { if (version >= 2) {
g_variant_builder_add(&options, "{sv}", "persist_mode", g_variant_new_uint32(2)); g_variant_builder_add(&options, "{sv}", "persist_mode", g_variant_new_uint32(2));
if (restore && *restore) g_variant_builder_add(&options, "{sv}", "restore_token", g_variant_new_string(restore)); if (restore && *restore) g_variant_builder_add(&options, "{sv}", "restore_token", g_variant_new_string(restore));
@@ -431,9 +669,26 @@ static struct uu_portal *open_persist(const char *restore, void (*save_token)(co
if (!results) goto done; if (!results) goto done;
g_variant_unref(results); g_variant_unref(results);
g_variant_builder_init(&options, G_VARIANT_TYPE_VARDICT); 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)); g_variant_builder_add(&options, "{sv}", "multiple", g_variant_new_boolean(FALSE));
/* Hidden cursor avoids duplicate pointer; supported since ScreenCast v1. */ /* Hidden cursor avoids a duplicate pointer in absolute mode: the viewer draws its own where
* it last sent motion. Relative mode has no such position, so the game's cursor has to come
* from the compositor. The host flips this at runtime through uu_portal_set_cursor_mode();
* UU_PORTAL_CURSOR_MODE=embedded is the startup default. Only sent when the backend
* advertises embedded, since an unsupported value closes the session. */
int cursor_mode = atomic_load(&cursor_mode_override);
if (cursor_mode < 0) {
const char *wanted = g_getenv("UU_PORTAL_CURSOR_MODE");
cursor_mode = (wanted && !g_ascii_strcasecmp(wanted, "embedded")) ? 2 : 1;
}
/* The host reads these back so its belief matches what the session actually requested. */
p->cursor_available = (int)interface_property(p, SCREEN, "AvailableCursorModes");
p->cursor_applied = 1;
if (cursor_mode == 2 && (p->cursor_available & 2)) {
g_variant_builder_add(&options, "{sv}", "cursor_mode", g_variant_new_uint32(2));
p->cursor_applied = 2;
}
results = request(p, SCREEN, "SelectSources", &options, 1, error); results = request(p, SCREEN, "SelectSources", &options, 1, error);
if (!results) goto done; if (!results) goto done;
g_variant_unref(results); g_variant_unref(results);
@@ -461,7 +716,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", fprintf(stderr, "Portal persistence: requested=%d restore_attempted=%d token_returned=%d\n",
version >= 2, restore && *restore, p->restore_token && *p->restore_token); 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); g_variant_unref(results);
if (*error) goto done; if (*error) goto done;
p->main_loop = g_main_loop_new(p->context, FALSE); p->main_loop = g_main_loop_new(p->context, FALSE);
@@ -494,11 +749,27 @@ struct uu_portal *uu_portal_open_persist_cancellable(const char *restore,
void (*save_token)(const char *, void *), void *save_data, void (*save_token)(const char *, void *), void *save_data,
uu_portal_cancelled_fn cancelled, void *cancel_data, uu_portal_cancelled_fn cancelled, void *cancel_data,
int *error, uint32_t *width, uint32_t *height) { 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 *), 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) { 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) { 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); return uu_portal_open_persist(restore, NULL, NULL, error, width, height);
@@ -545,11 +816,15 @@ void uu_portal_close(struct uu_portal *p) {
} }
void uu_portal_reset_frame(struct uu_portal *p) { void uu_portal_reset_frame(struct uu_portal *p) {
if (!p) return; if (!p) return;
if (p->pw_loop) pw_thread_loop_lock(p->pw_loop);
pthread_mutex_lock(&p->lock); 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->sequence = 0;
p->revision++; p->revision++;
if (p->frame) memset(p->frame, 0, p->frame_length); if (p->frame) memset(p->frame, 0, p->frame_length);
pthread_mutex_unlock(&p->lock); 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) { int uu_portal_capture(struct uu_portal *p, uint8_t *frame, size_t length) {
return uu_portal_capture_since(p, frame, length, NULL); return uu_portal_capture_since(p, frame, length, NULL);
@@ -566,6 +841,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) { int uu_portal_capture_since(struct uu_portal *p, uint8_t *frame, size_t length, uint64_t *revision) {
if (!p || !frame) return 11; if (!p || !frame) return 11;
uu_portal_dmabuf_disable(p);
pthread_mutex_lock(&p->lock); pthread_mutex_lock(&p->lock);
int result = atomic_load(&p->closed) ? 9 : p->error ? p->error : stream_stalled(p) ? 9 : int result = atomic_load(&p->closed) ? 9 : p->error ? p->error : stream_stalled(p) ? 9 :
!p->sequence ? 10 : length != p->frame_length ? 11 : 0; !p->sequence ? 10 : length != p->frame_length ? 11 : 0;
@@ -591,6 +867,36 @@ int uu_portal_capture_alive(struct uu_portal *p) {
pthread_mutex_unlock(&p->lock); pthread_mutex_unlock(&p->lock);
return alive; 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) { void uu_portal_input_dispatch(struct uu_portal *p) {
if (p->ei) portal_eis_dispatch(p); if (p->ei) portal_eis_dispatch(p);
} }
@@ -669,9 +975,98 @@ int uu_portal_button(struct uu_portal *p, int button, int pressed) {
if (!code) return 11; if (!code) return 11;
return notify(p, "NotifyPointerButton", g_variant_new("(o@a{sv}iu)", p->session, empty_options(), code, (guint)!!pressed)); return notify(p, "NotifyPointerButton", g_variant_new("(o@a{sv}iu)", p->session, empty_options(), code, (guint)!!pressed));
} }
/* Smooth scroll in stream pixels (positive scrolls down/right, like a touchpad); `finish` ends the
* gesture so clients may coast. */
int uu_portal_scroll(struct uu_portal *p, double dx, double dy, int finish) {
if (!p || !isfinite(dx) || !isfinite(dy)) return 11;
if (p->logical_width <= 0 || p->logical_height <= 0 || !p->width || !p->height) return 11;
int result = prepare_input(p); if (result) return result;
double lx = dx * p->logical_width / p->width, ly = dy * p->logical_height / p->height;
if (p->ei) return portal_eis_scroll(p, lx, ly, finish);
GVariantBuilder options; g_variant_builder_init(&options, G_VARIANT_TYPE_VARDICT);
if (finish) g_variant_builder_add(&options, "{sv}", "finish", g_variant_new_boolean(TRUE));
return notify(p, "NotifyPointerAxis", g_variant_new("(oa{sv}dd)", p->session, &options, lx, ly));
}
/* One finger (slot 0) in stream pixels: phase 0 down, 1 motion, 2 up. */
int uu_portal_touch_supported(struct uu_portal *p) { return p && (p->devices & 4); }
/* The portal offers a touchscreen this session's consent did not grant (restored from before touch). */
int uu_portal_touch_available(struct uu_portal *p) { return p && (p->available & 4); }
int uu_portal_touch(struct uu_portal *p, int phase, double x, double y) {
if (!uu_portal_touch_supported(p) || phase < 0 || phase > 2) return 11;
if (phase != 2 && (!isfinite(x) || !isfinite(y) || p->logical_width <= 0 || p->logical_height <= 0 ||
!p->width || !p->height || x < 0 || y < 0 || x >= p->width || y >= p->height)) return 11;
int result = prepare_input(p); if (result) return result;
if (p->ei) return portal_eis_touch(p, phase, x, y);
if (phase == 2) return notify(p, "NotifyTouchUp", g_variant_new("(o@a{sv}u)", p->session, empty_options(), 0u));
return notify(p, phase ? "NotifyTouchMotion" : "NotifyTouchDown", g_variant_new("(o@a{sv}uudd)", p->session, empty_options(), p->node, 0u,
p->absolute_stream_pixels ? x : x * p->logical_width / p->width,
p->absolute_stream_pixels ? y : y * p->logical_height / p->height));
}
int uu_portal_key(struct uu_portal *p, uint32_t symbol, int keycode, int pressed) { int uu_portal_key(struct uu_portal *p, uint32_t symbol, int keycode, int pressed) {
if (!p || !symbol || symbol > INT32_MAX) return 11; if (!p || !symbol || symbol > INT32_MAX) return 11;
int result = prepare_input(p); if (result) return result; int result = prepare_input(p); if (result) return result;
if (p->ei) return portal_eis_key(p, keycode, pressed); if (p->ei) return portal_eis_key(p, keycode, pressed);
return notify(p, "NotifyKeyboardKeysym", g_variant_new("(o@a{sv}iu)", p->session, empty_options(), (gint)symbol, (guint)!!pressed)); return notify(p, "NotifyKeyboardKeysym", g_variant_new("(o@a{sv}iu)", p->session, empty_options(), (gint)symbol, (guint)!!pressed));
} }
/* Logical position of the granted monitor: matches a Mutter logical monitor. */
int uu_portal_stream_position(struct uu_portal *p, int32_t *x, int32_t *y) {
if (!p || !p->has_position) return 11;
*x = p->position_x; *y = p->position_y;
return 0;
}
/* Mutter's monitors as "connector\twidth\theight\tx\ty\tprimary\n" lines: current mode in
* pixels, logical position. Returns the count, or -1 without Mutter (KDE, no session bus). */
int uu_portal_monitors(char *out, size_t length) {
if (!out || !length) return -1;
out[0] = 0;
GDBusConnection *bus = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
if (!bus) return -1;
GVariant *reply = g_dbus_connection_call_sync(bus, MUTTER_DISPLAY, MUTTER_DISPLAY_PATH, MUTTER_DISPLAY,
"GetCurrentState", NULL, G_VARIANT_TYPE("(ua((ssss)a(siiddada{sv})a{sv})a(iiduba(ssss)a{sv})a{sv})"),
G_DBUS_CALL_FLAGS_NONE, 3000, NULL, NULL);
g_object_unref(bus);
if (!reply) return -1;
GVariant *monitors = g_variant_get_child_value(reply, 1), *logical = g_variant_get_child_value(reply, 2);
int count = 0; size_t used = 0;
for (gsize i = 0; i < g_variant_n_children(logical); i++) {
gint32 x, y; gdouble scale; guint32 transform; gboolean primary; GVariant *specs, *props;
g_variant_get_child(logical, i, "(iidub@a(ssss)@a{sv})", &x, &y, &scale, &transform, &primary, &specs, &props);
const gchar *connector = NULL;
if (g_variant_n_children(specs)) g_variant_get_child(specs, 0, "(&s&s&s&s)", &connector, NULL, NULL, NULL);
gint32 width = 0, height = 0;
for (gsize m = 0; connector && m < g_variant_n_children(monitors); m++) {
GVariant *monitor = g_variant_get_child_value(monitors, m), *spec = g_variant_get_child_value(monitor, 0),
*modes = g_variant_get_child_value(monitor, 1);
const gchar *name = NULL; g_variant_get_child(spec, 0, "&s", &name);
for (gsize k = 0; name && !strcmp(name, connector) && k < g_variant_n_children(modes); k++) {
GVariant *mode = g_variant_get_child_value(modes, k), *mode_props = g_variant_get_child_value(mode, 6);
gboolean current = FALSE;
if (g_variant_lookup(mode_props, "is-current", "b", &current) && current)
g_variant_get_child(mode, 1, "i", &width), g_variant_get_child(mode, 2, "i", &height);
g_variant_unref(mode_props); g_variant_unref(mode);
}
g_variant_unref(modes); g_variant_unref(spec); g_variant_unref(monitor);
}
if (transform % 2) { gint32 t = width; width = height; height = t; } /* 90/270, flipped or not */
if (connector && width > 0 && height > 0) {
int n = snprintf(out + used, length - used, "%s\t%d\t%d\t%d\t%d\t%d\n", connector, width, height, x, y, primary ? 1 : 0);
if (n > 0 && (size_t)n < length - used) { used += (size_t)n; count++; }
}
g_variant_unref(specs); g_variant_unref(props);
}
g_variant_unref(monitors); g_variant_unref(logical); g_variant_unref(reply);
return count;
}
/* End the compositor session now (screen-share indicator off) while the handle stays valid;
* captures then report a closed stream until the handle is replaced. */
void uu_portal_end(struct uu_portal *p) {
if (!p || atomic_exchange(&p->closed, 1)) return;
/* A closed session no longer tracks owner changes, so its cached claim is stale. */
pthread_mutex_lock(&p->lock); p->clipboard_owns=0; pthread_mutex_unlock(&p->lock);
if (p->bus && p->session) {
GVariant *reply = g_dbus_connection_call_sync(p->bus, DEST, p->session, SESSION, "Close",
NULL, NULL, G_DBUS_CALL_FLAGS_NONE, 3000, NULL, NULL);
if (reply) g_variant_unref(reply);
}
}
+32
View File
@@ -2,28 +2,60 @@
#define UU_PORTAL_ENGINE_H #define UU_PORTAL_ENGINE_H
#include <stddef.h> #include <stddef.h>
#include <stdint.h> #include <stdint.h>
#include "dmabuf_frame.h"
struct uu_portal; struct uu_portal;
typedef int (*uu_portal_cancelled_fn)(void *data); 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. */ /* One object owns one consent/session and one PipeWire stream. */
struct uu_portal *uu_portal_open(int *error, uint32_t *width, uint32_t *height); struct uu_portal *uu_portal_open(int *error, uint32_t *width, uint32_t *height);
/* Saves the rotated token immediately after Start, before video initialization. */ /* 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); 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. */ /* 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); 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); struct uu_portal *uu_portal_open_restore(const char *restore, int *error, uint32_t *width, uint32_t *height);
/* Cursor mode for subsequent sessions: 1 hidden, 2 embedded (the compositor draws the pointer
* into the stream). -1 restores the UU_PORTAL_CURSOR_MODE default. The host switches this at
* runtime because the viewer cannot draw a pointer of its own during relative motion. */
void uu_portal_set_cursor_mode(int mode);
/* What the last session requested and what the backend offered, for host bookkeeping. */
int uu_portal_cursor_mode(struct uu_portal *portal);
int uu_portal_cursor_modes(struct uu_portal *portal);
const char *uu_portal_restore_token(struct uu_portal *portal); const char *uu_portal_restore_token(struct uu_portal *portal);
void uu_portal_close(struct uu_portal *portal); void uu_portal_close(struct uu_portal *portal);
int uu_portal_clipboard_ready(struct uu_portal *portal); int uu_portal_clipboard_ready(struct uu_portal *portal);
int uu_portal_clipboard_set(struct uu_portal *portal, const uint8_t *text, size_t length); int uu_portal_clipboard_set(struct uu_portal *portal, const uint8_t *text, size_t length);
/* Offers the text `from` still owns to `to`; 0 transferred, 1 nothing to transfer. */
int uu_portal_clipboard_copy(struct uu_portal *from, struct uu_portal *to);
int uu_portal_clipboard_poll(struct uu_portal *portal, uint8_t *text, size_t capacity); int uu_portal_clipboard_poll(struct uu_portal *portal, uint8_t *text, size_t capacity);
int uu_portal_alive(struct uu_portal *portal); int uu_portal_alive(struct uu_portal *portal);
int uu_portal_capture_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_input_dispatch(struct uu_portal *portal);
void uu_portal_logical_size(struct uu_portal *portal, uint32_t *width, uint32_t *height); void uu_portal_logical_size(struct uu_portal *portal, uint32_t *width, uint32_t *height);
void uu_portal_reset_frame(struct uu_portal *portal); 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(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); 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_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_button(struct uu_portal *portal, int button, int pressed);
int uu_portal_scroll(struct uu_portal *portal, double dx, double dy, int finish);
int uu_portal_touch_supported(struct uu_portal *portal);
int uu_portal_touch_available(struct uu_portal *portal);
int uu_portal_touch(struct uu_portal *portal, int phase, double x, double y);
int uu_portal_key(struct uu_portal *portal, uint32_t keysym, int keycode, int pressed); int uu_portal_key(struct uu_portal *portal, uint32_t keysym, int keycode, int pressed);
int uu_portal_stream_position(struct uu_portal *portal, int32_t *x, int32_t *y);
int uu_portal_monitors(char *out, size_t length);
void uu_portal_end(struct uu_portal *portal);
#endif #endif
+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) { 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 = {
if (engine->in_rgb_surf != VA_INVALID_ID) { .fd=dma_fd, .fourcc=0x34325258, .width=engine->cap_width, .height=engine->cap_height,
RT.vaDestroySurfaces(engine->va_dpy, &engine->in_rgb_surf, 1); .stride=stride, .size=stride * engine->cap_height, .modifier=0
engine->in_rgb_surf = VA_INVALID_ID; };
return vaapi_import_frame(engine, &frame);
} }
static void vaapi_clear_input(VaapiEngine *engine) {
if (engine->vpp_buf != VA_INVALID_ID) { if (engine->vpp_buf != VA_INVALID_ID) {
RT.vaDestroyBuffer(engine->va_dpy, engine->vpp_buf); RT.vaDestroyBuffer(engine->va_dpy, engine->vpp_buf);
engine->vpp_buf = VA_INVALID_ID; 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; int vaapi_import_frame(VaapiEngine *engine, const UuDmaFrame *frame) {
engine->stride = stride; 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; VADRMPRIMESurfaceDescriptor prime_desc;
memset(&prime_desc, 0, sizeof(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.width = engine->cap_width;
prime_desc.height = engine->cap_height; prime_desc.height = engine->cap_height;
prime_desc.num_objects = 1; prime_desc.num_objects = 1;
prime_desc.objects[0].fd = dma_fd; prime_desc.objects[0].fd = frame->fd;
prime_desc.objects[0].size = stride * engine->cap_height; prime_desc.objects[0].size = frame->size;
prime_desc.objects[0].drm_format_modifier = 0; prime_desc.objects[0].drm_format_modifier = frame->modifier;
prime_desc.num_layers = 1; 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].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]; VASurfaceAttrib attribs[2];
attribs[0].type = VASurfaceAttribMemoryType; 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) { int vaapi_upload_host_buffer(VaapiEngine* engine, const uint8_t* host_ptr, uint32_t pitch) {
if (!engine || !host_ptr) return -1; 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) { 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); 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 <stdint.h>
#include <stddef.h> #include <stddef.h>
#include "dmabuf_frame.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { 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 // 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_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 // 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); int vaapi_upload_host_buffer(VaapiEngine* engine, const uint8_t* host_ptr, uint32_t pitch);
+56 -65
View File
@@ -9,6 +9,8 @@
#include <stdlib.h> #include <stdlib.h>
#include <time.h> #include <time.h>
#include <unistd.h> #include <unistd.h>
#include "i18n.h"
#include "ui_theme.h"
#define QSIZE 64 #define QSIZE 64
static char queue[QSIZE][4096]; static char queue[QSIZE][4096];
@@ -45,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)); } 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 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) { static GtkWidget *frame(const char *title, GtkWidget **content) {
GtkCssProvider *p = gtk_css_provider_new(); gtk_css_provider_load_from_data(p, css, -1, NULL); uu_theme_init();
gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), GTK_STYLE_PROVIDER(p), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); uu_theme_load_css(".card { padding: 12px; } treeview.view { padding: 6px; }");
window = gtk_window_new(GTK_WINDOW_TOPLEVEL); window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), title); gtk_window_set_title(GTK_WINDOW(window), title);
g_signal_connect(window, "delete-event", G_CALLBACK(on_delete), NULL); g_signal_connect(window, "delete-event", G_CALLBACK(on_delete), NULL);
GtkWidget *overlay = gtk_overlay_new(); *content = vbox(14); GtkWidget *overlay = gtk_overlay_new(); *content = vbox(14);
gtk_container_set_border_width(GTK_CONTAINER(*content), 22); 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); 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); 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); gtk_widget_set_margin_bottom(toast, 30); gtk_widget_set_no_show_all(toast, TRUE);
@@ -97,9 +90,9 @@ static void format_size(guint64 size, int kind, char *out, size_t len) {
static void format_time(guint64 secs, char *out, size_t len) { static void format_time(guint64 secs, char *out, size_t len) {
if (!secs) { snprintf(out, len, "--"); return; } if (!secs) { snprintf(out, len, "--"); return; }
time_t t = (time_t)secs; struct tm tm; localtime_r(&t, &tm); time_t t = (time_t)secs; struct tm tm; localtime_r(&t, &tm);
strftime(out, len, "%Y年%m月%d日", &tm); strftime(out, len, L("%Y年%m月%d日", "%Y-%m-%d"), &tm);
} }
static const char *kind_name(int kind) { return kind == 4 ? "文件" : kind == 3 ? "磁盘" : "文件夹"; } static const char *kind_name(int kind) { return kind == 4 ? L("文件", "File") : kind == 3 ? L("磁盘", "Disk") : L("文件夹", "Folder"); }
/* ---------------- file transfer ---------------- */ /* ---------------- file transfer ---------------- */
enum { C_NAME, C_TIME, C_TYPE, C_SIZE, C_PATH, C_KIND, C_N }; enum { C_NAME, C_TIME, C_TYPE, C_SIZE, C_PATH, C_KIND, C_N };
@@ -111,7 +104,7 @@ static char local_dir[2048] = "", remote_dir[2048] = ":/";
static void load_local(const char *path) { static void load_local(const char *path) {
char *dir = g_strdup(path); /* path may alias local_dir */ char *dir = g_strdup(path); /* path may alias local_dir */
GDir *d = g_dir_open(dir, 0, NULL); GDir *d = g_dir_open(dir, 0, NULL);
if (!d) { show_toast("无法打开本机目录"); g_free(dir); return; } if (!d) { show_toast(L("无法打开本机目录", "Cannot open local folder")); g_free(dir); return; }
snprintf(local_dir, sizeof local_dir, "%s", dir); g_free(dir); snprintf(local_dir, sizeof local_dir, "%s", dir); g_free(dir);
gtk_entry_set_text(GTK_ENTRY(local_path), local_dir); gtk_entry_set_text(GTK_ENTRY(local_path), local_dir);
gtk_list_store_clear(local_store); gtk_list_store_clear(local_store);
@@ -150,7 +143,7 @@ static void on_row_activated(GtkTreeView *view, GtkTreePath *path, GtkTreeViewCo
g_free(full); g_free(full);
} }
static char *ask_name(const char *title) { static char *ask_name(const char *title) {
GtkWidget *dlg = gtk_dialog_new_with_buttons(title, GTK_WINDOW(window), GTK_DIALOG_MODAL, "取消", GTK_RESPONSE_CANCEL, "确定", GTK_RESPONSE_OK, NULL); GtkWidget *dlg = gtk_dialog_new_with_buttons(title, GTK_WINDOW(window), GTK_DIALOG_MODAL, L("取消", "Cancel"), GTK_RESPONSE_CANCEL, L("确定", "OK"), GTK_RESPONSE_OK, NULL);
GtkWidget *entry = gtk_entry_new(); gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE); GtkWidget *entry = gtk_entry_new(); gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
gtk_dialog_set_default_response(GTK_DIALOG(dlg), GTK_RESPONSE_OK); gtk_dialog_set_default_response(GTK_DIALOG(dlg), GTK_RESPONSE_OK);
GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dlg)); gtk_container_set_border_width(GTK_CONTAINER(area), 16); GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dlg)); gtk_container_set_border_width(GTK_CONTAINER(area), 16);
@@ -158,21 +151,21 @@ static char *ask_name(const char *title) {
char *name = NULL; char *name = NULL;
if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_OK) { if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_OK) {
const char *t = gtk_entry_get_text(GTK_ENTRY(entry)); const char *t = gtk_entry_get_text(GTK_ENTRY(entry));
if (*t && !strchr(t, '/') && strcmp(t, ".") && strcmp(t, "..")) name = g_strdup(t); else if (*t) show_toast("名称无效"); if (*t && !strchr(t, '/') && strcmp(t, ".") && strcmp(t, "..")) name = g_strdup(t); else if (*t) show_toast(L("名称无效", "Invalid name"));
} }
gtk_widget_destroy(dlg); gtk_widget_destroy(dlg);
return name; return name;
} }
static void on_local_mkdir(GtkButton *b, gpointer d) { static void on_local_mkdir(GtkButton *b, gpointer d) {
(void)b; (void)d; char *name = ask_name("新建文件夹"); if (!name) return; (void)b; (void)d; char *name = ask_name(L("新建文件夹", "New folder")); if (!name) return;
char *full = g_build_filename(local_dir, name, NULL); char *full = g_build_filename(local_dir, name, NULL);
if (mkdir(full, 0755) != 0) show_toast("无法创建文件夹"); else load_local(local_dir); if (mkdir(full, 0755) != 0) show_toast(L("无法创建文件夹", "Cannot create folder")); else load_local(local_dir);
g_free(full); g_free(name); g_free(full); g_free(name);
} }
static void on_remote_mkdir(GtkButton *b, gpointer d) { static void on_remote_mkdir(GtkButton *b, gpointer d) {
(void)b; (void)d; (void)b; (void)d;
if (!strcmp(remote_dir, ":/")) { show_toast("请先进入一个文件夹"); return; } if (!strcmp(remote_dir, ":/")) { show_toast(L("请先进入一个文件夹", "Open a folder first")); return; }
char *name = ask_name("新建文件夹"); if (!name) return; char *name = ask_name(L("新建文件夹", "New folder")); if (!name) return;
char *full = g_build_filename(remote_dir, name, NULL); char cmd[2200]; char *full = g_build_filename(remote_dir, name, NULL); char cmd[2200];
snprintf(cmd, sizeof cmd, "mkdir\t%s", full); push(cmd); g_free(full); g_free(name); snprintf(cmd, sizeof cmd, "mkdir\t%s", full); push(cmd); g_free(full); g_free(name);
} }
@@ -181,8 +174,8 @@ static void on_remote_mkdir(GtkButton *b, gpointer d) {
static void on_send(GtkButton *b, gpointer upload) { static void on_send(GtkButton *b, gpointer upload) {
(void)b; GtkTreeView *view = GTK_TREE_VIEW(upload ? local_view : remote_view); (void)b; GtkTreeView *view = GTK_TREE_VIEW(upload ? local_view : remote_view);
GtkTreeModel *m; GList *rows = gtk_tree_selection_get_selected_rows(gtk_tree_view_get_selection(view), &m); GtkTreeModel *m; GList *rows = gtk_tree_selection_get_selected_rows(gtk_tree_view_get_selection(view), &m);
if (!rows) { show_toast("请先选择要发送的文件"); return; } if (!rows) { show_toast(L("请先选择要发送的文件", "Select the files to send first")); return; }
if (upload && !strcmp(remote_dir, ":/")) { show_toast("请先在远端进入目标文件夹"); g_list_free_full(rows, (GDestroyNotify)gtk_tree_path_free); return; } if (upload && !strcmp(remote_dir, ":/")) { show_toast(L("请先在远端进入目标文件夹", "Open the destination folder on the remote side first")); g_list_free_full(rows, (GDestroyNotify)gtk_tree_path_free); return; }
int skipped = 0; int skipped = 0;
for (GList *r = rows; r; r = r->next) { for (GList *r = rows; r; r = r->next) {
GtkTreeIter it; char *full, *name; int kind; GtkTreeIter it; char *full, *name; int kind;
@@ -199,7 +192,7 @@ static void on_send(GtkButton *b, gpointer upload) {
g_free(full); g_free(name); g_free(full); g_free(name);
} }
g_list_free_full(rows, (GDestroyNotify)gtk_tree_path_free); g_list_free_full(rows, (GDestroyNotify)gtk_tree_path_free);
if (skipped) show_toast(upload ? "暂不支持上传文件夹,已跳过" : "不能下载整个磁盘,已跳过"); if (skipped) show_toast(upload ? L("暂不支持上传文件夹,已跳过", "Uploading folders is not supported yet; skipped") : L("不能下载整个磁盘,已跳过", "Cannot download a whole disk; skipped"));
} }
static void on_cancel_all(GtkButton *b, gpointer d) { (void)b; (void)d; push("cancel"); } static void on_cancel_all(GtkButton *b, gpointer d) { (void)b; (void)d; push("cancel"); }
static void on_clear_done(GtkButton *b, gpointer d) { static void on_clear_done(GtkButton *b, gpointer d) {
@@ -209,13 +202,13 @@ static void on_clear_done(GtkButton *b, gpointer d) {
} }
static GtkWidget *pane(int remote) { static GtkWidget *pane(int remote) {
GtkWidget *card = vbox(6); add_class(card, "card"); GtkWidget *card = vbox(6); add_class(card, "card");
GtkWidget *bar = hbox(6), *up = button("↑", NULL), *refresh = button("刷新", NULL), *mk = button("新建文件夹", NULL), *path = gtk_entry_new(); GtkWidget *bar = hbox(6), *up = button("↑", NULL), *refresh = button(L("刷新", "Refresh"), NULL), *mk = button(L("新建文件夹", "New folder"), NULL), *path = gtk_entry_new();
gtk_widget_set_tooltip_text(up, "上一级"); gtk_widget_set_tooltip_text(refresh, "刷新"); gtk_widget_set_tooltip_text(up, L("上一级", "Up")); gtk_widget_set_tooltip_text(refresh, L("刷新", "Refresh"));
gtk_box_pack_start(GTK_BOX(bar), up, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(bar), refresh, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(bar), up, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(bar), refresh, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(bar), mk, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(bar), path, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(bar), mk, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(bar), path, TRUE, TRUE, 0);
GtkListStore *store = gtk_list_store_new(C_N, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); GtkListStore *store = gtk_list_store_new(C_N, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
GtkWidget *view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); GtkWidget *view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
add_column(view, "名称", C_NAME, 1); add_column(view, "修改日期", C_TIME, 0); add_column(view, "类型", C_TYPE, 0); add_column(view, "大小", C_SIZE, 0); add_column(view, L("名称", "Name"), C_NAME, 1); add_column(view, L("修改日期", "Date modified"), C_TIME, 0); add_column(view, L("类型", "Type"), C_TYPE, 0); add_column(view, L("大小", "Size"), C_SIZE, 0);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), GTK_SELECTION_MULTIPLE); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), GTK_SELECTION_MULTIPLE);
g_signal_connect(view, "row-activated", G_CALLBACK(on_row_activated), GINT_TO_POINTER(remote)); g_signal_connect(view, "row-activated", G_CALLBACK(on_row_activated), GINT_TO_POINTER(remote));
g_signal_connect(up, "clicked", G_CALLBACK(remote ? on_remote_up : on_local_up), NULL); g_signal_connect(up, "clicked", G_CALLBACK(remote ? on_remote_up : on_local_up), NULL);
@@ -229,13 +222,13 @@ static GtkWidget *pane(int remote) {
return card; return card;
} }
static void build_files(void) { static void build_files(void) {
GtkWidget *content; frame("文件传输", &content); GtkWidget *content; frame(L("文件传输", "File transfer"), &content);
gtk_window_set_default_size(GTK_WINDOW(window), 1100, 760); gtk_window_set_default_size(GTK_WINDOW(window), 1100, 760);
GtkWidget *head = gtk_grid_new(); gtk_grid_set_column_homogeneous(GTK_GRID(head), TRUE); gtk_grid_set_column_spacing(GTK_GRID(head), 24); GtkWidget *head = gtk_grid_new(); gtk_grid_set_column_homogeneous(GTK_GRID(head), TRUE); gtk_grid_set_column_spacing(GTK_GRID(head), 24);
GtkWidget *left = hbox(10), *right = hbox(10); GtkWidget *left = hbox(10), *right = hbox(10);
char host[256]; if (gethostname(host, sizeof host) != 0) snprintf(host, sizeof host, "本机"); host[sizeof host - 1] = 0; char host[256]; if (gethostname(host, sizeof host) != 0) snprintf(host, sizeof host, L("本机", "This device")); host[sizeof host - 1] = 0;
GtkWidget *tag_l = label("本机", "tag"), *tag_r = label("远端", "tag"); add_class(tag_r, "remote"); GtkWidget *tag_l = label(L("本机", "This device"), "tag"), *tag_r = label(L("远端", "Remote"), "tag"); add_class(tag_r, "remote");
GtkWidget *send_r = button("发送 →", NULL), *send_l = button("← 发送", NULL); GtkWidget *send_r = button(L("发送 →", "Send →"), NULL), *send_l = button(L("← 发送", "← Send"), NULL);
g_signal_connect(send_r, "clicked", G_CALLBACK(on_send), GINT_TO_POINTER(1)); g_signal_connect(send_r, "clicked", G_CALLBACK(on_send), GINT_TO_POINTER(1));
g_signal_connect(send_l, "clicked", G_CALLBACK(on_send), NULL); g_signal_connect(send_l, "clicked", G_CALLBACK(on_send), NULL);
gtk_box_pack_start(GTK_BOX(left), label(host, "title"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(left), tag_l, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(left), label(host, "title"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(left), tag_l, FALSE, FALSE, 0);
@@ -247,25 +240,25 @@ static void build_files(void) {
gtk_grid_set_row_spacing(GTK_GRID(head), 14); gtk_grid_set_row_spacing(GTK_GRID(head), 14);
gtk_box_pack_start(GTK_BOX(content), head, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(content), head, TRUE, TRUE, 0);
GtkWidget *tasks = vbox(8); add_class(tasks, "card"); GtkWidget *tasks = vbox(8); add_class(tasks, "card");
GtkWidget *tbar = hbox(8), *cancel = button("全部取消", NULL), *clear = button("清除完结任务", NULL); GtkWidget *tbar = hbox(8), *cancel = button(L("全部取消", "Cancel all"), NULL), *clear = button(L("清除完结任务", "Clear finished"), NULL);
g_signal_connect(cancel, "clicked", G_CALLBACK(on_cancel_all), NULL); g_signal_connect(clear, "clicked", G_CALLBACK(on_clear_done), NULL); g_signal_connect(cancel, "clicked", G_CALLBACK(on_cancel_all), NULL); g_signal_connect(clear, "clicked", G_CALLBACK(on_clear_done), NULL);
gtk_box_pack_start(GTK_BOX(tbar), label("传输列表", "section"), FALSE, FALSE, 4); gtk_box_pack_start(GTK_BOX(tbar), label(L("传输列表", "Transfers"), "section"), FALSE, FALSE, 4);
gtk_box_pack_end(GTK_BOX(tbar), clear, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(tbar), cancel, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(tbar), clear, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(tbar), cancel, FALSE, FALSE, 0);
task_store = gtk_list_store_new(T_N, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); task_store = gtk_list_store_new(T_N, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
GtkWidget *tview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(task_store)); GtkWidget *tview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(task_store));
add_column(tview, "名称", T_NAME, 1); add_column(tview, "状态", T_STATUS, 0); add_column(tview, "大小", T_SIZE, 0); add_column(tview, L("名称", "Name"), T_NAME, 1); add_column(tview, L("状态", "Status"), T_STATUS, 0); add_column(tview, L("大小", "Size"), T_SIZE, 0);
add_column(tview, "发送路径", T_FROM, 1); add_column(tview, "接收路径", T_TO, 1); add_column(tview, L("发送路径", "From"), T_FROM, 1); add_column(tview, L("接收路径", "To"), T_TO, 1);
gtk_box_pack_start(GTK_BOX(tasks), tbar, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(tasks), scrolled(tview, 180), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(tasks), tbar, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(tasks), scrolled(tview, 180), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(content), tasks, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(content), tasks, TRUE, TRUE, 0);
const char *home = g_get_home_dir(); load_local(home ? home : "/"); const char *home = g_get_home_dir(); load_local(home ? home : "/");
gtk_entry_set_text(GTK_ENTRY(remote_path), "此电脑"); gtk_entry_set_text(GTK_ENTRY(remote_path), L("此电脑", "This PC"));
} }
struct listing { char *path; char *rows; }; struct listing { char *path; char *rows; };
static gboolean remote_idle(gpointer d) { static gboolean remote_idle(gpointer d) {
struct listing *l = d; struct listing *l = d;
snprintf(remote_dir, sizeof remote_dir, "%s", l->path); snprintf(remote_dir, sizeof remote_dir, "%s", l->path);
gtk_entry_set_text(GTK_ENTRY(remote_path), strcmp(remote_dir, ":/") ? remote_dir : "此电脑"); gtk_entry_set_text(GTK_ENTRY(remote_path), strcmp(remote_dir, ":/") ? remote_dir : L("此电脑", "This PC"));
gtk_list_store_clear(remote_store); gtk_list_store_clear(remote_store);
char **lines = g_strsplit(l->rows, "\n", -1); char **lines = g_strsplit(l->rows, "\n", -1);
for (char **line = lines; *line; line++) { for (char **line = lines; *line; line++) {
@@ -312,10 +305,10 @@ static GtkListStore *rule_store;
static GtkWidget *rule_stack; static GtkWidget *rule_stack;
static void on_add_rule(GtkButton *b, gpointer d) { static void on_add_rule(GtkButton *b, gpointer d) {
(void)b; (void)d; (void)b; (void)d;
GtkWidget *dlg = gtk_dialog_new_with_buttons("添加映射规则", GTK_WINDOW(window), GTK_DIALOG_MODAL, "取消", GTK_RESPONSE_CANCEL, "保存后立即启用", GTK_RESPONSE_OK, NULL); GtkWidget *dlg = gtk_dialog_new_with_buttons(L("添加映射规则", "Add mapping rule"), GTK_WINDOW(window), GTK_DIALOG_MODAL, L("取消", "Cancel"), GTK_RESPONSE_CANCEL, L("保存后立即启用", "Save and enable"), GTK_RESPONSE_OK, NULL);
GtkWidget *grid = gtk_grid_new(); gtk_grid_set_row_spacing(GTK_GRID(grid), 12); gtk_grid_set_column_spacing(GTK_GRID(grid), 24); GtkWidget *grid = gtk_grid_new(); gtk_grid_set_row_spacing(GTK_GRID(grid), 12); gtk_grid_set_column_spacing(GTK_GRID(grid), 24);
gtk_container_set_border_width(GTK_CONTAINER(grid), 20); gtk_container_set_border_width(GTK_CONTAINER(grid), 20);
const char *labels[] = {"名称", "本地端口", "目标地址", "目标端口"}, *hints[] = {"名称", "请输入端口", "", "请输入端口"}; const char *labels[] = {L("名称", "Name"), L("本地端口", "Local port"), L("目标地址", "Target address"), L("目标端口", "Target port")}, *hints[] = {L("名称", "Name"), L("请输入端口", "Enter port"), "", L("请输入端口", "Enter port")};
GtkWidget *entries[4]; GtkWidget *entries[4];
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
entries[i] = gtk_entry_new(); gtk_entry_set_placeholder_text(GTK_ENTRY(entries[i]), hints[i]); gtk_widget_set_hexpand(entries[i], TRUE); entries[i] = gtk_entry_new(); gtk_entry_set_placeholder_text(GTK_ENTRY(entries[i]), hints[i]); gtk_widget_set_hexpand(entries[i], TRUE);
@@ -328,7 +321,7 @@ static void on_add_rule(GtkButton *b, gpointer d) {
const char *name = gtk_entry_get_text(GTK_ENTRY(entries[0])), *host = gtk_entry_get_text(GTK_ENTRY(entries[2])); const char *name = gtk_entry_get_text(GTK_ENTRY(entries[0])), *host = gtk_entry_get_text(GTK_ENTRY(entries[2]));
char *end; long local = strtol(gtk_entry_get_text(GTK_ENTRY(entries[1])), &end, 10); int bad_local = *end || local < 0 || local > 65535; char *end; long local = strtol(gtk_entry_get_text(GTK_ENTRY(entries[1])), &end, 10); int bad_local = *end || local < 0 || local > 65535;
long port = strtol(gtk_entry_get_text(GTK_ENTRY(entries[3])), &end, 10); int bad_port = *end || port < 1 || port > 65535; long port = strtol(gtk_entry_get_text(GTK_ENTRY(entries[3])), &end, 10); int bad_port = *end || port < 1 || port > 65535;
if (!*name || strchr(name, '\t') || !*host || strchr(host, '\t') || bad_local || bad_port) { show_toast("请填写名称、有效端口和目标地址"); continue; } if (!*name || strchr(name, '\t') || !*host || strchr(host, '\t') || bad_local || bad_port) { show_toast(L("请填写名称、有效端口和目标地址", "Enter a name, valid ports and a target address")); continue; }
char cmd[1024]; snprintf(cmd, sizeof cmd, "add\t%s\t%ld\t%s\t%ld", name, local, host, port); push(cmd); char cmd[1024]; snprintf(cmd, sizeof cmd, "add\t%s\t%ld\t%s\t%ld", name, local, host, port); push(cmd);
break; break;
} }
@@ -336,27 +329,27 @@ static void on_add_rule(GtkButton *b, gpointer d) {
} }
static void on_remove_rule(GtkButton *b, gpointer view) { static void on_remove_rule(GtkButton *b, gpointer view) {
(void)b; GtkTreeModel *m; GtkTreeIter it; (void)b; GtkTreeModel *m; GtkTreeIter it;
if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(view), &m, &it)) { show_toast("请先选择一条规则"); return; } if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection(view), &m, &it)) { show_toast(L("请先选择一条规则", "Select a rule first")); return; }
int id; gtk_tree_model_get(m, &it, P_ID, &id, -1); char cmd[64]; snprintf(cmd, sizeof cmd, "remove\t%d", id); push(cmd); int id; gtk_tree_model_get(m, &it, P_ID, &id, -1); char cmd[64]; snprintf(cmd, sizeof cmd, "remove\t%d", id); push(cmd);
} }
static void build_portmap(void) { static void build_portmap(void) {
GtkWidget *content; frame("端口映射", &content); GtkWidget *content; frame(L("端口映射", "Port mapping"), &content);
gtk_window_set_default_size(GTK_WINDOW(window), 820, 560); gtk_window_set_default_size(GTK_WINDOW(window), 820, 560);
GtkWidget *head = hbox(12), *add = button("添加规则", "primary"), *del = button("删除", NULL); GtkWidget *head = hbox(12), *add = button(L("添加规则", "Add rule"), "primary"), *del = button(L("删除", "Remove"), NULL);
GtkWidget *dot = label("● 已连接", "online"); GtkWidget *dot = label(L("● 已连接", "● Connected"), "online");
gtk_box_pack_start(GTK_BOX(head), label(remote_name, "title"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(head), dot, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(head), label(remote_name, "title"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(head), dot, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(head), add, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(head), del, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(head), add, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(head), del, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(content), head, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(content), head, FALSE, FALSE, 0);
rule_store = gtk_list_store_new(P_N, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); rule_store = gtk_list_store_new(P_N, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
GtkWidget *view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(rule_store)); GtkWidget *view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(rule_store));
add_column(view, "名称", P_NAME, 1); add_column(view, "本地地址", P_LOCAL, 0); add_column(view, "目标地址", P_TARGET, 1); add_column(view, "状态", P_STATUS, 0); add_column(view, L("名称", "Name"), P_NAME, 1); add_column(view, L("本地地址", "Local address"), P_LOCAL, 0); add_column(view, L("目标地址", "Target address"), P_TARGET, 1); add_column(view, L("状态", "Status"), P_STATUS, 0);
rule_stack = gtk_stack_new(); rule_stack = gtk_stack_new();
GtkWidget *empty = label("当前没有端口映射规则,点击「添加规则」把远端端口映射到本机", "empty"); gtk_widget_set_halign(empty, GTK_ALIGN_CENTER); GtkWidget *empty = label(L("当前没有端口映射规则,点击「添加规则」把远端端口映射到本机", "No port mapping rules. Click \"Add rule\" to map a remote port to this computer"), "empty"); gtk_widget_set_halign(empty, GTK_ALIGN_CENTER);
gtk_stack_add_named(GTK_STACK(rule_stack), empty, "empty"); gtk_stack_add_named(GTK_STACK(rule_stack), empty, "empty");
gtk_stack_add_named(GTK_STACK(rule_stack), scrolled(view, 360), "list"); gtk_stack_add_named(GTK_STACK(rule_stack), scrolled(view, 360), "list");
GtkWidget *card = vbox(0); add_class(card, "card"); gtk_box_pack_start(GTK_BOX(card), rule_stack, TRUE, TRUE, 0); GtkWidget *card = vbox(0); add_class(card, "card"); gtk_box_pack_start(GTK_BOX(card), rule_stack, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(content), card, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(content), card, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(content), label("本地端口只监听 127.0.0.1;本地端口填 0 时自动分配。", "empty"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(content), label(L("本地端口只监听 127.0.0.1;本地端口填 0 时自动分配。", "Local ports listen on 127.0.0.1 only; enter 0 to pick a free port."), "empty"), FALSE, FALSE, 0);
g_signal_connect(add, "clicked", G_CALLBACK(on_add_rule), NULL); g_signal_connect(add, "clicked", G_CALLBACK(on_add_rule), NULL);
g_signal_connect(del, "clicked", G_CALLBACK(on_remove_rule), view); g_signal_connect(del, "clicked", G_CALLBACK(on_remove_rule), view);
} }
@@ -394,36 +387,36 @@ static void on_open_session(GtkTreeView *v, GtkTreePath *path, GtkTreeViewColumn
} }
static void on_kill_session(GtkButton *b, gpointer d) { static void on_kill_session(GtkButton *b, gpointer d) {
(void)b; (void)d; guint id = selected_session(); (void)b; (void)d; guint id = selected_session();
if (!id) { show_toast("请先选择一个会话"); return; } if (!id) { show_toast(L("请先选择一个会话", "Select a session first")); return; }
GtkWidget *dlg = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GtkWidget *dlg = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, "确定结束会话 %u?", id); GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, L("确定结束会话 %u?", "End session %u?"), id);
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dlg), "会话内正在运行的程序将被终止。"); gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dlg), L("会话内正在运行的程序将被终止。", "Programs running in the session will be terminated."));
gtk_dialog_add_buttons(GTK_DIALOG(dlg), "取消", GTK_RESPONSE_CANCEL, "结束会话", GTK_RESPONSE_OK, NULL); gtk_dialog_add_buttons(GTK_DIALOG(dlg), L("取消", "Cancel"), GTK_RESPONSE_CANCEL, L("结束会话", "End session"), GTK_RESPONSE_OK, NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dlg), GTK_RESPONSE_CANCEL); gtk_dialog_set_default_response(GTK_DIALOG(dlg), GTK_RESPONSE_CANCEL);
if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_OK) { char cmd[64]; snprintf(cmd, sizeof cmd, "kill\t%u", id); push(cmd); } if (gtk_dialog_run(GTK_DIALOG(dlg)) == GTK_RESPONSE_OK) { char cmd[64]; snprintf(cmd, sizeof cmd, "kill\t%u", id); push(cmd); }
gtk_widget_destroy(dlg); gtk_widget_destroy(dlg);
} }
static void build_terminal(void) { static void build_terminal(void) {
GtkWidget *content; frame("终端远控", &content); gtk_window_set_default_size(GTK_WINDOW(window), 820, 560); GtkWidget *content; frame(L("终端远控", "Remote terminal"), &content); gtk_window_set_default_size(GTK_WINDOW(window), 820, 560);
GtkWidget *head = hbox(12); session_dot = label("● 正在读取会话", "online"); GtkWidget *head = hbox(12); session_dot = label(L("● 正在读取会话", "● Loading sessions"), "online");
session_create = button("创建会话", "primary"); session_kill = button("结束会话", NULL); session_create = button(L("创建会话", "New session"), "primary"); session_kill = button(L("结束会话", "End session"), NULL);
gtk_box_pack_start(GTK_BOX(head), label(remote_name, "title"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(head), label(remote_name, "title"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(head), session_dot, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(head), session_dot, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(head), session_create, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(head), session_kill, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(head), session_create, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(head), session_kill, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(content), head, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(content), head, FALSE, FALSE, 0);
session_store = gtk_list_store_new(S_N, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); session_store = gtk_list_store_new(S_N, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
session_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(session_store)); session_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(session_store));
add_column(session_view, "会话 ID", S_ID, 0); add_column(session_view, "Shell", S_SHELL, 1); add_column(session_view, L("会话 ID", "Session ID"), S_ID, 0); add_column(session_view, "Shell", S_SHELL, 1);
add_column(session_view, "创建时间", S_TIME, 0); add_column(session_view, "状态", S_STATE, 0); add_column(session_view, L("创建时间", "Created"), S_TIME, 0); add_column(session_view, L("状态", "Status"), S_STATE, 0);
session_stack = gtk_stack_new(); session_stack = gtk_stack_new();
GtkWidget *empty = label("当前无正在运行的终端会话", "empty"); gtk_widget_set_halign(empty, GTK_ALIGN_CENTER); GtkWidget *empty = label(L("当前无正在运行的终端会话", "No running terminal sessions"), "empty"); gtk_widget_set_halign(empty, GTK_ALIGN_CENTER);
gtk_stack_add_named(GTK_STACK(session_stack), empty, "empty"); gtk_stack_add_named(GTK_STACK(session_stack), empty, "empty");
gtk_stack_add_named(GTK_STACK(session_stack), label("正在读取会话…", "empty"), "loading"); gtk_stack_add_named(GTK_STACK(session_stack), label(L("正在读取会话…", "Loading sessions…"), "empty"), "loading");
gtk_stack_add_named(GTK_STACK(session_stack), label("连接已断开,请关闭窗口后重试", "empty"), "offline"); gtk_stack_add_named(GTK_STACK(session_stack), label(L("连接已断开,请关闭窗口后重试", "Disconnected. Close the window and try again"), "empty"), "offline");
gtk_stack_add_named(GTK_STACK(session_stack), scrolled(session_view, 360), "list"); gtk_stack_add_named(GTK_STACK(session_stack), scrolled(session_view, 360), "list");
gtk_stack_set_visible_child_name(GTK_STACK(session_stack), "loading"); gtk_stack_set_visible_child_name(GTK_STACK(session_stack), "loading");
gtk_box_pack_start(GTK_BOX(content), session_stack, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(content), session_stack, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(content), label("双击接回会话;创建会话将在本机终端程序中打开。", "empty"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(content), label(L("双击接回会话;创建会话将在本机终端程序中打开。", "Double-click to reattach; new sessions open in a local terminal."), "empty"), FALSE, FALSE, 0);
gtk_widget_set_sensitive(session_create, FALSE); gtk_widget_set_sensitive(session_kill, FALSE); gtk_widget_set_sensitive(session_create, FALSE); gtk_widget_set_sensitive(session_kill, FALSE);
g_signal_connect(session_create, "clicked", G_CALLBACK(on_create_session), NULL); g_signal_connect(session_create, "clicked", G_CALLBACK(on_create_session), NULL);
g_signal_connect(session_kill, "clicked", G_CALLBACK(on_kill_session), NULL); g_signal_connect(session_kill, "clicked", G_CALLBACK(on_kill_session), NULL);
@@ -449,7 +442,7 @@ static gboolean sessions_idle(gpointer d) {
g_strfreev(f); g_strfreev(f);
} }
g_strfreev(lines); g_strfreev(lines);
gtk_label_set_text(GTK_LABEL(session_dot), s->connected ? "● 已连接" : "● 已断开"); gtk_label_set_text(GTK_LABEL(session_dot), s->connected ? L("● 已连接", "● Connected") : L("● 已断开", "● Disconnected"));
gtk_widget_set_sensitive(session_create, s->connected); gtk_widget_set_sensitive(session_kill, s->connected); gtk_widget_set_sensitive(session_create, s->connected); gtk_widget_set_sensitive(session_kill, s->connected);
gtk_widget_set_sensitive(session_view, s->connected); gtk_widget_set_sensitive(session_view, s->connected);
gtk_stack_set_visible_child_name(GTK_STACK(session_stack), s->connected ? (n ? "list" : "empty") : "offline"); gtk_stack_set_visible_child_name(GTK_STACK(session_stack), s->connected ? (n ? "list" : "empty") : "offline");
@@ -475,8 +468,6 @@ static void *ui_thread(void *d) {
(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; } 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) 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; show_window(NULL); gtk_main(); return NULL;
} }
/* Hidden windows retain their widgets so queued idle callbacks stay valid. */ /* Hidden windows retain their widgets so queued idle callbacks stay valid. */
+244 -165
View File
@@ -9,47 +9,36 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <time.h> #include <time.h>
#include <sys/stat.h>
#include "i18n.h"
#include "ui_theme.h"
static const char *CSS = static const char *CSS =
"window { background-color: #ffffff; }\n" ".sidebar { background-color: @theme_bg_color; border-right: 1px solid @uu_border; }\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 list, .sidebar row { background-color: transparent; }\n" ".sidebar list, .sidebar row { background-color: transparent; }\n"
".sidebar row { border-radius: 8px; margin: 1px 10px; padding: 8px 10px; }\n" ".sidebar row { border-radius: 8px; margin: 3px 12px; padding: 10px 12px; }\n"
".sidebar row:selected { background-color: #d4d4d9; color: #1d1d1f; }\n" ".sidebar row:hover { background-color: @uu_tint; }\n"
".devname { font-size: 15px; color: #1d1d1f; }\n" ".sidebar row:selected { background-color: @uu_tint; color: @uu_fg; }\n"
".offline { color: #9ca3af; }\n" ".devname { font-size: 15px; color: @uu_fg; }\n"
".dot { color: #22c55e; font-size: 10px; }\n" ".offline { color: @uu_muted; }\n"
".dot { font-size: 10px; }\n"
".dot.off { color: transparent; }\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 { 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: #c4c7cf; }\n" ".icon.off { background-color: @uu_border; color: @uu_muted; }\n"
".tag { background-color: #e8f0ff; color: #2f6bff; border-radius: 4px; font-size: 12px; padding: 1px 6px; }\n" ".header { border-bottom: 1px solid @uu_border; padding: 16px 24px; }\n"
".title { font-size: 20px; font-weight: 700; color: #1d1d1f; }\n" ".badge { background-color: @uu_tint; color: @uu_success; border-radius: 8px; padding: 4px 10px; font-size: 13px; }\n"
".header { border-bottom: 1px solid #e5e7eb; padding: 12px 22px; background-color: #f7f7f8; }\n" ".badge.off { background-color: @theme_bg_color; color: @uu_muted; }\n"
".badge { background-color: #1d1d1f; color: #ffffff; border-radius: 12px; padding: 3px 12px; font-size: 13px; }\n" ".hbtn { font-size: 17px; padding: 6px 10px; }\n"
".badge.off { background-color: #9ca3af; }\n" ".preview { background-image: none; background-color: @uu_tint; border-radius: 12px 12px 0 0; }\n"
".hbtn { background-image: none; background-color: transparent; border: none; font-size: 17px; color: #4b5563; padding: 4px 10px; }\n" ".enter { font-size: 18px; }\n"
".preview { background-image: linear-gradient(135deg, #a8c0ff 0%, #e2c2f2 50%, #f6c8a8 100%); border-radius: 12px 12px 0 0; }\n" ".toolbar { background-color: @uu_surface; border: 1px solid @uu_border; border-top: none; border-radius: 0 0 12px 12px; padding: 6px; }\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" ".tool { font-size: 15px; padding: 10px; }\n"
".toolbar { border: 1px solid #e5e7eb; border-top: none; border-radius: 0 0 12px 12px; padding: 4px; }\n" ".dashed { border: 1px dashed @uu_border; border-radius: 12px; padding: 36px; }\n"
".tool { background-image: none; background-color: transparent; border: none; font-size: 15px; color: #374151; padding: 10px; }\n" ".round { background-color: @uu_tint; border: none; border-radius: 16px; font-size: 26px; min-width: 64px; min-height: 64px; }\n"
".dashed { border: 1px dashed #d1d5db; border-radius: 12px; padding: 36px; }\n" ".card, .banner { padding: 18px 20px; }\n"
".round { background-image: none; background-color: #f3f4f6; border: none; border-radius: 40px; font-size: 26px; min-width: 64px; min-height: 64px; }\n" ".cardbtn { padding: 14px 18px; }\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";
typedef struct { char id[64]; char name[128]; int platform, online, current; } Device; typedef struct { char id[64]; char name[128]; int platform, online, current; char thumb[512]; } Device;
static Device devices[64]; static Device devices[64];
static int device_count; static int device_count;
static char queue[16][200]; static char queue[16][200];
@@ -84,6 +73,14 @@ static GtkWidget *label(const char *text, const char *cls) {
return l; 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 *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 *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 *vbox(int spacing) { return gtk_box_new(GTK_ORIENTATION_VERTICAL, spacing); }
static GtkWidget *platform_icon(int platform, int online) { static GtkWidget *platform_icon(int platform, int online) {
@@ -93,7 +90,7 @@ static GtkWidget *platform_icon(int platform, int online) {
} }
static gboolean hide_toast(gpointer d) { (void)d; gtk_widget_hide(toast); return G_SOURCE_REMOVE; } static gboolean hide_toast(gpointer d) { (void)d; gtk_widget_hide(toast); return G_SOURCE_REMOVE; }
static void show_toast(const char *text) { gtk_label_set_text(GTK_LABEL(toast), text); gtk_widget_show(toast); g_timeout_add(3500, hide_toast, NULL); } static void show_toast(const char *text) { gtk_label_set_text(GTK_LABEL(toast), text); gtk_widget_show(toast); g_timeout_add(3500, hide_toast, NULL); }
static void unsupported(GtkButton *b, gpointer what) { (void)b; char t[128]; snprintf(t, sizeof t, "%s:暂未支持", (const char *)what); show_toast(t); } static void unsupported(GtkButton *b, gpointer what) { (void)b; char t[128]; snprintf(t, sizeof t, L("%s:暂未支持", "%s: not supported yet"), (const char *)what); show_toast(t); }
static void connect_kind(const char *kind) { static void connect_kind(const char *kind) {
if (selected < 0) return; if (selected < 0) return;
@@ -102,7 +99,7 @@ static void connect_kind(const char *kind) {
snprintf(cmd, sizeof cmd, "connect\t%s\t%s", devices[selected].id, kind); snprintf(cmd, sizeof cmd, "connect\t%s\t%s", devices[selected].id, kind);
pthread_mutex_unlock(&d_lock); pthread_mutex_unlock(&d_lock);
push(cmd); push(cmd);
if (!strcmp(kind, "desktop") || !strcmp(kind, "watch")) show_toast("正在连接…"); if (!strcmp(kind, "desktop") || !strcmp(kind, "watch")) show_toast(L("正在连接…", "Connecting…"));
} }
static void on_tool(GtkButton *b, gpointer kind); static void on_tool(GtkButton *b, gpointer kind);
static void more_item(GtkButton *b, gpointer kind) { static void more_item(GtkButton *b, gpointer kind) {
@@ -110,35 +107,37 @@ static void more_item(GtkButton *b, gpointer kind) {
const char *k = kind; const char *k = kind;
if (!strcmp(k, "reboot") || !strcmp(k, "shutdown")) { if (!strcmp(k, "reboot") || !strcmp(k, "shutdown")) {
GtkWidget *d = gtk_message_dialog_new(GTK_WINDOW(dialog), GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, GtkWidget *d = gtk_message_dialog_new(GTK_WINDOW(dialog), GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE,
!strcmp(k, "reboot") ? "确定要重启被控电脑吗?" : "确定要关闭被控电脑吗?"); !strcmp(k, "reboot") ? L("确定要重启被控电脑吗?", "Restart the remote computer?") : L("确定要关闭被控电脑吗?", "Shut down the remote computer?"));
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(d), "远程会话会断开。"); gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(d), L("远程会话会断开。", "The remote session will be disconnected."));
gtk_dialog_add_buttons(GTK_DIALOG(d), "取消", GTK_RESPONSE_CANCEL, "确认", GTK_RESPONSE_OK, NULL); gtk_dialog_add_buttons(GTK_DIALOG(d), L("取消", "Cancel"), GTK_RESPONSE_CANCEL, L("确认", "Confirm"), GTK_RESPONSE_OK, NULL);
int ok = gtk_dialog_run(GTK_DIALOG(d)) == GTK_RESPONSE_OK; gtk_widget_destroy(d); int ok = gtk_dialog_run(GTK_DIALOG(d)) == GTK_RESPONSE_OK; gtk_widget_destroy(d);
if (ok) { connect_kind(k); show_toast("正在发送电源指令…"); } if (ok) { connect_kind(k); show_toast(L("正在发送电源指令…", "Sending power command…")); }
return; return;
} }
if (!strcmp(k, "unbind")) { if (!strcmp(k, "unbind")) {
GtkWidget *d = gtk_message_dialog_new(GTK_WINDOW(dialog), GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, GtkWidget *d = gtk_message_dialog_new(GTK_WINDOW(dialog), GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE,
"确定要从账号中删除该设备吗?"); L("确定要从账号中删除该设备吗?", "Remove this device from your account?"));
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(d), "删除后需要在该设备上重新登录才能再次远控。"); gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(d), L("删除后需要在该设备上重新登录才能再次远控。", "After removal you must sign in on that device again before you can control it."));
gtk_dialog_add_buttons(GTK_DIALOG(d), "取消", GTK_RESPONSE_CANCEL, "删除", GTK_RESPONSE_OK, NULL); gtk_dialog_add_buttons(GTK_DIALOG(d), L("取消", "Cancel"), GTK_RESPONSE_CANCEL, L("删除", "Remove"), GTK_RESPONSE_OK, NULL);
int ok = gtk_dialog_run(GTK_DIALOG(d)) == GTK_RESPONSE_OK; gtk_widget_destroy(d); int ok = gtk_dialog_run(GTK_DIALOG(d)) == GTK_RESPONSE_OK; gtk_widget_destroy(d);
if (ok) { gtk_widget_destroy(dialog); connect_kind(k); show_toast("正在删除设备…"); } if (ok) { gtk_widget_destroy(dialog); connect_kind(k); show_toast(L("正在删除设备…", "Removing device…")); }
return; return;
} }
gtk_widget_destroy(dialog); gtk_widget_destroy(dialog);
on_tool(NULL, kind); on_tool(NULL, kind);
} }
static void open_more(void) { static void open_more(void) {
GtkWidget *dialog = gtk_dialog_new_with_buttons("更多工具", GTK_WINDOW(window), GTK_DIALOG_MODAL, NULL, NULL); GtkWidget *dialog = gtk_dialog_new_with_buttons(L("更多工具", "More tools"), GTK_WINDOW(window), GTK_DIALOG_MODAL, NULL, NULL);
gtk_window_set_default_size(GTK_WINDOW(dialog), 520, -1); gtk_window_set_default_size(GTK_WINDOW(dialog), 520, -1);
GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dialog)), *box = vbox(10); GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dialog)), *box = vbox(10);
gtk_container_set_border_width(GTK_CONTAINER(box), 22); gtk_container_set_border_width(GTK_CONTAINER(box), 22);
gtk_box_pack_start(GTK_BOX(box), label("更多工具", "h2"), FALSE, FALSE, 6); gtk_box_pack_start(GTK_BOX(box), label(L("更多工具", "More tools"), "h2"), FALSE, FALSE, 6);
const char *names[] = {"🗂 文件传输", "▶ 观看模式", "⌨ 终端", "⇄ 端口映射", "⏻ 远程开机", "↻ 重启", "⏻ 关机", "🗑 删除设备"}; 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"}; const char *kinds[] = {"file", "watch", "terminal", "portmap", "wol", "reboot", "shutdown", "unbind"};
for (int i = 0; i < 8; i++) { for (int i = 0; i < 8; i++) {
GtkWidget *b = gtk_button_new(), *line = hbox(10); add_class(b, "cardbtn"); 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_start(GTK_BOX(line), label(names[i], "devname"), TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(line), label("›", "hint"), FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(line), label("›", "hint"), FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(b), line); gtk_container_add(GTK_CONTAINER(b), line);
@@ -146,8 +145,8 @@ static void open_more(void) {
else g_signal_connect(b, "clicked", G_CALLBACK(more_item), (gpointer)kinds[i]); else g_signal_connect(b, "clicked", G_CALLBACK(more_item), (gpointer)kinds[i]);
gtk_box_pack_start(GTK_BOX(box), b, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(box), b, FALSE, FALSE, 0);
} }
GtkWidget *foot = hbox(10), *order = button("调整顺序", "secondary"), *close = button("关闭", "secondary"); GtkWidget *foot = hbox(10), *order = button(L("调整顺序", "Reorder"), "secondary"), *close = button(L("关闭", "Close"), "secondary");
g_signal_connect(order, "clicked", G_CALLBACK(unsupported), "调整顺序"); g_signal_connect(order, "clicked", G_CALLBACK(unsupported), L("调整顺序", "Reorder"));
g_signal_connect_swapped(close, "clicked", G_CALLBACK(gtk_widget_destroy), dialog); g_signal_connect_swapped(close, "clicked", G_CALLBACK(gtk_widget_destroy), dialog);
gtk_box_pack_start(GTK_BOX(foot), order, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(foot), close, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(foot), order, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(foot), close, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(box), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 8); gtk_box_pack_start(GTK_BOX(box), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 8);
@@ -159,10 +158,10 @@ static void on_tool(GtkButton *b, gpointer kind) {
(void)b; (void)b;
if (!strcmp(kind, "more")) open_more(); if (!strcmp(kind, "more")) open_more();
else if (!strcmp(kind, "wol") || !strcmp(kind, "reboot") || !strcmp(kind, "shutdown")) else if (!strcmp(kind, "wol") || !strcmp(kind, "reboot") || !strcmp(kind, "shutdown"))
unsupported(NULL, (gpointer)(!strcmp(kind, "wol") ? "远程开机" : !strcmp(kind, "reboot") ? "重启" : "关机")); unsupported(NULL, (gpointer)(!strcmp(kind, "wol") ? L("远程开机", "Wake on LAN") : !strcmp(kind, "reboot") ? L("重启", "Restart") : L("关机", "Shut down")));
else connect_kind(kind); else connect_kind(kind);
} }
static void on_login(GtkButton *b, gpointer d) { (void)b; (void)d; push("login"); gtk_stack_set_visible_child_name(GTK_STACK(stack), "login"); gtk_label_set_text(GTK_LABEL(title_label), "登录"); } static void on_login(GtkButton *b, gpointer d) { (void)b; (void)d; push("login"); gtk_stack_set_visible_child_name(GTK_STACK(stack), "login"); gtk_label_set_text(GTK_LABEL(title_label), L("登录", "Sign in")); }
static void set_header(const char *title, int device_page) { static void set_header(const char *title, int device_page) {
gtk_label_set_text(GTK_LABEL(title_label), title); gtk_label_set_text(GTK_LABEL(title_label), title);
@@ -170,19 +169,52 @@ static void set_header(const char *title, int device_page) {
} }
static void show_page(const char *name, const char *title) { static void show_page(const char *name, const char *title) {
int need_login = strcmp(name, "assist") && strcmp(name, "login"); int need_login = strcmp(name, "assist") && strcmp(name, "login");
if (!logged_in && need_login) { set_header("全部设备", 0); gtk_stack_set_visible_child_name(GTK_STACK(stack), "welcome"); return; } if (!logged_in && need_login) { set_header(L("全部设备", "All devices"), 0); gtk_stack_set_visible_child_name(GTK_STACK(stack), "welcome"); return; }
set_header(title, 0); set_header(title, 0);
gtk_stack_set_visible_child_name(GTK_STACK(stack), name); gtk_stack_set_visible_child_name(GTK_STACK(stack), name);
} }
// ---- device preview: the last remote picture saved by the desktop window (src/viewer/thumbs.rs) ----
static GtkWidget *preview_bg;
static GdkPixbuf *thumb_pixbuf;
static char thumb_loaded[512];
static gint64 thumb_mtime;
static void load_thumb(const char *path) {
struct stat st; gint64 mtime = path[0] && stat(path, &st) == 0 ? (gint64)st.st_mtime : 0;
if (!strcmp(path, thumb_loaded) && mtime == thumb_mtime) return;
if (thumb_pixbuf) { g_object_unref(thumb_pixbuf); thumb_pixbuf = NULL; }
snprintf(thumb_loaded, sizeof thumb_loaded, "%s", path); thumb_mtime = mtime;
if (mtime) thumb_pixbuf = gdk_pixbuf_new_from_file(path, NULL);
if (preview_bg) gtk_widget_queue_draw(preview_bg);
}
static gboolean draw_preview(GtkWidget *w, cairo_t *cr, gpointer d) {
(void)d; if (!thumb_pixbuf) return FALSE;
double W = gtk_widget_get_allocated_width(w), H = gtk_widget_get_allocated_height(w), r = 12;
double pw = gdk_pixbuf_get_width(thumb_pixbuf), ph = gdk_pixbuf_get_height(thumb_pixbuf);
double scale = W / pw > H / ph ? W / pw : H / ph; // cover, centered
cairo_save(cr);
cairo_new_path(cr); cairo_arc(cr, r, r, r, G_PI, 1.5 * G_PI); cairo_arc(cr, W - r, r, r, 1.5 * G_PI, 2 * G_PI);
cairo_line_to(cr, W, H); cairo_line_to(cr, 0, H); cairo_close_path(cr); cairo_clip(cr);
cairo_translate(cr, (W - pw * scale) / 2, (H - ph * scale) / 2); cairo_scale(cr, scale, scale);
gdk_cairo_set_source_pixbuf(cr, thumb_pixbuf, 0, 0);
cairo_pattern_set_filter(cairo_get_source(cr), CAIRO_FILTER_GOOD); cairo_paint(cr);
cairo_restore(cr);
// Soft shade at the bottom keeps the "Open desktop" button readable on bright desktops.
cairo_pattern_t *g = cairo_pattern_create_linear(0, H * 0.55, 0, H);
cairo_pattern_add_color_stop_rgba(g, 0, 0, 0, 0, 0); cairo_pattern_add_color_stop_rgba(g, 1, 0, 0, 0, 0.35);
cairo_rectangle(cr, 0, 0, W, H); cairo_set_source(cr, g); cairo_fill(cr); cairo_pattern_destroy(g);
return FALSE;
}
static void show_device(int index) { static void show_device(int index) {
pthread_mutex_lock(&d_lock); pthread_mutex_lock(&d_lock);
if (index < 0 || index >= device_count) { pthread_mutex_unlock(&d_lock); return; } if (index < 0 || index >= device_count) { pthread_mutex_unlock(&d_lock); return; }
selected = index; selected = index;
char name[128]; snprintf(name, sizeof name, "%s", devices[index].name); char name[128]; snprintf(name, sizeof name, "%s", devices[index].name);
int online = devices[index].online; int online = devices[index].online;
char thumb[512]; snprintf(thumb, sizeof thumb, "%s", devices[index].thumb);
pthread_mutex_unlock(&d_lock); pthread_mutex_unlock(&d_lock);
load_thumb(thumb);
set_header(name, 1); set_header(name, 1);
gtk_label_set_markup(GTK_LABEL(badge), online ? "<span foreground='#22c55e'>●</span> 在线" : "离线"); gtk_label_set_text(GTK_LABEL(badge), online ? L("● 在线", "● Online") : L("离线", "Offline"));
GtkStyleContext *ctx = gtk_widget_get_style_context(badge); 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"); 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"); gtk_stack_set_visible_child_name(GTK_STACK(stack), "device");
@@ -194,15 +226,16 @@ static void on_row(GtkListBox *box, GtkListBoxRow *row, gpointer d) {
gtk_list_box_unselect_all(GTK_LIST_BOX(box == GTK_LIST_BOX(device_list) ? assist_list : device_list)); gtk_list_box_unselect_all(GTK_LIST_BOX(box == GTK_LIST_BOX(device_list) ? assist_list : device_list));
const char *kind = g_object_get_data(G_OBJECT(row), "kind"); const char *kind = g_object_get_data(G_OBJECT(row), "kind");
if (!kind) { show_device(GPOINTER_TO_INT(g_object_get_data(G_OBJECT(row), "index"))); return; } if (!kind) { show_device(GPOINTER_TO_INT(g_object_get_data(G_OBJECT(row), "index"))); return; }
if (!strcmp(kind, "all")) show_page("all", "全部设备"); if (!strcmp(kind, "all")) show_page("all", L("全部设备", "All devices"));
else if (!strcmp(kind, "assist")) show_page("assist", "远程协助"); else if (!strcmp(kind, "assist")) show_page("assist", L("远程协助", "Remote assistance"));
else if (!strcmp(kind, "favorite")) show_page("favorite", "收藏设备"); else if (!strcmp(kind, "favorite")) show_page("favorite", L("收藏设备", "Favorites"));
} }
static void on_card(GtkButton *b, gpointer index) { (void)b; show_device(GPOINTER_TO_INT(index)); } static void on_card(GtkButton *b, gpointer index) { (void)b; show_device(GPOINTER_TO_INT(index)); }
static GtkWidget *nav_row(const char *icon, const char *text, const char *kind) { static GtkWidget *nav_row(const char *icon, const char *text, const char *kind) {
GtkWidget *row = gtk_list_box_row_new(), *line = hbox(10); 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_box_pack_start(GTK_BOX(line), label(text, "devname"), TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(row), line); gtk_container_add(GTK_CONTAINER(row), line);
g_object_set_data_full(G_OBJECT(row), "kind", g_strdup(kind), g_free); g_object_set_data_full(G_OBJECT(row), "kind", g_strdup(kind), g_free);
@@ -220,18 +253,18 @@ static void on_info(GtkButton *b, gpointer index) {
int i = GPOINTER_TO_INT(index); int i = GPOINTER_TO_INT(index);
char name[128] = ""; char name[128] = "";
pthread_mutex_lock(&d_lock); if (i >= 0 && i < device_count) snprintf(name, sizeof name, "%s", devices[i].name); pthread_mutex_unlock(&d_lock); pthread_mutex_lock(&d_lock); if (i >= 0 && i < device_count) snprintf(name, sizeof name, "%s", devices[i].name); pthread_mutex_unlock(&d_lock);
GtkWidget *dialog = gtk_dialog_new_with_buttons("设备信息", GTK_WINDOW(window), GTK_DIALOG_MODAL, "完成", GTK_RESPONSE_OK, NULL); GtkWidget *dialog = gtk_dialog_new_with_buttons(L("设备信息", "Device info"), GTK_WINDOW(window), GTK_DIALOG_MODAL, L("完成", "Done"), GTK_RESPONSE_OK, NULL);
GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dialog)), *box = vbox(12); GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dialog)), *box = vbox(12);
gtk_container_set_border_width(GTK_CONTAINER(box), 20); gtk_container_set_border_width(GTK_CONTAINER(box), 20);
GtkWidget *c1 = vbox(8); add_class(c1, "card"); GtkWidget *c1 = vbox(8); add_class(c1, "card");
GtkWidget *r = hbox(8); gtk_box_pack_start(GTK_BOX(r), label("名称", "devname"), TRUE, TRUE, 0); gtk_box_pack_end(GTK_BOX(r), label(name, "hint"), FALSE, FALSE, 0); GtkWidget *r = hbox(8); gtk_box_pack_start(GTK_BOX(r), label(L("名称", "Name"), "devname"), TRUE, TRUE, 0); gtk_box_pack_end(GTK_BOX(r), label(name, "hint"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(c1), r, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(c1), r, FALSE, FALSE, 0);
GtkWidget *rename = button("重命名", "secondary"); gtk_widget_set_halign(rename, GTK_ALIGN_END); GtkWidget *rename = button(L("重命名", "Rename"), "secondary"); gtk_widget_set_halign(rename, GTK_ALIGN_END);
g_signal_connect(rename, "clicked", G_CALLBACK(unsupported), "重命名"); g_signal_connect(rename, "clicked", G_CALLBACK(unsupported), L("重命名", "Rename"));
gtk_box_pack_start(GTK_BOX(c1), rename, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(c1), rename, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(box), c1, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(box), c1, FALSE, FALSE, 0);
GtkWidget *c2 = vbox(10); add_class(c2, "card"); GtkWidget *c2 = vbox(10); add_class(c2, "card");
const char *rows[] = {"处理器", "网卡", "总内存", "系统版本", "显卡"}; const char *rows[] = {L("处理器", "Processor"), L("网卡", "Network adapter"), L("总内存", "Total memory"), L("系统版本", "OS version"), L("显卡", "Graphics")};
for (int k = 0; k < 5; k++) { for (int k = 0; k < 5; k++) {
GtkWidget *line = hbox(8); GtkWidget *line = hbox(8);
gtk_box_pack_start(GTK_BOX(line), label(rows[k], "devname"), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(line), label(rows[k], "devname"), TRUE, TRUE, 0);
@@ -239,7 +272,7 @@ static void on_info(GtkButton *b, gpointer index) {
gtk_box_pack_start(GTK_BOX(c2), line, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(c2), line, FALSE, FALSE, 0);
} }
gtk_box_pack_start(GTK_BOX(box), c2, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(box), c2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(box), label("硬件信息暂未获取。", "hint"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(box), label(L("硬件信息暂未获取。", "Hardware info not available yet."), "hint"), FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(area), box); gtk_container_add(GTK_CONTAINER(area), box);
gtk_widget_show_all(dialog); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); gtk_widget_show_all(dialog); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog);
} }
@@ -249,8 +282,9 @@ static gboolean apply_devices(gpointer d) {
(void)d; (void)d;
clear(device_list); clear(all_box); clear(device_list); clear(all_box);
pthread_mutex_lock(&d_lock); pthread_mutex_lock(&d_lock);
if (selected >= 0 && selected < device_count) load_thumb(devices[selected].thumb);
if (!banner_closed) gtk_widget_show_all(banner); if (!banner_closed) gtk_widget_show_all(banner);
char group[64]; snprintf(group, sizeof group, "⌄ 电脑 %d", device_count); char group[64]; snprintf(group, sizeof group, L("⌄ 电脑 %d", "⌄ Computers %d"), device_count);
gtk_box_pack_start(GTK_BOX(all_box), label(group, "group"), FALSE, FALSE, 8); gtk_box_pack_start(GTK_BOX(all_box), label(group, "group"), FALSE, FALSE, 8);
for (int i = 0; i < device_count; i++) { for (int i = 0; i < device_count; i++) {
GtkWidget *row = gtk_list_box_row_new(), *line = hbox(8); GtkWidget *row = gtk_list_box_row_new(), *line = hbox(8);
@@ -266,7 +300,7 @@ static gboolean apply_devices(gpointer d) {
GtkWidget *card = hbox(12); add_class(card, "card"); GtkWidget *card = hbox(12); add_class(card, "card");
gtk_box_pack_start(GTK_BOX(card), platform_icon(devices[i].platform, 1), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(card), platform_icon(devices[i].platform, 1), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(card), label(devices[i].name, "devname"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(card), label(devices[i].name, "devname"), FALSE, FALSE, 0);
if (devices[i].current) gtk_box_pack_start(GTK_BOX(card), label("本机", "tag"), FALSE, FALSE, 0); if (devices[i].current) gtk_box_pack_start(GTK_BOX(card), label(L("本机", "This device"), "tag"), FALSE, FALSE, 0);
GtkWidget *open = button("›", "hbtn"), *info = button("ⓘ", "hbtn"); GtkWidget *open = button("›", "hbtn"), *info = button("ⓘ", "hbtn");
g_signal_connect(info, "clicked", G_CALLBACK(on_info), GINT_TO_POINTER(i)); g_signal_connect(info, "clicked", G_CALLBACK(on_info), GINT_TO_POINTER(i));
if (!devices[i].current) { g_signal_connect(open, "clicked", G_CALLBACK(on_card), GINT_TO_POINTER(i)); gtk_box_pack_end(GTK_BOX(card), open, FALSE, FALSE, 0); } if (!devices[i].current) { g_signal_connect(open, "clicked", G_CALLBACK(on_card), GINT_TO_POINTER(i)); gtk_box_pack_end(GTK_BOX(card), open, FALSE, FALSE, 0); }
@@ -275,12 +309,20 @@ static gboolean apply_devices(gpointer d) {
gtk_box_pack_start(GTK_BOX(all_box), card, FALSE, FALSE, 4); gtk_box_pack_start(GTK_BOX(all_box), card, FALSE, FALSE, 4);
} }
pthread_mutex_unlock(&d_lock); pthread_mutex_unlock(&d_lock);
gtk_list_box_insert(GTK_LIST_BOX(device_list), nav_row("◼", "全部设备", "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); gtk_widget_show_all(device_list); gtk_widget_show_all(all_box);
return G_SOURCE_REMOVE; return G_SOURCE_REMOVE;
} }
static GtkWidget *account_who, *account_out;
/* The settings window is built once and kept; refresh its account card on every login change. */
static void refresh_account(void) {
if (!account_who) return;
gtk_label_set_text(GTK_LABEL(account_who), logged_in ? (user_text[0] ? user_text : L("已登录", "Signed in")) : L("未登录", "Not signed in"));
gtk_widget_set_sensitive(account_out, logged_in);
}
static gboolean apply_login(gpointer d) { static gboolean apply_login(gpointer d) {
(void)d; (void)d;
refresh_account();
gtk_label_set_text(GTK_LABEL(status_label), status_text); gtk_label_set_text(GTK_LABEL(status_label), status_text);
if (qr_path[0]) { if (qr_path[0]) {
GdkPixbuf *pix = gdk_pixbuf_new_from_file_at_size(qr_path, 240, 240, NULL); GdkPixbuf *pix = gdk_pixbuf_new_from_file_at_size(qr_path, 240, 240, NULL);
@@ -288,9 +330,9 @@ static gboolean apply_login(gpointer d) {
} else gtk_image_clear(GTK_IMAGE(qr_image)); } else gtk_image_clear(GTK_IMAGE(qr_image));
gtk_widget_set_visible(my_section, logged_in); gtk_widget_set_visible(my_section, logged_in);
const char *page = gtk_stack_get_visible_child_name(GTK_STACK(stack)); const char *page = gtk_stack_get_visible_child_name(GTK_STACK(stack));
if (logged_in && (!strcmp(page, "login") || !strcmp(page, "welcome"))) show_page("all", "全部设备"); if (logged_in && (!strcmp(page, "login") || !strcmp(page, "welcome"))) show_page("all", L("全部设备", "All devices"));
if (!logged_in && strcmp(page, "login") && strcmp(page, "assist")) show_page("welcome", "全部设备"); if (!logged_in && strcmp(page, "login") && strcmp(page, "assist")) show_page("welcome", L("全部设备", "All devices"));
if (!logged_in && qr_path[0]) { gtk_stack_set_visible_child_name(GTK_STACK(stack), "login"); set_header("登录", 0); } if (!logged_in && qr_path[0]) { gtk_stack_set_visible_child_name(GTK_STACK(stack), "login"); set_header(L("登录", "Sign in"), 0); }
return G_SOURCE_REMOVE; return G_SOURCE_REMOVE;
} }
@@ -299,28 +341,28 @@ static GtkWidget *build_welcome(void) {
GtkWidget *page = vbox(22); gtk_widget_set_valign(page, GTK_ALIGN_CENTER); gtk_widget_set_halign(page, GTK_ALIGN_CENTER); GtkWidget *page = vbox(22); gtk_widget_set_valign(page, GTK_ALIGN_CENTER); gtk_widget_set_halign(page, GTK_ALIGN_CENTER);
GtkWidget *art = gtk_event_box_new(); add_class(art, "preview"); gtk_widget_set_size_request(art, 520, 300); GtkWidget *art = gtk_event_box_new(); add_class(art, "preview"); gtk_widget_set_size_request(art, 520, 300);
gtk_box_pack_start(GTK_BOX(page), art, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(page), art, FALSE, FALSE, 0);
GtkWidget *t = label("随时访问个人设备,可用于办公、游戏、文件传输。", "h2"); gtk_widget_set_halign(t, GTK_ALIGN_CENTER); GtkWidget *t = label(L("随时访问个人设备,可用于办公、游戏、文件传输。", "Access your devices anytime for work, gaming and file transfer."), "h2"); gtk_widget_set_halign(t, GTK_ALIGN_CENTER);
gtk_box_pack_start(GTK_BOX(page), t, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(page), t, FALSE, FALSE, 0);
GtkWidget *b = button("立即登录", "primary"); gtk_widget_set_halign(b, GTK_ALIGN_CENTER); GtkWidget *b = button(L("立即登录", "Sign in now"), "primary"); gtk_widget_set_halign(b, GTK_ALIGN_CENTER);
g_signal_connect(b, "clicked", G_CALLBACK(on_login), NULL); g_signal_connect(b, "clicked", G_CALLBACK(on_login), NULL);
gtk_box_pack_start(GTK_BOX(page), b, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(page), b, FALSE, FALSE, 0);
return page; return page;
} }
static GtkWidget *build_login(void) { static GtkWidget *build_login(void) {
GtkWidget *page = vbox(16); gtk_widget_set_valign(page, GTK_ALIGN_CENTER); gtk_widget_set_halign(page, GTK_ALIGN_CENTER); GtkWidget *page = vbox(16); gtk_widget_set_valign(page, GTK_ALIGN_CENTER); gtk_widget_set_halign(page, GTK_ALIGN_CENTER);
GtkWidget *brand = label("UU 远程 Linux 控制端(非官方)", "h2"); gtk_widget_set_halign(brand, GTK_ALIGN_CENTER); GtkWidget *brand = label(L("UU 远程 Linux 控制端(非官方)", "UU Remote Linux viewer (unofficial)"), "h2"); gtk_widget_set_halign(brand, GTK_ALIGN_CENTER);
GtkWidget *t = label("扫码登录", "group"); gtk_widget_set_halign(t, GTK_ALIGN_CENTER); GtkWidget *t = label(L("扫码登录", "Scan to sign in"), "group"); gtk_widget_set_halign(t, GTK_ALIGN_CENTER);
gtk_box_pack_start(GTK_BOX(page), brand, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(page), brand, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(page), t, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(page), t, FALSE, FALSE, 0);
GtkWidget *box = vbox(0); add_class(box, "qrbox"); gtk_widget_set_halign(box, GTK_ALIGN_CENTER); GtkWidget *box = vbox(0); add_class(box, "qrbox"); gtk_widget_set_halign(box, GTK_ALIGN_CENTER);
qr_image = gtk_image_new(); gtk_widget_set_size_request(qr_image, 240, 240); qr_image = gtk_image_new(); gtk_widget_set_size_request(qr_image, 240, 240);
gtk_container_add(GTK_CONTAINER(box), qr_image); gtk_container_add(GTK_CONTAINER(box), qr_image);
gtk_box_pack_start(GTK_BOX(page), box, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(page), box, FALSE, FALSE, 0);
GtkWidget *h = label("请使用网易 UU 远程 App 扫一扫\n可快速登录", "hint"); gtk_label_set_justify(GTK_LABEL(h), GTK_JUSTIFY_CENTER); gtk_widget_set_halign(h, GTK_ALIGN_CENTER); GtkWidget *h = label(L("请使用网易 UU 远程 App 扫一扫\n可快速登录", "Scan with the NetEase UU Remote app\nto sign in quickly"), "hint"); gtk_label_set_justify(GTK_LABEL(h), GTK_JUSTIFY_CENTER); gtk_widget_set_halign(h, GTK_ALIGN_CENTER);
gtk_box_pack_start(GTK_BOX(page), h, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(page), h, FALSE, FALSE, 0);
status_label = label("", "status"); gtk_widget_set_halign(status_label, GTK_ALIGN_CENTER); status_label = label("", "status"); gtk_widget_set_halign(status_label, GTK_ALIGN_CENTER);
gtk_box_pack_start(GTK_BOX(page), status_label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(page), status_label, FALSE, FALSE, 0);
GtkWidget *again = button("刷新二维码", "secondary"); gtk_widget_set_halign(again, GTK_ALIGN_CENTER); GtkWidget *again = button(L("刷新二维码", "Refresh QR code"), "secondary"); gtk_widget_set_halign(again, GTK_ALIGN_CENTER);
g_signal_connect(again, "clicked", G_CALLBACK(on_login), NULL); g_signal_connect(again, "clicked", G_CALLBACK(on_login), NULL);
gtk_box_pack_start(GTK_BOX(page), again, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(page), again, FALSE, FALSE, 0);
return page; return page;
@@ -328,26 +370,28 @@ static GtkWidget *build_login(void) {
static GtkWidget *build_device(void) { static GtkWidget *build_device(void) {
GtkWidget *page = vbox(0); gtk_container_set_border_width(GTK_CONTAINER(page), 26); GtkWidget *page = vbox(0); gtk_container_set_border_width(GTK_CONTAINER(page), 26);
GtkWidget *preview = gtk_overlay_new(), *bg = gtk_event_box_new(); add_class(bg, "preview"); gtk_widget_set_size_request(bg, -1, 320); GtkWidget *preview = gtk_overlay_new(), *bg = gtk_event_box_new(); add_class(bg, "preview"); gtk_widget_set_size_request(bg, -1, 320);
preview_bg = bg; g_signal_connect_after(bg, "draw", G_CALLBACK(draw_preview), NULL);
gtk_container_add(GTK_CONTAINER(preview), bg); gtk_container_add(GTK_CONTAINER(preview), bg);
GtkWidget *enter = button("进入桌面 →", "enter"); GtkWidget *enter = button(L("进入桌面 →", "Open desktop →"), "enter");
gtk_widget_set_halign(enter, GTK_ALIGN_CENTER); gtk_widget_set_valign(enter, GTK_ALIGN_END); gtk_widget_set_margin_bottom(enter, 26); gtk_widget_set_halign(enter, GTK_ALIGN_CENTER); gtk_widget_set_valign(enter, GTK_ALIGN_END); gtk_widget_set_margin_bottom(enter, 26);
g_signal_connect(enter, "clicked", G_CALLBACK(on_tool), "desktop"); g_signal_connect(enter, "clicked", G_CALLBACK(on_tool), "desktop");
gtk_overlay_add_overlay(GTK_OVERLAY(preview), enter); gtk_overlay_add_overlay(GTK_OVERLAY(preview), enter);
gtk_box_pack_start(GTK_BOX(page), preview, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(page), preview, FALSE, FALSE, 0);
GtkWidget *tools = hbox(0); add_class(tools, "toolbar"); GtkWidget *tools = hbox(0); add_class(tools, "toolbar");
const char *names[] = {"🗂 文件传输", "▶ 观看模式", "⌨ 终端", "⇄ 端口映射", "▦"}, *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++) { 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]); g_signal_connect(b, "clicked", G_CALLBACK(on_tool), (gpointer)kinds[i]);
gtk_box_pack_start(GTK_BOX(tools), b, i < 4, TRUE, 0); 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); if (i < 4) gtk_box_pack_start(GTK_BOX(tools), gtk_separator_new(GTK_ORIENTATION_VERTICAL), FALSE, FALSE, 0);
} }
gtk_box_pack_start(GTK_BOX(page), tools, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(page), tools, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(page), label("快速启动", "h2"), FALSE, FALSE, 22); gtk_box_pack_start(GTK_BOX(page), label(L("快速启动", "Quick launch"), "h2"), FALSE, FALSE, 22);
GtkWidget *quick = vbox(10); add_class(quick, "dashed"); GtkWidget *quick = vbox(10); add_class(quick, "dashed");
GtkWidget *add = button("+", "round"); gtk_widget_set_halign(add, GTK_ALIGN_CENTER); GtkWidget *add = button("+", "round"); gtk_widget_set_halign(add, GTK_ALIGN_CENTER);
g_signal_connect(add, "clicked", G_CALLBACK(unsupported), "快速启动"); g_signal_connect(add, "clicked", G_CALLBACK(unsupported), L("快速启动", "Quick launch"));
GtkWidget *al = label("添加", "hint"); gtk_widget_set_halign(al, GTK_ALIGN_CENTER); GtkWidget *al = label(L("添加", "Add"), "hint"); gtk_widget_set_halign(al, GTK_ALIGN_CENTER);
gtk_box_pack_start(GTK_BOX(quick), add, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(quick), al, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(quick), add, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(quick), al, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(page), quick, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(page), quick, FALSE, FALSE, 0);
return page; return page;
@@ -357,8 +401,8 @@ static GtkWidget *build_all(void) {
GtkWidget *page = vbox(8); gtk_container_set_border_width(GTK_CONTAINER(page), 26); GtkWidget *page = vbox(8); gtk_container_set_border_width(GTK_CONTAINER(page), 26);
banner = hbox(10); add_class(banner, "banner"); banner = hbox(10); add_class(banner, "banner");
GtkWidget *text = vbox(4); GtkWidget *text = vbox(4);
gtk_box_pack_start(GTK_BOX(text), label("ⓘ 添加你的其他设备", "group"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(text), label(L("ⓘ 添加你的其他设备", "ⓘ Add your other devices"), "group"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(text), label("在其他电脑上安装 UU 远程官方客户端或本项目主机端,登录同一账号后即可在这里远程访问。", "hint"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(text), label(L("在其他电脑上安装 UU 远程官方客户端或本项目主机端,登录同一账号后即可在这里远程访问。", "Install the official UU Remote client or this project's host on another computer and sign in with the same account to access it here."), "hint"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(banner), text, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(banner), text, TRUE, TRUE, 0);
GtkWidget *x = button("×", "hbtn"); gtk_widget_set_valign(x, GTK_ALIGN_START); GtkWidget *x = button("×", "hbtn"); gtk_widget_set_valign(x, GTK_ALIGN_START);
g_signal_connect(x, "clicked", G_CALLBACK(close_banner), NULL); g_signal_connect(x, "clicked", G_CALLBACK(close_banner), NULL);
@@ -372,51 +416,51 @@ static GtkWidget *build_all(void) {
static void on_assist_connect(GtkButton *b, gpointer entry) { static void on_assist_connect(GtkButton *b, gpointer entry) {
(void)b; (void)b;
const char *id = gtk_entry_get_text(GTK_ENTRY(entry)); const char *id = gtk_entry_get_text(GTK_ENTRY(entry));
if (!id[0]) { show_toast("请输入伙伴的设备 ID"); return; } if (!id[0]) { show_toast(L("请输入伙伴的设备 ID", "Enter your partner's device ID")); return; }
GtkWidget *code_entry = g_object_get_data(G_OBJECT(entry), "assist-code"); GtkWidget *code_entry = g_object_get_data(G_OBJECT(entry), "assist-code");
const char *code = gtk_entry_get_text(GTK_ENTRY(code_entry)); const char *code = gtk_entry_get_text(GTK_ENTRY(code_entry));
if (!code[0]) { show_toast("请输入伙伴的设备验证码"); return; } if (!code[0]) { show_toast(L("请输入伙伴的设备验证码", "Enter your partner's verification code")); return; }
if (strpbrk(id, "\t\r\n") || strpbrk(code, "\t\r\n")) { show_toast("设备 ID 和验证码不能包含换行或制表符"); return; } if (strpbrk(id, "\t\r\n") || strpbrk(code, "\t\r\n")) { show_toast(L("设备 ID 和验证码不能包含换行或制表符", "Device ID and code cannot contain line breaks or tabs")); return; }
char cmd[200]; char cmd[200];
int n = snprintf(cmd, sizeof cmd, "assist\t%s\t%s", id, code); int n = snprintf(cmd, sizeof cmd, "assist\t%s\t%s", id, code);
if (n < 0 || (size_t)n >= sizeof cmd) { show_toast("设备 ID 或验证码过长"); return; } if (n < 0 || (size_t)n >= sizeof cmd) { show_toast(L("设备 ID 或验证码过长", "Device ID or code is too long")); return; }
int accepted = push(cmd); int accepted = push(cmd);
memset(cmd, 0, sizeof cmd); memset(cmd, 0, sizeof cmd);
if (!accepted) { show_toast("连接请求过多,请稍后重试"); return; } if (!accepted) { show_toast(L("连接请求过多,请稍后重试", "Too many connection requests, try again later")); return; }
gtk_entry_set_text(GTK_ENTRY(code_entry), ""); gtk_entry_set_text(GTK_ENTRY(code_entry), "");
show_toast("正在连接…"); show_toast(L("正在连接…", "Connecting…"));
} }
static GtkWidget *build_assist(void) { static GtkWidget *build_assist(void) {
GtkWidget *page = vbox(20); gtk_container_set_border_width(GTK_CONTAINER(page), 26); GtkWidget *page = vbox(20); gtk_container_set_border_width(GTK_CONTAINER(page), 26);
GtkWidget *mine = vbox(14); add_class(mine, "card"); GtkWidget *mine = vbox(14); add_class(mine, "card");
GtkWidget *top = hbox(10); gtk_box_pack_start(GTK_BOX(top), label("本设备", "h2"), TRUE, TRUE, 0); GtkWidget *top = hbox(10); gtk_box_pack_start(GTK_BOX(top), label(L("本设备", "This device"), "h2"), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(top), label("允许他人远程协助", "devname"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(top), label(L("允许他人远程协助", "Allow remote assistance"), "devname"), FALSE, FALSE, 0);
GtkWidget *sw = gtk_switch_new(); gtk_widget_set_sensitive(sw, FALSE); gtk_box_pack_start(GTK_BOX(top), sw, FALSE, FALSE, 0); GtkWidget *sw = gtk_switch_new(); gtk_widget_set_sensitive(sw, FALSE); gtk_box_pack_start(GTK_BOX(top), sw, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mine), top, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(mine), top, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mine), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(mine), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0);
GtkWidget *grid = hbox(40), *c1 = vbox(6), *c2 = vbox(6); GtkWidget *grid = hbox(40), *c1 = vbox(6), *c2 = vbox(6);
gtk_box_pack_start(GTK_BOX(c1), label("本设备 ID", "devname"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(c1), label(L("本设备 ID", "This device's ID"), "devname"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(c1), label("— — —", "big"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(c1), label("— — —", "big"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(c2), label("验证方式:仅使用临时验证码", "devname"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(c2), label(L("验证方式:仅使用临时验证码", "Verification: temporary code only"), "devname"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(c2), label("—", "big"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(c2), label("—", "big"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(c2), label("每次远控结束刷新", "hint"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(c2), label(L("每次远控结束刷新", "Refreshed after every remote session"), "hint"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(grid), c1, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(grid), c2, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(grid), c1, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(grid), c2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mine), grid, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(mine), grid, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mine), label("本机被协助由 uuremote-server 主机端提供(uuremote-server assist)。", "hint"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(mine), label(L("本机被协助由 uuremote-server 主机端提供(uuremote-server assist)。", "Assistance for this computer is provided by the uuremote-server host (uuremote-server assist)."), "hint"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(page), mine, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(page), mine, FALSE, FALSE, 0);
GtkWidget *peer = vbox(12); add_class(peer, "card"); GtkWidget *peer = vbox(12); add_class(peer, "card");
gtk_box_pack_start(GTK_BOX(peer), label("远控伙伴设备", "h2"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(peer), label(L("远控伙伴设备", "Control a partner's device"), "h2"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(peer), label("通过其他设备的【设备 ID】及【设备验证码】启动远程控制", "hint"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(peer), label(L("通过其他设备的【设备 ID】及【设备验证码】启动远程控制", "Start remote control with another device's [Device ID] and [Verification code]"), "hint"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(peer), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(peer), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(peer), label("伙伴的设备 ID", "devname"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(peer), label(L("伙伴的设备 ID", "Partner's device ID"), "devname"), FALSE, FALSE, 0);
GtkWidget *row = hbox(20), *entry = gtk_entry_new(); gtk_entry_set_placeholder_text(GTK_ENTRY(entry), "请输入设备 ID"); gtk_widget_set_size_request(entry, 320, -1); GtkWidget *row = hbox(20), *entry = gtk_entry_new(); gtk_entry_set_placeholder_text(GTK_ENTRY(entry), L("请输入设备 ID", "Enter device ID")); gtk_widget_set_size_request(entry, 320, -1);
GtkWidget *code = gtk_entry_new(); gtk_entry_set_placeholder_text(GTK_ENTRY(code), "请输入设备验证码"); GtkWidget *code = gtk_entry_new(); gtk_entry_set_placeholder_text(GTK_ENTRY(code), L("请输入设备验证码", "Enter verification code"));
gtk_entry_set_visibility(GTK_ENTRY(code), FALSE); gtk_entry_set_visibility(GTK_ENTRY(code), FALSE);
gtk_entry_set_input_purpose(GTK_ENTRY(code), GTK_INPUT_PURPOSE_PASSWORD); gtk_entry_set_input_purpose(GTK_ENTRY(code), GTK_INPUT_PURPOSE_PASSWORD);
gtk_entry_set_max_length(GTK_ENTRY(entry), 64); gtk_entry_set_max_length(GTK_ENTRY(code), 64); gtk_entry_set_max_length(GTK_ENTRY(entry), 64); gtk_entry_set_max_length(GTK_ENTRY(code), 64);
g_object_set_data(G_OBJECT(entry), "assist-code", code); g_object_set_data(G_OBJECT(entry), "assist-code", code);
g_signal_connect(code, "activate", G_CALLBACK(on_assist_connect), entry); g_signal_connect(code, "activate", G_CALLBACK(on_assist_connect), entry);
GtkWidget *go = button("连接", "primary"); g_signal_connect(go, "clicked", G_CALLBACK(on_assist_connect), entry); GtkWidget *go = button(L("连接", "Connect"), "primary"); g_signal_connect(go, "clicked", G_CALLBACK(on_assist_connect), entry);
gtk_box_pack_start(GTK_BOX(row), entry, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(row), code, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(row), go, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(row), entry, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(row), code, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(row), go, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(peer), row, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(peer), row, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(page), peer, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(page), peer, FALSE, FALSE, 0);
@@ -424,10 +468,10 @@ static GtkWidget *build_assist(void) {
} }
static void on_add_favorite(GtkButton *b, gpointer d) { static void on_add_favorite(GtkButton *b, gpointer d) {
(void)b; (void)d; (void)b; (void)d;
GtkWidget *dialog = gtk_dialog_new_with_buttons("添加收藏设备", GTK_WINDOW(window), GTK_DIALOG_MODAL, "取消", GTK_RESPONSE_CANCEL, "添加", GTK_RESPONSE_OK, NULL); GtkWidget *dialog = gtk_dialog_new_with_buttons(L("添加收藏设备", "Add favorite device"), GTK_WINDOW(window), GTK_DIALOG_MODAL, L("取消", "Cancel"), GTK_RESPONSE_CANCEL, L("添加", "Add"), GTK_RESPONSE_OK, NULL);
GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dialog)), *card = vbox(12); add_class(card, "card"); GtkWidget *area = gtk_dialog_get_content_area(GTK_DIALOG(dialog)), *card = vbox(12); add_class(card, "card");
gtk_container_set_border_width(GTK_CONTAINER(area), 16); gtk_container_set_border_width(GTK_CONTAINER(area), 16);
const char *names[] = {"伙伴的设备 ID", "设备验证码(可选)", "备注名称(可选)"}, *hints[] = {"请输入设备 ID", "请输入设备验证码", "请输入名称"}; const char *names[] = {L("伙伴的设备 ID", "Partner's device ID"), L("设备验证码(可选)", "Verification code (optional)"), L("备注名称(可选)", "Nickname (optional)")}, *hints[] = {L("请输入设备 ID", "Enter device ID"), L("请输入设备验证码", "Enter verification code"), L("请输入名称", "Enter a name")};
GtkWidget *first = NULL; GtkWidget *first = NULL;
for (int i = 0; i < 3; i++) { for (int i = 0; i < 3; i++) {
GtkWidget *line = hbox(20), *e = gtk_entry_new(); gtk_entry_set_placeholder_text(GTK_ENTRY(e), hints[i]); gtk_widget_set_size_request(e, 280, -1); GtkWidget *line = hbox(20), *e = gtk_entry_new(); gtk_entry_set_placeholder_text(GTK_ENTRY(e), hints[i]); gtk_widget_set_size_request(e, 280, -1);
@@ -440,17 +484,17 @@ static void on_add_favorite(GtkButton *b, gpointer d) {
int response = gtk_dialog_run(GTK_DIALOG(dialog)); int response = gtk_dialog_run(GTK_DIALOG(dialog));
int has_id = first && gtk_entry_get_text(GTK_ENTRY(first))[0]; int has_id = first && gtk_entry_get_text(GTK_ENTRY(first))[0];
gtk_widget_destroy(dialog); gtk_widget_destroy(dialog);
if (response == GTK_RESPONSE_OK) show_toast(has_id ? "收藏设备:暂未支持" : "请输入伙伴的设备 ID"); if (response == GTK_RESPONSE_OK) show_toast(has_id ? L("收藏设备:暂未支持", "Favorite devices: not supported yet") : L("请输入伙伴的设备 ID", "Enter your partner's device ID"));
} }
static GtkWidget *build_favorite(void) { static GtkWidget *build_favorite(void) {
GtkWidget *page = vbox(10); gtk_container_set_border_width(GTK_CONTAINER(page), 26); GtkWidget *page = vbox(10); gtk_container_set_border_width(GTK_CONTAINER(page), 26);
GtkWidget *add = button("添加收藏设备", "secondary"); gtk_widget_set_halign(add, GTK_ALIGN_END); GtkWidget *add = button(L("添加收藏设备", "Add favorite device"), "secondary"); gtk_widget_set_halign(add, GTK_ALIGN_END);
g_signal_connect(add, "clicked", G_CALLBACK(on_add_favorite), NULL); g_signal_connect(add, "clicked", G_CALLBACK(on_add_favorite), NULL);
gtk_box_pack_start(GTK_BOX(page), add, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(page), add, FALSE, FALSE, 0);
fav_stack = gtk_stack_new(); fav_stack = gtk_stack_new();
GtkWidget *empty = vbox(10); gtk_widget_set_valign(empty, GTK_ALIGN_CENTER); GtkWidget *empty = vbox(10); gtk_widget_set_valign(empty, GTK_ALIGN_CENTER);
GtkWidget *box = label("📦", "big"); gtk_widget_set_halign(box, GTK_ALIGN_CENTER); GtkWidget *box = label("📦", "big"); gtk_widget_set_halign(box, GTK_ALIGN_CENTER);
GtkWidget *t = label("暂无收藏", "devname"); gtk_widget_set_halign(t, GTK_ALIGN_CENTER); GtkWidget *t = label(L("暂无收藏", "No favorites yet"), "devname"); gtk_widget_set_halign(t, GTK_ALIGN_CENTER);
gtk_box_pack_start(GTK_BOX(empty), box, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(empty), t, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(empty), box, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(empty), t, FALSE, FALSE, 0);
gtk_stack_add_named(GTK_STACK(fav_stack), empty, "empty"); gtk_stack_add_named(GTK_STACK(fav_stack), empty, "empty");
gtk_box_pack_start(GTK_BOX(page), fav_stack, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(page), fav_stack, TRUE, TRUE, 0);
@@ -478,7 +522,7 @@ static GtkWidget *settings_card(GtkWidget **rows, int n) {
return card; return card;
} }
static GtkWidget *settings_page(void) { GtkWidget *p = vbox(14); gtk_container_set_border_width(GTK_CONTAINER(p), 22); return p; } static GtkWidget *settings_page(void) { GtkWidget *p = vbox(14); gtk_container_set_border_width(GTK_CONTAINER(p), 22); return p; }
static GtkWidget *edit_button(const char *what) { GtkWidget *b = button("编辑", "secondary"); g_signal_connect(b, "clicked", G_CALLBACK(unsupported), (gpointer)what); return b; } static GtkWidget *edit_button(const char *what) { GtkWidget *b = button(L("编辑", "Edit"), "secondary"); g_signal_connect(b, "clicked", G_CALLBACK(unsupported), (gpointer)what); return b; }
static gboolean settings_hidden(GtkWidget *w, GdkEvent *e, gpointer d) { (void)e; (void)d; gtk_widget_hide(w); return TRUE; } static gboolean settings_hidden(GtkWidget *w, GdkEvent *e, gpointer d) { (void)e; (void)d; gtk_widget_hide(w); return TRUE; }
static gboolean settings_key(GtkWidget *w, GdkEventKey *e, gpointer d) { (void)d; if (e->keyval == GDK_KEY_Escape) { gtk_widget_hide(w); return TRUE; } return FALSE; } static gboolean settings_key(GtkWidget *w, GdkEventKey *e, gpointer d) { (void)d; if (e->keyval == GDK_KEY_Escape) { gtk_widget_hide(w); return TRUE; } return FALSE; }
// Compositors such as Hyprland draw no title bar, so windows carry their own (with a close button). // Compositors such as Hyprland draw no title bar, so windows carry their own (with a close button).
@@ -488,15 +532,31 @@ static void own_titlebar(GtkWidget *w, const char *title) {
gtk_header_bar_set_show_close_button(GTK_HEADER_BAR(bar), TRUE); gtk_header_bar_set_show_close_button(GTK_HEADER_BAR(bar), TRUE);
gtk_window_set_titlebar(GTK_WINDOW(w), bar); gtk_window_set_titlebar(GTK_WINDOW(w), bar);
} }
static atomic_int host_active;
static GtkWidget *host_switch;
static gboolean host_idle(gpointer d) { (void)d; if (host_switch) gtk_switch_set_active(GTK_SWITCH(host_switch), atomic_load(&host_active)); return G_SOURCE_REMOVE; }
void uu_viewer_ui_set_host(int active) { atomic_store(&host_active, active != 0); g_idle_add(host_idle, NULL); }
static void on_host(GObject *o, GParamSpec *p, gpointer d) {
(void)p; (void)d; int on = gtk_switch_get_active(GTK_SWITCH(o));
if (on != atomic_load(&host_active)) { atomic_store(&host_active, on); push(on ? "host\ton" : "host\toff"); }
}
static void on_language(GtkComboBox *c, gpointer d) {
(void)d; int english = gtk_combo_box_get_active(c) == 1;
if (english == uu_i18n_english()) return;
if (!uu_i18n_save(english)) show_toast(L("无法保存语言设置", "Could not save the language"));
else push("relaunch");
}
static void confirm_logout(void);
static void on_sign_out(GtkButton *b, gpointer d) { (void)b; (void)d; if (logged_in) confirm_logout(); }
static void open_settings(void) { static void open_settings(void) {
if (settings_window) { gtk_window_present(GTK_WINDOW(settings_window)); return; } if (settings_window) { refresh_account(); gtk_window_present(GTK_WINDOW(settings_window)); return; }
settings_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); settings_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(settings_window), "设置"); gtk_window_set_title(GTK_WINDOW(settings_window), L("设置", "Settings"));
gtk_window_set_transient_for(GTK_WINDOW(settings_window), GTK_WINDOW(window)); gtk_window_set_transient_for(GTK_WINDOW(settings_window), GTK_WINDOW(window));
gtk_window_set_default_size(GTK_WINDOW(settings_window), 680, 600); gtk_window_set_default_size(GTK_WINDOW(settings_window), 680, 600);
g_signal_connect(settings_window, "delete-event", G_CALLBACK(settings_hidden), NULL); g_signal_connect(settings_window, "delete-event", G_CALLBACK(settings_hidden), NULL);
g_signal_connect(settings_window, "key-press-event", G_CALLBACK(settings_key), NULL); g_signal_connect(settings_window, "key-press-event", G_CALLBACK(settings_key), NULL);
own_titlebar(settings_window, "设置"); own_titlebar(settings_window, L("设置", "Settings"));
GtkWidget *root = vbox(0), *tabs = gtk_stack_new(), *switcher = gtk_stack_switcher_new(); GtkWidget *root = vbox(0), *tabs = gtk_stack_new(), *switcher = gtk_stack_switcher_new();
gtk_stack_switcher_set_stack(GTK_STACK_SWITCHER(switcher), GTK_STACK(tabs)); gtk_stack_switcher_set_stack(GTK_STACK_SWITCHER(switcher), GTK_STACK(tabs));
gtk_widget_set_halign(switcher, GTK_ALIGN_CENTER); gtk_widget_set_margin_top(switcher, 10); gtk_widget_set_margin_bottom(switcher, 6); gtk_widget_set_halign(switcher, GTK_ALIGN_CENTER); gtk_widget_set_margin_top(switcher, 10); gtk_widget_set_margin_bottom(switcher, 6);
@@ -504,60 +564,77 @@ static void open_settings(void) {
gtk_box_pack_start(GTK_BOX(root), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(root), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), FALSE, FALSE, 0);
// 常规 // 常规
GtkWidget *general = settings_page(); GtkWidget *general = settings_page();
const char *wake[] = {"永不", "接通电源时", "始终"}, *close_opts[] = {"最小化", "退出程序"}; GtkWidget *acct = hbox(12), *acct_text = vbox(2);
GtkWidget *g1[] = { setting_row("开机自启动", NULL, gtk_switch_new()), gtk_box_pack_start(GTK_BOX(acct_text), label(L("账号", "Account"), "devname"), FALSE, FALSE, 0);
setting_row("保持唤醒状态", "防止电脑进入睡眠状态,导致无法远程访问。", combo(wake, 3)), account_who = label("", "hint"); gtk_box_pack_start(GTK_BOX(acct_text), account_who, FALSE, FALSE, 0);
setting_row("关闭窗口时", NULL, combo(close_opts, 2)) }; gtk_box_pack_start(GTK_BOX(acct), acct_text, TRUE, TRUE, 0);
account_out = button(L("退出登录", "Sign out"), "secondary"); gtk_widget_set_valign(account_out, GTK_ALIGN_CENTER);
g_signal_connect(account_out, "clicked", G_CALLBACK(on_sign_out), NULL); gtk_box_pack_end(GTK_BOX(acct), account_out, FALSE, FALSE, 0);
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)),
setting_row(L("关闭窗口时", "When closing the window"), NULL, combo(close_opts, 2)) };
gtk_box_pack_start(GTK_BOX(general), settings_card(g1, 3), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(general), settings_card(g1, 3), FALSE, FALSE, 0);
GtkWidget *path = hbox(8); GtkWidget *change = button("修改路径", "secondary"), *open = button("打开文件夹", "secondary"); GtkWidget *path = hbox(8); GtkWidget *change = button(L("修改路径", "Change path"), "secondary"), *open = button(L("打开文件夹", "Open folder"), "secondary");
g_signal_connect(change, "clicked", G_CALLBACK(unsupported), "修改路径"); g_signal_connect(open, "clicked", G_CALLBACK(unsupported), "打开文件夹"); g_signal_connect(change, "clicked", G_CALLBACK(unsupported), L("修改路径", "Change path")); g_signal_connect(open, "clicked", G_CALLBACK(unsupported), L("打开文件夹", "Open folder"));
gtk_box_pack_end(GTK_BOX(path), open, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(path), change, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(path), open, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(path), change, FALSE, FALSE, 0);
GtkWidget *g2[] = { setting_row("传输文件存储路径", "~/Downloads", path) }; GtkWidget *g2[] = { setting_row(L("传输文件存储路径", "Received files folder"), "~/Downloads", path) };
gtk_box_pack_start(GTK_BOX(general), settings_card(g2, 1), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(general), settings_card(g2, 1), FALSE, FALSE, 0);
GtkWidget *real = button("在手机 App 中查看", "secondary"); gtk_widget_set_sensitive(real, FALSE); GtkWidget *real = button(L("在手机 App 中查看", "View in the mobile app"), "secondary"); gtk_widget_set_sensitive(real, FALSE);
GtkWidget *g3[] = { setting_row("实名认证", NULL, real) }; GtkWidget *g3[] = { setting_row(L("实名认证", "Identity verification"), NULL, real) };
gtk_box_pack_start(GTK_BOX(general), settings_card(g3, 1), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(general), settings_card(g3, 1), FALSE, FALSE, 0);
gtk_stack_add_titled(GTK_STACK(tabs), general, "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(); GtkWidget *security = settings_page();
const char *verify[] = {"仅使用临时验证码", "仅使用自定义验证码", "临时与自定义验证码"}; const char *verify[] = {L("仅使用临时验证码", "Temporary code only"), L("仅使用自定义验证码", "Custom code only"), L("临时与自定义验证码", "Temporary and custom codes")};
GtkWidget *s1[] = { setting_row("允许同账号控制本设备", NULL, gtk_switch_new()), setting_row("允许他人远程协助", NULL, gtk_switch_new()) }; host_switch = gtk_switch_new(); gtk_switch_set_active(GTK_SWITCH(host_switch), atomic_load(&host_active));
GtkWidget *s2[] = { setting_row("远程协助连接本设备的验证方式", NULL, combo(verify, 3)) }; g_signal_connect(host_switch, "notify::active", G_CALLBACK(on_host), NULL);
GtkWidget *s3[] = { setting_row("客户端锁定", "防止客户端设置被修改,保障数据与使用安全。", gtk_switch_new()) }; GtkWidget *s1[] = { setting_row(L("允许同账号控制本设备", "Allow the same account to control this device"), L("默认关闭。开启后本机会出现在你的设备列表中,可被远程控制(uuremote-server 用户服务)", "Off by default. When on, this computer appears in your device list and can be controlled (uuremote-server user service)"), host_switch), setting_row(L("允许他人远程协助", "Allow remote assistance"), NULL, gtk_switch_new()) };
GtkWidget *s2[] = { setting_row(L("远程协助连接本设备的验证方式", "Verification for remote assistance"), NULL, combo(verify, 3)) };
GtkWidget *s3[] = { setting_row(L("客户端锁定", "Lock client"), L("防止客户端设置被修改,保障数据与使用安全。", "Prevents client settings from being changed, keeping data and usage safe."), gtk_switch_new()) };
gtk_box_pack_start(GTK_BOX(security), settings_card(s1, 2), FALSE, FALSE, 0); 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(s2, 1), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(security), settings_card(s3, 1), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(security), settings_card(s3, 1), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(security), label("本机被控相关设置由 uuremote-server 主机端提供。", "hint"), FALSE, FALSE, 0); gtk_stack_add_titled(GTK_STACK(tabs), security, "security", L("安全", "Security"));
gtk_stack_add_titled(GTK_STACK(tabs), security, "security", "🔒 安全");
// 键盘 // 键盘
GtkWidget *keys = settings_page(); GtkWidget *keys = settings_page();
gtk_box_pack_start(GTK_BOX(keys), label("仅控制端响应的快捷键", "h2"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(keys), label(L("仅控制端响应的快捷键", "Viewer-only shortcuts"), "h2"), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(keys), label("远控时按下以下快捷键,仅在控制端本地响应,不会发送到被控端。", "hint"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(keys), label(L("远控时按下以下快捷键,仅在控制端本地响应,不会发送到被控端。", "These shortcuts are handled locally on the viewer and are not sent to the remote device."), "hint"), FALSE, FALSE, 0);
GtkWidget *addk = button("添加控制端快捷键", "secondary"); g_signal_connect(addk, "clicked", G_CALLBACK(unsupported), "添加快捷键"); GtkWidget *addk = button(L("添加控制端快捷键", "Add viewer shortcut"), "secondary"); g_signal_connect(addk, "clicked", G_CALLBACK(unsupported), L("添加快捷键", "Add shortcut"));
GtkWidget *k1[] = { setting_row("当前暂无设置", NULL, NULL), setting_row("", NULL, addk) }; GtkWidget *k1[] = { setting_row(L("当前暂无设置", "Nothing set yet"), NULL, NULL), setting_row("", NULL, addk) };
gtk_box_pack_start(GTK_BOX(keys), settings_card(k1, 2), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(keys), settings_card(k1, 2), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(keys), label("功能快捷键", "h2"), FALSE, FALSE, 6); gtk_box_pack_start(GTK_BOX(keys), label(L("功能快捷键", "Function shortcuts"), "h2"), FALSE, FALSE, 6);
gtk_box_pack_start(GTK_BOX(keys), label("按下以下快捷键时,仅在本地触发对应功能,不会发送到被控端。", "hint"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(keys), label(L("按下以下快捷键时,仅在本地触发对应功能,不会发送到被控端。", "These shortcuts trigger local functions only and are not sent to the remote device."), "hint"), FALSE, FALSE, 0);
const char *fns[] = {"使用被控端鼠标/解锁鼠标", "被控时解除防窥模式", "切换上一个屏幕", "切换下一个屏幕", "显示/隐藏悬浮球", "静音/取消静音", "老板键(隐藏/显示所有客户端窗口)", "发送 Ctrl+Alt+Delete 组合键"}; const char *fns[] = {L("使用被控端鼠标/解锁鼠标", "Use remote mouse / release mouse"), L("被控时解除防窥模式", "Turn off privacy screen while controlled"), L("切换上一个屏幕", "Previous screen"), L("切换下一个屏幕", "Next screen"), L("显示/隐藏悬浮球", "Show/hide floating ball"), L("静音/取消静音", "Mute/unmute"), L("老板键(隐藏/显示所有客户端窗口)", "Boss key (hide/show all client windows)"), L("发送 Ctrl+Alt+Delete 组合键", "Send Ctrl+Alt+Delete")};
GtkWidget *k2[8]; GtkWidget *k2[8];
for (int i = 0; i < 8; i++) k2[i] = setting_row(fns[i], NULL, edit_button(fns[i])); 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); 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); GtkWidget *kscroll = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(kscroll), keys);
gtk_stack_add_titled(GTK_STACK(tabs), kscroll, "keys", "⌨ 键盘"); gtk_stack_add_titled(GTK_STACK(tabs), kscroll, "keys", L("键盘", "Keyboard"));
// 网络 // 网络
GtkWidget *network = settings_page(); GtkWidget *network = settings_page();
const char *proxy[] = {"使用系统环境代理", "不使用代理"}; const char *proxy[] = {L("使用系统环境代理", "Use system proxy"), L("不使用代理", "No proxy")};
GtkWidget *n1[] = { setting_row("代理设置", NULL, combo(proxy, 2)) }; 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_box_pack_start(GTK_BOX(network), settings_card(n1, 1), FALSE, FALSE, 0);
gtk_stack_add_titled(GTK_STACK(tabs), network, "network", "🌐 网络"); gtk_stack_add_titled(GTK_STACK(tabs), network, "network", L("网络", "Network"));
gtk_box_pack_start(GTK_BOX(root), tabs, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(root), tabs, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(settings_window), root); gtk_container_add(GTK_CONTAINER(settings_window), root);
gtk_widget_show_all(settings_window); gtk_widget_show_all(settings_window);
} }
static void confirm_logout(void) { static void confirm_logout(void) {
GtkWidget *d = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, "确定要退出登录吗?"); GtkWidget *d = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, L("确定要退出登录吗?", "Sign out?"));
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(d), "退出登录会中断正在进行中的连接,你的设备也将从本账户删除。请谨慎操作!"); gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(d), L("退出登录会中断正在进行中的连接,你的设备也将从本账户删除。请谨慎操作!", "Signing out ends active connections and removes your device from this account. Be careful!"));
gtk_dialog_add_buttons(GTK_DIALOG(d), "取消", GTK_RESPONSE_CANCEL, "确认", GTK_RESPONSE_OK, NULL); gtk_dialog_add_buttons(GTK_DIALOG(d), L("取消", "Cancel"), GTK_RESPONSE_CANCEL, L("确认", "Confirm"), GTK_RESPONSE_OK, NULL);
if (gtk_dialog_run(GTK_DIALOG(d)) == GTK_RESPONSE_OK) push("logout"); if (gtk_dialog_run(GTK_DIALOG(d)) == GTK_RESPONSE_OK) push("logout");
gtk_widget_destroy(d); gtk_widget_destroy(d);
} }
@@ -571,15 +648,15 @@ static void on_menu(GtkMenuItem *item, gpointer what) {
static void popup(GtkButton *b, gpointer kind) { static void popup(GtkButton *b, gpointer kind) {
GtkWidget *menu = gtk_menu_new(); GtkWidget *menu = gtk_menu_new();
if (!strcmp(kind, "account")) { if (!strcmp(kind, "account")) {
GtkWidget *who = gtk_menu_item_new_with_label(logged_in ? (user_text[0] ? user_text : "已登录") : "未登录"); gtk_widget_set_sensitive(who, FALSE); GtkWidget *who = gtk_menu_item_new_with_label(logged_in ? (user_text[0] ? user_text : L("已登录", "Signed in")) : L("未登录", "Not signed in")); gtk_widget_set_sensitive(who, FALSE);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), who); gtk_menu_shell_append(GTK_MENU_SHELL(menu), who);
GtkWidget *out = gtk_menu_item_new_with_label("退出登录"); g_signal_connect(out, "activate", G_CALLBACK(on_menu), "logout"); GtkWidget *out = gtk_menu_item_new_with_label(L("退出登录", "Sign out")); g_signal_connect(out, "activate", G_CALLBACK(on_menu), "logout");
gtk_widget_set_sensitive(out, logged_in); gtk_menu_shell_append(GTK_MENU_SHELL(menu), out); gtk_widget_set_sensitive(out, logged_in); gtk_menu_shell_append(GTK_MENU_SHELL(menu), out);
} else if (!strcmp(kind, "notice")) { } else if (!strcmp(kind, "notice")) {
GtkWidget *none = gtk_menu_item_new_with_label("暂无通知"); gtk_widget_set_sensitive(none, FALSE); GtkWidget *none = gtk_menu_item_new_with_label(L("暂无通知", "No notifications")); gtk_widget_set_sensitive(none, FALSE);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), none); gtk_menu_shell_append(GTK_MENU_SHELL(menu), none);
} else { } else {
const char *labels[] = {"刷新设备列表", "设置", "退出程序"}, *whats[] = {"refresh", "settings", "quit"}; const char *labels[] = {L("刷新设备列表", "Refresh device list"), L("设置", "Settings"), L("退出程序", "Quit")}, *whats[] = {"refresh", "settings", "quit"};
for (int i = 0; i < 3; i++) { GtkWidget *it = gtk_menu_item_new_with_label(labels[i]); g_signal_connect(it, "activate", G_CALLBACK(on_menu), (gpointer)whats[i]); gtk_menu_shell_append(GTK_MENU_SHELL(menu), it); } for (int i = 0; i < 3; i++) { GtkWidget *it = gtk_menu_item_new_with_label(labels[i]); g_signal_connect(it, "activate", G_CALLBACK(on_menu), (gpointer)whats[i]); gtk_menu_shell_append(GTK_MENU_SHELL(menu), it); }
} }
gtk_widget_show_all(menu); gtk_widget_show_all(menu);
@@ -591,34 +668,34 @@ static void *run(void *arg) {
(void)arg; (void)arg;
int ok = gtk_init_check(NULL, NULL); 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) 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) { if (ok) {
GtkCssProvider *css = gtk_css_provider_new(); uu_theme_init();
gtk_css_provider_load_from_data(css, CSS, -1, NULL); uu_theme_load_css(CSS);
gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), GTK_STYLE_PROVIDER(css), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL); window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "UU 远程 Linux 控制端(非官方)"); 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); gtk_window_set_default_size(GTK_WINDOW(window), 1180, 780);
g_signal_connect(window, "delete-event", G_CALLBACK(on_delete), NULL); g_signal_connect(window, "delete-event", G_CALLBACK(on_delete), NULL);
own_titlebar(window, "UU 远程 Linux 控制端(非官方)"); own_titlebar(window, L("UU 远程 Linux 控制端(非官方)", "UU Remote Linux viewer (unofficial)"));
GtkWidget *root = hbox(0); GtkWidget *root = hbox(0);
// Sidebar // Sidebar
GtkWidget *side = vbox(0); add_class(side, "sidebar"); gtk_widget_set_size_request(side, 270, -1); GtkWidget *side = vbox(0); add_class(side, "sidebar"); gtk_widget_set_size_request(side, 270, -1);
my_section = vbox(0); 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); 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("⧉ 我的设备", "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); 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); 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); 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 *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 *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 *welcome_nav = gtk_list_box_new(); g_signal_connect(welcome_nav, "row-activated", G_CALLBACK(on_row), NULL);
GtkWidget *ah = label("⧉ 远程协助", "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); 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); 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("◧", "开始协助", "assist"), -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("★", "收藏设备", "favorite"), -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_box_pack_start(GTK_BOX(side_inner), assist, FALSE, FALSE, 0);
gtk_list_box_unselect_all(GTK_LIST_BOX(assist)); gtk_list_box_unselect_all(GTK_LIST_BOX(assist));
(void)welcome_nav; (void)welcome_nav;
@@ -628,13 +705,14 @@ static void *run(void *arg) {
// Main area // Main area
GtkWidget *main = vbox(0), *header = hbox(10); add_class(header, "header"); GtkWidget *main = vbox(0), *header = hbox(10); add_class(header, "header");
badge = gtk_label_new(""); add_class(badge, "badge"); badge = gtk_label_new(""); add_class(badge, "badge");
title_label = label("全部设备", "title"); 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), badge, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(header), title_label, 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); gtk_box_pack_start(GTK_BOX(header), more_button, FALSE, FALSE, 0);
const char *icons[] = {"☰", "◉", "🔔"}, *kinds[] = {"menu", "account", "notice"}; const char *icons[] = {"open-menu-symbolic", "avatar-default-symbolic", "preferences-system-notifications-symbolic"}, *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 *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); gtk_box_pack_start(GTK_BOX(main), header, FALSE, FALSE, 0);
GtkWidget *overlay = gtk_overlay_new(); GtkWidget *overlay = gtk_overlay_new();
stack = gtk_stack_new(); stack = gtk_stack_new();
@@ -676,12 +754,13 @@ void uu_viewer_ui_set_devices(const char *tsv) {
device_count = 0; device_count = 0;
char *copy = strdup(tsv ? tsv : ""), *save = NULL; char *copy = strdup(tsv ? tsv : ""), *save = NULL;
for (char *line = strtok_r(copy, "\n", &save); line && device_count < 64; line = strtok_r(NULL, "\n", &save)) { for (char *line = strtok_r(copy, "\n", &save); line && device_count < 64; line = strtok_r(NULL, "\n", &save)) {
char *f[5] = {0}, *s2 = NULL; int n = 0; char *f[6] = {0}, *s2 = NULL; int n = 0;
for (char *p = strtok_r(line, "\t", &s2); p && n < 5; p = strtok_r(NULL, "\t", &s2)) f[n++] = p; for (char *p = strtok_r(line, "\t", &s2); p && n < 6; p = strtok_r(NULL, "\t", &s2)) f[n++] = p;
if (n < 5) continue; if (n < 5) continue;
Device *d = &devices[device_count++]; Device *d = &devices[device_count++];
snprintf(d->id, sizeof d->id, "%s", f[0]); snprintf(d->name, sizeof d->name, "%s", f[1]); snprintf(d->id, sizeof d->id, "%s", f[0]); snprintf(d->name, sizeof d->name, "%s", f[1]);
d->platform = atoi(f[2]); d->online = atoi(f[3]); d->current = atoi(f[4]); d->platform = atoi(f[2]); d->online = atoi(f[3]); d->current = atoi(f[4]);
snprintf(d->thumb, sizeof d->thumb, "%s", n > 5 && f[5][0] == '/' ? f[5] : "");
} }
free(copy); free(copy);
selected = -1; selected = -1;
@@ -715,8 +794,8 @@ static int replace_result;
static gboolean confirm_replace(gpointer d) { static gboolean confirm_replace(gpointer d) {
(void)d; (void)d;
GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, "打开后将断开当前与该设备的连接,继续吗?"); GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, L("打开后将断开当前与该设备的连接,继续吗?", "Opening this disconnects your current connection to this device. Continue?"));
gtk_dialog_add_buttons(GTK_DIALOG(dialog), "取消", GTK_RESPONSE_CANCEL, "继续", GTK_RESPONSE_OK, NULL); gtk_dialog_add_buttons(GTK_DIALOG(dialog), L("取消", "Cancel"), GTK_RESPONSE_CANCEL, L("继续", "Continue"), GTK_RESPONSE_OK, NULL);
int accepted = gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK; int accepted = gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK;
gtk_widget_destroy(dialog); gtk_widget_destroy(dialog);
pthread_mutex_lock(&init_lock); replace_result = accepted; pthread_cond_signal(&init_cond); pthread_mutex_unlock(&init_lock); pthread_mutex_lock(&init_lock); replace_result = accepted; pthread_cond_signal(&init_cond); pthread_mutex_unlock(&init_lock);
+66 -51
View File
@@ -1,5 +1,6 @@
/* Native Hyprland/wlroots desktop bridge. Protocol XMLs retain upstream licenses. */ /* Native Hyprland/wlroots desktop bridge. Protocol XMLs retain upstream licenses. */
#define _GNU_SOURCE #define _GNU_SOURCE
#include "wayland_transform.h"
#include <wayland-client.h> #include <wayland-client.h>
#include <xkbcommon/xkbcommon.h> #include <xkbcommon/xkbcommon.h>
#include <pthread.h> #include <pthread.h>
@@ -60,7 +61,7 @@ static struct xkb_state *key_state;
static unsigned char held_keys[768]; static unsigned char held_keys[768];
/* Mobile input-method text (#13/#46). The protocol has no per-key remap request, but /* Mobile input-method text (#13/#46). The protocol has no per-key remap request, but
zwp_virtual_keyboard_v1_keymap may be re-sent at any time, so the pristine keymap text is kept zwp_virtual_keyboard_v1_keymap may be re-sent at any time, so the pristine keymap text is kept
and a spare keycode is pointed at one character's keysym at a time. Never logs the text. */ and printable codes on a separate text keyboard carry each batch. Never logs the text. */
#define UU_TEXT_SPARE 32 #define UU_TEXT_SPARE 32
static char *keymap_text; static char *keymap_text;
static size_t keymap_text_len, keymap_insert; static size_t keymap_text_len, keymap_insert;
@@ -158,35 +159,16 @@ static size_t symbols_close(const char *text) {
} }
return 0; return 0;
} }
/* Named keycodes the keymap gives no symbol to. Reading the compositor's own list is the only /* Reusable codes for the separate text-only keyboard. Remapping real printable keys on that device
portable way: pressing an unmapped keycode types nothing, and uu_wl_key never matches one keeps the physical-key map untouched and is the form Chromium accepts; the evdev "reserved" codes
because it searches by keysym. Highest first, since uu_wl_key takes the lowest match. */ that have no symbol are discarded by some clients. */
static unsigned find_spare_codes(xkb_keycode_t *out,unsigned limit) { static unsigned find_spare_codes(xkb_keycode_t *out,unsigned limit) {
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; unsigned count=0;
xkb_keycode_t min=xkb_keymap_min_keycode(keymap); for(unsigned i=0;i<sizeof(text_codes)/sizeof(text_codes[0]) && count<limit;i++)
for(xkb_keycode_t code=xkb_keymap_max_keycode(keymap);code>min && count<limit;code--) { if(xkb_keymap_key_get_name(keymap,text_codes[i])) out[count++]=text_codes[i];
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; 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 void press_keycode(xkb_keycode_t code) { static void press_keycode(xkb_keycode_t code) {
zwp_virtual_keyboard_v1_key(keyboard,timestamp(),code-8,WL_KEYBOARD_KEY_STATE_PRESSED); zwp_virtual_keyboard_v1_key(keyboard,timestamp(),code-8,WL_KEYBOARD_KEY_STATE_PRESSED);
zwp_virtual_keyboard_v1_key(keyboard,timestamp(),code-8,WL_KEYBOARD_KEY_STATE_RELEASED); zwp_virtual_keyboard_v1_key(keyboard,timestamp(),code-8,WL_KEYBOARD_KEY_STATE_RELEASED);
@@ -207,6 +189,11 @@ static void release_held_keys_locked(void) {
key_state and held_keys: pressed and released here. */ 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) { 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(); release_held_keys_locked();
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; if(rekey_keyboard()!=0) return -1;
size_t at=keymap_insert; size_t at=keymap_insert;
memcpy(buffer,keymap_text,at); memcpy(buffer,keymap_text,at);
@@ -217,13 +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); 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(upload_keymap(buffer,at+(keymap_text_len-keymap_insert))!=0) return -1;
zwp_virtual_keyboard_v1_modifiers(keyboard,0,0,0,0);
if(sync_display()!=0) return -1; if(sync_display()!=0) return -1;
usleep(8000);
for(unsigned i=0;i<count;i++) { press_keycode(codes[i]); (*typed)++; } for(unsigned i=0;i<count;i++) { press_keycode(codes[i]); (*typed)++; }
if(sync_display()!=0) return -1;
return 0; return 0;
} }
/* Type UTF-8 like xdotool type does on X11, but on Wayland: characters the session keymap already /* Type UTF-8 like xdotool type does on X11: each character is a Unicode keysym carried by the
has go out as ordinary keycodes, the rest share the spares of one keymap upload (~70 KB, so one text-only keyboard's printable codes, one keymap upload (~70 KB, so one batch per upload) in text
batch per upload), in text order. Never logs the text. */ order. Never logs the text. */
static int type_utf8_locked(const char *text) { static int type_utf8_locked(const char *text) {
size_t capacity=keymap_text_len+(size_t)UU_TEXT_SPARE*96+64; size_t capacity=keymap_text_len+(size_t)UU_TEXT_SPARE*96+64;
char *buffer=malloc(capacity); char *buffer=malloc(capacity);
@@ -245,16 +235,11 @@ static int type_utf8_locked(const char *text) {
if(cp=='\n') sym=0xff0d; /* Return */ if(cp=='\n') sym=0xff0d; /* Return */
else if(cp=='\t') sym=0xff09; /* Tab */ 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<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 */ /* Every character goes out as a Unicode keysym, including ASCII: a plain Latin-1 keysym
else sym=(xkb_keysym_t)(0x1000000|cp); /* Unicode keysym */ is what a running input method composes as pinyin, so "abc" would turn into candidates
xkb_keycode_t existing=existing_keycode(sym); instead of reaching the field. */
if(existing) { else sym=(xkb_keysym_t)(0x1000000|cp);
if(count && flush_batch(buffer,capacity,names,codes,count,&typed)!=0) { failed=1; break; } if(count==spare_count) {
count=0;
press_keycode(existing); typed++;
continue;
}
if(count==UU_TEXT_SPARE) {
if(flush_batch(buffer,capacity,names,codes,count,&typed)!=0) { failed=1; break; } if(flush_batch(buffer,capacity,names,codes,count,&typed)!=0) { failed=1; break; }
count=0; count=0;
} }
@@ -265,14 +250,26 @@ static int type_utf8_locked(const char *text) {
} }
if(!failed && count) failed=flush_batch(buffer,capacity,names,codes,count,&typed)!=0; if(!failed && count) failed=flush_batch(buffer,capacity,names,codes,count,&typed)!=0;
free(buffer); free(buffer);
/* Restore the pristine keymap whatever happened above, so uu_wl_key keeps its own symbol map. */
if(upload_keymap(keymap_text,keymap_text_len)!=0) return -1;
return failed && !typed?-1:typed; return failed && !typed?-1:typed;
} }
int uu_wl_type_utf8(const char *text) { int uu_wl_type_utf8(const char *text) {
pthread_mutex_lock(&lock); pthread_mutex_lock(&lock);
int typed=-1; int typed=-1;
if(initialized && text && keymap_text && keymap_insert && spare_count) typed=type_utf8_locked(text); if(initialized && text && keymap_text && keymap_insert && spare_count) {
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; if(typed>=0 && wl_display_flush(display)<0) typed=-1;
pthread_mutex_unlock(&lock); return typed; pthread_mutex_unlock(&lock); return typed;
} }
@@ -544,9 +541,9 @@ int uu_wl_init(int32_t *w,int32_t *h) {
for(selected=0;selected<output_count;selected++) if(!strcmp(outputs[selected].name,name)) break; for(selected=0;selected<output_count;selected++) if(!strcmp(outputs[selected].name,name)) break;
if(selected==output_count) goto end; if(selected==output_count) goto end;
} }
/* Rotated output coordinate mapping needs separate acceptance. */ if(!uu_output_transform_supported(outputs[selected].transform,getenv("NIRI_SOCKET")!=NULL)) goto end;
if(outputs[selected].transform!=WL_OUTPUT_TRANSFORM_NORMAL) goto end;
width=outputs[selected].width; height=outputs[selected].height; width=outputs[selected].width; height=outputs[selected].height;
if(outputs[selected].transform&1) {uint32_t t=width;width=height;height=t;}
if(!width || !height || width>16384 || height>16384 || (uint64_t)width*height*4>256*1024*1024) goto end; if(!width || !height || width>16384 || height>16384 || (uint64_t)width*height*4>256*1024*1024) goto end;
if(power_manager) { if(power_manager) {
power=zwlr_output_power_manager_v1_get_output_power(power_manager,outputs[selected].handle); power=zwlr_output_power_manager_v1_get_output_power(power_manager,outputs[selected].handle);
@@ -574,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 /* 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. */ only costs that path - uu_wl_type_utf8 refuses and the caller keeps its own fallback. */
keymap_insert=symbols_close(keymap_text); keymap_insert=symbols_close(keymap_text);
spare_count=find_spare_codes(spare_codes,sizeof(spare_codes)/sizeof(spare_codes[0])); spare_count=find_spare_codes(spare_codes,UU_TEXT_SPARE);
} }
initialized=1; *w=width; *h=height; result=0; initialized=1; *w=width; *h=height; result=0;
end: end:
@@ -588,8 +585,9 @@ int uu_wl_select_output(const char *name,uint32_t expected_w,uint32_t expected_h
if(!initialized || !name || sync_display()!=0) goto end; if(!initialized || !name || sync_display()!=0) goto end;
unsigned target; unsigned target;
for(target=0;target<output_count;target++) if(!strcmp(outputs[target].name,name)) break; for(target=0;target<output_count;target++) if(!strcmp(outputs[target].name,name)) break;
if(target==output_count || outputs[target].transform!=WL_OUTPUT_TRANSFORM_NORMAL) goto end; if(target==output_count || !uu_output_transform_supported(outputs[target].transform,getenv("NIRI_SOCKET")!=NULL)) goto end;
uint32_t w=outputs[target].width,h=outputs[target].height; uint32_t w=outputs[target].width,h=outputs[target].height;
if(outputs[target].transform&1) {uint32_t t=w;w=h;h=t;}
if(w!=expected_w || h!=expected_h || !w || !h || w>16384 || h>16384 || (uint64_t)w*h*4>256*1024*1024) goto end; if(w!=expected_w || h!=expected_h || !w || !h || w>16384 || h>16384 || (uint64_t)w*h*4>256*1024*1024) goto end;
struct zwlr_virtual_pointer_v1 *next=NULL; struct zwlr_virtual_pointer_v1 *next=NULL;
if(pointer_manager) { if(pointer_manager) {
@@ -640,7 +638,7 @@ retry:;
for(unsigned i=0;i<2;i++) { frame_clear(&frames[i]); dma_clear(&frames[i]); } for(unsigned i=0;i<2;i++) { frame_clear(&frames[i]); dma_clear(&frames[i]); }
pending=0; goto retry; pending=0; goto retry;
} }
if(frame->failed || !frame->pixels || frame->width!=width || frame->height!=height) goto end; if(frame->failed || !frame->pixels || frame->width!=outputs[selected].width || frame->height!=outputs[selected].height) goto end;
zwlr_screencopy_frame_v1_destroy(frame->handle); frame->handle=NULL; zwlr_screencopy_frame_v1_destroy(frame->handle); frame->handle=NULL;
const char *pipeline=getenv("UU_WAYLAND_PIPELINE"); const char *pipeline=getenv("UU_WAYLAND_PIPELINE");
if(!pipeline || strcmp(pipeline,"0")) { if(!pipeline || strcmp(pipeline,"0")) {
@@ -651,11 +649,22 @@ retry:;
} }
{ {
for(uint32_t y=0;y<height;y++) { for(uint32_t y=0;y<height;y++) {
uint32_t source=(frame->flags&ZWLR_SCREENCOPY_FRAME_V1_FLAGS_Y_INVERT)?height-y-1:y;
uint8_t *row=out+(size_t)y*width*4; uint8_t *row=out+(size_t)y*width*4;
memcpy(row,(uint8_t*)frame->pixels+(size_t)source*frame->stride,width*4); if(outputs[selected].transform==WL_OUTPUT_TRANSFORM_NORMAL &&
frame->format!=WL_SHM_FORMAT_XBGR8888 && frame->format!=WL_SHM_FORMAT_ABGR8888) {
uint32_t sy=(frame->flags&ZWLR_SCREENCOPY_FRAME_V1_FLAGS_Y_INVERT)?height-1-y:y;
memcpy(row,(uint8_t*)frame->pixels+(size_t)sy*frame->stride,width*4);
continue;
}
for(uint32_t x=0;x<width;x++) {
uint32_t sx=x,sy=y,sw=frame->width,sh=frame->height;
uu_source_pixel(outputs[selected].transform,sw,sh,x,y,&sx,&sy);
if(frame->flags&ZWLR_SCREENCOPY_FRAME_V1_FLAGS_Y_INVERT) sy=sh-1-sy;
const uint8_t *pixel=(uint8_t*)frame->pixels+(size_t)sy*frame->stride+sx*4;
memcpy(row+x*4,pixel,4);
if(frame->format==WL_SHM_FORMAT_XBGR8888 || frame->format==WL_SHM_FORMAT_ABGR8888) { if(frame->format==WL_SHM_FORMAT_XBGR8888 || frame->format==WL_SHM_FORMAT_ABGR8888) {
for(uint32_t x=0;x<width;x++) { uint8_t red=row[x*4]; row[x*4]=row[x*4+2]; row[x*4+2]=red; } row[x*4]=pixel[2];row[x*4+2]=pixel[0];
}
} }
} }
result=0; result=0;
@@ -675,7 +684,13 @@ int uu_wl_move(int32_t x,int32_t y,int relative) {
double scale=outputs[selected].scale; double scale=outputs[selected].scale;
zwlr_virtual_pointer_v1_motion(pointer,timestamp(),wl_fixed_from_double(x/scale),wl_fixed_from_double(y/scale)); zwlr_virtual_pointer_v1_motion(pointer,timestamp(),wl_fixed_from_double(x/scale),wl_fixed_from_double(y/scale));
} }
else if(x>=0 && y>=0 && x<(int32_t)width && y<(int32_t)height) zwlr_virtual_pointer_v1_motion_absolute(pointer,timestamp(),x,y,width,height); else if(x>=0 && y>=0 && x<(int32_t)width && y<(int32_t)height) {
uint32_t sx,sy,sw=outputs[selected].width,sh=outputs[selected].height;
/* niri/Smithay applies the output transform to absolute device coordinates. */
if(getenv("NIRI_SOCKET")) uu_source_pixel(outputs[selected].transform,sw,sh,x,y,&sx,&sy);
else {sx=x;sy=y;sw=width;sh=height;}
zwlr_virtual_pointer_v1_motion_absolute(pointer,timestamp(),sx,sy,sw,sh);
}
else goto end; else goto end;
zwlr_virtual_pointer_v1_frame(pointer); result=wl_display_flush(display)<0?-1:0; zwlr_virtual_pointer_v1_frame(pointer); result=wl_display_flush(display)<0?-1:0;
} }
+14
View File
@@ -0,0 +1,14 @@
#include <stdint.h>
/* Map upright output pixels to untransformed capture/device coordinates (Smithay Transform). */
static inline void uu_source_pixel(int transform,uint32_t w,uint32_t h,uint32_t x,uint32_t y,uint32_t *sx,uint32_t *sy) {
*sx=x;*sy=y;
switch(transform) {
case 1:*sx=y;*sy=h-1-x;break;
case 2:*sx=w-1-x;*sy=h-1-y;break;
case 3:*sx=w-1-y;*sy=x;break;
}
}
/* Rotated capture and pointer mapping have hardware acceptance only on niri. */
static inline int uu_output_transform_supported(int transform,int niri) {
return transform==0 || (niri && transform>=1 && transform<=3);
}
+53 -6
View File
@@ -56,6 +56,15 @@ static void track_injected_key(int keycode, int is_press) {
} }
} }
/* XShmAttach fails asynchronously (BadAccess when the X server cannot reach our segment, e.g. a
* server in another container); Xlib's default handler would exit the process before the XGetImage fallback. */
static volatile int g_shm_attach_failed = 0;
static int shm_attach_error(Display *display, XErrorEvent *event) {
(void)display; (void)event;
g_shm_attach_failed = 1;
return 0;
}
static void shm_open_image(void) { static void shm_open_image(void) {
g_use_shm = 0; g_use_shm = 0;
if (!XShmQueryExtension(g_display)) return; if (!XShmQueryExtension(g_display)) return;
@@ -66,9 +75,15 @@ static void shm_open_image(void) {
if (g_shminfo.shmid == -1) return; if (g_shminfo.shmid == -1) return;
g_shminfo.shmaddr = g_shm_image->data = (char *)shmat(g_shminfo.shmid, 0, 0); g_shminfo.shmaddr = g_shm_image->data = (char *)shmat(g_shminfo.shmid, 0, 0);
g_shminfo.readOnly = False; g_shminfo.readOnly = False;
if (g_shminfo.shmaddr != (char *)-1 && XShmAttach(g_display, &g_shminfo)) { if (g_shminfo.shmaddr != (char *)-1) {
XSync(g_display, False); XSync(g_display, False);
g_use_shm = 1; g_shm_attach_failed = 0;
int (*previous)(Display *, XErrorEvent *) = XSetErrorHandler(shm_attach_error);
Status attached = XShmAttach(g_display, &g_shminfo);
XSync(g_display, False);
XSetErrorHandler(previous);
if (attached && !g_shm_attach_failed) g_use_shm = 1;
else fprintf(stderr, "X11 shared-memory capture unavailable; using XGetImage\n");
} }
shmctl(g_shminfo.shmid, IPC_RMID, 0); // 标记删除,进程退出时自动回收;失败时也不遗留段 shmctl(g_shminfo.shmid, IPC_RMID, 0); // 标记删除,进程退出时自动回收;失败时也不遗留段
} }
@@ -316,12 +331,30 @@ static int class_is_terminal(const char *value) {
return 0; 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) { 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; if (!g_probe && !(g_probe = XOpenDisplay(NULL))) return 0;
Window focus = 0; int revert = 0; Window focus = 0; int revert = 0;
XGetInputFocus(g_probe, &focus, &revert); 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; Window cur = focus;
for (int depth = 0; depth < 12 && cur; depth++) { for (int depth = 0; depth < 12 && cur; depth++) {
XClassHint hint = {0}; XClassHint hint = {0};
@@ -329,14 +362,28 @@ int x11_terminal_shortcut_state(void) {
int terminal = class_is_terminal(hint.res_name) || class_is_terminal(hint.res_class); 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_name) XFree(hint.res_name);
if (hint.res_class) XFree(hint.res_class); if (hint.res_class) XFree(hint.res_class);
cached_window = focus;
cached_terminal = terminal;
last_query = now;
return terminal; return terminal;
} }
Window root, parent, *children = NULL; unsigned int n = 0; 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 (children) XFree(children);
if (parent == root) return 0; if (parent == root) {
cached_window = 0;
cached_terminal = 0;
return 0;
}
cur = parent; cur = parent;
} }
cached_window = focus;
cached_terminal = 0;
last_query = now;
return 0; return 0;
} }
+90
View File
@@ -0,0 +1,90 @@
#!/usr/bin/env python3
"""Run the opt-in microphone sink-loss regression on a private PulseAudio daemon.
No hardware modules or default configuration are loaded. The Rust test generates
audio in memory and observes only its own null sinks. Requires pactl and parec.
在独立 PulseAudio 服务中运行麦克风回归;仅使用空设备及内存生成音,需要 pactl、parec。
"""
import argparse
import os
from pathlib import Path
import shutil
import subprocess
import sys
import tempfile
import time
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--daemon", default=shutil.which("pulseaudio"), help="PulseAudio 可执行文件 / PulseAudio executable")
parser.add_argument("--module-dir", help="解压包的模块目录 / module directory for an unpacked package")
parser.add_argument("--test-binary", help="已有 Cargo 测试程序;默认构建 / existing Cargo test executable; otherwise build")
parser.add_argument("--smoke", action="store_true", help="验证生成音传输 / check generated audio delivery instead of target loss")
args = parser.parse_args()
if not args.daemon:
parser.error("请用 --daemon 指定 PulseAudio,无需系统服务 / provide --daemon; no system service is needed")
repo = Path(__file__).resolve().parent.parent
with tempfile.TemporaryDirectory(prefix="uu-microphone-test-") as temp:
private = Path(temp)
for name in ["runtime", "state", "config", "cache"]:
(private / name).mkdir(mode=0o700)
cookie = private / "cookie"
cookie.write_bytes(os.urandom(256))
socket = private / "runtime/native"
env = os.environ.copy()
env.update(
XDG_RUNTIME_DIR=str(private / "runtime"), XDG_CONFIG_HOME=str(private / "config"),
XDG_STATE_HOME=str(private / "state"), XDG_CACHE_HOME=str(private / "cache"),
PULSE_RUNTIME_PATH=str(private / "runtime"), PULSE_STATE_PATH=str(private / "state"),
PULSE_COOKIE=str(cookie), PULSE_SERVER="unix:" + str(socket), UU_MICROPHONE_ISOLATED_TEST="1",
UU_MICROPHONE="1",
)
command = [args.daemon, "-n", "--daemonize=no", "--use-pid-file=no", "--exit-idle-time=-1",
"--disable-shm=yes", "--realtime=no", "--high-priority=no",
"--load=module-native-protocol-unix socket=" + str(socket)
+ " auth-anonymous=1 auth-cookie=" + str(cookie)]
if args.module_dir:
command.append("--dl-search-path=" + args.module_dir)
with (private / "daemon.log").open("w") as log:
daemon = subprocess.Popen(command, env=env, stdout=log, stderr=log)
try:
for _ in range(100):
if daemon.poll() is not None:
raise RuntimeError("独立服务启动失败 / isolated server failed:\n" + (private / "daemon.log").read_text()[-2000:])
if socket.exists() and subprocess.run(
["pactl", "--server=" + env["PULSE_SERVER"], "info"], env=env,
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
).returncode == 0:
break
time.sleep(0.03)
else:
raise RuntimeError("独立 PulseAudio 未就绪 / isolated PulseAudio did not become ready")
test = "microphone::tests::pulse_target_loss_never_routes_to_default_output"
if args.smoke:
test = "microphone::tests::pipewire_virtual_microphone_receives_generated_tone"
if args.test_binary:
command = [str(Path(args.test_binary).resolve()), test, "--ignored", "--exact"]
else:
command = ["cargo", "test", "--locked", "--bin", "uuremote-server", test,
"--", "--ignored", "--exact"]
listing = subprocess.run(command + ["--list", "--color=never"], cwd=repo, env=env,
capture_output=True, text=True)
if listing.returncode:
print(listing.stderr, file=sys.stderr)
return listing.returncode
if f"{test}: test" not in listing.stdout.splitlines():
parser.error("目标测试不存在,拒绝零项成功 / requested test is absent; refusing a zero-test success")
return subprocess.run(command, cwd=repo, env=env).returncode
finally:
if daemon.poll() is None:
daemon.terminate()
try:
daemon.wait(timeout=3)
except subprocess.TimeoutExpired:
daemon.kill()
daemon.wait()
if __name__ == "__main__":
raise SystemExit(main())
+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

+177
View File
@@ -0,0 +1,177 @@
# 实验性防窥 / 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.
- 壁纸模式下新出现的窗口也会被送到虚拟输出:KWin 按它认为"当前活动"的屏幕放置新窗口,而那块
屏幕可能是遮罩下的物理屏,远端就看不到。主机在防窥期间保持加载一个 KWin 脚本,新窗口和换了
屏幕的窗口都会被送回虚拟输出,恢复时卸载。
In wallpaper mode, windows that appear later are also sent to the virtual output: KWin places a
new window on the screen it considers active, which may be one under the cover, where the viewer
cannot see it. The host keeps a KWin script loaded for the privacy session that sends new windows
and windows that changed screen back to the virtual output, and unloads it on restore.
- KDE 不处理虚拟输出共享上的 portal 输入,防窥期间指针、按键和文字改走 uinput(需要 `/dev/uinput`
权限,见 README);手机拖动手势在此期间按普通鼠标拖动处理。
KDE ignores portal input on a virtual-output share, so pointer, keys and text use uinput while the
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.
- iOS 控制端选“关闭显示器”发 `enable=0, privacy_type=3`:iOS 的 `enable` 是图片模式开关,关屏意图由 `type=3` 表达;iOS“不启用”发 `enable=0, privacy_type=1`。主机只对 iOS 控制端把 `0/3` 归一化为开屏保关屏(日志 `iOS screen-off encoding normalized`),其他控制端(包括已验收的 Android 4.43.0)保持字段 1 的语义。
The iOS viewer sends `enable=0, privacy_type=3` for "turn off the display": its `enable` is the picture-mode switch and `type=3` carries the intent; iOS "off" is `enable=0, privacy_type=1`. The host normalizes `0/3` to screen-off for iOS controllers only (log: `iOS screen-off encoding normalized`); other controllers, including the verified Android 4.43.0, keep the field-1 semantics.
- Windows 控制端每个 RPC 7 都带 `enable=0`,意图全在 `type`:`0/0` 关闭、`0/2` 屏保、`0/3` 关屏。其中 `0/0` 和 `0/2` 已在 Windows 客户端上实测;主机只对 `controller_platform=1` 做这层归一化(日志 `Windows encoding normalized`),Android 和 macOS 保持字段 1 的语义。
The Windows viewer sends every RPC 7 with `enable=0` and carries the intent in `type`: `0/0` off, `0/2` picture, `0/3` screen off. `0/0` and `0/2` were verified live on the Windows client. The host normalizes this for `controller_platform=1` only (log: `Windows encoding normalized`); Android and macOS keep the field-1 semantics.
- RPC 25 `update_screen_saver_req` → RpcResponse 21:开启隐私模式前发送,主机回空成功应答,画面仍用本机壁纸。
Sent before picture mode; answered empty (success), the host keeps its own wallpaper.
- FeatureFlag 4 `ff_private_screen` = 2 (ENHANCED_PRIVACY);SettingMetric 4 `private_screen`、7 `private_screen_type`
上报当前实际模式(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`.
+15
View File
@@ -0,0 +1,15 @@
修复网络波动后信令重连卡住,以及 Linux 控制端在平铺窗口管理器下画面空白。/ Fixes signaling reconnect stalling after a network hiccup, and the Linux viewer showing a blank window under tiling compositors.
### 修复 / Fixed
- **网络异常后停在 Acquired room signaling credentials(#115,感谢 @Changxi-M)**:信令 WebSocket 握手没有超时,网络半断时会无限等待,重连不再重试。现在握手限时 20 秒,超时后按原有退避重试。
The signaling WebSocket handshake is now bounded to 20 s, so a stalled handshake falls back to the normal reconnect retry instead of hanging forever.
- **控制端窗口平铺后画面空白(#118,感谢 @shao-zhijie)**:Linux 控制端只在收到新解码帧时绘制,合成器调整窗口尺寸后静止画面不会重绘;在尚未收到首帧时,Wayland 也不会映射没有提交缓冲的窗口。现在窗口尺寸变化/重新显示时用最后一帧重绘,无帧时先画黑底。
The Linux viewer now repaints the last frame after a compositor resize/expose, and paints a black frame before the first decoded frame so Wayland maps the window.
### 验证范围 / Validation
单元测试与 CI;#115、#118 的场景尚未实机复现,欢迎反馈。
### 下载 / Download
`uu-remote-linux_0.2.34_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.34-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.34`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+21
View File
@@ -0,0 +1,21 @@
信令可走 HTTP 代理、二维码登录错误分类、重复主机实例诊断,以及 Wayland 手机端文字输入兜底。/ Signaling through an opt-in HTTP proxy, clearer QR login errors, duplicate-host diagnostics, and a Wayland fallback for mobile text input.
### 新增 / Added
- **信令遵循 `UU_USE_PROXY=1`(#123)**:主机和 Linux 控制端的 WebSocket 信令改用与 REST 接口相同的 HTTP 客户端,开启 `UU_USE_PROXY=1` 后也走环境里的 HTTP/HTTPS 代理(不支持 SOCKS;选中的代理失败不会改为直连;不跟随重定向)。不代理 ICE/WebRTC 媒体。默认(不开代理)行为不变。
Host and viewer signaling now use the same HTTP client as the REST API, so `UU_USE_PROXY=1` applies to signaling too (HTTP/HTTPS proxies only, no direct fallback, no redirects). Media is not proxied; the default is unchanged.
- **Wayland/Portal 手机端文字输入兜底(#119,感谢 @shofukantkts)**:没有空闲键码的合成器和 Portal 后端上,手机端输入的文字经剪贴板 + Shift+Insert 粘贴;`UU_WAYLAND_TEXT=0` 可关闭。
Mobile text input on Portal and compositors without spare keycodes is pasted via the clipboard and Shift+Insert; `UU_WAYLAND_TEXT=0` disables it.
### 修复 / Fixed
- **二维码登录错误分类(#121)**:状态查询失败不再一律提示「网络超时」,区分超时、连接失败、响应异常与二维码过期;诊断只含阶段、类别、耗时和状态码,不输出票据、URL 或服务器内容。
QR polling failures are no longer all reported as a network timeout; timeouts, connection failures, bad responses and expiry are distinguished, with diagnostics that never include tickets, URLs or server content.
- **重复主机实例(#122)**:同一身份的两个主机实例(拷贝了 `config.json`,或残留的旧手动实例)会互相把对方踢出房间,表现为控制端一连就断。`doctor` 现在能数到重新执行后进程名为 `exe` 的实例并给出提示;README 说明不要在机器之间拷贝 `config.json`;日志会记录无 peer id 的 leave 事件结构(仅键名/类型/长度)。
Two host instances sharing one identity kick each other out of the room. `doctor` now counts re-executed instances and warns about extras, the README explains not to copy `config.json` between machines, and leave events without a peer id log their shape (keys/types/lengths only).
### 验证范围 / Validation
单元测试与 CI。#123 在真实 Linux X11 主机上实测不开代理时信令与 iPhone 桌面连接正常;经真实代理的信令尚未实测。#122 的修复在报告环境实机验证。
### 下载 / Download
`uu-remote-linux_0.2.35_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.35-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.35`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+15
View File
@@ -0,0 +1,15 @@
修复 X11 共享内存被拒时主机直接退出,以及 Linux 控制端加入已有会话时可能永久黑屏。/ Fixes the host exiting when X11 refuses shared memory, and a possible black screen when the Linux viewer joins a host that already streams to another session.
### 修复 / Fixed
- **X11 MIT-SHM 被拒时直接退出**:X 服务器无法访问本程序的共享内存段时(例如 X 服务器在另一个容器里),`XShmAttach` 返回 BadAccess,Xlib 默认错误处理直接结束了进程,原有的 `XGetImage` 退路没有机会执行。现在捕获该错误并改用 `XGetImage` 抓屏。
When `XShmAttach` is refused (BadAccess, e.g. an X server in another container), the host now falls back to `XGetImage` instead of being terminated by Xlib's default error handler.
- **控制端加入已有会话时黑屏(#124,感谢 @shao-zhijie)**:Linux 控制端过去只在丢包或解码出错时请求关键帧;加入一条已在推流的干净 H.264 流时永远等不到 IDR。现在首帧显示前每 30 个访问单元请求一次关键帧(PLI),300 个仍无画面时日志给出提示。
The Linux viewer now requests key frames (PLI) every 30 access units until the first frame is shown, and logs a warning after 300.
### 验证范围 / Validation
单元测试与 CI。共享内存退路尚待在报告环境实机确认;#124 中官方 Mac 主机是否响应 PLI 尚未实测。
### 下载 / Download
`uu-remote-linux_0.2.36_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.36-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.36`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+13
View File
@@ -0,0 +1,13 @@
`UU_USE_PROXY=1` 时经 TCP/TLS(可走 HTTP 代理)连接 TURN 中继,供 UDP 到不了中继服务器的主机使用。/ With `UU_USE_PROXY=1`, TURN relays are also reached over TCP/TLS (optionally through the HTTP proxy) for hosts whose UDP cannot reach the relay servers.
### 新增 / Added
- **TURN over TCP/TLS**:云端在强制中继的会话里也会下发 `turns:<IP>:<端口>?transport=tcp`,原来使用的 webrtc-ice 只支持 UDP 中继,UDP 被限制、只能经 HTTP 代理出网的主机因此拿不到任何中继候选,控制端一直"正在尝试重连"。现在开启 `UU_USE_PROXY=1` 后,主机会经 `HTTPS_PROXY`/`ALL_PROXY` 中的无认证 `http://` 代理(没有则直连)建立 TCP/TLS 中继连接。TURN 证书按 CA 链校验,仅在云端下发的地址为 IP 时容忍名称不匹配;媒体仍由 DTLS-SRTP 端到端加密。未开启时只用 UDP 中继,行为不变(`vendor/webrtc-ice/PATCHES.md`)。
With `UU_USE_PROXY=1` the host also opens TURN relays over TCP/TLS through the unauthenticated `http://` proxy (or directly), chain-verifying certificates and tolerating a name mismatch only for IP TURN URLs. The default stays UDP-only.
### 验证范围 / Validation
单元测试(经模拟代理的 CONNECT 与 STUN/ChannelData 分帧)与 CI;与真实 TURN 服务器的 TCP/TLS 分配尚待在报告环境实机确认。
### 下载 / Download
`uu-remote-linux_0.2.37_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.37-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.37`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+13
View File
@@ -0,0 +1,13 @@
TURN over TLS 改为同时信任系统证书库。/ TURN over TLS now also trusts the system certificate store.
### 修复 / Fixed
- **TURN over TLS 报 UnknownIssuer**:v0.2.37 的 TCP/TLS 中继只信任内置的 Mozilla 根证书;在会检查 TLS 的 HTTP 代理后面,中继证书由主机管理员装在系统证书库里的 CA 重新签发,OpenSSL 能通过、我们却报 `UnknownIssuer`。现在同时信任系统证书库(与 OpenSSL 一致)和内置根证书。仅影响 `UU_USE_PROXY=1` 时的 TCP/TLS 中继。
TCP/TLS relays (only with `UU_USE_PROXY=1`) now trust the system certificate store as well as the bundled Mozilla roots, so CAs added for TLS-inspecting proxies are honoured.
### 验证范围 / Validation
单元测试与 CI;报告环境实机验证进行中。
### 下载 / Download
`uu-remote-linux_0.2.38_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.38-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.38`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+13
View File
@@ -0,0 +1,13 @@
Linux 控制端像官方控制端一样请求桌面视频轨道,修复第二个会话永久黑屏。/ The Linux viewer now requests the desktop video track like the official viewer, fixing a permanently black second session.
### 修复 / Fixed
- **第二个会话黑屏(#124,感谢 @shao-zhijie 的码流取证)**:被控端已在给别的控制端推流时,Linux 控制端只会接上那条流的中段,没有 SPS/PPS/IDR,永远无法解码;官方主机也不响应 RTCP PLI。官方 iPhone 控制端在 CONTROL 通道打开后会立即发 RPC 15 `SendVideoTrackReq`(无字段);Linux 控制端现在桌面会话里也发这一条。
Desktop sessions now send RpcRequest case 15 `SendVideoTrackReq` (no fields) right after CONTROL opens, as the official iPhone viewer does, so the host starts a track for this session instead of the viewer joining another session's stream mid-GOP.
### 验证范围 / Validation
单元测试与 CI;官方 iPhone 控制端发送该 RPC 的行为来自本项目主机日志(`response_field=11 value=None`)。与官方 macOS 主机的第二会话场景尚待报告者实测。
### 下载 / Download
`uu-remote-linux_0.2.39_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.39-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.39`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+23
View File
@@ -0,0 +1,23 @@
GNOME 多显示器与精确触控、niri 适配、控制端控制中心与中英文界面,以及登录设备注册修复。/ GNOME multi-monitor and precise touch, niri support, a viewer control center with Chinese/English UI, and a login device-registration fix.
### 新增 / Added
- **GNOME(Wayland / Portal)多显示器切换(#128,感谢 @spixyy7)**:逐块显示器公布并各自保存 Portal 授权,首次在主机上授权一次,之后静默恢复;最后一个控制端断开后立即停止屏幕共享。
GNOME Portal: per-monitor sources with per-monitor saved grants (asked once, restored silently); screen sharing stops when the last viewer leaves.
- **niri 支持(#71,感谢 @WALKERKILLER)**:`UU_WAYLAND_MULTISCREEN=1` 下的显示器枚举与切换、旋转输出的正向采集与指针映射、手机端中文输入。其他合成器行为不变。
niri: output enumeration/switching, upright capture and pointer mapping for rotated outputs, and mobile text input; other compositors unchanged.
- **原生控制端(#129,感谢 @spixyy7)**:按被控端原始分辨率解码、中英文界面(`UU_LANG` 或设置)、控制中心(`Ctrl+Alt+M`)、网络状态面板(`Ctrl+Alt+G`,显示实测 RTT)、连接加载画面。控制端登录不会开启本机被控服务(默认关闭)。
Native viewer: native-resolution decode, Chinese/English UI, control center, network panel with measured RTT, connection screen. Viewer login does not enable the local host service (off by default).
### 修复 / Fixed
- **GNOME 触控偏移(#128)**:绝对移动与点击改走当前 Portal 流,不再映射到整个多屏桌面。/ Absolute pointer goes through the current Portal stream.
- **账号下出现永远离线的“幽灵”设备(#127,感谢 @spixyy7)**:主机与控制端同时登录时,设备注册在配置文件锁下串行进行并复用已注册的设备。/ Device registration is serialized under a config lock.
- **控制端**:控制中心卡顿与随后的花屏、Wayland 下关闭文件传输窗口崩溃(#129)。/ Viewer menu stalls and resulting corruption; crash closing the file-transfer window on Wayland.
- **TURN over TCP/TLS 经检查型代理**:代理返回 HTTP 时给出明确错误(代理在检查 TLS 内容,TURN 无法通过),不再报含糊的解析错误。/ A clear error when an inspecting proxy answers with HTTP inside the relay stream.
### 验证范围 / Validation
单元测试与 CI。GNOME 多显示器/触控由贡献者在 Fedora 44 / GNOME 50.6 双屏实机验证;niri 与控制端改动由各自贡献者实机验证(控制端 RTT 补丁实测仅覆盖 Android 控制端场景)。
### 下载 / Download
`uu-remote-linux_0.2.40_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.40-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.40`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+18
View File
@@ -0,0 +1,18 @@
修复原生控制端连 Mac 无画面,GNOME 手机控制端新增手势滚动,控制端记住画质设置。/ Fixes the native viewer showing no picture from Mac hosts, adds gesture scrolling for phone viewers on GNOME, and remembers viewer quality settings.
### 修复 / Fixed
- **原生控制端连 Mac 被控端一直“连接中”、无画面(#136,感谢 @coolxll 二分定位)**:v0.2.40 在本地重置后只等 IDR,Mac 对 PLI 不回 IDR 时会一直丢帧。现在 H.264 I 片和恢复点 SEI 也可作为重启点,最多等待 1.5 秒后照常解码。
Native viewer: after a local reset it accepted only IDR frames, so a Mac host that answers PLI without one stayed blank. I slices and recovery-point SEI now count, and the wait is capped at 1.5 s.
### 新增 / Added
- **GNOME(Portal)手机控制端手势(#134、#131,感谢 @spixyy7)**:触控模式下拖动即平滑滚动(终端里也能滚),按住 0.45 秒后拖动为选中,短按为点击;默认不再需要触摸屏授权。`UU_TOUCH_INPUT=touch` 改用真触控,`=0` 保持鼠标拖动。输入法 ASCII 直接按键输入。
GNOME Portal phone viewers: drag scrolls smoothly (also in terminals), hold-then-drag selects, tap clicks, with no touchscreen consent by default; `UU_TOUCH_INPUT=touch` / `=0` select real touch or mouse drags.
- **控制端跨会话记住画质、帧率和真彩设置(#133,感谢 @spixyy7)**。/ The viewer remembers quality, frame rate and true-color choices.
### 验证范围 / Validation
单元测试与 CI。手机手势由贡献者在 Fedora 44 / GNOME 50.6 + 官方 Android 控制端实机验证;#136 的修复尚未连真实 Mac 被控端验证。
### 下载 / Download
`uu-remote-linux_0.2.41_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.41-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.41`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+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.**
+16
View File
@@ -0,0 +1,16 @@
修复版:终端会话结束/重连归属与列表通知,iOS 上传默认目录与关闭显示器兼容。/ Fix release: terminal session termination, reconnect ownership and list notifications; iOS default upload directory and screen-off compatibility.
### 修复 / Fixed
- **终端会话生命周期(#197)**:结束会话按 JSON `session_id` 选择目标(不再误用帧头请求编号),并清理该 PTY 会话内的全部进程组;Ctrl+C 发往前台进程组;重连后只接受当前附着连接的输入/缩放/信号;会话列表补齐 shell 名称、连接状态与 `last_active_ms`,变更时发送列表通知。/ Terminal close now targets the JSON `session_id` and cleans up all process groups of that PTY session; signals go to the foreground process group; after reconnect only the attached channel may drive the session; the session list gains shell name, attach state and `last_active_ms`, with change notifications.
- **iOS 上传默认目录(#198)**:iOS 直接上传时解析 `:/Default` 默认接收目录。/ iOS direct uploads resolve the `:/Default` receive-directory alias.
- **iOS 关闭显示器(#199)**:兼容 iOS 端 `enable=0,type=3` 的关闭显示器编码。/ Accept the iOS screen-off encoding (`enable=0,type=3`).
感谢 @cnetst、@RiverOnVenus 的贡献。/ Thanks to @cnetst and @RiverOnVenus.
### 验证范围 / Validation
单元测试与 CI;#197 作者在 Ubuntu ARM64 上与官方客户端实测,#199 附 iOS 实机日志。维护方未做 Mac/手机客户端界面验收。
### 下载 / Download
`uu-remote-linux_0.2.54_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.54-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.54`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+14
View File
@@ -0,0 +1,14 @@
修复版:Linux → Windows 文本剪贴板。/ Fix release: Linux → Windows text clipboard.
### 修复 / Fixed
- **Windows 文本剪贴板(#200,修 #151)**:主机提供 Windows Unicode 文本(预定义格式 id 13)时不再附带格式名字段,避免 Windows 控制端把它注册成自定义格式、导致无法粘贴。Mac 格式名、UTF-16LE 编码、CRLF 与结尾 NUL 不变。/ The host now offers predefined Windows Unicode text (id 13) without a format name, so the Windows viewer no longer registers it as a custom format and standard paste works. Mac format names, UTF-16LE encoding, CRLF and the terminating NUL are unchanged.
感谢 @max2787 的贡献。/ Thanks to @max2787.
### 验证范围 / Validation
单元测试与 CI;#200 作者在 Debian 13 / Xfce 上与官方 Windows 控制端实测双向复制粘贴(中文、多行、emoji)。维护方未做 Windows/Mac 客户端界面验收。
### 下载 / Download
`uu-remote-linux_0.2.55_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.55-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.55`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+19
View File
@@ -0,0 +1,19 @@
功能与修复版:防窥模式、嵌入式光标、NVENC 关键帧画质。/ Feature and fix release: privacy mode, embedded cursor, NVENC keyframe quality.
### 新增 / Added
- **嵌入式光标跟随控制端鼠标模式(#203)**:Portal 采集在控制端使用相对移动("使用被控端鼠标"、Mac 触控板模式)时请求 `cursor_mode=embedded`,让游戏光标出现在画面中;绝对移动时保持隐藏,只显示一个指针。/ Portal capture asks for an embedded cursor while the viewer sends relative motion, so the game's cursor shows in the picture; absolute motion keeps it hidden.
### 修复 / Fixed
- **Windows 控制端防窥请求(#202)**:Windows 控制端(平台 1)以 `enable=0` 加 `privacy_type` 表达意图,主机现在按类型(2 画面、3 熄屏)开启防窥,不再误判为关闭。/ The host now honours the Windows viewer's `enable=0` + `privacy_type` encoding instead of treating it as "off".
- **防窥画面模式下的新窗口(#201)**:KWin 防窥模式中后出现的窗口和桌宠会被移到虚拟输出,不再落在被遮盖的物理屏上而看不见。/ Windows that appear later in KWin picture mode are moved to the virtual output instead of the covered physical screen.
- **NVENC 关键帧模糊(#205,修 #103)**:NVENC 的 VBV 缓冲默认按 libx264 规则取码率并限制在 500–8000 kbit,关键帧不再糊;VAAPI 不变,`UU_NVENC_BUFFER_MS` 仍可覆盖。/ The NVENC VBV buffer now follows the libx264 rule (bitrate, clamped to 500–8000 kbit) so keyframes stop blurring; VAAPI is unchanged and `UU_NVENC_BUFFER_MS` still overrides.
感谢 @RiverOnVenus 与 @Chr0mium24 的贡献。/ Thanks to @RiverOnVenus and @Chr0mium24.
### 验证范围 / Validation
单元测试与 CI;#201、#203 作者在 KDE Plasma 6 Wayland 上实测。维护方未做 Windows/Mac 客户端界面验收。
### 下载 / Download
`uu-remote-linux_0.2.56_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.56-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.56`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+17
View File
@@ -0,0 +1,17 @@
功能与修复版:可选控制端麦克风输入、文件传输空路径防护。/ Feature and fix release: opt-in controller microphone, file-transfer empty-path guard.
### 新增 / Added
- **控制端麦克风输入(实验性,默认关闭,#207)**:设置 `UU_MICROPHONE=1` 后,主机通过已认证的桌面 WebRTC 连接接收控制端 Opus 音轨,并提供独立虚拟麦克风 **UU-远程麦克风**(`uu-remote-microphone`),不修改系统默认输入输出。需要 PipeWire-pulse 或 PulseAudio 13+、`libopus.so.0`、`libpulse.so.0` 与 `pactl`;详见 `docs/remote-microphone.md`。/ With `UU_MICROPHONE=1` the host receives the viewer's Opus track over the authenticated desktop WebRTC connection and exposes a dedicated virtual microphone, leaving system defaults untouched. See `docs/remote-microphone.md`.
### 修复 / Fixed
- **文件传输空路径(#208)**:不带路径的 `send_request` 现在返回协议错误,不再从根目录遍历。/ A `send_request` without a path now returns a protocol error instead of walking `/`.
感谢 @JuckZ 的贡献。/ Thanks to @JuckZ.
### 验证范围 / Validation
单元测试与 CI;维护方未做麦克风实机验收。Windows 4.44.1 新下载流程与端口映射(#208)仍未支持。
### 下载 / Download
`uu-remote-linux_0.2.57_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.57-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.57`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+16
View File
@@ -0,0 +1,16 @@
修复版:唤醒助手注册、锁屏监测改用 logind D-Bus、HUD 中文字体。/ Fix release: wake-helper registration, logind D-Bus lock monitoring, CJK HUD font.
### 修复 / Fixed
- **网络唤醒助手注册(#209)**:注册唤醒助手时补发 `inner_ip`,云端不再以 422 拒绝,`UU_WOL_HELPER=1` 的主机可以接收唤醒推送并发送魔术包。/ The wake helper registration now sends `inner_ip`, so the cloud accepts it and forwards wake-on-LAN pushes.
- **锁屏监测(#217、#218)**:改为通过 D-Bus 订阅 logind `LockedHint`,不再每秒启动 `loginctl`,减少进程轮询与审计日志噪声;无图形会话时保持订阅、不阻塞启动。/ Lock state is now watched via logind D-Bus `LockedHint` instead of spawning `loginctl` every second.
- **HUD 中文显示(#219)**:HUD 字体选择优先含汉字的字体,修复部分系统(如 Omarchy)HUD 中文显示为方框。/ The HUD prefers a CJK-capable font, fixing tofu boxes on some systems.
感谢 @enrzh、@AYssu、@Onekki 的贡献。/ Thanks to @enrzh, @AYssu and @Onekki.
### 验证范围 / Validation
单元测试与 CI;#209 由贡献者端到端实测(iOS 控制端唤醒 Windows PC)。维护方未做锁屏监测与 HUD 字体实机验收。
### 下载 / Download
`uu-remote-linux_0.2.58_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.58-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.58`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+15
View File
@@ -0,0 +1,15 @@
修复版:KDE 锁屏冷连接显示真实锁屏界面、适配 Cargo 新 build-dir 布局。/ Fix release: real lock screen on KDE locked cold connections, Cargo build-dir layout fix.
### 修复 / Fixed
- **KDE 锁屏冷连接(#227、#229)**:KDE Plasma(KWin)锁屏后 Portal 采集仍可用,主机默认在锁屏时也打开采集,冷连接直接看到真实锁屏界面并可用远程键盘输入密码,不再停在「正在传输画面」;`UU_LOCKED_CAPTURE=0` 关闭,`UU_LOCKED_CAPTURE=1` 在无法识别桌面时强制开启。GNOME 行为不变。/ On KDE Plasma the host now keeps Portal capture open while locked, so a cold connection shows the real lock screen; `UU_LOCKED_CAPTURE=0` disables it. GNOME is unchanged.
- **源码构建(#226)**:适配 Cargo 新的 build-dir 布局,引擎插件复制到 profile 目录。/ Engine plugins are copied to the profile directory under Cargo's newer build-dir layout.
感谢 @RiverOnVenus 的贡献。/ Thanks to @RiverOnVenus.
### 验证范围 / Validation
单元测试与 CI;#229 由贡献者在 Plasma 6.8.2 + 官方 Windows 控制端实测锁屏冷连接与远程键盘解锁。维护方未做 KDE 实机验收。
### 下载 / Download
`uu-remote-linux_0.2.59_<amd64|arm64>.deb`,或 `uu-remote-linux-v0.2.59-<x86_64|aarch64>-linux.tar.gz`(解压后运行 `./install.sh`),或 `docker pull ghcr.io/vallierdev/uu-remote-linux:v0.2.59`(x86_64)。
**非官方项目,与网易无关。** / **Unofficial, not affiliated with NetEase.**
+79
View File
@@ -0,0 +1,79 @@
# Remote microphone / 控制端麦克风(实验性)
Opt-in controller-to-host Opus audio uses the existing authenticated desktop WebRTC connection and exposes a dedicated virtual microphone to Linux applications.
可选功能:通过原有、已认证的桌面 WebRTC 连接接收控制端 Opus 音轨,为 Linux 应用提供独立虚拟麦克风。
## Enable / 启用
Requires Linux, running PipeWire-pulse or PulseAudio 13+, the `libopus.so.0` / `libpulse.so.0` runtimes, and `pactl`. Debian/Ubuntu: install `libopus0 pulseaudio-utils`; Arch: install `opus libpulse`. No administrator privileges or additional network listener are needed at runtime. Both libraries are loaded only when requested; ordinary builds need no PulseAudio or Opus development package or extra link-time dependency.
需要 Linux、已运行的 PipeWire-pulse 或 PulseAudio 13+、`libopus.so.0` / `libpulse.so.0` 和 `pactl`。Debian/Ubuntu 对应 `libopus0 pulseaudio-utils`;Arch 对应 `opus libpulse`。运行时无需管理员权限,也不新增监听端口;普通构建无需安装 PulseAudio、Opus 开发包或增加链接依赖。
```ini
# ~/.config/systemd/user/uuremote-native.service.d/microphone.conf
[Service]
Environment=UU_MICROPHONE=1
```
```sh
systemctl --user daemon-reload
systemctl --user restart uuremote-native.service
```
The host creates the input device **UU-Remote-Microphone** (`uu-remote-microphone`) and a private backing sink (`uu-remote-mic-input`). In the application that should receive your voice, select UU-Remote-Microphone as its input. This patch does not change the system default input or output device. The backing sink is an audio destination for the decoder; it is not the device to select as an application microphone.
被控端会出现 **UU-远程麦克风** 输入设备(英文界面显示 **UU-Remote-Microphone**)。在需要使用麦克风的应用中选择这个输入。设备与音频流的显示名称跟随被控端语言,技术名称 `uu-remote-microphone`、`uu-remote-mic-input` 不变。补丁不修改系统默认输入、输出;底层的 `uu-remote-mic-input` 是解码器内部输出目标,不是应用应选择的麦克风。
Device and stream display labels follow the host language; the technical sink/source identifiers stay unchanged.
Enable the controller's microphone in the official UU client. The host completes VirtualAudioDriverPolicyRequest (RpcRequest field 21) using RpcResponse field 17 with a correctly encoded two-byte tag. It commits the reception gate and queues its reply/notification as one ordered transition before any network send can block. CONTROL and TEXT callbacks share the same transition lock, so a stalled open reply cannot overwrite a later close. Reception starts closed; connecting alone does not request capture. Opus is decoded at 48 kHz stereo and written through libpulse with PA_STREAM_DONT_MOVE, preventing rescue to a physical output on either supported audio server. A disconnected or superseded desktop drops queued audio and closes playback. Tool-only peers cannot inject microphone audio. A new incoming track replaces the previous track of the same peer.
在官方控制端中开启麦克风。被控端通过正确编码的 RPC 响应确认虚拟声卡策略;接收开关和回复、通知的排队操作使用统一的状态锁,均在网络发送之前完成,避免拥塞时旧开麦请求覆盖后到的关麦。接收初始为关闭,单纯建立远控连接不会主动要求采集。Opus 解码为 48 kHz 双声道,通过 libpulse 的禁止迁移标志仅写入虚拟麦克风,两个支持的音频后端均不会在目标丢失后转向物理输出。断开或桌面会话被替换时清空待播放内容并停止播放;文件、终端等非桌面连接不接收麦克风。
If an external tool removes the virtual endpoints, or the audio server restarts, reception stops. Restart the host to recreate its endpoints.
如果外部工具删除了虚拟设备,或音频服务重启,接收会停止。重启被控端服务可重新创建设备。
No microphone audio is logged, saved or played through physical speakers by this receiver. Applications consuming the virtual input retain their own behavior. A 40 ms initial jitter window and a maximum 12-packet queue limit backlog. RTP timestamps determine missing audio duration for Opus loss concealment, including variable-duration packets and sequence/timestamp rollover. Each track claims a unique generation before its worker is spawned; a superseded worker checks that generation before processing audio.
接收器不记录、保存麦克风音频,也不将它播放到物理扬声器。读取虚拟输入的应用仍按各自设置工作。初始抖动缓冲为 40 毫秒,队列最多 12 包;根据 RTP 时间戳推导缺失音频时长后进行 Opus 补偿,支持可变包长与序号、时间戳回绕。新音轨在启动接收任务前取得唯一归属编号,旧任务处理音频前会核验该编号。
The endpoint lock lives in a private per-user directory under `/tmp`, independently of `UU_CONFIG`, `XDG_RUNTIME_DIR` and `TMPDIR`. Recovery requires an exact match of module kind and arguments, including the remap source's master. Cleanup checks the module id and arguments again before unloading, and the route is released on ordinary error returns as well as shutdown.
设备锁位于 `/tmp` 下的用户私有目录,不随配置目录、`XDG_RUNTIME_DIR` 或 `TMPDIR` 变化。恢复设备时严格匹配模块类型及全部参数,包括虚拟输入的 master;清理前再次核验模块编号及参数。常规错误返回与正常关闭都会释放设备。
Native PulseAudio uses its `norewinds` null-sink option to avoid the default two-second idle buffer on first playback. This Pulse-only option is not passed to PipeWire. Unsupported older PulseAudio servers leave the opt-in microphone disabled.
原生 PulseAudio 使用空设备的 `norewinds` 选项,避免首次播放时的默认两秒空闲缓冲;不向 PipeWire 传递这个专用参数。较旧、不受支持的 PulseAudio 不会启用麦克风。
## Validation / 验证
Opus-dependent unit tests print a skip diagnostic when `libopus.so.0` is unavailable, so default tests still pass without this optional runtime. CI's `inproc-av` jobs install libopus and exercise these tests. The explicitly requested audio-server smoke tests require the runtime and fail if it is missing.
缺少可选的 `libopus.so.0` 时,依赖 Opus 的单元测试会输出跳过说明,默认测试仍能通过。CI 的 `inproc-av` 任务安装 libopus 并实际运行这些测试;显式启用的音频服务真机测试需要该运行库,缺少时会失败。
```sh
cargo test --locked --bin uuremote-server --features wayland,portal,engine-plugins microphone::tests
# Real audio-server smoke test: independent test endpoints, generated audio only, in memory.
UU_MICROPHONE=1 \
cargo test --locked --bin uuremote-server --features wayland,portal,engine-plugins \
microphone::tests::pipewire_virtual_microphone_receives_generated_tone -- --ignored --exact
```
The smoke test creates process-specific sink/source names, plays and captures only through those endpoints, waits for its playback task to end before removing them, and never reuses the host's microphone. A separate config file alone does not isolate audio resources. Unit tests cover cross-process locking, module ownership, concurrent track claims, 10/20/40/60 ms loss, mixed-duration gaps, clock rollover, WebRTC track replacement, and CONTROL/TEXT ordering under send congestion. Earlier controller acceptance passed with Windows 4.44.0.3919 on CachyOS using the previous receiver backend. The native playback backend is checked separately with generated audio; Windows acceptance has not been repeated after that backend change.
真机测试使用进程专属的虚拟输入、输出名称,仅在测试设备之间播放和采集,等播放任务结束后再删除设备,不复用正式服务的麦克风。单独更换配置文件不能隔离音频资源。回归测试覆盖跨进程锁、模块归属、并发音轨、10/20/40/60 毫秒包的丢包、混合时长缺口、时钟回绕、WebRTC 音轨替换及拥塞时的 CONTROL/TEXT 顺序。之前的接收后端已用 Windows 4.44.0.3919 在 CachyOS 实机通过控制端验收;原生播放后端另用生成音验证,更换后尚未重复 Windows 实机验收。
An optional native PulseAudio check starts a private server with no hardware modules. It first confirms sustained generated audio, then verifies that removing its playback target closes the stream and leaves the default null sink silent. Use `--smoke` to check audio delivery alone. The wrapper verifies that the named test exists before running it, so an old `--test-binary` cannot silently pass with zero tests. It needs a PulseAudio executable; `--daemon` and `--module-dir` also support unpacked packages. It does not start or modify a system service.
可选的原生 PulseAudio 检查会启动不加载硬件模块的独立服务,先确认持续生成音正常,再验证播放目标消失后音频流关闭、默认空设备保持静音;`--smoke` 仅验证生成音传输。脚本会检查目标测试存在,旧 `--test-binary` 不会以零项测试误报成功。需要 PulseAudio 可执行文件,`--daemon`、`--module-dir` 也支持解压后的程序包,不启动或修改系统服务。
```sh
python3 contrib/check-microphone-pulse.py
python3 contrib/check-microphone-pulse.py --smoke
```
To disable, remove `microphone.conf`, reload the user manager and restart the host. The virtual endpoints are removed on normal shutdown. After a crash, the next enabled run reuses only the exact tagged modules created by this receiver.
停用时删除 `microphone.conf`,重新加载并重启用户服务。正常退出会删除虚拟设备;异常退出后,下次启用仅复用本接收器创建并标记的同名模块。
+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 //! 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. //! 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. //! 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. //! `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>) fn start(source: &str, tx: tokio::sync::mpsc::Sender<bytes::Bytes>)
-> Result<(Stopper, tokio::task::JoinHandle<Result<(), String>>), String> { -> Result<(Stopper, tokio::task::JoinHandle<Result<(), String>>), String> {
let stop = Arc::new(AtomicBool::new(false)); 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 mut child = spawn_encoder(source)?;
let stdout = child.stdout.take().ok_or("Encoder stdout missing")?; let stdout = child.stdout.take().ok_or("Encoder stdout missing")?;
let job = tokio::task::spawn_blocking(move || read_packets(stdout, &tx)); let job = tokio::task::spawn_blocking(move || read_packets(stdout, &tx));
Ok((Stopper { stop, child: Some(child) }, job)) 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 { fn closed(pc: &RTCPeerConnection) -> bool {
matches!(pc.connection_state(), RTCPeerConnectionState::Closed | RTCPeerConnectionState::Failed) 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())?; let result = job.await.map_err(|e| e.to_string())?;
if packets == 0 { result } else { Ok(()) } 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();
}
}
+109 -9
View File
@@ -91,6 +91,48 @@ pub struct UUAuthClient {
guest_id: Option<String>, guest_id: Option<String>,
} }
/// QR failures are safe to display: never retain a URL, source error or response body.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum QrRequestErrorKind { Timeout, Connect, Decode, Body, Request }
impl QrRequestErrorKind {
fn from_reqwest(error: &reqwest::Error) -> Self {
if error.is_timeout() { Self::Timeout }
else if error.is_connect() { Self::Connect }
else if error.is_decode() { Self::Decode }
else if error.is_body() { Self::Body }
else { Self::Request }
}
fn label(self) -> &'static str {
match self { Self::Timeout => "timeout", Self::Connect => "connect", Self::Decode => "decode",
Self::Body => "body", Self::Request => "request" }
}
}
#[derive(Debug)]
pub struct QrRequestError {
pub kind: QrRequestErrorKind,
phase: &'static str,
elapsed_ms: u128,
http_status: Option<u16>,
}
impl std::fmt::Display for QrRequestError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "phase={} kind={} elapsed_ms={} http_status={:?}",
self.phase, self.kind.label(), self.elapsed_ms, self.http_status)
}
}
impl QrRequestError {
pub fn response_received(&self) -> bool { self.http_status.is_some() }
fn new(kind: QrRequestErrorKind, phase: &'static str, started: std::time::Instant, http_status: Option<u16>) -> Self {
Self { kind, phase, elapsed_ms: started.elapsed().as_millis(), http_status }
}
}
async fn send_qr_request(request: reqwest::RequestBuilder, started: std::time::Instant) -> Result<(u16, serde_json::Value), QrRequestError> {
let resp = request.send().await.map_err(|e| QrRequestError::new(QrRequestErrorKind::from_reqwest(&e), "send", started, None))?;
let status = resp.status().as_u16();
let value = resp.json().await.map_err(|e| QrRequestError::new(QrRequestErrorKind::from_reqwest(&e), "response", started, Some(status)))?;
Ok((status, value))
}
/// Transport failures name only the outer request; the cause (certificate, proxy, DNS, /// Transport failures name only the outer request; the cause (certificate, proxy, DNS,
/// timeout) lives in the source chain. URL user-info (proxy credentials) and query /// timeout) lives in the source chain. URL user-info (proxy credentials) and query
/// strings are removed before the chain is shown. /// strings are removed before the chain is shown.
@@ -121,17 +163,20 @@ fn redact_urls(text: &str) -> String {
out out
} }
/// Cloud API clients ignore ambient HTTP/SOCKS proxy settings by default: a local /// Cloud API and signaling clients ignore ambient HTTP/HTTPS proxy settings by default: a local
/// proxy that intercepts TLS breaks login and signaling. `UU_USE_PROXY=1` opts back /// proxy that intercepts TLS breaks login and signaling. `UU_USE_PROXY=1` opts back
/// into reqwest's standard proxy environment handling. /// into reqwest's standard proxy environment handling.
pub fn http_client_builder() -> reqwest::ClientBuilder { pub fn http_client_builder() -> reqwest::ClientBuilder {
let builder = reqwest::Client::builder(); let builder = reqwest::Client::builder();
if std::env::var("UU_USE_PROXY").ok().as_deref().is_some_and(proxy_requested) { if proxy_enabled() {
builder builder
} else { } else {
builder.no_proxy() builder.no_proxy()
} }
} }
pub(crate) fn proxy_enabled() -> bool {
std::env::var("UU_USE_PROXY").ok().as_deref().is_some_and(proxy_requested)
}
fn proxy_requested(value: &str) -> bool { fn proxy_requested(value: &str) -> bool {
matches!(value.trim().to_ascii_lowercase().as_str(), "1" | "true" | "yes" | "on") matches!(value.trim().to_ascii_lowercase().as_str(), "1" | "true" | "yes" | "on")
} }
@@ -253,13 +298,13 @@ impl UUAuthClient {
/// Signed POST with an optional JSON body (None = empty body, like Moya `requestPlain`) and an /// Signed POST with an optional JSON body (None = empty body, like Moya `requestPlain`) and an
/// explicit timeout. The official clients long-poll the QR status with a 60 s request timeout. /// explicit timeout. The official clients long-poll the QR status with a 60 s request timeout.
pub async fn post_with_timeout(&self, path: &str, body: Option<&serde_json::Value>, timeout: std::time::Duration) -> Result<(u16, serde_json::Value), String> { pub async fn post_with_timeout(&self, path: &str, body: Option<&serde_json::Value>, timeout: std::time::Duration) -> Result<(u16, serde_json::Value), QrRequestError> {
let body_str = body.map(serde_json::to_string).transpose().map_err(|e| e.to_string())?.unwrap_or_default(); let started = std::time::Instant::now();
let resp = self.http.post(format!("{}{}", BASE_URL, path)).timeout(timeout) let body_str = body.map(serde_json::to_string).transpose()
.headers(self.build_headers("POST", path, &body_str)).body(body_str) .map_err(|_| QrRequestError::new(QrRequestErrorKind::Request, "encode", started, None))?.unwrap_or_default();
.send().await.map_err(|e| format!("HTTP post {path} failed: {}", transport_error(&e)))?; let request = self.http.post(format!("{}{}", BASE_URL, path)).timeout(timeout)
let status = resp.status().as_u16(); .headers(self.build_headers("POST", path, &body_str)).body(body_str);
Ok((status, resp.json().await.unwrap_or(serde_json::Value::Null))) send_qr_request(request, started).await
} }
/// Signed JSON POST to another API host (the signature covers the path only). /// Signed JSON POST to another API host (the signature covers the path only).
@@ -389,3 +434,58 @@ mod guest_tests {
for value in ["", "0", "false", "no", "off", "2"] { assert!(!super::proxy_requested(value)); } for value in ["", "0", "false", "no", "off", "2"] { assert!(!super::proxy_requested(value)); }
} }
} }
#[cfg(test)]
mod qr_request_tests {
use super::*;
use std::time::{Duration, Instant};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
// Synthetic, loopback-only responses: no account, device, proxy or live login API.
async fn response(reply: &'static [u8], stall: bool) -> QrRequestError {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
let (mut socket, _) = listener.accept().await.unwrap();
let mut request = [0u8; 4096];
let _ = socket.read(&mut request).await.unwrap();
socket.write_all(reply).await.unwrap();
if stall { std::future::pending::<()>().await; }
});
let request = reqwest::Client::builder().no_proxy().build().unwrap()
.post(format!("http://fixture-user:fixture-password@{addr}/fixture-path?token=fixture-ticket"))
.timeout(Duration::from_secs(2));
let error = send_qr_request(request, Instant::now()).await.unwrap_err();
server.abort();
let output = format!("{error} {error:?}");
for secret in ["fixture-user", "fixture-password", "fixture-path", "fixture-ticket", "fixture-body", "127.0.0.1", "http://"] {
assert!(!output.contains(secret));
}
error
}
#[tokio::test]
async fn qr_request_distinguishes_send_timeout_body_timeout_and_bad_json_without_secrets() {
let error = response(b"", true).await;
assert_eq!((error.kind, error.phase, error.http_status), (QrRequestErrorKind::Timeout, "send", None));
assert!(!error.response_received());
let error = response(b"HTTP/1.1 200 OK\r\nContent-Length: 100\r\n\r\n", true).await;
assert_eq!((error.kind, error.phase, error.http_status), (QrRequestErrorKind::Timeout, "response", Some(200)));
assert!(error.response_received());
let error = response(b"HTTP/1.1 502 Bad Gateway\r\nContent-Length: 12\r\n\r\nfixture-body", false).await;
assert_eq!((error.kind, error.phase, error.http_status), (QrRequestErrorKind::Decode, "response", Some(502)));
assert!(error.response_received());
}
#[tokio::test]
async fn qr_connection_failure_is_not_a_timeout() {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
drop(listener);
let request = reqwest::Client::builder().no_proxy().build().unwrap()
.post(format!("http://{addr}/fixture-ticket")).timeout(Duration::from_secs(2));
let error = send_qr_request(request, Instant::now()).await.unwrap_err();
assert_eq!((error.kind, error.phase, error.http_status), (QrRequestErrorKind::Connect, "send", None));
assert!(!format!("{error} {error:?}").contains("fixture-ticket"));
}
}
+4 -1
View File
@@ -82,8 +82,10 @@ pub struct ScreenCapture {
impl ScreenCapture { impl ScreenCapture {
pub fn open_portal(cancelled: &std::sync::atomic::AtomicBool) -> Result<Self, crate::portal::PortalError> { pub fn open_portal(cancelled: &std::sync::atomic::AtomicBool) -> Result<Self, crate::portal::PortalError> {
let session = std::sync::Arc::new(crate::portal::PortalSession::open_cancellable(cancelled)?); let session = std::sync::Arc::new(crate::portal::PortalSession::open_cancellable(cancelled)?);
crate::portal::register(&session);
let (width, height) = session.size();
Ok(Self { backend: crate::desktop_backend::DesktopBackend::Portal, init_error: None, Ok(Self { backend: crate::desktop_backend::DesktopBackend::Portal, init_error: None,
display: "wayland:portal".into(), width: session.width, height: session.height, display: "wayland:portal".into(), width, height,
portal: Some(session), kms: None, buffer: Mutex::new(Vec::new()) }) portal: Some(session), kms: None, buffer: Mutex::new(Vec::new()) })
} }
pub fn new() -> Result<Self, String> { pub fn new() -> Result<Self, String> {
@@ -179,6 +181,7 @@ impl Drop for ScreenCapture {
/// Keep the display visible only while a peer is streaming; never unlock it. /// Keep the display visible only while a peer is streaming; never unlock it.
pub fn keep_display_awake() -> Result<(), String> { 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::Kms { return Ok(()); }
if crate::desktop_backend::detect()? == crate::desktop_backend::DesktopBackend::Portal { if crate::desktop_backend::detect()? == crate::desktop_backend::DesktopBackend::Portal {
return crate::desktop_power::wake(); return crate::desktop_power::wake();
+39 -2
View File
@@ -17,6 +17,9 @@ impl TextFormat {
} }
fn id(self)->u64{match self{Self::Windows=>UNICODE_TEXT,Self::Mac=>0}} 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}} fn name(self)->&'static str{match self{Self::Windows=>"CF_UNICODETEXT",Self::Mac=>MAC_TEXT}}
/// Issue #151 reports that Windows registers even `predefined_13` as a custom format.
/// Omit the name for predefined id 13; verified with the official Windows viewer on an X11 host.
fn offer_name(self)->Option<&'static str>{match self{Self::Windows=>None,Self::Mac=>Some(MAC_TEXT)}}
fn encode(self,text:&str)->Vec<u8>{match self{Self::Windows=>encode_windows(text),Self::Mac=>text.as_bytes().to_vec()}} 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>{ fn decode(self,data:&[u8])->Result<String,&'static str>{
match self{ match self{
@@ -96,7 +99,7 @@ impl State{
if text.contains('\0')||encode_windows(&text).len()>MAX_BYTES{return Err("clipboard encoded text exceeds limit");} if text.contains('\0')||encode_windows(&text).len()>MAX_BYTES{return Err("clipboard encoded text exceeds limit");}
self.local=Some(text); self.local=Some(text);
let mut list=Vec::new(); 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);if let Some(name)=kind.offer_name(){string(2,name,&mut format);}nested(1,&format,&mut list);}
Ok(request(id,1,&list)) Ok(request(id,1,&list))
} }
pub fn request(&mut self,rpc:&[u8],next:&mut impl FnMut()->u64)->Result<ResultMessages,&'static str>{ pub fn request(&mut self,rpc:&[u8],next:&mut impl FnMut()->u64)->Result<ResultMessages,&'static str>{
@@ -188,6 +191,36 @@ impl State{
#[cfg(test)] #[cfg(test)]
mod tests{ mod tests{
use super::*; use super::*;
#[test]
fn windows_format_offer_omits_name_field_entirely(){
for offer in [State::default().offer(42,"hi".into()).unwrap(),State::default().offer_any_host(42,"hi".into()).unwrap()]{
assert_eq!(number(header(&offer).unwrap(),1),Ok(42));
let list=bytes(bytes(&offer,9).unwrap().unwrap(),1).unwrap().unwrap();
let formats=decode_wire(list).unwrap();
let WireValue::Bytes(windows)=formats[0].value else{panic!("missing Windows format")};
assert_eq!(windows,&[8,13]); // Only field 1: not even an empty field 2.
assert!(decode_wire(windows).unwrap().iter().all(|field|field.number!=2));
if formats.len()==2{
let WireValue::Bytes(mac)=formats[1].value else{panic!("missing Mac format")};
assert_eq!(number(mac,1),Ok(0));
assert_eq!(bytes(mac,2),Ok(Some(MAC_TEXT.as_bytes())));
}
}
}
#[test]
fn unnamed_windows_offer_still_serves_utf16le_with_crlf_and_nul(){
let mut provider=State::default();
provider.offer(1,"A中🙂\nB\r\n".into()).unwrap();
let mut ask=Vec::new();int(1,13,&mut ask);string(2,"test-key",&mut ask);
let out=provider.request(&request(2,2,&ask),&mut||3).unwrap();
assert_eq!(out.messages.iter().map(|m|m.0).collect::<Vec<_>>(),vec![22,21]);
let confirm=bytes(bytes(&out.messages[0].1,5).unwrap().unwrap(),2).unwrap().unwrap();
assert_eq!(number(confirm,1),Ok(1));assert_eq!(number(confirm,3),Ok(1));
let block=bytes(bytes(&out.messages[1].1,9).unwrap().unwrap(),3).unwrap().unwrap();
assert_eq!(text_field(block,1),Ok("test-key"));
assert_eq!(number(block,2),Ok(0));
assert_eq!(bytes(block,3).unwrap().unwrap(),&[0x41,0,0x2d,0x4e,0x3d,0xd8,0x42,0xde,13,0,10,0,0x42,0,13,0,10,0,0,0]);
}
#[test] fn mac_utf8_text_round_trips_both_directions(){ #[test] fn mac_utf8_text_round_trips_both_directions(){
// Mac host offer: format list {1 id 0, 2 "public.utf8-plain-text"} (observed live). // Mac host offer: format list {1 id 0, 2 "public.utf8-plain-text"} (observed live).
let mut mac=Vec::new();int(1,0,&mut mac);string(2,MAC_TEXT,&mut mac); let mut mac=Vec::new();int(1,0,&mut mac);string(2,MAC_TEXT,&mut mac);
@@ -210,7 +243,11 @@ mod tests{
let data=bytes(bytes(bytes(&out.messages[1].1,9).unwrap().unwrap(),3).unwrap().unwrap(),3).unwrap().unwrap(); let data=bytes(bytes(bytes(&out.messages[1].1,9).unwrap().unwrap(),3).unwrap().unwrap(),3).unwrap().unwrap();
assert_eq!(data,b"hi"); assert_eq!(data,b"hi");
// Host-side offers are unchanged: CF_UNICODETEXT only. // 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!(bytes(format,2),Ok(None));
} }
#[test] #[test]
fn desktop_clipboard_negotiates_and_buffers_unicode_until_confirmation(){ fn desktop_clipboard_negotiates_and_buffers_unicode_until_confirmation(){
+4
View File
@@ -182,6 +182,10 @@ pub fn encode_echo_response_with_clipboard(seq: u64, timestamp: u64, request_seq
// 6 ff_file_transfer_ftp = LIST_COMPRESS (zlib dir_data), 8 ff_clipboard = SUPPORT_TEXT_CHANGE. // 6 ff_file_transfer_ftp = LIST_COMPRESS (zlib dir_data), 8 ff_clipboard = SUPPORT_TEXT_CHANGE.
let mut flags = vec![8, crate::capture_setting::FEATURE_VERSION as u8, 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]; 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]); } if clipboard { flags.extend_from_slice(&[64, 3]); }
action.push(34); action.push(34);
action.push(flags.len() as u8); action.push(flags.len() as u8);
+121 -2
View File
@@ -79,6 +79,107 @@ fn mapping(kind: u8, payload: &[u8]) -> Vec<u8> {
crate::initialization::envelope(1, 0, 27, &frame) 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] #[tokio::test]
async fn closing_unnegotiated_peers_releases_callback_state() { async fn closing_unnegotiated_peers_releases_callback_state() {
for desktop in [false, true] { for desktop in [false, true] {
@@ -142,7 +243,16 @@ async fn locked_control_unlock_requests_and_tools_work_without_a_video_frame() {
let frame = tokio::time::timeout(Duration::from_secs(5), async { let frame = tokio::time::timeout(Duration::from_secs(5), async {
loop { loop {
let (channel, message) = terminal_viewer.messages.recv().await.unwrap(); let (channel, message) = terminal_viewer.messages.recv().await.unwrap();
if channel == "BINARY_DATA_CHANNEL" { break crate::terminal::decode(&message).unwrap(); } if channel != "BINARY_DATA_CHANNEL" {
continue;
}
// The process-global terminal change watch also broadcasts the field-28
// list-invalidated notification here, which is not a TERM frame.
if let Some(frame) = crate::terminal::decode(&message) {
if frame.kind == crate::terminal::LIST_RESP && frame.session == 71 {
break frame;
}
}
} }
}).await.unwrap(); }).await.unwrap();
assert_eq!((frame.kind, frame.session), (crate::terminal::LIST_RESP, 71)); assert_eq!((frame.kind, frame.session), (crate::terminal::LIST_RESP, 71));
@@ -198,7 +308,16 @@ async fn locked_control_unlock_requests_and_tools_work_without_a_video_frame() {
let frame = tokio::time::timeout(Duration::from_secs(5), async { let frame = tokio::time::timeout(Duration::from_secs(5), async {
loop { loop {
let (channel, message) = terminal_viewer.messages.recv().await.unwrap(); let (channel, message) = terminal_viewer.messages.recv().await.unwrap();
if channel == "BINARY_DATA_CHANNEL" { break crate::terminal::decode(&message).unwrap(); } if channel != "BINARY_DATA_CHANNEL" {
continue;
}
// The process-global terminal change watch also broadcasts the field-28
// list-invalidated notification here, which is not a TERM frame.
if let Some(frame) = crate::terminal::decode(&message) {
if frame.kind == crate::terminal::LIST_RESP && frame.session == 72 {
break frame;
}
}
} }
}).await.unwrap(); }).await.unwrap();
assert_eq!((frame.kind, frame.session), (crate::terminal::LIST_RESP, 72)); assert_eq!((frame.kind, frame.session), (crate::terminal::LIST_RESP, 72));
+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 /// 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. /// lock-screen policy. Session-bus setup and each method call are bounded to three seconds.
pub fn wake() -> Result<(), String> { pub fn wake() -> Result<(), String> {
if crate::privacy_screen::active() { return Ok(()); }
if !gnome_portal_active() { if !gnome_portal_active() {
return Ok(()); return Ok(());
} }
+207 -25
View File
@@ -1,6 +1,6 @@
//! Portal availability is independent of the authenticated CONTROL transport. //! Portal availability is independent of the authenticated CONTROL transport.
use std::future::Future; use std::future::Future;
use std::sync::{Arc, atomic::{AtomicBool, Ordering}}; use std::sync::{Arc, OnceLock, atomic::{AtomicBool, Ordering}};
use std::time::Instant; use std::time::Instant;
use tokio::sync::{watch, Mutex}; use tokio::sync::{watch, Mutex};
use crate::{capture::ScreenCapture, input::DesktopInputSession}; use crate::{capture::ScreenCapture, input::DesktopInputSession};
@@ -29,6 +29,7 @@ pub struct PortalDesktop {
state: watch::Sender<State>, state: watch::Sender<State>,
opening: Arc<Mutex<()>>, opening: Arc<Mutex<()>>,
locked: watch::Receiver<Option<bool>>, locked: watch::Receiver<Option<bool>>,
capture_while_locked: bool,
} }
struct CancelOnDrop(Arc<AtomicBool>); struct CancelOnDrop(Arc<AtomicBool>);
@@ -71,6 +72,7 @@ enum AttemptOutcome {
Ready(Arc<ScreenCapture>), Ready(Arc<ScreenCapture>),
Retry(String), Retry(String),
Terminal(String), Terminal(String),
Deferred,
Cancelled, Cancelled,
} }
@@ -85,14 +87,52 @@ fn classify(result: Result<Arc<ScreenCapture>, PortalError>) -> AttemptOutcome {
} }
} }
/// A consent dialog opened behind the lock screen cannot be approved, so its denied/timed-out
/// error must not end this connection's supervisor: ask again after the local unlock.
fn defer_consent(error: &PortalError, state: Option<bool>) -> bool {
state == Some(true) && matches!(error.code, 4 | 5)
}
/// True when this iteration sees a lock state it has not attempted under yet. Waking and resetting
/// the retry delay must happen once per transition, not once per 200 ms poll: a locked state would
/// otherwise re-run wake, inhibitor and publish on every tick and defeat the 5 s retry backoff.
fn fresh_state(previous: Option<Option<bool>>, state: Option<bool>) -> bool {
previous != Some(state)
}
fn should_prepare_power(healthy: bool, force_wake: bool) -> bool { fn should_prepare_power(healthy: bool, force_wake: bool) -> bool {
!healthy || force_wake !healthy || force_wake
} }
/// KWin keeps the Portal screencast, including the lock screen, alive while the session is
/// locked, so a cold connection can show the real lock screen. Mutter closes the session on
/// lock, so other desktops keep the existing black-frame path. `UU_LOCKED_CAPTURE=0` opts out.
fn capture_while_locked() -> bool {
static ENABLED: OnceLock<bool> = OnceLock::new();
*ENABLED.get_or_init(|| {
match std::env::var("UU_LOCKED_CAPTURE").ok().filter(|value| !value.is_empty()) {
Some(value) => !matches!(value.to_ascii_lowercase().as_str(), "0" | "off" | "false" | "no"),
None => ["XDG_CURRENT_DESKTOP", "XDG_SESSION_DESKTOP"].iter().any(|key|
std::env::var(key).is_ok_and(|desktop| desktop.split(':')
.any(|part| part.eq_ignore_ascii_case("KDE")))),
}
})
}
/// Capture may start and continue in this lock state. An unknown state keeps the old wait on
/// desktops whose compositor closes the session on lock.
fn attempt_allowed(state: Option<bool>, capture_while_locked: bool) -> bool {
match state {
Some(false) => true,
Some(true) | None => capture_while_locked,
}
}
fn prepare_attempt<W, I>( fn prepare_attempt<W, I>(
cancelled: &AtomicBool, cancelled: &AtomicBool,
owner: &DesktopInputSession, owner: &DesktopInputSession,
locked: &watch::Receiver<Option<bool>>, locked: &watch::Receiver<Option<bool>>,
allow_locked: bool,
wake: W, wake: W,
inhibit: I, inhibit: I,
) -> Option<AttemptPrep> ) -> Option<AttemptPrep>
@@ -102,7 +142,7 @@ where
{ {
let current = || !cancelled.load(Ordering::Acquire) let current = || !cancelled.load(Ordering::Acquire)
&& owner.is_current() && owner.is_current()
&& *locked.borrow() == Some(false); && attempt_allowed(*locked.borrow(), allow_locked);
if !current() { return None; } if !current() { return None; }
let wake = wake(); let wake = wake();
if !current() { return None; } if !current() { return None; }
@@ -114,7 +154,8 @@ where
impl PortalDesktop { impl PortalDesktop {
pub fn new(screen: Arc<ScreenCapture>) -> Self { pub fn new(screen: Arc<ScreenCapture>) -> Self {
Self { state: watch::channel(State { waiting: screen.init_error.is_some(), screen }).0, Self { state: watch::channel(State { waiting: screen.init_error.is_some(), screen }).0,
opening: Arc::new(Mutex::new(())), locked: crate::session_lock::watch_locked() } opening: Arc::new(Mutex::new(())), locked: crate::session_lock::watch_locked(),
capture_while_locked: capture_while_locked() }
} }
pub fn begin(&self) { pub fn begin(&self) {
// GNOME closes the Portal session on lock; a cached screen with a dead session // GNOME closes the Portal session on lock; a cached screen with a dead session
@@ -123,12 +164,31 @@ impl PortalDesktop {
|| state.screen.portal.as_ref().is_some_and(|portal| !portal.is_alive())); || state.screen.portal.as_ref().is_some_and(|portal| !portal.is_alive()));
} }
pub fn snapshot(&self) -> State { self.state.borrow().clone() } pub fn snapshot(&self) -> State { self.state.borrow().clone() }
/// No desktop controller left: stop sharing the screen. begin() then sees the dead
/// session and the next controller's maintain() reopens it with the saved consent.
pub fn end_idle(&self) {
if let Some(portal) = self.snapshot().screen.portal.as_ref().filter(|portal| portal.is_alive()) {
portal.end();
log::info!("Portal screen sharing ended: no desktop controller");
}
}
pub fn subscribe(&self) -> watch::Receiver<State> { self.state.subscribe() } pub fn subscribe(&self) -> watch::Receiver<State> { self.state.subscribe() }
pub fn lock_state(&self) -> watch::Receiver<Option<bool>> { self.locked.clone() } pub fn lock_state(&self) -> watch::Receiver<Option<bool>> { self.locked.clone() }
/// Whether capture may run in this lock state for this desktop. Shares the rule used by
/// maintain(), so capture-setting requests do not stall behind a lock the compositor does
/// not honor.
pub fn capture_allowed(&self, locked: Option<bool>) -> bool {
attempt_allowed(locked, self.capture_while_locked)
}
#[cfg(test)] #[cfg(test)]
pub fn with_lock_state(screen: Arc<ScreenCapture>, locked: watch::Receiver<Option<bool>>) -> Self { pub fn with_lock_state(screen: Arc<ScreenCapture>, locked: watch::Receiver<Option<bool>>) -> Self {
Self::with_lock_state_and_capture(screen, locked, false)
}
#[cfg(test)]
pub fn with_lock_state_and_capture(screen: Arc<ScreenCapture>, locked: watch::Receiver<Option<bool>>,
capture_while_locked: bool) -> Self {
Self { state: watch::channel(State { waiting: screen.init_error.is_some(), screen }).0, Self { state: watch::channel(State { waiting: screen.init_error.is_some(), screen }).0,
opening: Arc::new(Mutex::new(())), locked } opening: Arc::new(Mutex::new(())), locked, capture_while_locked }
} }
#[cfg(test)] #[cfg(test)]
pub fn publish_test_screen(&self, screen: Arc<ScreenCapture>) { pub fn publish_test_screen(&self, screen: Arc<ScreenCapture>) {
@@ -196,22 +256,27 @@ impl PortalDesktop {
let inhibit = Arc::new(inhibit); let inhibit = Arc::new(inhibit);
let open = Arc::new(open); let open = Arc::new(open);
let mut locked = self.locked.clone(); let mut locked = self.locked.clone();
let mut previous = None; let allow_locked = self.capture_while_locked;
let mut previous: Option<Option<bool>> = None;
let mut defer_until_unlock = false;
let mut retry_at = Instant::now(); let mut retry_at = Instant::now();
loop { loop {
if !owner.is_current() { return Ok(()); } if !owner.is_current() { return Ok(()); }
let state = *locked.borrow_and_update(); let state = *locked.borrow_and_update();
if state != Some(false) { if state == Some(false) { defer_until_unlock = false; }
if previous == Some(false) { self.pause(&owner); } if state != Some(false) && previous == Some(Some(false)) { self.pause(&owner); }
} else { if state == Some(true) && previous != Some(Some(true)) && allow_locked {
// A fresh unlocked transition gets an immediate wake/recovery attempt. log::info!("Desktop is locked; opening Portal capture for the lock screen");
let force_wake = previous != Some(false); }
if attempt_allowed(state, allow_locked) && !defer_until_unlock {
// A fresh transition into an attempted state gets an immediate wake/recovery attempt.
let force_wake = fresh_state(previous, state);
if force_wake { retry_at = Instant::now(); } if force_wake { retry_at = Instant::now(); }
let mut attempt_locked = locked.clone(); let mut attempt_locked = locked.clone();
let outcome = tokio::select! { let outcome = tokio::select! {
biased; biased;
_ = wait_for_lock(&mut locked) => AttemptOutcome::Cancelled, _ = wait_for_lock(&mut locked, allow_locked) => AttemptOutcome::Cancelled,
outcome = self.portal_attempt(&owner, &mut attempt_locked, retry_at, force_wake, wake.clone(), inhibit.clone(), open.clone()) => outcome, outcome = self.portal_attempt(&owner, &mut attempt_locked, allow_locked, retry_at, force_wake, wake.clone(), inhibit.clone(), open.clone()) => outcome,
}; };
match outcome { match outcome {
AttemptOutcome::Ready(screen) => self.publish(&owner, screen), AttemptOutcome::Ready(screen) => self.publish(&owner, screen),
@@ -220,11 +285,12 @@ impl PortalDesktop {
log::warn!("Portal desktop recovery deferred: {error}"); log::warn!("Portal desktop recovery deferred: {error}");
retry_at = Instant::now() + std::time::Duration::from_secs(5); retry_at = Instant::now() + std::time::Duration::from_secs(5);
} }
AttemptOutcome::Deferred => { defer_until_unlock = true; }
AttemptOutcome::Cancelled => {} AttemptOutcome::Cancelled => {}
} }
if *locked.borrow_and_update() != Some(false) { self.pause(&owner); } if !attempt_allowed(*locked.borrow_and_update(), allow_locked) { self.pause(&owner); }
} }
previous = *locked.borrow_and_update(); previous = Some(*locked.borrow_and_update());
tokio::select! { tokio::select! {
_ = locked.changed() => {}, _ = locked.changed() => {},
_ = tokio::time::sleep(std::time::Duration::from_millis(200)) => {}, _ = tokio::time::sleep(std::time::Duration::from_millis(200)) => {},
@@ -233,20 +299,20 @@ impl PortalDesktop {
} }
async fn portal_attempt<W, I, O>(&self, owner: &Arc<DesktopInputSession>, async fn portal_attempt<W, I, O>(&self, owner: &Arc<DesktopInputSession>,
locked: &mut watch::Receiver<Option<bool>>, retry_at: Instant, force_wake: bool, locked: &mut watch::Receiver<Option<bool>>, allow_locked: bool, retry_at: Instant, force_wake: bool,
wake: Arc<W>, inhibit: Arc<I>, open: Arc<O>) -> AttemptOutcome wake: Arc<W>, inhibit: Arc<I>, open: Arc<O>) -> AttemptOutcome
where where
W: Fn() -> Result<(), String> + Send + Sync + 'static, W: Fn() -> Result<(), String> + Send + Sync + 'static,
I: Fn() -> IdleGuard + Send + Sync + 'static, I: Fn() -> IdleGuard + Send + Sync + 'static,
O: Fn(Arc<ScreenCapture>, Arc<AtomicBool>) -> Result<Arc<ScreenCapture>, PortalError> + Send + Sync + 'static, O: Fn(Arc<ScreenCapture>, Arc<AtomicBool>) -> Result<Arc<ScreenCapture>, PortalError> + Send + Sync + 'static,
{ {
if !owner.is_current() || *locked.borrow() != Some(false) || Instant::now() < retry_at { if !owner.is_current() || !attempt_allowed(*locked.borrow(), allow_locked) || Instant::now() < retry_at {
return AttemptOutcome::Cancelled; return AttemptOutcome::Cancelled;
} }
let gate = self.opening.clone().lock_owned().await; let gate = self.opening.clone().lock_owned().await;
// The state can change while this attempt waits for an earlier worker // The state can change while this attempt waits for an earlier worker
// to finish rotating the Portal permission token. // to finish rotating the Portal permission token.
if !owner.is_current() || *locked.borrow() != Some(false) { if !owner.is_current() || !attempt_allowed(*locked.borrow(), allow_locked) {
return AttemptOutcome::Cancelled; return AttemptOutcome::Cancelled;
} }
let screen = self.snapshot().screen; let screen = self.snapshot().screen;
@@ -263,6 +329,7 @@ impl PortalDesktop {
&prep_cancel, &prep_cancel,
&prep_owner, &prep_owner,
&prep_locked, &prep_locked,
allow_locked,
|| (*wake)(), || (*wake)(),
|| (*inhibit)(), || (*inhibit)(),
)).await { )).await {
@@ -274,7 +341,7 @@ impl PortalDesktop {
// Held by the cancellable async helper, not the blocking worker, so a // Held by the cancellable async helper, not the blocking worker, so a
// lock transition releases it while worker cleanup may still be running. // lock transition releases it while worker cleanup may still be running.
let _inhibitor = prep.inhibitor; let _inhibitor = prep.inhibitor;
if !owner.is_current() || *locked.borrow() != Some(false) { if !owner.is_current() || !attempt_allowed(*locked.borrow(), allow_locked) {
return AttemptOutcome::Cancelled; return AttemptOutcome::Cancelled;
} }
// A new controller can arrive while the cached Portal handle is alive // A new controller can arrive while the cached Portal handle is alive
@@ -290,19 +357,25 @@ impl PortalDesktop {
} }
open(screen, worker_cancel) open(screen, worker_cancel)
}).await; }).await;
if !owner.is_current() || *locked.borrow() != Some(false) { if !owner.is_current() || !attempt_allowed(*locked.borrow(), allow_locked) {
return AttemptOutcome::Cancelled; return AttemptOutcome::Cancelled;
} }
match result { match result {
Ok(Err(error)) if defer_consent(&error, *locked.borrow()) => {
// The consent dialog opened behind the lock screen cannot be approved here.
// Keep this connection alive and ask again after the local unlock.
log::info!("Portal consent is behind the lock screen; waiting for the local unlock");
AttemptOutcome::Deferred
}
Ok(result) => classify(result), Ok(result) => classify(result),
Err(_) => AttemptOutcome::Terminal("Portal initialization worker failed".into()), Err(_) => AttemptOutcome::Terminal("Portal initialization worker failed".into()),
} }
} }
} }
async fn wait_for_lock(locked: &mut watch::Receiver<Option<bool>>) { async fn wait_for_lock(locked: &mut watch::Receiver<Option<bool>>, allow_locked: bool) {
while locked.changed().await.is_ok() { while locked.changed().await.is_ok() {
if *locked.borrow_and_update() != Some(false) { return; } if !attempt_allowed(*locked.borrow_and_update(), allow_locked) { return; }
} }
} }
@@ -433,19 +506,19 @@ mod tests {
let wakes = AtomicUsize::new(0); let wakes = AtomicUsize::new(0);
let inhibitors = AtomicUsize::new(0); let inhibitors = AtomicUsize::new(0);
let cancelled = AtomicBool::new(true); let cancelled = AtomicBool::new(true);
assert!(prepare_attempt(&cancelled, &owner, &locked, assert!(prepare_attempt(&cancelled, &owner, &locked, false,
|| { wakes.fetch_add(1, Ordering::Relaxed); Ok(()) }, || { wakes.fetch_add(1, Ordering::Relaxed); Ok(()) },
|| { inhibitors.fetch_add(1, Ordering::Relaxed); IdleGuard::default() }).is_none()); || { inhibitors.fetch_add(1, Ordering::Relaxed); IdleGuard::default() }).is_none());
assert_eq!(wakes.load(Ordering::Relaxed), 0); assert_eq!(wakes.load(Ordering::Relaxed), 0);
cancelled.store(false, Ordering::Release); cancelled.store(false, Ordering::Release);
lock.send(Some(true)).unwrap(); lock.send(Some(true)).unwrap();
assert!(prepare_attempt(&cancelled, &owner, &locked, assert!(prepare_attempt(&cancelled, &owner, &locked, false,
|| { wakes.fetch_add(1, Ordering::Relaxed); Ok(()) }, || { wakes.fetch_add(1, Ordering::Relaxed); Ok(()) },
|| { inhibitors.fetch_add(1, Ordering::Relaxed); IdleGuard::default() }).is_none()); || { inhibitors.fetch_add(1, Ordering::Relaxed); IdleGuard::default() }).is_none());
assert_eq!(wakes.load(Ordering::Relaxed), 0); assert_eq!(wakes.load(Ordering::Relaxed), 0);
lock.send(Some(false)).unwrap(); lock.send(Some(false)).unwrap();
let locked_during_wake = lock.clone(); let locked_during_wake = lock.clone();
assert!(prepare_attempt(&cancelled, &owner, &locked, assert!(prepare_attempt(&cancelled, &owner, &locked, false,
|| { || {
wakes.fetch_add(1, Ordering::Relaxed); wakes.fetch_add(1, Ordering::Relaxed);
locked_during_wake.send(Some(true)).unwrap(); locked_during_wake.send(Some(true)).unwrap();
@@ -456,7 +529,7 @@ mod tests {
assert_eq!(inhibitors.load(Ordering::Relaxed), 0); assert_eq!(inhibitors.load(Ordering::Relaxed), 0);
lock.send(Some(false)).unwrap(); lock.send(Some(false)).unwrap();
let replacement = input.desktop_session(); let replacement = input.desktop_session();
assert!(prepare_attempt(&cancelled, &owner, &locked, assert!(prepare_attempt(&cancelled, &owner, &locked, false,
|| { wakes.fetch_add(1, Ordering::Relaxed); Ok(()) }, || { wakes.fetch_add(1, Ordering::Relaxed); Ok(()) },
|| { inhibitors.fetch_add(1, Ordering::Relaxed); IdleGuard::default() }).is_none()); || { inhibitors.fetch_add(1, Ordering::Relaxed); IdleGuard::default() }).is_none());
assert_eq!(wakes.load(Ordering::Relaxed), 1); assert_eq!(wakes.load(Ordering::Relaxed), 1);
@@ -471,6 +544,115 @@ mod tests {
drop(guard); drop(guard);
assert!(flag.load(Ordering::Acquire)); assert!(flag.load(Ordering::Acquire));
} }
#[test]
fn locked_capture_gate_follows_the_compositor_rule() {
assert!(attempt_allowed(Some(false), false));
assert!(!attempt_allowed(Some(true), false));
assert!(!attempt_allowed(None, false));
assert!(attempt_allowed(Some(true), true));
assert!(attempt_allowed(None, true));
}
#[test]
fn wake_and_retry_reset_once_per_lock_transition() {
assert!(fresh_state(None, Some(true)));
assert!(!fresh_state(Some(Some(true)), Some(true)));
assert!(fresh_state(Some(Some(true)), Some(false)));
assert!(!fresh_state(Some(Some(false)), Some(false)));
assert!(fresh_state(Some(Some(true)), None));
assert!(!fresh_state(Some(None), None));
}
#[test]
fn consent_failures_are_deferred_only_while_locked() {
for code in [4, 5] {
assert!(defer_consent(&PortalError { code }, Some(true)));
assert!(!defer_consent(&PortalError { code }, Some(false)));
assert!(!defer_consent(&PortalError { code }, None));
}
assert!(!defer_consent(&PortalError { code: 8 }, Some(true)));
assert!(!defer_consent(&PortalError { code: 13 }, Some(true)));
}
#[tokio::test]
async fn wait_for_lock_ends_on_a_lock_the_compositor_does_not_honor() {
use std::time::Duration;
let (lock, mut locked) = watch::channel(Some(false));
let mut task = tokio::spawn(async move { wait_for_lock(&mut locked, false).await; });
lock.send(Some(true)).unwrap();
tokio::time::timeout(Duration::from_secs(1), &mut task).await
.expect("lock must end the wait").unwrap();
}
#[tokio::test]
async fn wait_for_lock_ignores_lock_changes_when_capture_is_allowed() {
use std::time::Duration;
let (lock, mut locked) = watch::channel(Some(false));
let mut task = tokio::spawn(async move { wait_for_lock(&mut locked, true).await; });
lock.send(Some(true)).unwrap();
assert!(tokio::time::timeout(Duration::from_millis(100), &mut task).await.is_err(),
"lock cancelled an allowed wait");
lock.send(None).unwrap();
assert!(tokio::time::timeout(Duration::from_millis(100), &mut task).await.is_err(),
"unknown lock cancelled an allowed wait");
task.abort();
let _ = task.await;
}
#[test]
fn locked_attempt_is_allowed_when_the_compositor_keeps_the_stream() {
let input = Arc::new(crate::input::InputInjector::without_desktop());
let owner = input.desktop_session();
let (lock, locked) = watch::channel(Some(true));
let cancelled = AtomicBool::new(false);
let wakes = AtomicUsize::new(0);
assert!(prepare_attempt(&cancelled, &owner, &locked, true,
|| { wakes.fetch_add(1, Ordering::Relaxed); Ok(()) },
|| IdleGuard::default()).is_some());
lock.send(None).unwrap();
assert!(prepare_attempt(&cancelled, &owner, &locked, true,
|| { wakes.fetch_add(1, Ordering::Relaxed); Ok(()) },
|| IdleGuard::default()).is_some());
assert_eq!(wakes.load(Ordering::Relaxed), 2);
}
#[tokio::test]
async fn locked_capture_keeps_the_attempt_running() {
use std::time::Duration;
let (lock, locked) = watch::channel(Some(false));
let host = Arc::new(PortalDesktop::with_lock_state_and_capture(
Arc::new(ScreenCapture::unavailable("pending".into())), locked, true));
let input = Arc::new(crate::input::InputInjector::without_desktop());
let owner = input.desktop_session();
let releases = Arc::new(AtomicUsize::new(0));
let worker_release = Arc::new(AtomicBool::new(false));
let (started, mut started_rx) = tokio::sync::mpsc::unbounded_channel();
let task = tokio::spawn({
let host = host.clone();
let owner = owner.clone();
let releases = releases.clone();
let worker_release = worker_release.clone();
async move {
host.maintain_with(owner,
|| Ok(()),
move || IdleGuard(Some(Inhibitor::Fake(DropSignal(releases.clone())))),
move |screen, cancel| {
let _ = started.send(());
while !worker_release.load(Ordering::Acquire) && !cancel.load(Ordering::Acquire) {
std::thread::sleep(Duration::from_millis(1));
}
if cancel.load(Ordering::Acquire) { return Err(PortalError { code: 13 }); }
Ok(screen)
}).await
}
});
started_rx.recv().await.unwrap();
lock.send(Some(true)).unwrap();
tokio::time::sleep(Duration::from_millis(50)).await;
assert_eq!(releases.load(Ordering::Relaxed), 0, "lock released a compositor-backed attempt");
worker_release.store(true, Ordering::Release);
let deadline = tokio::time::Instant::now() + Duration::from_secs(2);
while host.snapshot().waiting {
assert!(tokio::time::Instant::now() < deadline, "locked attempt did not publish");
tokio::task::yield_now().await;
}
task.abort();
let _ = task.await;
}
#[tokio::test] #[tokio::test]
async fn lock_transition_cancels_blocked_attempt_and_releases_inhibitor() { async fn lock_transition_cancels_blocked_attempt_and_releases_inhibitor() {
let (lock, locked) = watch::channel(Some(false)); let (lock, locked) = watch::channel(Some(false));
+55 -2
View File
@@ -127,6 +127,11 @@ pub async fn run() -> Result<(), String> {
line("render node", writable(&std::env::var("UU_VAAPI_DEVICE").unwrap_or_else(|_| "/dev/dri/renderD128".into()))); line("render node", writable(&std::env::var("UU_VAAPI_DEVICE").unwrap_or_else(|_| "/dev/dri/renderD128".into())));
println!("-- audio"); println!("-- audio");
line(crate::i18n::s("麦克风输入", "microphone input"),
crate::i18n::s("控制端 Opus 到固定虚拟输入(可选)", "controller Opus to pinned virtual input (opt-in)"));
line("UU_MICROPHONE", if crate::microphone::requested() { crate::i18n::s("已启用", "enabled") } else { crate::i18n::s("已禁用", "disabled") });
line(crate::i18n::s("虚拟麦克风", "virtual microphone"), command_output("pactl", &["list", "short", "sources"]).await
.is_some_and(|sources| sources.lines().any(|line| line.split('\t').nth(1) == Some(crate::microphone::SOURCE))));
for tool in ["pactl", "pw-cli"] { for tool in ["pactl", "pw-cli"] {
line(tool, command_output("sh", &["-c", &format!("command -v {tool} >/dev/null && echo found || echo missing")]).await.unwrap_or_else(|| "unknown".into())); line(tool, command_output("sh", &["-c", &format!("command -v {tool} >/dev/null && echo found || echo missing")]).await.unwrap_or_else(|| "unknown".into()));
} }
@@ -147,11 +152,39 @@ pub async fn run() -> Result<(), String> {
Err(_) => line("config mode", "missing (run `uuremote-server login`)"), Err(_) => line("config mode", "missing (run `uuremote-server login`)"),
} }
line("service", command_output("systemctl", &["--user", "is-active", "uuremote-native.service"]).await.unwrap_or_else(|| "systemctl unavailable".into())); line("service", command_output("systemctl", &["--user", "is-active", "uuremote-native.service"]).await.unwrap_or_else(|| "systemctl unavailable".into()));
let running = command_output("pgrep", &["-c", "-x", "uuremote-server"]).await.filter(|n| !n.is_empty()).unwrap_or_else(|| "unknown".into()); let running = host_processes();
line("uuremote-server procs", format!("{running} (including this one; more than 2 means duplicates)")); line("uuremote-server procs", format!("{} (including this one; more than 2 means duplicates)", running.map_or_else(|| "unknown".into(), |n| n.to_string())));
if running.is_some_and(|n| n > 2) {
println!(" ! another host instance is running (check `pgrep -af uuremote`); stop the extra one, e.g. an old copy started by hand");
println!(" instances sharing one identity, on this or another machine, kick each other out of the room: never copy config.json between machines");
}
Ok(()) Ok(())
} }
/// Hosts re-exec through /proc/self/exe (comm "exe"), so match the executable's file name, not the process name.
/// Helpers a host spawns (Wayland capture, login window) are its children and are not separate instances.
fn host_processes() -> Option<usize> {
let hosts: Vec<(u32, u32)> = std::fs::read_dir("/proc").ok()?.flatten()
.filter_map(|entry| Some((entry.file_name().to_str()?.parse::<u32>().ok()?, entry.path())))
.filter(|(_, dir)| std::fs::read_link(dir.join("exe")).is_ok_and(|exe| is_host_executable(&exe)))
.filter_map(|(pid, dir)| Some((pid, parent_pid(&std::fs::read_to_string(dir.join("stat")).ok()?)?)))
.collect();
Some(top_level(&hosts))
}
/// Field 4 of /proc/<pid>/stat; the command name in field 2 may contain spaces and parentheses.
fn parent_pid(stat: &str) -> Option<u32> {
stat.rsplit_once(')')?.1.split_whitespace().nth(1)?.parse().ok()
}
fn top_level(hosts: &[(u32, u32)]) -> usize {
hosts.iter().filter(|(_, parent)| !hosts.iter().any(|(pid, _)| pid == parent)).count()
}
fn is_host_executable(exe: &std::path::Path) -> bool {
exe.file_name().and_then(|name| name.to_str()).is_some_and(|name| name.trim_end_matches(" (deleted)") == "uuremote-server")
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
#[test] #[test]
@@ -174,4 +207,24 @@ mod tests {
assert!(!super::missing_display(DesktopBackend::Wayland, false, None, None)); assert!(!super::missing_display(DesktopBackend::Wayland, false, None, None));
assert!(!super::missing_display(DesktopBackend::X11, true, None, None)); assert!(!super::missing_display(DesktopBackend::X11, true, None, None));
} }
#[test]
fn host_processes_match_the_executable_even_after_reexec() {
use std::path::Path;
for exe in ["/usr/bin/uuremote-server", "/home/u/.local/bin/uuremote-server", "/usr/bin/uuremote-server (deleted)"] {
assert!(super::is_host_executable(Path::new(exe)));
}
for exe in ["/usr/bin/uuremote-viewer", "/usr/bin/bash", "/usr/bin/uuremote-server-old"] {
assert!(!super::is_host_executable(Path::new(exe)));
}
}
#[test]
fn host_helpers_are_not_counted_as_instances() {
assert_eq!(super::parent_pid("8943 (exe) S 1699 8943 1699 0 -1"), Some(1699));
assert_eq!(super::parent_pid("12 (a) b (c) R 7 12"), Some(7));
// service 10 with a login window 11, a stale copy 20, doctor 30
assert_eq!(super::top_level(&[(10, 1), (11, 10), (20, 5), (30, 9)]), 3);
assert_eq!(super::top_level(&[(10, 1), (11, 10), (30, 9)]), 2);
}
} }
+1
View File
@@ -87,6 +87,7 @@ pub use native::symbol;
pub trait Missing { fn missing() -> Self; } pub trait Missing { fn missing() -> Self; }
impl Missing for () { fn missing() -> Self {} } impl Missing for () { fn missing() -> Self {} }
impl Missing for i32 { fn missing() -> Self { -1 } } impl Missing for i32 { fn missing() -> Self { -1 } }
impl Missing for usize { fn missing() -> Self { 0 } }
impl<T> Missing for *mut T { fn missing() -> Self { std::ptr::null_mut() } } impl<T> Missing for *mut T { fn missing() -> Self { std::ptr::null_mut() } }
/// Declares engine C functions: an `extern "C"` block when linked statically, or dlsym-resolved /// Declares engine C functions: an `extern "C"` block when linked statically, or dlsym-resolved
+70 -1
View File
@@ -147,6 +147,10 @@ fn io_error(e: &std::io::Error) -> u64 {
/// anything else is rooted at "/". /// anything else is rooted at "/".
pub fn normalize(path: &str) -> PathBuf { pub fn normalize(path: &str) -> PathBuf {
let p = path.replace('\\', "/"); let p = path.replace('\\', "/");
// Official Mac 4.46.0 UURemoteServer (x86_64, 0x10019f8a5–0x10019f9f7)
// resolves :/Default to its receive directory. iOS quick upload sends this alias;
// our receive directory is HOME, also reported in SystemMetrics/RemoteDownloadPath.
if p.trim_end_matches('/') == ":/Default" { return home(); }
// The host registers as a PC, so the viewer builds drive paths ("C:/x", or ":/" when it // The host registers as a PC, so the viewer builds drive paths ("C:/x", or ":/" when it
// knows no drive letter). Linux has a single root: any drive prefix maps to "/". // knows no drive letter). Linux has a single root: any drive prefix maps to "/".
let p = match p.split_once(':') { let p = match p.split_once(':') {
@@ -455,7 +459,10 @@ impl FileSession {
/// Upload to this host. receive_request{1 id,2 path,3 files,4 strategy,5 folder_name,6 list_data,7 task_unique_id} /// Upload to this host. receive_request{1 id,2 path,3 files,4 strategy,5 folder_name,6 list_data,7 task_unique_id}
fn receive_request(&self, rid: u64, f: &[WireField]) { fn receive_request(&self, rid: u64, f: &[WireField]) {
let id = TaskId::parse(f); let id = TaskId::parse(f);
let target = normalize(&get_text(f, 2)); let raw_target = get_text(f, 2);
let target = normalize(&raw_target);
log::info!("File transfer upload destination: default={} exists={}",
raw_target.replace('\\', "/").trim_end_matches('/') == ":/Default", target.is_dir());
let folder = get_text(f, 5); let folder = get_text(f, 5);
let strategy = get_uint(f, 4); let strategy = get_uint(f, 4);
let files = parse_files(get_all(f, 3), get_bytes(f, 6)); let files = parse_files(get_all(f, 3), get_bytes(f, 6));
@@ -561,6 +568,13 @@ impl FileSession {
fn send_request(self: &Arc<Self>, rid: u64, f: &[WireField]) { fn send_request(self: &Arc<Self>, rid: u64, f: &[WireField]) {
let id = TaskId::parse(f); let id = TaskId::parse(f);
let raw = get_text(f, 2); let raw = get_text(f, 2);
// Newer viewers (Windows 4.44.1, #208) send only the task id here; an empty path must not
// become "/" and walk the whole filesystem into a misleading permission error.
if raw.trim().is_empty() {
log::info!("File transfer send_request without path: task={} fields={:?}", id.task, f.iter().map(|x| x.number).collect::<Vec<_>>());
self.respond(rid, 2, Enc::default().msg(1, id.enc()).uint(2, FT_PROTOCOL));
return;
}
let path = normalize(&raw); let path = normalize(&raw);
let collected = collect_download(&path).map_err(|e| io_error(&e)); let collected = collect_download(&path).map_err(|e| io_error(&e));
let mut body = Enc::default().msg(1, id.enc()); let mut body = Enc::default().msg(1, id.enc());
@@ -715,6 +729,61 @@ mod tests {
assert_eq!(parse_files(vec![], Some(&gz.finish().unwrap())), files); assert_eq!(parse_files(vec![], Some(&gz.finish().unwrap())), files);
} }
#[test] #[test]
fn ios_default_path_resolves_to_the_advertised_receive_directory() {
for path in [":/Default", ":\\Default", ":/Default/"] {
assert_eq!(normalize(path), home());
assert!(!is_this_pc(path));
}
assert_eq!(normalize("/Default"), PathBuf::from("/Default"));
assert_eq!(normalize("C:/Default"), PathBuf::from("/Default"));
assert_eq!(normalize(":/Default-other"), PathBuf::from("/Default-other"));
}
#[test]
fn ios_quick_upload_checks_conflicts_writes_and_completes_in_default_directory() {
let name = format!(".uu-ios-test-{}-{}", std::process::id(),
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos());
let dir = home().join(&name);
std::fs::create_dir(&dir).unwrap();
struct Cleanup(PathBuf);
impl Drop for Cleanup { fn drop(&mut self) { let _ = std::fs::remove_dir_all(&self.0); } }
let _cleanup = Cleanup(dir.clone());
let rel = format!("{name}/x.bin");
std::fs::write(dir.join("x.bin"), b"old").unwrap();
let (tx, mut rx) = mpsc::unbounded_channel();
let s = FileSession::new(tx, Arc::new(AtomicU64::new(1)));
let call = |case: u32, body: Enc| {
let rpc = Enc::default().msg(1, Enc::default().uint(1, 17)).msg(8, Enc::default().msg(case, body));
assert!(s.handle(&decode_wire(&crate::initialization::envelope(1, 1, 21, &rpc.0)).unwrap()));
};
let response = |m: Vec<u8>, case: u32| {
let outer = decode_wire(&m).unwrap();
let rpc = decode_wire(get_bytes(&outer, 22).unwrap()).unwrap();
assert_eq!(get_uint(&decode_wire(get_bytes(&rpc, 1).unwrap()).unwrap(), 1), 17);
let ftp = decode_wire(get_bytes(&rpc, 4).unwrap()).unwrap();
get_bytes(&ftp, case).unwrap().to_vec()
};
call(11, Enc::default().text(1, ":/Default").text(2, &rel));
let exist = response(rx.try_recv().unwrap(), 8);
let exist = decode_wire(&exist).unwrap();
assert_eq!(get_text(&exist, 1), ":/Default");
assert_eq!(get_uint(&decode_wire(get_bytes(&exist, 2).unwrap()).unwrap(), 2), 1);
let id = TaskId { task: 991, index: 1 };
let info = FileInfo { rel_path: rel, size: 6, modified: 0 };
call(1, Enc::default().msg(1, id.enc()).text(2, ":/Default").bytes(6, &list_data(&[info])));
let received = response(rx.try_recv().unwrap(), 1);
assert_eq!(get_uint(&decode_wire(&received).unwrap(), 3), FT_SUCCEEDED);
call(3, Enc::default().msg(1, id.enc()).uint(3, 6));
let confirmed = response(rx.try_recv().unwrap(), 3);
assert_eq!(get_uint(&decode_wire(&confirmed).unwrap(), 3), FT_SUCCEEDED);
call(4, Enc::default().msg(1, id.enc()).bytes(3, b"abcdef"));
let block = response(rx.try_recv().unwrap(), 4);
assert_eq!(get_uint(&decode_wire(&block).unwrap(), 3), FT_SUCCEEDED);
call(9, Enc::default().msg(1, id.enc()).uint(2, FT_SUCCEEDED));
let done = response(rx.try_recv().unwrap(), 6);
assert_eq!(get_uint(&decode_wire(&done).unwrap(), 2), FT_SUCCEEDED);
assert_eq!(std::fs::read(dir.join("x.bin")).unwrap(), b"abcdef");
}
#[test]
fn upload_writes_blocks_and_confirms() { fn upload_writes_blocks_and_confirms() {
let dir = std::env::temp_dir().join(format!("uu-up-{}", std::process::id())); let dir = std::env::temp_dir().join(format!("uu-up-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap(); std::fs::create_dir_all(&dir).unwrap();
+40
View File
@@ -36,6 +36,46 @@ pub fn payload(mtu: usize, annex_b: &[u8]) -> Result<Vec<Bytes>, String> {
Ok(out) 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)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
+57
View File
@@ -0,0 +1,57 @@
//! UI language: Chinese (the official clients' wording) or English.
//! `UU_LANG=zh|en`, else the choice saved from the settings window (`language` next to config.json),
//! else the locale (`LC_ALL` / `LC_MESSAGES` / `LANG` starting with `zh` → Chinese, anything else → English).
use std::sync::OnceLock;
static ENGLISH: OnceLock<bool> = OnceLock::new();
fn parse(value: &str) -> Option<bool> {
let value = value.trim().to_ascii_lowercase();
if value.starts_with("zh") { Some(false) } else if value.starts_with("en") { Some(true) } else { None }
}
fn saved_path() -> std::path::PathBuf {
crate::config::path().parent().map_or_else(|| "language".into(), |dir| dir.join("language"))
}
fn detect() -> bool {
if let Some(english) = std::env::var("UU_LANG").ok().as_deref().and_then(parse) { return english; }
if let Some(english) = std::fs::read_to_string(saved_path()).ok().as_deref().and_then(parse) { return english; }
let locale = ["LC_ALL", "LC_MESSAGES", "LANG"].iter()
.find_map(|name| std::env::var(name).ok().filter(|v| !v.is_empty()));
!locale.is_some_and(|v| v.to_ascii_lowercase().starts_with("zh"))
}
pub fn english() -> bool { *ENGLISH.get_or_init(detect) }
/// Pick the text for the current language.
pub fn s(zh: &'static str, en: &'static str) -> &'static str { if english() { en } else { zh } }
/// Saves the settings-window choice; it applies on the next start.
pub fn save(english: bool) -> std::io::Result<()> {
let path = saved_path();
if let Some(dir) = path.parent() { std::fs::create_dir_all(dir)?; }
std::fs::write(path, if english { "en\n" } else { "zh\n" })
}
/// `tr!("连接失败:{e}", "Connection failed: {e}")` formats the string for the current language.
#[macro_export]
macro_rules! tr {
($zh:literal, $en:literal $(, $arg:expr)* $(,)?) => {
if $crate::i18n::english() { format!($en $(, $arg)*) } else { format!($zh $(, $arg)*) }
};
}
// The GTK windows (c_engine/i18n.h) ask the same question so both halves always agree.
#[no_mangle] pub extern "C" fn uu_i18n_english() -> std::os::raw::c_int { english().into() }
#[no_mangle] pub extern "C" fn uu_i18n_save(english: std::os::raw::c_int) -> std::os::raw::c_int {
save(english != 0).is_ok().into()
}
#[cfg(test)] mod tests {
#[test] fn language_values_are_parsed(){
assert_eq!(super::parse("zh_CN.UTF-8"),Some(false));
assert_eq!(super::parse("EN\n"),Some(true));
assert_eq!(super::parse("sr_RS"),None);
}
}
+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 //! 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 //! imported as a VA surface and converted/scaled by VPP, so the CPU never touches the pixels (XShm upload
//! when DRI3 is unavailable). //! 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 //! 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). //! 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_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_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_upload_host_buffer(engine: *mut VaapiEngineOpaque, host_ptr: *const u8, pitch: u32) -> libc::c_int;
fn vaapi_encode_frame( fn vaapi_encode_frame(
engine: *mut VaapiEngineOpaque, engine: *mut VaapiEngineOpaque,
@@ -130,6 +132,7 @@ impl Drop for SafeDri3Capture {
} }
pub struct Config { pub struct Config {
pub portal: Option<Arc<crate::portal::PortalSession>>,
pub display: String, pub display: String,
pub input: (u32, u32), pub input: (u32, u32),
pub output: Option<(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( fn run_vaapi(
config: Config, config: Config,
units: mpsc::Sender<EncodedUnit>, units: mpsc::Sender<EncodedUnit>,
@@ -257,6 +282,9 @@ fn run_vaapi(
return Err("Failed to create native VAAPI engine".into()); return Err("Failed to create native VAAPI engine".into());
} }
let engine = SafeVaapiEngine(raw_engine); 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. // 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())?; 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); 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> { fn vaapi_wait(dri3: &Option<SafeDri3Capture>, capture: &mut Option<DamageCapture>, timeout: Duration) -> Result<bool, String> {
match (dri3, capture) { match (dri3, capture) {
(Some(c), _) => match unsafe { dri3_capture_wait_damage(c.0, timeout.as_millis().min(1000) as i32) } { (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)] #[cfg(test)]
mod budget_tests { mod budget_tests {
use super::*; 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] #[tokio::test]
async fn closing_encoder_output_wakes_a_blocked_capture() { async fn closing_encoder_output_wakes_a_blocked_capture() {
let budget = Arc::new(Semaphore::new(0)); 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);
}
}
+928 -17
View File
File diff suppressed because it is too large. Load diff
+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}; use crate::{capture_setting::VideoCodec, desktop_session::PortalDesktop, video_track::VideoTrack};
async fn black_frame(codec: VideoCodec) -> Result<Bytes, String> { 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(); let mut command = crate::video::ffmpeg_command();
command.args(["-hide_banner", "-loglevel", "error", "-nostdin", command.args(["-hide_banner", "-loglevel", "error", "-nostdin",
"-f", "lavfi", "-i", "color=c=black:s=1280x720:r=1", "-frames:v", "1", "-f", "lavfi", "-i", "color=c=black:s=1280x720:r=1", "-frames:v", "1",
+135 -27
View File
@@ -8,7 +8,7 @@
//! (analysis/tools-fix-20261013/viewer-fieldmd.json). Results are written to the private //! (analysis/tools-fix-20261013/viewer-fieldmd.json). Results are written to the private
//! config file (chmod 600). Tokens and tickets are never printed or logged. //! config file (chmod 600). Tokens and tickets are never printed or logged.
use crate::auth::{Credentials, UUAuthClient}; use crate::auth::{Credentials, QrRequestErrorKind, UUAuthClient};
use crate::login_ui::{LoginUi, Tone}; use crate::login_ui::{LoginUi, Tone};
use serde_json::{json, Value}; use serde_json::{json, Value};
use std::time::Duration; use std::time::Duration;
@@ -127,6 +127,35 @@ fn render_qr(content: &str) -> Result<String, String> {
/// API code for an expired login QR code. /// API code for an expired login QR code.
const QR_EXPIRED: i64 = 1190; const QR_EXPIRED: i64 = 1190;
/// QR API errors must not echo server messages/validation fields: they may contain credentials.
fn qr_data<'a>(stage: &str, status: u16, body: &'a Value) -> Result<&'a Value, String> {
let code = body.get("code").and_then(Value::as_i64);
if status == 200 && code == Some(0) { return Ok(body.get("data").unwrap_or(&Value::Null)); }
Err(format!("{stage}: http_status={status} api_code={code:?}"))
}
#[derive(Debug, PartialEq, Eq)]
enum QrPollAction { Wait(i64), Scanned, Confirmed, Refresh(Duration), Failed(&'static str) }
/// Preserve the official refresh policy; a failed query says nothing about QR expiry.
fn qr_poll_action(last_status: i64, http_status: u16, body: &Value) -> QrPollAction {
if body.get("code").and_then(Value::as_i64) == Some(QR_EXPIRED) {
return QrPollAction::Failed(crate::i18n::s("二维码已失效","QR code expired"));
}
let Ok(data) = qr_data("qrcode status", http_status, body) else {
return QrPollAction::Failed(crate::i18n::s("二维码状态查询失败","QR status check failed"));
};
match data.get("status").and_then(Value::as_i64) {
Some(1) => QrPollAction::Wait(1),
Some(2) if last_status != 2 => QrPollAction::Scanned,
Some(2) => QrPollAction::Wait(2),
Some(0) => QrPollAction::Refresh(Duration::from_millis(350)),
Some(3) => QrPollAction::Refresh(Duration::ZERO),
Some(4) => QrPollAction::Confirmed,
_ => QrPollAction::Failed(crate::i18n::s("二维码状态响应异常","Unexpected QR status response")),
}
}
/// QR modules as RGBA pixels: `scale` pixels per module, `quiet` light modules around the code. /// QR modules as RGBA pixels: `scale` pixels per module, `quiet` light modules around the code.
fn qr_rgba(content: &str, scale: usize, quiet: usize) -> Result<(Vec<u8>, usize), String> { fn qr_rgba(content: &str, scale: usize, quiet: usize) -> Result<(Vec<u8>, usize), String> {
let code = qrcode::QrCode::new(content.as_bytes()).map_err(|e| format!("QR encode failed: {e}"))?; let code = qrcode::QrCode::new(content.as_bytes()).map_err(|e| format!("QR encode failed: {e}"))?;
@@ -218,10 +247,10 @@ pub async fn run(gui: bool) -> Result<(), String> {
}; };
match &result { match &result {
Ok(name) => { Ok(name) => {
ui.done(&format!("登录成功\n{name}")); ui.done(&crate::tr!("登录成功\n{name}","Signed in\n{name}"));
ui.status("登录信息已保存到本机配置,可以关闭此窗口", Tone::Ok); ui.status(crate::i18n::s("登录信息已保存到本机配置,可以关闭此窗口","Sign-in saved to the local config; you can close this window"), Tone::Ok);
} }
Err(e) => { eprintln!("login failed: {e}"); ui.status(&format!("登录失败:{e}"), Tone::Error); } Err(e) => { eprintln!("login failed: {e}"); ui.status(&crate::tr!("登录失败:{e}","Sign-in failed: {e}"), Tone::Error); }
} }
if ui.shown() { ui.wait_closed().await; } if ui.shown() { ui.wait_closed().await; }
result.map(|_| ()) result.map(|_| ())
@@ -243,7 +272,26 @@ pub fn prepare_identity() -> Result<(Value, Credentials), String> {
Ok((cfg, creds)) Ok((cfg, creds))
} }
/// Holds an exclusive lock beside config.json while a device identity is created: the host's own QR
/// window and the viewer's sign-in can run at once, and two `device/windows/init` calls would leave the
/// account bound to one device while config.json keeps the other (the host then shows as offline).
struct IdentityLock(std::fs::File);
impl IdentityLock {
fn acquire() -> Result<Self, String> {
use std::os::unix::io::AsRawFd;
let path = crate::config::path().with_extension("lock");
if let Some(dir) = path.parent() { let _ = std::fs::create_dir_all(dir); }
let file = std::fs::OpenOptions::new().create(true).truncate(false).write(true).open(&path).map_err(|_| "Cannot open the identity lock")?;
if unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX) } != 0 { return Err("Cannot lock the device identity".into()) }
Ok(Self(file))
}
}
impl Drop for IdentityLock { fn drop(&mut self) { use std::os::unix::io::AsRawFd; unsafe { libc::flock(self.0.as_raw_fd(), libc::LOCK_UN); } } }
pub async fn prepare_device() -> Result<(Value, Credentials), String> { pub async fn prepare_device() -> Result<(Value, Credentials), String> {
// Read the configuration only after taking the lock, so a waiting process sees the device the
// first one registered instead of creating its own.
let _lock = tokio::task::spawn_blocking(IdentityLock::acquire).await.map_err(|_| "Identity lock task failed")??;
let (mut cfg, mut creds) = prepare_identity()?; let (mut cfg, mut creds) = prepare_identity()?;
let get = |cfg: &Value, k: &str| std::env::var(format!("UU_{}", k.to_uppercase())).ok().filter(|v| !v.is_empty()) let get = |cfg: &Value, k: &str| std::env::var(format!("UU_{}", k.to_uppercase())).ok().filter(|v| !v.is_empty())
.or_else(|| cfg.get(k).and_then(|v| v.as_str()).map(str::to_owned)).unwrap_or_default(); .or_else(|| cfg.get(k).and_then(|v| v.as_str()).map(str::to_owned)).unwrap_or_default();
@@ -276,10 +324,18 @@ pub(crate) async fn flow(ui: &LoginUi) -> Result<String, String> {
// every QR within seconds (#68). // every QR within seconds (#68).
let timeout = Duration::from_secs(60); let timeout = Duration::from_secs(60);
loop { loop {
let (status, resp) = client.post_with_timeout("/api/v1/qrcode/gen/login", None, timeout).await?; let (status, resp) = match client.post_with_timeout("/api/v1/qrcode/gen/login", None, timeout).await {
let d = match data("qrcode gen", status, &resp) { Ok(r) => r,
Err(e) if e.response_received() => {
eprintln!("QR generation response failed: {e}");
wait_for_refresh(ui, crate::i18n::s("二维码加载失败","QR code failed to load")).await;
continue;
}
Err(e) => return Err(format!("QR generation failed: {e}")),
};
let d = match qr_data("qrcode gen", status, &resp) {
Ok(d) => d.clone(), Ok(d) => d.clone(),
Err(e) => { println!("QR code could not be loaded ({e})"); wait_for_refresh(ui, "二维码加载失败").await; continue; } Err(e) => { println!("QR code could not be loaded ({e})"); wait_for_refresh(ui, crate::i18n::s("二维码加载失败","QR code failed to load")).await; continue; }
}; };
let url = d.get("qrcode_jump_url").and_then(|v| v.as_str()).ok_or("qrcode gen returned no qrcode_jump_url")?.to_string(); let url = d.get("qrcode_jump_url").and_then(|v| v.as_str()).ok_or("qrcode gen returned no qrcode_jump_url")?.to_string();
let ticket = qr_ticket(&d).ok_or("qrcode gen returned no status ticket")?.to_string(); let ticket = qr_ticket(&d).ok_or("qrcode gen returned no status ticket")?.to_string();
@@ -288,7 +344,7 @@ pub(crate) async fn flow(ui: &LoginUi) -> Result<String, String> {
let modules = qrcode::QrCode::new(url.as_bytes()).map_err(|e| e.to_string())?.width() + 2; let modules = qrcode::QrCode::new(url.as_bytes()).map_err(|e| e.to_string())?.width() + 2;
let (rgba, edge) = qr_rgba(&url, (224 / modules).max(2), 1)?; let (rgba, edge) = qr_rgba(&url, (224 / modules).max(2), 1)?;
ui.qr(&rgba, edge); ui.qr(&rgba, edge);
ui.status("等待扫码…", Tone::Info); ui.status(crate::i18n::s("等待扫码…","Waiting for scan…"), Tone::Info);
} }
if let Some(path)=std::env::var_os("UU_LOGIN_QR_PNG") { if let Some(path)=std::env::var_os("UU_LOGIN_QR_PNG") {
use std::io::Write; use std::io::Write;
@@ -303,26 +359,44 @@ pub(crate) async fn flow(ui: &LoginUi) -> Result<String, String> {
let query = json!({"token": ticket, "qrcode_jump_url": url, "login_status": login_status}); let query = json!({"token": ticket, "qrcode_jump_url": url, "login_status": login_status});
let (status, resp) = match client.post_with_timeout("/api/v1/qrcode/login/status", Some(&query), timeout).await { let (status, resp) = match client.post_with_timeout("/api/v1/qrcode/login/status", Some(&query), timeout).await {
Ok(r) => r, Ok(r) => r,
Err(_) => break "网络超时,二维码已停止刷新", Err(e) => {
eprintln!("QR status query failed: {e}; last_status={login_status}");
break match e.kind {
QrRequestErrorKind::Timeout => crate::i18n::s("二维码状态查询超时(不代表二维码已失效)","QR status check timed out (the QR code may still be valid)"),
_ => crate::i18n::s("二维码状态查询失败(不代表二维码已失效)","QR status check failed (the QR code may still be valid)"),
}; };
let code = resp.get("code").and_then(|c| c.as_i64()); }
if code == Some(QR_EXPIRED) { break "二维码已失效"; } };
let Ok(d) = data("qrcode status", status, &resp) else { break "二维码状态查询失败"; }; match qr_poll_action(login_status, status, &resp) {
let st = d.get("status").and_then(|v| v.as_i64()).unwrap_or(login_status); QrPollAction::Wait(st) => {
match st { if st == 1 && login_status != 1 { ui.status(crate::i18n::s("等待扫码…","Waiting for scan…"), Tone::Info); }
1 => {} login_status = st;
2 => if login_status != 2 { }
QrPollAction::Scanned => {
login_status = 2;
println!("已扫码,请在手机上确认 (scanned, confirm on the phone)"); println!("已扫码,请在手机上确认 (scanned, confirm on the phone)");
ui.status("已扫码,请在手机上确认登录", Tone::Ok); ui.status(crate::i18n::s("已扫码,请在手机上确认登录","Scanned, confirm the sign-in on your phone"), Tone::Ok);
}, }
3 => { println!("QR code expired; generating a new one"); break ""; } QrPollAction::Refresh(delay) => {
0 => { tokio::time::sleep(Duration::from_millis(350)).await; break ""; } if delay.is_zero() { println!("QR code expired; generating a new one"); }
4 => { else { tokio::time::sleep(delay).await; }
break "";
}
QrPollAction::Confirmed => {
println!("已确认,正在完成登录 (confirmed, completing login)");
ui.status(crate::i18n::s("已确认,正在完成登录…","Confirmed, finishing sign-in…"), Tone::Info);
let body = json!({"token": ticket, "qrcode_jump_url": url}); let body = json!({"token": ticket, "qrcode_jump_url": url});
let (status, resp) = client.post_with_timeout("/api/v1/login/by_qrcode", Some(&body), timeout).await?; let (status, resp) = match client.post_with_timeout("/api/v1/login/by_qrcode", Some(&body), timeout).await {
let d = match data("qrcode login", status, &resp) { Ok(r) => r,
Err(e) if e.response_received() => {
eprintln!("QR login exchange response failed: {e}");
break crate::i18n::s("登录失败","Sign-in failed");
}
Err(e) => return Err(format!("QR login exchange failed: {e}")),
};
let d = match qr_data("qrcode login", status, &resp) {
Ok(d) => d, Ok(d) => d,
Err(e) => { println!("QR login not granted ({e})"); break "登录失败"; } Err(e) => { println!("QR login not granted ({e})"); break crate::i18n::s("登录失败","Sign-in failed"); }
}; };
let token = d.get("token").and_then(|v| v.as_str()).ok_or("login returned no token")?; let token = d.get("token").and_then(|v| v.as_str()).ok_or("login returned no token")?;
let user = d.get("user_id").and_then(|v| v.as_str()).ok_or("login returned no user_id")?; let user = d.get("user_id").and_then(|v| v.as_str()).ok_or("login returned no user_id")?;
@@ -339,9 +413,12 @@ pub(crate) async fn flow(ui: &LoginUi) -> Result<String, String> {
println!("Logged in as {} ({}); saved to {}", nickname, user, path.display()); println!("Logged in as {} ({}); saved to {}", nickname, user, path.display());
return Ok(if nickname.is_empty() { user.to_string() } else { nickname.to_string() }); return Ok(if nickname.is_empty() { user.to_string() } else { nickname.to_string() });
} }
other => { println!("QR status: {other}"); break "二维码已失效"; } QrPollAction::Failed(reason) => {
eprintln!("QR status query stopped: http_status={status} api_code={:?} status={:?} last_status={login_status}",
resp.get("code").and_then(Value::as_i64), resp.get("data").and_then(|d| d.get("status")).and_then(Value::as_i64));
break reason;
}
} }
login_status = st;
}; };
if !failure.is_empty() { wait_for_refresh(ui, failure).await; } if !failure.is_empty() { wait_for_refresh(ui, failure).await; }
} }
@@ -357,7 +434,7 @@ fn qr_ticket(gen: &Value) -> Option<&str> {
/// or (no window and no terminal, e.g. a service) one minute. /// or (no window and no terminal, e.g. a service) one minute.
async fn wait_for_refresh(ui: &LoginUi, reason: &str) { async fn wait_for_refresh(ui: &LoginUi, reason: &str) {
use std::io::IsTerminal; use std::io::IsTerminal;
ui.status(&format!("{reason},请点击「刷新二维码」"), Tone::Error); ui.status(&crate::tr!("{reason},请点击「刷新二维码」","{reason}. Click \"Refresh QR code\"."), Tone::Error);
ui.offer_refresh(true); ui.offer_refresh(true);
let terminal = !ui.quiet() && std::io::stdin().is_terminal(); let terminal = !ui.quiet() && std::io::stdin().is_terminal();
if terminal { println!("{reason}. Press Enter to show a new QR code (按回车刷新二维码)"); } if terminal { println!("{reason}. Press Enter to show a new QR code (按回车刷新二维码)"); }
@@ -376,6 +453,37 @@ async fn wait_for_refresh(ui: &LoginUi, reason: &str) {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
#[test]
fn qr_poll_keeps_waiting_scanned_and_confirmed_distinct() {
let reply = |status| json!({"code": 0, "data": {"status": status}});
assert_eq!(qr_poll_action(1, 200, &reply(1)), QrPollAction::Wait(1));
assert_eq!(qr_poll_action(1, 200, &reply(2)), QrPollAction::Scanned);
assert_eq!(qr_poll_action(2, 200, &reply(2)), QrPollAction::Wait(2));
assert_eq!(qr_poll_action(2, 200, &reply(4)), QrPollAction::Confirmed);
assert_eq!(qr_poll_action(1, 200, &reply(0)), QrPollAction::Refresh(Duration::from_millis(350)));
assert_eq!(qr_poll_action(2, 200, &reply(3)), QrPollAction::Refresh(Duration::ZERO));
assert_eq!(qr_poll_action(2, 400, &json!({"code": 1190})), QrPollAction::Failed(crate::i18n::s("二维码已失效","QR code expired")));
}
#[test]
fn qr_poll_failures_do_not_imply_expiry_or_confirmation() {
for last in [1, 2] {
for body in [json!(null), json!({"code": 1}), json!({"code": 0, "data": {"status": 4}})] {
assert_eq!(qr_poll_action(last, 503, &body), QrPollAction::Failed(crate::i18n::s("二维码状态查询失败","QR status check failed")));
}
assert_eq!(qr_poll_action(last, 200, &json!({"code": 1})), QrPollAction::Failed(crate::i18n::s("二维码状态查询失败","QR status check failed")));
for data in [json!(null), json!({}), json!({"status": "4"}), json!({"status": 99}), json!({"status": -1})] {
assert_eq!(qr_poll_action(last, 200, &json!({"code": 0, "data": data})), QrPollAction::Failed(crate::i18n::s("二维码状态响应异常","Unexpected QR status response")));
}
}
}
#[test]
fn qr_api_errors_do_not_echo_server_content() {
let body = json!({"code": 1001, "msg": "fixture-token", "data": [{"loc": "fixture-ticket"}]});
assert_eq!(qr_data("qrcode gen", 400, &body).unwrap_err(), "qrcode gen: http_status=400 api_code=Some(1001)");
}
#[test] #[test]
fn status_ticket_prefers_status_query_ticket() { fn status_ticket_prefers_status_query_ticket() {
assert_eq!(qr_ticket(&json!({"token": "old", "status_query_ticket": "new"})), Some("new")); assert_eq!(qr_ticket(&json!({"token": "old", "status_query_ticket": "new"})), Some("new"));
+62 -15
View File
@@ -1,9 +1,11 @@
//! UU Remote Pure Native Linux Server (Rust Edition) //! UU Remote Pure Native Linux Server (Rust Edition)
//! Zero-Wine, Zero-Python, Single-Binary, 5 Native Tools Integrated //! Zero-Wine, Zero-Python, Single-Binary, 5 Native Tools Integrated
mod ws_transport;
mod engine_plugin; mod engine_plugin;
mod doctor; mod doctor;
mod wol; mod wol;
mod wallpaper;
mod desktop_backend; mod desktop_backend;
mod desktop_mode; mod desktop_mode;
mod desktop_session; mod desktop_session;
@@ -15,6 +17,7 @@ mod wayland;
mod auth; mod auth;
mod assist; mod assist;
mod config; mod config;
mod i18n;
mod login; mod login;
mod login_ui; mod login_ui;
mod session_lock; mod session_lock;
@@ -42,8 +45,11 @@ mod damage_capture;
mod inproc_encoder; mod inproc_encoder;
mod capture_setting; mod capture_setting;
mod audio; mod audio;
mod microphone;
mod virtual_audio; mod virtual_audio;
mod privacy_screen;
mod system_actions; mod system_actions;
mod annotation;
mod capability; mod capability;
mod protocol; mod protocol;
mod control_protocol; mod control_protocol;
@@ -69,6 +75,8 @@ use webrtc::WebRtcSession;
/// Set before a normal return when the host must come back in the other mode (signed in / out). /// Set before a normal return when the host must come back in the other mode (signed in / out).
static RESTART: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false); static RESTART: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
struct AbortOnDrop(tokio::task::AbortHandle);
impl Drop for AbortOnDrop { fn drop(&mut self) { self.0.abort(); } }
fn superseded_peer_ids(sessions: &HashMap<String, WebRtcSession>, ice: &str, desktop: bool) -> Vec<String> { fn superseded_peer_ids(sessions: &HashMap<String, WebRtcSession>, ice: &str, desktop: bool) -> Vec<String> {
sessions.iter().filter(|(id, peer)| id.as_str() == ice || (desktop && peer.desktop)) sessions.iter().filter(|(id, peer)| id.as_str() == ice || (desktop && peer.desktop))
.map(|(id, _)| id.clone()).collect() .map(|(id, _)| id.clone()).collect()
@@ -204,7 +212,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"]; "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). /// Unknown arguments and illegal set-encoder / set-codec values exit 2 (never start a second host).
@@ -626,9 +634,26 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
if login::run(gui).await.is_err() { std::process::exit(1); } // error already shown if login::run(gui).await.is_err() { std::process::exit(1); } // error already shown
return Ok(()); 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(); virtual_audio::init();
let _audio_cleanup=virtual_audio::Cleanup; let _audio_cleanup=virtual_audio::Cleanup;
microphone::init();
let _microphone_cleanup = microphone::Cleanup;
log::info!("Starting uu-remote-linux host v{}...", env!("CARGO_PKG_VERSION")); log::info!("Starting uu-remote-linux host v{}...", env!("CARGO_PKG_VERSION"));
session_ice::configure_relay_transport();
// Before host.pid, and before assist: a missing or failed assist session must still handle SIGUSR2. // Before host.pid, and before assist: a missing or failed assist session must still handle SIGUSR2.
let _ = install_host_signals(None); let _ = install_host_signals(None);
video::warm_auto_probe(); video::warm_auto_probe();
@@ -663,7 +688,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
} }
#[cfg(not(target_os="linux"))] #[cfg(not(target_os="linux"))]
let _ = tokio::signal::ctrl_c().await; let _ = tokio::signal::ctrl_c().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(); microphone::shutdown().await; virtual_audio::disable(); terminal::shutdown_all(); std::process::exit(0); }
let _ = signal_tx.send(true); let _ = signal_tx.send(true);
}); });
let mut assist = if assist_enabled { Some(assist::Assist::start(&mut shutdown, unified).await?) } else { None }; let mut assist = if assist_enabled { Some(assist::Assist::start(&mut shutdown, unified).await?) } else { None };
@@ -694,7 +719,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
// One exit path for commands, signals, transport failures and UI failures. // One exit path for commands, signals, transport failures and UI failures.
if let Some(session) = assist.as_mut() { session.allowed = false; } if let Some(session) = assist.as_mut() { session.allowed = false; }
for (_, old) in webrtc_sessions.lock().await.drain() { close_peer(&old.pc).await; } for (_, old) in webrtc_sessions.lock().await.drain() { close_peer(&old.pc).await; }
virtual_audio::disable(); input.shutdown(); terminal::shutdown_all(); privacy_screen::shutdown(); microphone::shutdown().await; virtual_audio::disable(); input.shutdown(); terminal::shutdown_all();
// Switching identity (signed in / out) restarts at once and the new identity republishes the same // 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 // 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. // (a guest cancel then fails). Only a real stop withdraws here.
@@ -711,6 +736,21 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
assist: &mut Option<assist::Assist>, commands: &mut mpsc::Receiver<assist::Command>, webrtc_sessions: Arc<Mutex<HashMap<String, WebRtcSession>>>) -> Result<(), Box<dyn std::error::Error>> { assist: &mut Option<assist::Assist>, commands: &mut mpsc::Receiver<assist::Command>, webrtc_sessions: Arc<Mutex<HashMap<String, WebRtcSession>>>) -> Result<(), Box<dyn std::error::Error>> {
let portal_desktop = (capture.backend == desktop_backend::DesktopBackend::Portal && !desktop_backend::headless()) let portal_desktop = (capture.backend == desktop_backend::DesktopBackend::Portal && !desktop_backend::headless())
.then(|| Arc::new(desktop_session::PortalDesktop::new(capture.clone()))); .then(|| Arc::new(desktop_session::PortalDesktop::new(capture.clone())));
// Stop sharing the screen once no desktop controller is left. Viewers send stop_capture
// before leaving and phones reconnect within seconds, so require two idle checks in a row.
let idle_watch = portal_desktop.clone().map(|portal| {
let sessions = webrtc_sessions.clone();
tokio::spawn(async move {
let mut idle = 0u8;
loop {
tokio::time::sleep(std::time::Duration::from_secs(2)).await;
if sessions.lock().await.values().any(|s| s.role.is_desktop()) { idle = 0; continue; }
idle = idle.saturating_add(1);
if idle >= 2 { portal.end_idle(); }
}
})
});
let _idle_watch = idle_watch.map(|task| AbortOnDrop(task.abort_handle()));
let mut auth = if let Some(session) = assist.as_ref() { session.client.clone() } else { let mut auth = if let Some(session) = assist.as_ref() { session.client.clone() } else {
let creds = match config::file().and_then(Credentials::load) { let creds = match config::file().and_then(Credentials::load) {
Ok(creds) => creds, Ok(creds) => creds,
@@ -740,11 +780,12 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
client client
}; };
let mut wallpaper_task = AbortOnDrop(wallpaper::start(auth.clone()));
// One peer per viewer connection (desktop, file transfer, terminal...), keyed by ice_id. // 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 next_capture_type: Option<(u64,crate::session_ice::SessionIce)> = None;
let mut capture_types: HashMap<String, (u64,crate::session_ice::SessionIce)> = HashMap::new(); let mut capture_types: HashMap<String, (u64,crate::session_ice::SessionIce)> = HashMap::new();
let mut mac_by_ice: HashMap<String, bool> = HashMap::new(); let mut controller_by_ice: HashMap<String, crate::input::Controller> = HashMap::new();
let mut next_mac = false; let mut next_controller = crate::input::Controller::Other;
// Tool peers ask here to become the desktop (capture_desktop on an existing connection, #99). // Tool peers ask here to become the desktop (capture_desktop on an existing connection, #99).
let (desktop_requests, mut desktop_requested) = mpsc::unbounded_channel::<String>(); let (desktop_requests, mut desktop_requested) = mpsc::unbounded_channel::<String>();
@@ -777,6 +818,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"); 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)); 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)); auth = Arc::new(UUAuthClient::new(login::wait_for_credentials(stale).await));
wallpaper_task.0.abort();
wallpaper_task = AbortOnDrop(wallpaper::start(auth.clone()));
continue; continue;
} }
Err(e) => { Err(e) => {
@@ -816,8 +859,8 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
Arc::new(cli) Arc::new(cli)
} }
Err(e) => { Err(e) => {
let _ = e; // ws_transport errors carry only a category or HTTP status, never the token or URL.
log::error!("Failed to connect signaling; retrying in 5s (details omitted)"); log::error!("Failed to connect signaling; retrying in 5s: {e}");
tokio::time::sleep(tokio::time::Duration::from_secs(5)).await; tokio::time::sleep(tokio::time::Duration::from_secs(5)).await;
continue; continue;
} }
@@ -868,6 +911,8 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
let mut desktop_ended = false; let mut desktop_ended = false;
for id in ended { if let Some(s) = sessions.remove(&id) { desktop_ended |= s.role.is_desktop(); close_peer(&s.pc).await; } } for id in ended { if let Some(s) = sessions.remove(&id) { desktop_ended |= s.role.is_desktop(); close_peer(&s.pc).await; } }
if desktop_ended && !sessions.values().any(|s| s.role.is_desktop()) { if let Some(s) = assist.as_mut() { s.session_ended()?; } } if desktop_ended && !sessions.values().any(|s| s.role.is_desktop()) { if let Some(s) = assist.as_mut() { s.session_ended()?; } }
// The controller left: stop sharing now; reconnecting reopens silently with the saved consent.
if !sessions.values().any(|s| s.role.is_desktop()) { if let Some(portal) = &portal_desktop { portal.end_idle(); } }
if let Some(s) = assist.as_mut() { s.tick()?; } if let Some(s) = assist.as_mut() { s.tick()?; }
} }
SignalingEvent::Connected => { SignalingEvent::Connected => {
@@ -929,9 +974,9 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
.and_then(|s| s.as_str()) .and_then(|s| s.as_str())
); );
} }
SignalingEvent::ConnectRequest { capture_type, ice_id, transport, controller_mac } => { SignalingEvent::ConnectRequest { capture_type, ice_id, transport, controller } => {
if mac_by_ice.len()>=32 { mac_by_ice.clear(); } if controller_by_ice.len()>=32 { controller_by_ice.clear(); }
match ice_id.clone() { Some(id) => { mac_by_ice.insert(id, controller_mac); } None => next_mac = controller_mac } match ice_id.clone() { Some(id) => { controller_by_ice.insert(id, controller); } None => next_controller = controller }
// Pending cloud credentials live only within this room; cap // Pending cloud credentials live only within this room; cap
// requests that never receive an offer rather than retain them. // requests that never receive an offer rather than retain them.
if capture_types.len()>=32 { capture_types.clear(); } if capture_types.len()>=32 { capture_types.clear(); }
@@ -962,8 +1007,8 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
let (capture_type,transport) = capture_types.remove(&ice).or_else(|| next_capture_type.take()).unwrap_or((1,crate::session_ice::SessionIce::default())); let (capture_type,transport) = capture_types.remove(&ice).or_else(|| next_capture_type.take()).unwrap_or((1,crate::session_ice::SessionIce::default()));
// CaptureType: 0 unknown, 1 desktop, 2 window; 5 file transfer, 8 terminal, 9 port mapping. // CaptureType: 0 unknown, 1 desktop, 2 window; 5 file transfer, 8 terminal, 9 port mapping.
let desktop = capture_type <= 2; let desktop = capture_type <= 2;
let controller_mac = mac_by_ice.remove(&ice).unwrap_or(next_mac); let controller = controller_by_ice.remove(&ice).unwrap_or(next_controller);
if desktop { input.set_mac_controller(controller_mac); } if desktop { input.set_controller(controller); }
log::info!("Offer for connection: capture_type={} desktop={} active_peers={}", capture_type, desktop, sessions.len()); log::info!("Offer for connection: capture_type={} desktop={} active_peers={}", capture_type, desktop, sessions.len());
// An expired NVENC failure is re-probed in the background. This offer keeps the cached encoder. // An expired NVENC failure is re-probed in the background. This offer keeps the cached encoder.
if desktop { video::warm_auto_probe(); video::check_ffmpeg_usable(); } if desktop { video::warm_auto_probe(); video::check_ffmpeg_usable(); }
@@ -995,7 +1040,8 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
match WebRtcSession::new(session_capture, input.clone(), signaling_client.clone(), desktop, transport, match WebRtcSession::new(session_capture, input.clone(), signaling_client.clone(), desktop, transport,
if desktop { portal_desktop.clone() } else { None }).await { if desktop { portal_desktop.clone() } else { None }).await {
Ok(mut sess) => { Ok(mut sess) => {
sess.controller_mac = controller_mac; sess.controller = controller;
if desktop { crate::privacy_screen::set_viewer_controller(controller); }
if !desktop { if !desktop {
let (requests, peer) = (desktop_requests.clone(), ice.clone()); let (requests, peer) = (desktop_requests.clone(), ice.clone());
sess.on_desktop_request(move || { let _ = requests.send(peer.clone()); }); sess.on_desktop_request(move || { let _ = requests.send(peer.clone()); });
@@ -1062,7 +1108,7 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
log::info!("Desktop request on a tool connection not supported with the Portal backend; open the desktop before port mapping"); log::info!("Desktop request on a tool connection not supported with the Portal backend; open the desktop before port mapping");
continue; continue;
} }
let controller_mac = peer.controller_mac; let controller = peer.controller;
let current = peer.desktop_capture(); let current = peer.desktop_capture();
// Same recovery as a desktop offer: the display may have come up or been resized after this peer. // Same recovery as a desktop offer: the display may have come up or been resized after this peer.
let resized = current.init_error.is_none() && current.backend == desktop_backend::DesktopBackend::X11 let resized = current.init_error.is_none() && current.backend == desktop_backend::DesktopBackend::X11
@@ -1076,7 +1122,8 @@ async fn serve(mut capture: Arc<ScreenCapture>, input: Arc<InputInjector>, shutd
} }
} else { None }; } else { None };
video::warm_auto_probe(); video::check_ffmpeg_usable(); video::warm_auto_probe(); video::check_ffmpeg_usable();
input.set_mac_controller(controller_mac); input.set_controller(controller);
crate::privacy_screen::set_viewer_controller(controller);
input.bind_portal(screen.as_ref().map_or_else(|| sessions[&ice].capture.portal.clone(), |screen| screen.portal.clone())); input.bind_portal(screen.as_ref().map_or_else(|| sessions[&ice].capture.portal.clone(), |screen| screen.portal.clone()));
// One desktop at a time, as for a new desktop offer. Peers offered as desktops // One desktop at a time, as for a new desktop offer. Peers offered as desktops
// close; a promoted tool peer only stops its desktop and keeps its tools. // close; a promoted tool peer only stops its desktop and keeps its tools.
+439
View File
@@ -0,0 +1,439 @@
//! Controller Opus -> a dedicated virtual microphone. Never record or log audio payloads.
//! Opt in with UU_MICROPHONE=1. The normal desktop-output/monitor route is not changed.
use std::collections::HashMap;
use std::os::fd::AsRawFd;
use std::process::{Command, Stdio};
use std::sync::{Arc, Mutex, OnceLock, atomic::{AtomicBool, Ordering}};
use std::time::Duration;
use tokio::io::{AsyncWrite, AsyncWriteExt};
use tokio::sync::watch;
use webrtc::{peer_connection::{RTCPeerConnection, peer_connection_state::RTCPeerConnectionState},
rtp::packet::Packet, rtp_transceiver::rtp_codec::RTPCodecType, track::track_remote::TrackRemote};
mod pulse;
pub const SOURCE: &str = "uu-remote-microphone";
const SINK: &str = "uu-remote-mic-input";
const MAX_PACKETS: u16 = 12;
static AVAILABLE: AtomicBool = AtomicBool::new(false);
static ROUTE: OnceLock<Mutex<Option<Route>>> = OnceLock::new();
struct Workers { stopped: watch::Sender<bool>, active: watch::Sender<usize> }
fn workers() -> &'static Workers {
static STATE: OnceLock<Workers> = OnceLock::new();
STATE.get_or_init(|| Workers { stopped: watch::channel(false).0, active: watch::channel(0).0 })
}
struct Worker;
impl Worker {
fn new() -> Self { workers().active.send_modify(|count| *count += 1); Self }
}
impl Drop for Worker {
fn drop(&mut self) { workers().active.send_modify(|count| *count -= 1); }
}
struct Module { id: u32, kind: &'static str, args: Vec<String> }
struct Route { source: Module, sink: Module, _lock: std::fs::File }
pub fn requested() -> bool { std::env::var("UU_MICROPHONE").is_ok_and(|v| v == "1") }
pub fn available() -> bool { AVAILABLE.load(Ordering::Acquire) }
pub fn policy_request(rpc: &[crate::protocol::WireField]) -> Option<u64> {
use crate::protocol::{decode_wire, WireValue};
let body = rpc.iter().find_map(|f| match (f.number, &f.value) { (21, WireValue::Bytes(b)) => Some(*b), _ => None })?;
let fields = decode_wire(body).ok()?;
Some(fields.iter().find_map(|f| match (f.number, &f.value) { (1, WireValue::Varint(v)) => Some(*v), _ => None }).unwrap_or(0))
}
fn pactl(args: &[&str]) -> Result<String, String> {
let out = Command::new("pactl").args(args).env("LC_ALL", "C")
.stdin(Stdio::null()).stderr(Stdio::null()).output().map_err(|_| "pactl unavailable")?;
if !out.status.success() { return Err("PulseAudio virtual microphone operation failed".into()); }
Ok(String::from_utf8_lossy(&out.stdout).trim().to_owned())
}
impl Module {
fn matching_id(line: &str, kind: &str, args: &[String]) -> Option<u32> {
let mut fields = line.split('\t');
let id = fields.next()?.parse().ok()?;
if fields.next()? != kind { return None; }
let actual: Vec<_> = fields.next()?.split_whitespace().collect();
(actual.len() == args.len() && args.iter().all(|arg| actual.contains(&arg.as_str()))).then_some(id)
}
fn open(kind: &'static str, args: Vec<String>) -> Result<Self, String> {
let modules = pactl(&["list", "short", "modules"])?;
let key = &args[0];
let named: Vec<_> = modules.lines().filter(|line| line.split('\t').nth(2)
.is_some_and(|a| a.split_whitespace().any(|a| a == key))).collect();
let id = if named.is_empty() {
let mut command = vec!["load-module", kind];
command.extend(args.iter().map(String::as_str));
pactl(&command)?.parse().map_err(|_| "Virtual microphone module returned no id")?
} else if named.len() == 1 {
Self::matching_id(named[0], kind, &args).ok_or("Virtual microphone name already belongs to another module")?
} else {
return Err("Virtual microphone module ownership is ambiguous".into());
};
Ok(Self { id, kind, args })
}
fn unload(&self) {
// Audio-server restarts may reuse numeric ids; never unload an unrelated replacement.
if pactl(&["list", "short", "modules"]).is_ok_and(|list| list.lines()
.any(|line| Self::matching_id(line, self.kind, &self.args) == Some(self.id))) {
let _ = pactl(&["unload-module", &self.id.to_string()]);
}
}
}
fn route_lock_path(source: &str) -> Result<std::path::PathBuf, String> {
use std::os::unix::fs::{DirBuilderExt, MetadataExt};
// Fixed per-user endpoints need a lock shared even by launchers with different UU_CONFIG,
// XDG_RUNTIME_DIR or TMPDIR. Only the lock inode persists; flock releases on process exit.
let dir = std::path::PathBuf::from(format!("/tmp/uu-remote-linux-{}", unsafe { libc::geteuid() }));
std::fs::DirBuilder::new().recursive(true).mode(0o700).create(&dir)
.map_err(|_| "Microphone runtime directory unavailable")?;
let metadata = std::fs::symlink_metadata(&dir).map_err(|_| "Microphone runtime directory unavailable")?;
if !metadata.is_dir() || metadata.uid() != unsafe { libc::geteuid() } || metadata.mode() & 0o077 != 0 {
return Err("Microphone runtime directory is not private".into());
}
Ok(dir.join(format!("{source}.lock")))
}
fn route_lock(source: &str) -> Result<std::fs::File, String> {
use std::os::unix::fs::OpenOptionsExt;
let lock = std::fs::OpenOptions::new().read(true).write(true).create(true).truncate(false).mode(0o600)
.custom_flags(libc::O_NOFOLLOW | libc::O_CLOEXEC).open(route_lock_path(source)?)
.map_err(|_| "Microphone ownership lock unavailable")?;
if unsafe { libc::flock(lock.as_raw_fd(), libc::LOCK_EX | libc::LOCK_NB) } != 0 {
return Err("Another host owns the virtual microphone".into());
}
Ok(lock)
}
fn native_pulse(info: &str) -> Result<bool, String> {
let field = |key: &str| info.lines().find_map(|line| line.strip_prefix(key).map(str::trim));
let name = field("Server Name:").ok_or("Microphone audio server unavailable")?;
if name.to_ascii_lowercase().contains("pipewire") { return Ok(false); }
if !name.eq_ignore_ascii_case("pulseaudio") { return Err("Unsupported microphone audio server".into()); }
let major = field("Server Version:").and_then(|v| v.split('.').next()).and_then(|v| v.parse::<u32>().ok());
if !major.is_some_and(|v| v >= 13) { return Err("Remote microphone requires PulseAudio 13 or newer".into()); }
Ok(true)
}
fn sink_args(name: &str) -> Result<Vec<String>, String> {
let description = crate::i18n::s("UU-远程麦克风输入", "UU-Remote-Microphone-Input");
let mut args = vec![format!("sink_name={name}"), format!("sink_properties=device.description={description}"),
"rate=48000".into(), "channels=2".into()];
// PulseAudio 13+: norewinds starts the null sink with a 50 ms block instead of 2 s of
// idle silence. PipeWire's compatible module does not accept this Pulse-only argument.
if native_pulse(&pactl(&["info"])?)? { args.push("norewinds=1".into()); }
Ok(args)
}
impl Route {
fn new(sink_name: &str, source_name: &str) -> Result<Self, String> {
let lock = route_lock(source_name)?;
let sink = Module::open("module-null-sink", sink_args(sink_name)?)?;
let description = crate::i18n::s("UU-远程麦克风", "UU-Remote-Microphone");
let source = Module::open("module-remap-source", vec![format!("source_name={source_name}"),
format!("master={sink_name}.monitor"), format!("source_properties=device.description={description}"),
"rate=48000".into(), "channels=2".into()]);
match source {
Ok(source) => Ok(Route { source, sink, _lock: lock }),
Err(e) => { sink.unload(); Err(e) }
}
}
}
impl Drop for Route {
fn drop(&mut self) { self.source.unload(); self.sink.unload(); }
}
pub struct Cleanup;
impl Drop for Cleanup {
fn drop(&mut self) {
AVAILABLE.store(false, Ordering::Release);
workers().stopped.send_replace(true);
// On an unexpected unwind leave recovery to the next run rather than move a live stream
// off its disappearing sink. Normal shutdown waits for every playback worker below.
if *workers().active.borrow() == 0 { release_route(); }
}
}
pub fn init() {
if !requested() { return; }
let mut state = ROUTE.get_or_init(|| Mutex::new(None)).lock().unwrap();
if state.is_some() { return; }
let result = (|| {
let _ = Decoder::new()?;
pulse::available()?;
Route::new(SINK, SOURCE)
})();
match result {
Ok(route) => {
*state = Some(route);
workers().stopped.send_replace(false);
AVAILABLE.store(true, Ordering::Release);
log::info!("Remote microphone virtual input ready (48 kHz stereo, pinned Pulse stream)");
}
Err(error) => log::warn!("Remote microphone unavailable: {error}"),
}
}
pub async fn shutdown() {
AVAILABLE.store(false, Ordering::Release);
workers().stopped.send_replace(true);
let mut active = workers().active.subscribe();
let _ = active.wait_for(|count| *count == 0).await;
release_route();
}
fn release_route() {
if let Some(state) = ROUTE.get() {
state.lock().unwrap().take();
}
}
#[cfg(target_os = "linux")]
struct Opus {
_handle: usize,
create: unsafe extern "C" fn(i32, i32, *mut i32) -> *mut libc::c_void,
destroy: unsafe extern "C" fn(*mut libc::c_void),
decode: unsafe extern "C" fn(*mut libc::c_void, *const u8, i32, *mut i16, i32, i32) -> i32,
samples: unsafe extern "C" fn(*const u8, i32, i32) -> i32,
}
#[cfg(target_os = "linux")]
fn opus() -> Result<&'static Opus, String> {
static LIB: OnceLock<Option<Opus>> = OnceLock::new();
LIB.get_or_init(|| unsafe {
let handle = libc::dlopen(c"libopus.so.0".as_ptr(), libc::RTLD_NOW | libc::RTLD_LOCAL);
if handle.is_null() { return None; }
let names = [c"opus_decoder_create", c"opus_decoder_destroy", c"opus_decode", c"opus_packet_get_nb_samples"];
let functions: Vec<_> = names.iter().map(|name| libc::dlsym(handle, name.as_ptr())).collect();
if functions.iter().any(|f| f.is_null()) { libc::dlclose(handle); return None; }
// The library stays loaded for the process lifetime; signatures match the public Opus API.
Some(Opus { _handle: handle as usize, create: std::mem::transmute(functions[0]),
destroy: std::mem::transmute(functions[1]), decode: std::mem::transmute(functions[2]),
samples: std::mem::transmute(functions[3]) })
}).as_ref().ok_or_else(|| "libopus runtime unavailable".into())
}
struct Decoder(*mut libc::c_void);
#[derive(Debug, PartialEq, Eq)]
enum Frame { Opus(Vec<u8>), Conceal(u32) }
// One task owns the decoder and all calls; no decoder state is shared concurrently.
unsafe impl Send for Decoder {}
impl Decoder {
fn new() -> Result<Self, String> {
#[cfg(target_os = "linux")] {
let mut error = 0;
let decoder = unsafe { (opus()?.create)(48000, 2, &mut error) };
if error == 0 && !decoder.is_null() { return Ok(Self(decoder)); }
}
Err("Opus microphone decoder unavailable".into())
}
fn decode(&mut self, frame: &Frame) -> Result<(Vec<u8>, u32), String> {
#[cfg(target_os = "linux")] {
let (packet, size) = match frame {
Frame::Opus(data) if valid_packet(data) => (Some(data.as_slice()), 5760),
Frame::Conceal(samples) if (120..=5760).contains(samples) && samples % 120 == 0 => (None, *samples as i32),
_ => return Err("Invalid microphone Opus frame".into()),
};
let data = packet.unwrap_or(&[]);
let mut pcm = vec![0i16; 5760 * 2];
let samples = unsafe { (opus()?.decode)(self.0, if packet.is_some() { data.as_ptr() } else { std::ptr::null() },
data.len() as i32, pcm.as_mut_ptr(), size, 0) };
if samples <= 0 { return Err("Microphone Opus decode failed".into()); }
let bytes = pcm[..samples as usize * 2].iter().flat_map(|s| s.to_le_bytes()).collect();
return Ok((bytes, samples as u32));
}
#[allow(unreachable_code)] { let _ = frame; Err("Microphone decoding requires Linux".into()) }
}
}
impl Drop for Decoder {
fn drop(&mut self) { #[cfg(target_os = "linux")] if let Ok(lib) = opus() { unsafe { (lib.destroy)(self.0); } } }
}
fn packet_samples(data: &[u8]) -> Option<u32> {
if data.is_empty() || data.len() > 8192 { return None; }
#[cfg(target_os = "linux")] {
let samples = unsafe { (opus().ok()?.samples)(data.as_ptr(), data.len() as i32, 48000) };
return (120..=5760).contains(&samples).then_some(samples as u32);
}
#[allow(unreachable_code)] None
}
fn valid_packet(data: &[u8]) -> bool { packet_samples(data).is_some() }
/// Fixed memory and bounded reordering across sequence wrap; stale backlog is discarded.
#[derive(Default)]
struct Jitter { next: Option<u16>, timestamp: Option<u32>, last_samples: Option<u32>, packets: HashMap<u16, QueuedPacket> }
struct QueuedPacket { timestamp: u32, samples: u32, payload: Vec<u8> }
impl Jitter {
fn push(&mut self, packet: Packet) {
let Some(samples) = packet_samples(&packet.payload) else { return; };
let seq = packet.header.sequence_number;
let next = *self.next.get_or_insert(seq);
let ahead = seq.wrapping_sub(next);
if ahead >= 0x8000 { return; }
if ahead >= MAX_PACKETS { self.packets.clear(); self.next = Some(seq); self.timestamp = None; }
self.packets.entry(seq).or_insert_with(|| QueuedPacket {
timestamp: packet.header.timestamp, samples, payload: packet.payload.to_vec(),
});
}
/// A future packet's RTP clock bounds the missing audio, including variable packet durations.
fn pop(&mut self) -> Option<Frame> {
if self.packets.is_empty() { return None; }
let seq = self.next?;
self.next = Some(seq.wrapping_add(1));
if let Some(packet) = self.packets.remove(&seq) {
self.timestamp = Some(packet.timestamp.wrapping_add(packet.samples));
self.last_samples = Some(packet.samples);
return Some(Frame::Opus(packet.payload));
}
let inferred = self.timestamp.and_then(|timestamp| {
let (&future, packet) = self.packets.iter().min_by_key(|(n, _)| n.wrapping_sub(seq))?;
let missing = u32::from(future.wrapping_sub(seq));
let gap = packet.timestamp.wrapping_sub(timestamp);
// Ignore timestamp discontinuities/DTX; do not manufacture seconds of concealment.
(missing > 0 && (missing * 120..=missing * 5760).contains(&gap) && gap % 120 == 0)
.then(|| gap / missing / 120 * 120)
});
let samples = inferred.or(self.last_samples).unwrap_or(960);
self.timestamp = self.timestamp.map(|timestamp| timestamp.wrapping_add(samples));
Some(Frame::Conceal(samples))
}
}
type Writer = std::pin::Pin<Box<dyn AsyncWrite + Send>>;
struct Playback { decoder: Decoder, writer: Writer, output: Option<pulse::Output> }
impl Playback {
fn new() -> Result<Self, String> {
Self::at(SINK)
}
fn at(sink: &str) -> Result<Self, String> {
let decoder = Decoder::new()?;
let (writer, output) = pulse::start(sink)?;
Ok(Self { decoder, writer: Box::pin(writer), output: Some(output) })
}
async fn write(&mut self, frame: &Frame) -> Result<u32, String> {
let (bytes, samples) = self.decoder.decode(frame)?;
match tokio::time::timeout(Duration::from_millis(200), self.writer.write_all(&bytes)).await {
Ok(Ok(())) => {},
Ok(Err(_)) => {
if let Some(output) = self.output.as_mut() {
if let Err(error) = output.stop().await { return Err(error); }
}
return Err("Microphone playback ended".into());
},
Err(_) => return Err("Microphone playback stalled".into()),
}
Ok(samples)
}
async fn stop(&mut self) {
if let Some(output) = self.output.as_mut() { let _ = output.stop().await; }
}
}
type Factory = Arc<dyn Fn() -> Result<Playback, String> + Send + Sync>;
#[derive(Clone)]
pub struct Session { open: watch::Sender<bool>, owner: watch::Sender<u64>, serial: Arc<Mutex<()>>, factory: Factory }
impl Session {
pub fn new() -> Self {
// Do not request or accept capture until the controller explicitly enables it.
Self { open: watch::channel(false).0, owner: watch::channel(0).0, serial: Arc::new(Mutex::new(())), factory: Arc::new(Playback::new) }
}
/// Official SimpleAction map: 23 microphone_opened, 24 microphone_closed.
pub fn action(&self, action: u64) -> bool {
self.action_with(action, || {})
}
/// Commit the gate and enqueue its notifications as one ordered transition across channels.
/// The callback only queues messages; actual network sends must happen outside this lock.
pub fn action_with(&self, action: u64, enqueue: impl FnOnce()) -> bool {
match action {
23 | 24 => {
let _serial = self.serial.lock().unwrap();
self.open.send_replace(action == 23);
enqueue();
log::info!("Remote microphone switch: open={}", action == 23);
true
},
_ => false,
}
}
fn claim_track(&self) -> (u64, watch::Receiver<u64>) {
let owner = self.owner.subscribe();
let mut generation = 0;
self.owner.send_modify(|id| { *id = id.wrapping_add(1); generation = *id; });
(generation, owner)
}
pub fn attach(&self, pc: &Arc<RTCPeerConnection>, active: watch::Receiver<bool>) {
let weak = Arc::downgrade(pc);
let session = self.clone();
pc.on_track(Box::new(move |track, _, _| {
let (session, active, weak) = (session.clone(), active.clone(), weak.clone());
Box::pin(async move {
if track.kind() != RTPCodecType::Audio { return; }
if !track.codec().capability.mime_type.eq_ignore_ascii_case("audio/opus") {
log::warn!("Incoming microphone track uses an unsupported codec"); return;
}
log::info!("Incoming microphone Opus track received");
if let Some(pc) = weak.upgrade() {
let (generation, owner) = session.claim_track();
let worker = Worker::new();
tokio::spawn(session.receive(track, pc, active, generation, owner, worker));
}
})
}));
}
async fn receive(self, track: Arc<TrackRemote>, pc: Arc<RTCPeerConnection>, mut active: watch::Receiver<bool>,
generation: u64, mut owner: watch::Receiver<u64>, _worker: Worker) {
let mut stopped = workers().stopped.subscribe();
let mut open = self.open.subscribe();
let mut jitter = Jitter::default();
let mut player: Option<Playback> = None;
let mut next = tokio::time::Instant::now();
let mut health = tokio::time::interval(Duration::from_millis(100));
let mut played = 0u64;
let mut lost = 0u64;
// TrackRemote reads are not cancel safe. Keep the same future across timer and gate ticks.
let mut pending = Box::pin(track.read_rtp());
loop {
// A worker can first run after its replacement has already subscribed. Check the id,
// not only changed(): both receivers may otherwise have marked the latest id as seen.
if *stopped.borrow() || *owner.borrow_and_update() != generation { break; }
let allowed = *open.borrow() && *active.borrow() && pc.connection_state() == RTCPeerConnectionState::Connected;
if !allowed {
jitter = Jitter::default();
if let Some(mut output) = player.take() { output.stop().await; log::info!("Remote microphone playback paused"); }
}
tokio::select! {
biased;
_ = stopped.changed() => break,
_ = owner.changed() => break,
change = open.changed() => {
if change.is_err() { break; }
jitter = Jitter::default();
if let Some(mut output) = player.take() { output.stop().await; }
},
change = active.changed() => if change.is_err() { break; },
_ = health.tick() => {
if matches!(pc.connection_state(), RTCPeerConnectionState::Closed | RTCPeerConnectionState::Failed) { break; }
},
_ = tokio::time::sleep_until(next), if player.is_some() && allowed => {
if let Some(packet) = jitter.pop() {
if matches!(packet, Frame::Conceal(_)) { lost += 1; }
match player.as_mut().unwrap().write(&packet).await {
Ok(samples) => {
played += 1;
next = (next + Duration::from_secs_f64(f64::from(samples) / 48000.)).max(tokio::time::Instant::now());
if played == 1 || played % 250 == 0 { log::info!("Remote microphone playback: frames={played} concealed={lost}"); }
},
Err(error) => { log::warn!("{error}"); break; }
}
} else {
next = tokio::time::Instant::now() + Duration::from_millis(10);
}
},
received = &mut pending => {
let Ok((packet, _)) = received else { break; };
pending.set(track.read_rtp());
if !allowed || !valid_packet(&packet.payload) { continue; }
if player.is_none() {
match (self.factory)() {
Ok(output) => { player = Some(output); next = tokio::time::Instant::now() + Duration::from_millis(40); },
Err(error) => { log::warn!("{error}"); break; }
}
}
jitter.push(packet);
},
}
}
if let Some(mut output) = player { output.stop().await; }
log::info!("Remote microphone track ended: frames={played} concealed={lost}");
}
}
#[cfg(test)]
mod tests;
+187
View File
@@ -0,0 +1,187 @@
//! Pulse playback pinned with PA_STREAM_DONT_MOVE, supported by PulseAudio and PipeWire-pulse.
//! Load the stable public C API at runtime so opt-out builds need no Pulse development package.
use std::ffi::{CStr, CString};
use std::sync::OnceLock;
use std::time::{Duration, Instant};
use tokio::io::{AsyncReadExt, DuplexStream};
use tokio::sync::watch;
type Handle = *mut libc::c_void;
type Free = Option<unsafe extern "C" fn(Handle)>;
#[repr(C)]
struct SampleSpec { format: i32, rate: u32, channels: u8 }
#[repr(C)]
struct BufferAttr { maxlength: u32, tlength: u32, prebuf: u32, minreq: u32, fragsize: u32 }
struct Api {
_library: usize,
mainloop_new: unsafe extern "C" fn() -> Handle,
mainloop_free: unsafe extern "C" fn(Handle),
mainloop_get_api: unsafe extern "C" fn(Handle) -> Handle,
mainloop_iterate: unsafe extern "C" fn(Handle, i32, *mut i32) -> i32,
context_new: unsafe extern "C" fn(Handle, *const libc::c_char) -> Handle,
context_connect: unsafe extern "C" fn(Handle, *const libc::c_char, u32, Handle) -> i32,
context_get_state: unsafe extern "C" fn(Handle) -> i32,
context_disconnect: unsafe extern "C" fn(Handle),
context_unref: unsafe extern "C" fn(Handle),
stream_new: unsafe extern "C" fn(Handle, *const libc::c_char, *const SampleSpec, Handle) -> Handle,
stream_connect_playback: unsafe extern "C" fn(Handle, *const libc::c_char, *const BufferAttr, u32, Handle, Handle) -> i32,
stream_get_state: unsafe extern "C" fn(Handle) -> i32,
stream_get_device_name: unsafe extern "C" fn(Handle) -> *const libc::c_char,
stream_writable_size: unsafe extern "C" fn(Handle) -> usize,
stream_write: unsafe extern "C" fn(Handle, *const libc::c_void, usize, Free, i64, i32) -> i32,
stream_disconnect: unsafe extern "C" fn(Handle) -> i32,
stream_unref: unsafe extern "C" fn(Handle),
}
fn api() -> Result<&'static Api, String> {
static API: OnceLock<Option<Api>> = OnceLock::new();
API.get_or_init(|| unsafe {
let library = libc::dlopen(c"libpulse.so.0".as_ptr(), libc::RTLD_NOW | libc::RTLD_LOCAL);
if library.is_null() { return None; }
macro_rules! load {
($name:expr, $signature:ty) => {{
let function = libc::dlsym(library, $name.as_ptr());
if function.is_null() { return None; }
std::mem::transmute::<Handle, $signature>(function)
}};
}
let result = (|| Some(Api {
_library: library as usize,
mainloop_new: load!(c"pa_mainloop_new", unsafe extern "C" fn() -> Handle),
mainloop_free: load!(c"pa_mainloop_free", unsafe extern "C" fn(Handle)),
mainloop_get_api: load!(c"pa_mainloop_get_api", unsafe extern "C" fn(Handle) -> Handle),
mainloop_iterate: load!(c"pa_mainloop_iterate", unsafe extern "C" fn(Handle, i32, *mut i32) -> i32),
context_new: load!(c"pa_context_new", unsafe extern "C" fn(Handle, *const libc::c_char) -> Handle),
context_connect: load!(c"pa_context_connect", unsafe extern "C" fn(Handle, *const libc::c_char, u32, Handle) -> i32),
context_get_state: load!(c"pa_context_get_state", unsafe extern "C" fn(Handle) -> i32),
context_disconnect: load!(c"pa_context_disconnect", unsafe extern "C" fn(Handle)),
context_unref: load!(c"pa_context_unref", unsafe extern "C" fn(Handle)),
stream_new: load!(c"pa_stream_new", unsafe extern "C" fn(Handle, *const libc::c_char, *const SampleSpec, Handle) -> Handle),
stream_connect_playback: load!(c"pa_stream_connect_playback", unsafe extern "C" fn(Handle, *const libc::c_char, *const BufferAttr, u32, Handle, Handle) -> i32),
stream_get_state: load!(c"pa_stream_get_state", unsafe extern "C" fn(Handle) -> i32),
stream_get_device_name: load!(c"pa_stream_get_device_name", unsafe extern "C" fn(Handle) -> *const libc::c_char),
stream_writable_size: load!(c"pa_stream_writable_size", unsafe extern "C" fn(Handle) -> usize),
stream_write: load!(c"pa_stream_write", unsafe extern "C" fn(Handle, *const libc::c_void, usize, Free, i64, i32) -> i32),
stream_disconnect: load!(c"pa_stream_disconnect", unsafe extern "C" fn(Handle) -> i32),
stream_unref: load!(c"pa_stream_unref", unsafe extern "C" fn(Handle)),
}))();
if result.is_none() { libc::dlclose(library); }
result
}).as_ref().ok_or_else(|| "libpulse runtime unavailable".into())
}
pub(super) fn available() -> Result<(), String> { api().map(|_| ()) }
struct Stream { api: &'static Api, mainloop: Handle, context: Handle, stream: Handle }
impl Drop for Stream {
fn drop(&mut self) { unsafe {
if !self.stream.is_null() { (self.api.stream_disconnect)(self.stream); (self.api.stream_unref)(self.stream); }
if !self.context.is_null() { (self.api.context_disconnect)(self.context); (self.api.context_unref)(self.context); }
if !self.mainloop.is_null() { (self.api.mainloop_free)(self.mainloop); }
} }
}
impl Stream {
fn connect(api: &'static Api, sink: &CStr, stopped: &watch::Receiver<bool>) -> Result<Self, String> { unsafe {
let mut output = Self { api, mainloop: (api.mainloop_new)(), context: std::ptr::null_mut(), stream: std::ptr::null_mut() };
if output.mainloop.is_null() { return Err("Microphone audio loop unavailable".into()); }
let client = CString::new(crate::i18n::s("UU 远程麦克风", "UU Remote microphone")).unwrap();
output.context = (api.context_new)((api.mainloop_get_api)(output.mainloop), client.as_ptr());
// PA_CONTEXT_NOAUTOSPAWN: connecting to the configured server must not start another one.
if output.context.is_null() || (api.context_connect)(output.context, std::ptr::null(), 1, std::ptr::null_mut()) < 0 {
return Err("Microphone audio server unavailable".into());
}
let context = output.context;
output.wait(stopped, || (api.context_get_state)(context) == 4)?; // PA_CONTEXT_READY
let spec = SampleSpec { format: 3, rate: 48000, channels: 2 }; // PA_SAMPLE_S16LE
let name = CString::new(crate::i18n::s("远程麦克风", "Remote-Microphone")).unwrap();
output.stream = (api.stream_new)(context, name.as_ptr(), &spec, std::ptr::null_mut());
let attr = BufferAttr { maxlength: u32::MAX, tlength: 5760, prebuf: u32::MAX, minreq: 1920, fragsize: u32::MAX };
// pulse/def.h: PA_STREAM_DONT_MOVE | PA_STREAM_ADJUST_LATENCY. A disappearing target
// must fail closed; PipeWire-only node properties cannot enforce this on PulseAudio.
if output.stream.is_null() || (api.stream_connect_playback)(output.stream, sink.as_ptr(), &attr,
0x0200 | 0x2000, std::ptr::null_mut(), std::ptr::null_mut()) < 0 {
return Err("Microphone audio target unavailable".into());
}
let stream = output.stream;
output.wait(stopped, || (api.stream_get_state)(stream) == 2)?; // PA_STREAM_READY
let actual = (api.stream_get_device_name)(stream);
if actual.is_null() || CStr::from_ptr(actual) != sink { return Err("Microphone audio target changed".into()); }
Ok(output)
} }
fn pump(&mut self) -> Result<(), String> { unsafe {
if (self.api.mainloop_iterate)(self.mainloop, 0, std::ptr::null_mut()) < 0
|| (self.api.context_get_state)(self.context) >= 5
|| (!self.stream.is_null() && (self.api.stream_get_state)(self.stream) >= 3) {
return Err("Microphone audio connection ended".into());
}
Ok(())
} }
fn wait(&mut self, stopped: &watch::Receiver<bool>, ready: impl Fn() -> bool) -> Result<(), String> {
let deadline = Instant::now() + Duration::from_secs(3);
loop {
if *stopped.borrow() { return Err("Microphone playback stopped".into()); }
self.pump()?;
if ready() { return Ok(()); }
if Instant::now() >= deadline { return Err("Microphone audio connection timed out".into()); }
std::thread::sleep(Duration::from_millis(2));
}
}
fn write(&mut self, pcm: &[u8], stopped: &watch::Receiver<bool>) -> Result<(), String> {
if pcm.len() % 4 != 0 { return Err("Invalid microphone PCM frame".into()); }
let deadline = Instant::now() + Duration::from_millis(200);
let mut offset = 0;
while offset < pcm.len() {
if *stopped.borrow() { return Err("Microphone playback stopped".into()); }
self.pump()?;
let available = unsafe { (self.api.stream_writable_size)(self.stream) };
if available == usize::MAX { return Err("Microphone audio stream ended".into()); }
let count = available.min(pcm.len() - offset) & !3;
if count > 0 {
// With no free callback libpulse copies these bytes before returning.
if unsafe { (self.api.stream_write)(self.stream, pcm[offset..].as_ptr().cast(), count, None, 0, 0) } < 0 {
return Err("Microphone audio write failed".into());
}
offset += count;
} else {
if Instant::now() >= deadline {
return Err(format!("Microphone playback stalled: remaining={} writable={available}", pcm.len() - offset));
}
std::thread::sleep(Duration::from_millis(2));
}
}
self.pump()
}
}
pub(super) struct Output { stopped: watch::Sender<bool>, task: Option<tokio::task::JoinHandle<Result<(), String>>> }
impl Output {
pub(super) async fn stop(&mut self) -> Result<(), String> {
self.stopped.send_replace(true);
if let Some(task) = self.task.take() {
return task.await.map_err(|_| "Microphone audio worker aborted")?;
}
Ok(())
}
}
impl Drop for Output { fn drop(&mut self) { self.stopped.send_replace(true); } }
pub(super) fn start(sink: &str) -> Result<(DuplexStream, Output), String> {
let api = api()?;
let sink = CString::new(sink).map_err(|_| "Invalid microphone audio target")?;
let (writer, mut reader) = tokio::io::duplex(65536);
let (stop, mut stopped) = watch::channel(false);
let runtime = tokio::runtime::Handle::current();
let task = tokio::task::spawn_blocking(move || {
let mut output = Stream::connect(api, &sink, &stopped)?;
let mut buffer = [0; 23040]; // maximum 120 ms stereo PCM
loop {
if *stopped.borrow() { return Ok(()); }
let count = runtime.block_on(async { tokio::select! {
biased;
_ = stopped.changed() => Ok(0),
result = reader.read(&mut buffer) => result,
} }).map_err(|_| "Microphone PCM input ended")?;
if count == 0 { return Ok(()); }
output.write(&buffer[..count], &stopped)?;
}
});
Ok((writer, Output { stopped: stop, task: Some(task) }))
}
+533
View File
@@ -0,0 +1,533 @@
#![cfg(target_os = "linux")]
use super::*;
use tokio::io::AsyncReadExt;
use webrtc::track::track_local::{track_local_static_rtp::TrackLocalStaticRTP, TrackLocalWriter};
use webrtc::rtp_transceiver::rtp_codec::RTCRtpCodecCapability;
use webrtc::interceptor::{mock::{mock_builder::MockBuilder, mock_interceptor::MockInterceptor},
registry::Registry, Attributes, RTPReader};
fn have_opus() -> bool {
match opus() {
Ok(_) => true,
Err(error) => { eprintln!("Skipping Opus-dependent microphone test: {error}"); false }
}
}
#[derive(Default)]
struct ReadPause {
requested: AtomicBool, entered: tokio::sync::Notify,
resume: tokio::sync::Notify, completed: tokio::sync::Notify,
}
struct PausedReader { reader: Arc<dyn RTPReader + Send + Sync>, pause: Arc<ReadPause> }
#[async_trait::async_trait]
impl RTPReader for PausedReader {
async fn read(&self, buffer: &mut [u8], attributes: &Attributes) -> Result<(Packet, Attributes), webrtc::interceptor::Error> {
let result = self.reader.read(buffer, attributes).await?;
if self.pause.requested.swap(false, Ordering::AcqRel) {
// The packet has already been consumed; cancelling here would lose it.
self.pause.entered.notify_one();
self.pause.resume.notified().await;
self.pause.completed.notify_one();
}
Ok(result)
}
}
fn pause_registry(pause: Arc<ReadPause>) -> Registry {
let mut registry = Registry::new();
registry.add(Box::new(MockBuilder::new(move |_| {
let pause = pause.clone();
Ok(Arc::new(MockInterceptor { bind_remote_stream_fn: Some(Box::new(move |_, reader| {
let pause = pause.clone();
Box::pin(async move {
Arc::new(PausedReader { reader, pause }) as Arc<dyn RTPReader + Send + Sync>
})
})), ..Default::default() }))
})));
registry
}
fn tone() -> Vec<u8> {
tone_samples(960)
}
fn tone_samples(samples: usize) -> Vec<u8> {
let handle = opus().unwrap()._handle as *mut libc::c_void;
let create: unsafe extern "C" fn(i32, i32, i32, *mut i32) -> *mut libc::c_void = unsafe {
std::mem::transmute(libc::dlsym(handle, c"opus_encoder_create".as_ptr()))
};
let encode: unsafe extern "C" fn(*mut libc::c_void, *const i16, i32, *mut u8, i32) -> i32 = unsafe {
std::mem::transmute(libc::dlsym(handle, c"opus_encode".as_ptr()))
};
let destroy: unsafe extern "C" fn(*mut libc::c_void) = unsafe {
std::mem::transmute(libc::dlsym(handle, c"opus_encoder_destroy".as_ptr()))
};
let pcm: Vec<i16> = (0..samples).flat_map(|i| {
let s = ((i as f64 * std::f64::consts::TAU * 1000. / 48000.).sin() * 6000.) as i16;
[s, s]
}).collect();
let mut error = 0;
let enc = unsafe { create(48000, 2, 2048, &mut error) };
assert_eq!(error, 0);
assert!(!enc.is_null());
let mut out = vec![0; 4000];
let n = unsafe { encode(enc, pcm.as_ptr(), samples as i32, out.as_mut_ptr(), out.len() as i32) };
unsafe { destroy(enc); }
assert!(n > 0);
out.truncate(n as usize);
out
}
fn packet(seq: u16, data: &[u8]) -> Packet {
packet_at(seq, u32::from(seq) * 960, data)
}
fn packet_at(seq: u16, timestamp: u32, data: &[u8]) -> Packet {
Packet { header: webrtc::rtp::header::Header { version: 2, sequence_number: seq,
timestamp, marker: true, ..Default::default() },
payload: bytes::Bytes::copy_from_slice(data) }
}
fn rms(bytes: &[u8]) -> f64 {
let sum: f64 = bytes.chunks_exact(2).map(|s| f64::from(i16::from_le_bytes([s[0], s[1]])).powi(2)).sum();
(sum / (bytes.len() / 2).max(1) as f64).sqrt()
}
#[test]
fn opus_decodes_generated_tone_and_conceals_loss() {
if !have_opus() { return; }
assert!(!valid_packet(&[]));
assert!(!valid_packet(&vec![0; 8193]));
let data = tone();
let mut decoder = Decoder::new().unwrap();
let (pcm, frames) = decoder.decode(&Frame::Opus(data)).unwrap();
assert_eq!(frames, 960);
assert_eq!(pcm.len(), 3840);
assert!(rms(&pcm) > 1000.);
assert_eq!(decoder.decode(&Frame::Conceal(960)).unwrap().0.len(), 3840);
assert!(decoder.decode(&Frame::Opus(vec![])).is_err());
assert!(decoder.decode(&Frame::Conceal(0)).is_err());
}
#[test]
fn reorder_handles_wrap_loss_duplicates_and_bounded_backlog() {
if !have_opus() { return; }
let data = tone();
let mut jitter = Jitter::default();
for seq in [65535, 1, 0, 0] { jitter.push(packet(seq, &data)); }
for _ in 0..3 { assert_eq!(jitter.pop(), Some(Frame::Opus(data.clone()))); }
assert!(jitter.pop().is_none());
jitter.push(packet(3, &data));
assert_eq!(jitter.pop(), Some(Frame::Conceal(960))); // sequence 2 was lost
assert_eq!(jitter.pop(), Some(Frame::Opus(data.clone())));
jitter.push(packet(0, &data)); // late retransmission
assert!(jitter.pop().is_none());
for seq in 4..1000 { jitter.push(packet(seq, &data)); assert!(jitter.packets.len() <= MAX_PACKETS as usize); }
assert!(jitter.next.unwrap() >= 988);
}
#[test]
fn loss_duration_follows_rtp_clock_across_wrap_and_packet_sizes() {
if !have_opus() { return; }
for samples in [480, 960, 1920, 2880] {
let data = tone_samples(samples);
let mut decoder = Decoder::new().unwrap();
let mut jitter = Jitter::default();
let timestamp = u32::MAX - 239;
jitter.push(packet_at(65535, timestamp, &data));
assert_eq!(decoder.decode(&jitter.pop().unwrap()).unwrap().1, samples as u32);
jitter.push(packet_at(1, timestamp.wrapping_add(samples as u32 * 2), &data));
let loss = jitter.pop().unwrap();
assert_eq!(loss, Frame::Conceal(samples as u32));
assert_eq!(decoder.decode(&loss).unwrap().1, samples as u32);
assert_eq!(decoder.decode(&jitter.pop().unwrap()).unwrap().1, samples as u32);
assert!(jitter.pop().is_none());
}
}
#[test]
fn variable_losses_preserve_total_time_and_bound_discontinuities() {
if !have_opus() { return; }
let data = tone();
let mut jitter = Jitter::default();
let mut decoder = Decoder::new().unwrap();
jitter.push(packet_at(0, 0, &data));
decoder.decode(&jitter.pop().unwrap()).unwrap();
// Two missing packets total 50 ms; their individual durations cannot be inferred.
jitter.push(packet_at(3, 960 + 2400, &data));
let mut concealed = 0;
for _ in 0..2 { concealed += decoder.decode(&jitter.pop().unwrap()).unwrap().1; }
assert_eq!(concealed, 2400);
decoder.decode(&jitter.pop().unwrap()).unwrap();
jitter.push(packet_at(5, 48_000_000, &data));
assert_eq!(jitter.pop(), Some(Frame::Conceal(960))); // discontinuity is not a huge loss
}
#[test]
fn ownership_lock_is_shared_across_config_directories() {
const CHILD: &str = "UU_MICROPHONE_TEST_LOCK";
if let Ok(source) = std::env::var(CHILD) {
assert!(route_lock(&source).is_err(), "a different UU_CONFIG bypassed the endpoint lock");
return;
}
let source = format!("uu-microphone-test-{}", std::process::id());
let lock = route_lock(&source).unwrap();
for config in ["first/config.json", "second/config.json"] {
let result = Command::new(std::env::current_exe().unwrap())
.args(["microphone::tests::ownership_lock_is_shared_across_config_directories", "--exact"])
.env(CHILD, &source).env("UU_CONFIG", std::env::temp_dir().join(config))
.env("XDG_RUNTIME_DIR", std::env::temp_dir().join(config).with_extension("runtime"))
.env("TMPDIR", std::env::temp_dir().join(config).with_extension("temporary"))
.output().unwrap();
assert!(result.status.success(), "{}", String::from_utf8_lossy(&result.stdout));
}
drop(lock);
drop(route_lock(&source).expect("the lock must be released on drop"));
std::fs::remove_file(route_lock_path(&source).unwrap()).unwrap();
}
#[test]
fn recovery_requires_exact_module_arguments_and_master() {
let args = vec!["source_name=uu-remote-microphone".into(), "master=uu-remote-mic-input.monitor".into(),
"source_properties=device.description=UU-Remote-Microphone".into(), "rate=48000".into(), "channels=2".into()];
let line = format!("42\tmodule-remap-source\t{}", args.join(" "));
assert_eq!(Module::matching_id(&line, "module-remap-source", &args), Some(42));
for foreign in [line.replace("master=uu-remote-mic-input.monitor", "master=physical-microphone"),
line.replace("description=UU-Remote-Microphone", "description=UU-Remote-Microphone-Foreign"),
format!("{line} remix=no")] {
assert_eq!(Module::matching_id(&foreign, "module-remap-source", &args), None);
}
}
#[test]
fn native_sink_options_are_not_applied_to_pipewire_or_unsupported_servers() {
assert_eq!(native_pulse("Server Name: pulseaudio\nServer Version: 13.0"), Ok(true));
assert_eq!(native_pulse("Server Name: PulseAudio (on PipeWire 1.6.9)\nServer Version: 15.0.0"), Ok(false));
assert!(native_pulse("Server Name: pulseaudio\nServer Version: 12.2").is_err());
assert!(native_pulse("Server Name: unsupported\nServer Version: 99.0").is_err());
assert!(native_pulse("").is_err());
}
#[test]
fn concurrent_track_claims_have_only_one_current_owner() {
let session = Session::new();
let claimed = Arc::new(std::sync::Barrier::new(2));
let workers: Vec<_> = (0..2).map(|_| {
let (session, claimed) = (session.clone(), claimed.clone());
std::thread::spawn(move || {
let (generation, mut owner) = session.claim_track();
claimed.wait(); // both workers start receiving only after both tracks have claimed
let current = *owner.borrow_and_update() == generation;
(generation, current)
})
}).collect();
let owners: Vec<_> = workers.into_iter().map(|w| w.join().unwrap()).collect();
assert_eq!(owners.iter().filter(|(_, current)| *current).count(), 1);
assert!(owners.contains(&(2, true)));
assert!(owners.contains(&(1, false)));
}
#[tokio::test]
async fn congested_reply_cannot_overwrite_a_later_close() {
let session = Session::new();
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
let (pending, wait_pending) = tokio::sync::oneshot::channel();
let (resume, wait_resume) = tokio::sync::oneshot::channel();
let sending = tokio::spawn(async move {
let notice = rx.recv().await.unwrap();
pending.send(()).unwrap();
wait_resume.await.unwrap(); // the ordered outbox is blocked in its network send
notice
});
session.action_with(23, || { tx.send(23).unwrap(); });
wait_pending.await.unwrap();
assert!(*session.open.borrow());
session.action(24); // independent TEXT callback closes while the CONTROL reply is pending
assert!(!*session.open.borrow());
resume.send(()).unwrap();
assert_eq!(sending.await.unwrap(), 23);
assert!(!*session.open.borrow(), "completing an old send must not apply an old policy");
}
#[test]
fn state_and_notice_enqueue_are_serialized_across_channels() {
let session = Session::new();
let notices = Arc::new(Mutex::new(Vec::new()));
let (inside, entered) = std::sync::mpsc::channel();
let release = Arc::new(std::sync::Barrier::new(2));
let open = {
let (session, notices, release) = (session.clone(), notices.clone(), release.clone());
std::thread::spawn(move || { session.action_with(23, || {
inside.send(()).unwrap();
release.wait();
notices.lock().unwrap().push(23);
}); })
};
entered.recv().unwrap();
let close = {
let (session, notices) = (session.clone(), notices.clone());
std::thread::spawn(move || { session.action_with(24, || { notices.lock().unwrap().push(24); }); })
};
release.wait();
open.join().unwrap(); close.join().unwrap();
assert_eq!(*notices.lock().unwrap(), [23, 24]);
assert!(!*session.open.borrow());
}
#[tokio::test]
async fn shutdown_waits_for_receivers_before_removing_endpoints() {
const CHILD: &str = "UU_MICROPHONE_TEST_SHUTDOWN";
if std::env::var_os(CHILD).is_none() {
let result = Command::new(std::env::current_exe().unwrap())
.args(["microphone::tests::shutdown_waits_for_receivers_before_removing_endpoints", "--exact"])
.env(CHILD, "1").output().unwrap();
assert!(result.status.success(), "{}", String::from_utf8_lossy(&result.stdout));
return;
}
let worker = Worker::new();
let stopped = Arc::new(AtomicBool::new(false));
let finished = stopped.clone();
let task = tokio::spawn(async move {
let mut stopping = workers().stopped.subscribe();
stopping.wait_for(|stopped| *stopped).await.unwrap();
tokio::time::sleep(Duration::from_millis(20)).await;
finished.store(true, Ordering::Release);
drop(worker);
});
tokio::time::timeout(Duration::from_secs(1), shutdown()).await.unwrap();
assert!(stopped.load(Ordering::Acquire));
task.await.unwrap();
}
#[tokio::test]
async fn webrtc_microphone_obeys_mute_desktop_role_and_disconnect() {
if !have_opus() { return; }
tokio::time::timeout(Duration::from_secs(15), async {
let (left, right, router) = crate::test_network::virtual_network().await;
async fn peer(settings: webrtc::api::setting_engine::SettingEngine, registry: Registry) -> Arc<RTCPeerConnection> {
let mut m = webrtc::api::media_engine::MediaEngine::default();
m.register_default_codecs().unwrap();
Arc::new(webrtc::api::APIBuilder::new().with_media_engine(m).with_setting_engine(settings).with_interceptor_registry(registry)
.build().new_peer_connection(Default::default()).await.unwrap())
}
let pause = Arc::new(ReadPause::default());
let sender = peer(left, Registry::new()).await;
let host = peer(right, pause_registry(pause.clone())).await;
// Match the real host: its existing desktop sound track negotiates a bidirectional m-line.
host.add_track(Arc::new(TrackLocalStaticRTP::new(RTCRtpCodecCapability {
mime_type: "audio/opus".into(), clock_rate: 48000, channels: 2, ..Default::default()
}, "desktop-sound".into(), "host".into()))).await.unwrap();
let track = Arc::new(TrackLocalStaticRTP::new(RTCRtpCodecCapability {
mime_type: "audio/opus".into(), clock_rate: 48000, channels: 2, ..Default::default()
}, "mic".into(), "generated-tone".into()));
sender.add_track(track.clone()).await.unwrap();
let replacement = Arc::new(TrackLocalStaticRTP::new(RTCRtpCodecCapability {
mime_type: "audio/opus".into(), clock_rate: 48000, channels: 2, ..Default::default()
}, "replacement-mic".into(), "generated-tone".into()));
sender.add_track(replacement.clone()).await.unwrap();
let (created, mut outputs) = tokio::sync::mpsc::unbounded_channel();
let session = Session { factory: Arc::new(move || {
let (writer, reader) = tokio::io::duplex(65536);
created.send(reader).unwrap();
Ok(Playback { decoder: Decoder::new()?, writer: Box::pin(writer), output: None })
}), ..Session::new() };
assert!(!session.action(2));
assert!(session.action(24));
let (desktop, active) = watch::channel(true);
session.attach(&host, active);
let mut gathered = sender.gathering_complete_promise().await;
let offer = sender.create_offer(None).await.unwrap();
sender.set_local_description(offer).await.unwrap(); gathered.recv().await;
host.set_remote_description(sender.local_description().await.unwrap()).await.unwrap();
let mut gathered = host.gathering_complete_promise().await;
let answer = host.create_answer(None).await.unwrap();
host.set_local_description(answer).await.unwrap(); gathered.recv().await;
sender.set_remote_description(host.local_description().await.unwrap()).await.unwrap();
while sender.connection_state() != RTCPeerConnectionState::Connected { tokio::time::sleep(Duration::from_millis(10)).await; }
let data = tone();
let sending = tokio::spawn(async move {
for seq in 0..500 { let _ = track.write_rtp(&packet(seq, &data)).await; tokio::time::sleep(Duration::from_millis(20)).await; }
});
tokio::time::sleep(Duration::from_millis(200)).await;
assert!(outputs.try_recv().is_err()); // muted before the first packet
session.action(23);
let mut pcm = outputs.recv().await.unwrap();
let mut frame = vec![0; 3840];
pcm.read_exact(&mut frame).await.unwrap();
assert!(rms(&frame) > 1000.);
// Playback must keep pace with a continuous 20 ms source, not add a polling delay
// to every frame (which eventually overflows the jitter buffer and skips speech).
let mut played_frames = 0;
let _ = tokio::time::timeout(Duration::from_millis(600), async {
loop { pcm.read_exact(&mut frame).await.unwrap(); played_frames += 1; }
}).await;
assert!((25..=35).contains(&played_frames), "wrong real-time playout rate: {played_frames} frames / 600 ms");
pause.requested.store(true, Ordering::Release);
pause.entered.notified().await;
// Span several playout ticks and at least two health ticks with a consumed RTP packet.
tokio::time::sleep(Duration::from_millis(250)).await;
pause.resume.notify_one();
tokio::time::timeout(Duration::from_secs(1), pause.completed.notified()).await
.expect("timer ticks cancelled a pending RTP read and lost its packet");
let data = tone();
let replacing = tokio::spawn(async move {
for seq in 0..500 { let _ = replacement.write_rtp(&packet(seq, &data)).await; tokio::time::sleep(Duration::from_millis(20)).await; }
});
let mut replacement_pcm = outputs.recv().await.unwrap();
replacement_pcm.read_exact(&mut frame).await.unwrap();
assert!(rms(&frame) > 1000.);
tokio::time::timeout(Duration::from_secs(1), pcm.read_to_end(&mut Vec::new())).await.unwrap().unwrap();
let mut pcm = replacement_pcm;
session.action(24);
let mut remainder = Vec::new();
tokio::time::timeout(Duration::from_secs(1), pcm.read_to_end(&mut remainder)).await.unwrap().unwrap();
tokio::time::sleep(Duration::from_millis(100)).await;
assert!(outputs.try_recv().is_err());
desktop.send_replace(false);
session.action(23);
tokio::time::sleep(Duration::from_millis(100)).await;
assert!(outputs.try_recv().is_err()); // a demoted desktop cannot inject audio
desktop.send_replace(true);
let mut resumed = outputs.recv().await.unwrap();
resumed.read_exact(&mut frame).await.unwrap();
assert!(rms(&frame) > 1000.);
host.close().await.unwrap(); sender.close().await.unwrap();
tokio::time::timeout(Duration::from_secs(1), resumed.read_to_end(&mut Vec::new())).await.unwrap().unwrap();
sending.abort(); replacing.abort(); router.lock().await.stop().await.unwrap();
}).await.expect("microphone WebRTC integration timed out");
}
/// Explicit opt-in only; records the generated tone from our isolated virtual source in memory.
#[tokio::test]
#[ignore]
async fn pipewire_virtual_microphone_receives_generated_tone() {
assert!(requested(), "run with UU_MICROPHONE=1; the test creates independent audio endpoints");
let sink = format!("uu-mic-test-input-{}", std::process::id());
let source = format!("uu-mic-test-source-{}", std::process::id());
let route = Route::new(&sink, &source).unwrap();
let mut recorder = tokio::process::Command::new("parec").args(["--raw", "--format=s16le", "--rate=48000", "--channels=2",
&format!("--device={source}"), "--latency-msec=20"])
.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null()).kill_on_drop(true).spawn().unwrap();
let mut capture = recorder.stdout.take().unwrap();
let mut player = Playback::at(&sink).unwrap();
let (stop, mut stopped) = watch::channel(false);
let generating = tokio::spawn(async move {
let data = tone();
for _ in 0..100 {
if *stopped.borrow() { break; }
player.write(&Frame::Opus(data.clone())).await.unwrap();
tokio::select! { _ = stopped.changed() => break, _ = tokio::time::sleep(Duration::from_millis(20)) => {} }
}
player.stop().await;
});
let received = tokio::time::timeout(Duration::from_secs(4), async {
let mut frame = vec![0; 3840];
loop { capture.read_exact(&mut frame).await?; if rms(&frame) > 1000. { return Ok::<_, std::io::Error>(()); } }
}).await;
let inputs = pactl(&["--format=json", "list", "sink-inputs"]);
let devices = [pactl(&["--format=json", "list", "sinks"]), pactl(&["--format=json", "list", "sources"])];
let stopped = recorder.kill().await;
stop.send_replace(true);
let generated = generating.await;
drop(route);
let sources = pactl(&["list", "short", "sources"]).unwrap();
assert!(!sources.lines().any(|line| line.split('\t').nth(1) == Some(source.as_str())));
std::fs::remove_file(route_lock_path(&source).unwrap()).unwrap();
stopped.unwrap();
assert!(!generated.is_err_and(|e| e.is_panic()), "tone generator panicked");
received.expect("generated tone did not reach the virtual microphone").unwrap();
let inputs: serde_json::Value = serde_json::from_str(&inputs.unwrap()).unwrap();
let pid = std::process::id().to_string();
let properties = inputs.as_array().unwrap().iter().find_map(|input| {
let properties = input.get("properties")?;
(properties.get("application.process.id")?.as_str()? == pid
&& properties.get("media.name")?.as_str()? == crate::i18n::s("远程麦克风", "Remote-Microphone")).then_some(properties)
}).expect("localized microphone stream missing");
assert_eq!(properties["application.name"], crate::i18n::s("UU 远程麦克风", "UU Remote microphone"));
for (data, name, description) in [
(&devices[0], &sink, crate::i18n::s("UU-远程麦克风输入", "UU-Remote-Microphone-Input")),
(&devices[1], &source, crate::i18n::s("UU-远程麦克风", "UU-Remote-Microphone")),
] {
let devices: serde_json::Value = serde_json::from_str(data.as_ref().unwrap()).unwrap();
let device = devices.as_array().unwrap().iter().find(|device| device["name"] == name.as_str()).unwrap();
assert_eq!(device["description"], description);
}
}
/// Run through contrib/check-microphone-pulse.py, never against the desktop's audio server.
#[tokio::test]
#[ignore]
async fn pulse_target_loss_never_routes_to_default_output() {
assert_eq!(std::env::var("UU_MICROPHONE_ISOLATED_TEST").as_deref(), Ok("1"));
assert!(std::env::var("PULSE_SERVER").is_ok_and(|s| s.starts_with("unix:")));
assert!(pactl(&["list", "short", "sinks"]).unwrap().is_empty(), "requires an empty isolated server");
assert!(pactl(&["list", "short", "sources"]).unwrap().is_empty(), "requires an empty isolated server");
let fallback_name = format!("uu-mic-test-default-{}", std::process::id());
let fallback = Module::open("module-null-sink", sink_args(&fallback_name).unwrap()).unwrap();
struct Fallback(Module);
impl Drop for Fallback { fn drop(&mut self) { self.0.unload(); } }
let _fallback = Fallback(fallback);
pactl(&["set-default-sink", &fallback_name]).unwrap();
let sink = format!("uu-mic-test-pinned-{}", std::process::id());
let source = format!("uu-mic-test-pinned-source-{}", std::process::id());
let route = Route::new(&sink, &source).unwrap();
let mut player = Playback::at(&sink).unwrap();
let generating = tokio::spawn(async move {
let frame = Frame::Opus(tone());
let mut failed_closed = false;
for _ in 0..150 {
if player.write(&frame).await.is_err() { failed_closed = true; break; }
tokio::time::sleep(Duration::from_millis(20)).await;
}
player.stop().await;
failed_closed
});
tokio::time::timeout(Duration::from_secs(3), async {
while pactl(&["list", "short", "sink-inputs"]).unwrap().is_empty() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
}).await.unwrap();
let mut probe = tokio::process::Command::new("parec").args(["--raw", "--format=s16le", "--rate=48000", "--channels=2",
&format!("--device={source}"), "--latency-msec=20"])
.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null()).kill_on_drop(true).spawn().unwrap();
let mut baseline = probe.stdout.take().unwrap();
let flowing = tokio::time::timeout(Duration::from_secs(3), async {
let mut frame = vec![0; 3840];
let mut audible = 0;
loop {
baseline.read_exact(&mut frame).await?;
audible = if rms(&frame) > 1000. { audible + 1 } else { 0 };
if audible >= 15 { return Ok::<_, std::io::Error>(()); } // 300 ms of healthy playback
}
}).await;
let probe_stopped = probe.kill().await;
if !matches!(&flowing, Ok(Ok(()))) {
generating.abort(); let _ = generating.await;
panic!("no sustained generated tone before removing the target: {flowing:?}");
}
probe_stopped.unwrap();
flowing.expect("no sustained generated tone before removing the target").unwrap();
let mut recorder = tokio::process::Command::new("parec").args(["--raw", "--format=s16le", "--rate=48000", "--channels=2",
&format!("--device={fallback_name}.monitor"), "--latency-msec=20"])
.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null()).kill_on_drop(true).spawn().unwrap();
let mut capture = recorder.stdout.take().unwrap();
tokio::time::sleep(Duration::from_millis(200)).await;
assert!(!generating.is_finished(), "playback failed before the target was removed");
route.source.unload(); route.sink.unload(); // remove the target while audio is still flowing
let mut generating = generating;
let ended = tokio::time::timeout(Duration::from_secs(2), &mut generating).await;
if ended.is_err() { generating.abort(); let _ = generating.await; }
let mut peak = 0.0_f64;
let observed = async {
let deadline = tokio::time::sleep(Duration::from_millis(350));
tokio::pin!(deadline);
let mut frame = vec![0; 3840];
loop { tokio::select! {
_ = &mut deadline => break,
read = capture.read_exact(&mut frame) => { read?; peak = peak.max(rms(&frame)); },
} }
Ok::<_, std::io::Error>(())
}.await;
recorder.kill().await.unwrap();
observed.unwrap();
assert!(ended.expect("playback did not stop after its target disappeared").unwrap());
assert!(pactl(&["list", "short", "sink-inputs"]).unwrap().is_empty());
assert_eq!(peak, 0.0, "microphone audio reached the default output");
drop(route);
std::fs::remove_file(route_lock_path(&source).unwrap()).unwrap();
}
+808 -44
View File
File diff suppressed because it is too large. Load diff
+112
View File
@@ -23,6 +23,61 @@ pub fn desktop_key() -> &'static str {
if desktop.split(':').any(|v| v == "kde") { "kde" } else { "gnome" } if desktop.split(':').any(|v| v == "kde") { "kde" } else { "gnome" }
} }
/// 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> { pub fn take(dir: &Path, key: &str) -> Option<String> {
let path = dir.join(key); let path = dir.join(key);
let mut file = OpenOptions::new().read(true).custom_flags(libc::O_NOFOLLOW).open(&path).ok()?; let mut file = OpenOptions::new().read(true).custom_flags(libc::O_NOFOLLOW).open(&path).ok()?;
@@ -68,4 +123,61 @@ mod tests {
assert!(save(&dir, "gnome", &"x".repeat(4097)).is_err()); assert!(save(&dir, "gnome", &"x".repeat(4097)).is_err());
fs::remove_dir_all(dir).unwrap(); 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();
}
} }
+36
View File
@@ -0,0 +1,36 @@
//! 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>;
/// Recompute `Entered::pointer_region` after the virtual output was recreated. None keeps
/// the stored region (backends without a virtual output, or a layout not settled yet).
fn refresh_pointer_region(&self) -> Option<[f64; 4]> { None }
}
/// The backend for this session, if the desktop has one.
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));
}
}
+97
View File
@@ -0,0 +1,97 @@
//! KWin scripts (org.kde.kwin.Scripting): one-shot ones, plus the new-window keeper that picture
//! mode leaves loaded for the whole privacy session.
use super::super::tool::gdbus;
const ONE_SHOT: &str = "uu-privacy";
const KEEP_WINDOWS: &str = "uu-privacy-windows";
fn call(object: &str, method: &str, args: &[&str]) -> Result<String, String> { gdbus("org.kde.KWin", object, method, args) }
/// Output names go into a JS string literal.
fn escape(output: &str) -> String { output.replace('\\', "\\\\").replace('"', "\\\"") }
/// Windows that belong on the captured output. Desktop pets and tool palettes use toolbar/utility
/// windows, which `normalWindow` misses; panels, the desktop and transient popups stay where they
/// are, so the layout of the physical outputs is unchanged.
const MOVABLE: &str = r#"function movable(w) {
if (!w || w.desktopWindow || w.dock) return false;
if (w.tooltip || w.popupMenu || w.dropdownMenu || w.comboBox || w.dndIcon) return false;
return w.normalWindow || w.dialog || w.toolbar || w.utility || w.splash;
}"#;
/// Loads `js` under `name` and runs it. `keep` leaves it loaded with its signal connections alive;
/// otherwise it is unloaded after the run, as the one-shot scripts expect.
fn script(js: &str, name: &str, keep: bool) -> Result<(), String> {
let dir = std::env::var_os("XDG_RUNTIME_DIR").map(std::path::PathBuf::from).ok_or("missing runtime directory")?;
let file = dir.join(format!("uu-privacy-{name}-{}.js", std::process::id()));
std::fs::write(&file, js).map_err(|e| e.kind().to_string())?;
// A script left loaded by a host that died would keep running with a stale target.
let _ = call("/Scripting", "org.kde.kwin.Scripting.unloadScript", &[name]);
let result = call("/Scripting", "org.kde.kwin.Scripting.loadScript", &[&file.to_string_lossy(), name]).and_then(|out| {
let id: String = out.chars().filter(char::is_ascii_digit).collect();
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));
// A failed run must not leave a half-started keeper behind.
if !keep || result.is_err() { let _ = call("/Scripting", "org.kde.kwin.Scripting.unloadScript", &[name]); }
let _ = std::fs::remove_file(file);
result.map(|_| ())
}
/// Sends every movable window to `output` (a name from kscreen-doctor).
pub fn move_windows_to(output: &str) -> Result<(), String> {
let output = escape(output);
script(&format!(r#"{movable}
const v = workspace.screens.find(o => o.name == "{output}");
if (v) for (const w of workspace.windowList()) if (movable(w)) workspace.sendClientToScreen(w, v);"#, movable = MOVABLE), ONE_SHOT, false)
}
/// Keeps windows on `output`. Picture mode turns the physical outputs back on as secondaries, and
/// KWin then places a new window on the screen it considers active, which can be one hidden under
/// the cover: the viewer would never see it. Every window is checked when it appears and whenever
/// its geometry changes, so an application that places itself on a physical output is sent back.
/// `frameGeometryChanged` is the trigger because KWin 6.8 does not emit `outputChanged` for
/// `sendClientToScreen` moves (verified live). Unloaded by `unload_keep_windows` on restore.
pub fn keep_windows_on(output: &str) -> Result<(), String> {
let output = escape(output);
script(&format!(r#"{movable}
function keep(w) {{
if (!movable(w)) return;
// The cover windows belong on the physical outputs.
if (w.resourceClass === "uuremote-server" || (w.caption || "").indexOf("uu-remote-linux privacy") === 0) return;
const screen = workspace.screens.find(o => o.name === "{output}");
if (!screen || (w.output && w.output.name === "{output}")) return;
workspace.sendClientToScreen(w, screen);
}}
function watch(w) {{
if (!w) return;
// One window that cannot be moved or observed must not stop the others.
try {{
keep(w);
w.frameGeometryChanged.connect(function () {{ keep(w); }});
}} catch (e) {{}}
}}
// New windows first: a throwing sweep must not leave them unhandled.
workspace.windowAdded.connect(watch);
workspace.windowList().forEach(watch);
"#, movable = MOVABLE), KEEP_WINDOWS, true)
}
/// Stops following new windows. A name that is not loaded (screen-off mode, a restarted KWin
/// session) reports false without an error.
pub fn unload_keep_windows() -> Result<(), String> {
call("/Scripting", "org.kde.kwin.Scripting.unloadScript", &[KEEP_WINDOWS]).map(|_| ())
}
/// Hides the cover window from the task manager. GTK's skip-taskbar hint is an X11 hint and KWin
/// ignores it on Wayland, so the cover showed up as an unidentified window with the theme's
/// 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;"#, ONE_SHOT, false)
}
#[cfg(test)]
mod tests {
#[test]
fn escapes_output_names_for_the_script() {
assert_eq!(super::escape("DP-3"), "DP-3");
assert_eq!(super::escape(r#"a"b\c"#), r#"a\"b\\c"#);
}
}
+119
View File
@@ -0,0 +1,119 @@
//! 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, and a
//! second KWin script keeps windows that appear later on the virtual output too.
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")?;
// Loaded before the physical outputs come back: from then on KWin places a new window on the
// screen it considers active, which may be one that is about to be covered.
match kwin::keep_windows_on(&virtual_name) {
Ok(()) => log::info!("Privacy new-window keeper: loaded"),
Err(e) => log::warn!("Privacy new-window keeper: {e}"),
}
outputs::set(&data.outputs, true).map_err(|e| format!("enable outputs: {e}"))?;
if let Err(e) = outputs::set_primary(&virtual_name) { log::warn!("Privacy virtual output priority: {e}"); }
kwin::move_windows_to(&virtual_name).map_err(|e| format!("move windows: {e}"))?;
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 refresh_pointer_region(&self) -> Option<[f64; 4]> {
// The old virtual output disappears with the replaced session; wait for the layout to
// settle on the new one before taking its share of the bounding box.
let layout = outputs::layout().ok()?;
let virtuals: Vec<_> = layout.iter().filter(|o| o.name.starts_with("Virtual")).collect();
let target = match virtuals.as_slice() { [only] => *only, _ => return None };
outputs::region(&layout, &target.name)
}
fn leave(&self, data: &serde_json::Value) -> Result<(), String> {
let data: Data = serde_json::from_value(data.clone()).map_err(|_| "invalid KDE recovery data")?;
// KWin persists the device flag: a failure is returned (after restoring the outputs) so the
// controller keeps the recovery record and the guard for the next attempt. A device that
// no longer exists is skipped, so a record replayed after a reboot cannot wedge recovery.
let devices = input::restore(&data.devices).map_err(|e| format!("enable input devices: {e}"));
// Stop following new windows before the virtual output goes away.
if let Err(e) = kwin::unload_keep_windows() { log::warn!("Privacy new-window keeper: {e}"); }
// Physical outputs first: switching back opens a monitor share, which needs them enabled.
// The wait also matters: a share opened before KWin applies the mode got the virtual
// output's geometry (seen live: 1920x1080 instead of the panel's 3072x1920).
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]);
}
}
+323
View File
@@ -0,0 +1,323 @@
//! 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, AtomicU64, 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);
/// Bumped when a new first desktop session spawns its auto-enable thread. A reconnect that beats
/// the 500 ms poll would otherwise leave the old waiter running for up to five minutes.
static AUTO_GENERATION: AtomicU64 = AtomicU64::new(0);
/// iOS viewers encode "screen off" as `enable=0, type=3`, and Windows viewers carry every request
/// in `type` with `enable=0`; see `protocol::Request::normalize_ios_screen_off` and
/// `protocol::Request::normalize_windows`.
static VIEWER_IOS: AtomicBool = AtomicBool::new(false);
static VIEWER_WINDOWS: AtomicBool = AtomicBool::new(false);
pub fn supported() -> bool { backend::detect().is_some() }
/// Record the desktop controller's platform for the RPC 7 encoder quirks.
pub fn set_viewer_controller(controller: crate::input::Controller) {
VIEWER_IOS.store(controller == crate::input::Controller::Ios, Ordering::Relaxed);
VIEWER_WINDOWS.store(controller == crate::input::Controller::Windows, Ordering::Relaxed);
}
pub fn active() -> bool { ACTIVE.load(Ordering::Relaxed) }
/// The viewer's privacy_type now in effect.
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()? }
/// A session rebuild replaced the virtual output: refresh the region absolute input maps into.
pub fn refresh_pointer_region() {
if !active() { return; }
for _ in 0..10 {
if let Some(region) = backend::detect().and_then(backend::Backend::refresh_pointer_region) {
if let Ok(mut pointer) = POINTER.lock() { *pointer = Some(region); }
return;
}
std::thread::sleep(std::time::Duration::from_millis(50));
}
log::warn!("Privacy pointer region not refreshed: virtual output layout did not settle");
}
fn publish(active: Option<&Active>) {
ACTIVE.store(active.is_some(), Ordering::Relaxed);
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, mut request) = protocol::parse(rpc)?;
if request.normalize_ios_screen_off(VIEWER_IOS.load(Ordering::Relaxed)) {
// The viewer chose a mode even if the switch is refused below; cancel a pending auto-enable
// as an accepted request would.
VIEWER_OVERRIDE.store(true, Ordering::Relaxed);
log::info!("Privacy request: iOS screen-off encoding normalized (enable=0 type=3)");
} else if request.normalize_windows(VIEWER_WINDOWS.load(Ordering::Relaxed)) {
VIEWER_OVERRIDE.store(true, Ordering::Relaxed);
log::info!("Privacy request: Windows encoding normalized (enable=0 mode={:?})", request.mode);
}
if let Some(e) = refuse(request.enable, request.mode) {
log::warn!("Privacy request refused: enable={} mode={:?}: {e}", request.enable, request.mode);
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 watch is authoritative while it has a value. A None (the logind monitor lost the session)
/// must not fail open: ask logind directly before covering a possibly locked desktop.
fn currently_locked() -> bool {
let locked = crate::session_lock::watch_locked();
let state = *locked.borrow();
match state {
Some(state) => state,
None => crate::session_lock::locked_now() == Some(true),
}
}
/// The capture session and the viewer's CONTROL state need a moment after the peer connects;
/// retry while the portal session is still missing, and let the viewer's RPC 7 win if it arrives.
fn auto_enable(mode: Mode, generation: u64) {
// A locked desktop is already covered. Switching the share to the virtual output would hide
// the lock screen the viewer needs to unlock, so wait for the local unlock first. Bounded:
// a viewer that never unlocks, or leaves, must not hold this thread forever.
let current = || AUTO_GENERATION.load(Ordering::Acquire) == generation;
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(300);
while currently_locked() {
if !current() { return; }
if VIEWER_OVERRIDE.load(Ordering::Relaxed) {
log::info!("Privacy auto: skipped, the viewer already chose a mode");
return;
}
if STATE.try_lock().is_ok_and(|state| state.sessions == 0) {
log::info!("Privacy auto: skipped, the desktop session ended");
return;
}
if std::time::Instant::now() >= deadline {
log::info!("Privacy auto: desktop stayed locked; not covering it");
return;
}
std::thread::sleep(std::time::Duration::from_millis(500));
}
for attempt in 1..=5 {
if !current() { return; }
if VIEWER_OVERRIDE.load(Ordering::Relaxed) {
log::info!("Privacy auto: skipped, the viewer already chose a mode");
return;
}
// 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; }
let generation = AUTO_GENERATION.fetch_add(1, Ordering::AcqRel) + 1;
std::thread::spawn(move || {
std::thread::sleep(std::time::Duration::from_millis(1500));
auto_enable(mode, generation);
});
}
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);
}
}
+146
View File
@@ -0,0 +1,146 @@
//! 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 }
impl Request {
/// iOS viewers encode "turn off the display" as `enable=0, privacy_type=3`: their enable bit is
/// the picture-mode switch, and the explicit screen-off type carries the intent. iOS "off" is
/// `enable=0, type=1` (seen live), so rewrite only this exact combination. Android 4.43.0 was
/// verified with the field-1 semantics, so the rewrite is iOS-only.
pub fn normalize_ios_screen_off(&mut self, ios: bool) -> bool {
if ios && !self.enable && self.mode == Some(Mode::ScreenOff) {
self.enable = true;
return true;
}
false
}
/// Windows viewers send every privacy request with `enable=0` and carry the intent in
/// `privacy_type`: `0/0` is off, `0/2` picture and `0/3` screen-off (verified live on the
/// Windows client). Android 4.43.0 and macOS keep field 1 as the master switch.
pub fn normalize_windows(&mut self, windows: bool) -> bool {
if windows && !self.enable && self.mode.is_some() {
self.enable = true;
return true;
}
false
}
}
pub fn parse(rpc: &[crate::protocol::WireField]) -> Option<(Vec<u8>, Request)> {
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]);
}
#[test]
fn normalizes_ios_screen_off_only() {
let screen_off = crate::protocol::decode_wire(&[10, 2, 8, 42, 58, 4, 8, 0, 16, 3]).unwrap();
let (_, mut request) = parse(&screen_off).unwrap();
assert!(request.normalize_ios_screen_off(true));
assert!(request.enable);
assert_eq!(request.mode, Some(Mode::ScreenOff));
let (_, mut request) = parse(&screen_off).unwrap();
assert!(!request.normalize_ios_screen_off(false));
assert!(!request.enable);
// An iOS "off" (type 1) and a Mac-style enable (1,3) must stay untouched.
let off = crate::protocol::decode_wire(&[10, 2, 8, 42, 58, 4, 8, 0, 16, 1]).unwrap();
let (_, mut request) = parse(&off).unwrap();
assert!(!request.normalize_ios_screen_off(true));
assert!(!request.enable);
let mac = crate::protocol::decode_wire(&[10, 2, 8, 42, 58, 4, 8, 1, 16, 3]).unwrap();
let (_, mut request) = parse(&mac).unwrap();
assert!(!request.normalize_ios_screen_off(true));
assert!(request.enable);
}
#[test]
fn normalizes_windows_encoding_only() {
// Windows: enable is always 0, the type carries the intent.
for (wire, mode) in [(2u8, Mode::Picture), (3u8, Mode::ScreenOff)] {
let bytes = [10, 2, 8, 42, 58, 4, 8, 0, 16, wire];
let (_, mut request) = parse(&crate::protocol::decode_wire(&bytes).unwrap()).unwrap();
assert!(request.normalize_windows(true));
assert!(request.enable);
assert_eq!(request.mode, Some(mode));
}
// Off stays off: type 0 (seen when the Windows switch is turned off) and type 1.
for wire in [0u8, 1] {
let bytes = [10, 2, 8, 42, 58, 4, 8, 0, 16, wire];
let (_, mut request) = parse(&crate::protocol::decode_wire(&bytes).unwrap()).unwrap();
assert!(!request.normalize_windows(true));
assert!(!request.enable);
}
// Other platforms and explicit enables are untouched.
let picture = crate::protocol::decode_wire(&[10, 2, 8, 42, 58, 4, 8, 0, 16, 2]).unwrap();
let (_, mut request) = parse(&picture).unwrap();
assert!(!request.normalize_windows(false));
assert!(!request.enable);
let explicit = crate::protocol::decode_wire(&[10, 2, 8, 42, 58, 4, 8, 1, 16, 2]).unwrap();
let (_, mut request) = parse(&explicit).unwrap();
assert!(!request.normalize_windows(true));
assert!(request.enable);
}
}
+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);
}
}
+77
View File
@@ -56,6 +56,31 @@ impl SessionIce {
} }
} }
/// With `UU_USE_PROXY=1`, also gather TURN relays over TCP/TLS (through the HTTP proxy when
/// one is configured); hosts whose UDP cannot reach the TURN servers then still get a relay.
pub fn configure_relay_transport() {
if !crate::auth::proxy_enabled() { return; }
let value = ["HTTPS_PROXY", "https_proxy", "ALL_PROXY", "all_proxy"].iter().find_map(|name| std::env::var(name).ok()).filter(|v| !v.is_empty());
let proxy = match value.as_deref().map(relay_proxy) {
Some(Ok(proxy)) => Some(proxy),
Some(Err(reason)) => { log::warn!("TURN over TCP/TLS disabled: {reason}"); return; }
None => None,
};
log::info!("TURN over TCP/TLS enabled: via_http_proxy={}", proxy.is_some());
webrtc::ice::agent::turn_tcp::set_relay_transport(webrtc::ice::agent::turn_tcp::RelayTransport { http_proxy: proxy });
}
/// `host:port` of an unauthenticated HTTP proxy URL; never echoes the value.
fn relay_proxy(value: &str) -> Result<String, &'static str> {
let url = reqwest::Url::parse(&if value.contains("://") { value.to_owned() } else { format!("http://{value}") })
.map_err(|_| "invalid proxy URL")?;
if url.scheme() != "http" { return Err("only http:// proxies are supported for TURN"); }
if !url.username().is_empty() || url.password().is_some() { return Err("proxy authentication is not supported for TURN"); }
let host = url.host_str().ok_or("invalid proxy URL")?;
let port = url.port_or_known_default().ok_or("invalid proxy URL")?;
Ok(format!("{host}:{port}")) // host_str() keeps IPv6 brackets
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
@@ -74,4 +99,56 @@ mod tests {
assert_eq!(config.ice_servers.len(),1); assert_eq!(config.ice_servers.len(),1);
assert!(config.ice_servers[0].urls.iter().all(|s|s.starts_with("stun:"))); assert!(config.ice_servers[0].urls.iter().all(|s|s.starts_with("stun:")));
} }
#[test]
fn relay_proxy_accepts_plain_http_only() {
assert_eq!(super::relay_proxy("http://proxy.invalid:8889").unwrap(), "proxy.invalid:8889");
assert_eq!(super::relay_proxy("proxy.invalid:8889/").unwrap(), "proxy.invalid:8889");
assert_eq!(super::relay_proxy("http://[::1]:3128").unwrap(), "[::1]:3128");
for bad in ["socks5://proxy.invalid:1080", "https://proxy.invalid:443", "http://user:[email protected]:8889", "::"] {
assert!(super::relay_proxy(bad).is_err());
}
}
#[test]
fn turn_tcp_frames_stun_and_padded_channel_data() {
use webrtc::ice::agent::turn_tcp::frame_len;
assert_eq!(frame_len([0x01, 0x01, 0x00, 0x08]), Some(28));
assert_eq!(frame_len([0x40, 0x00, 0x00, 0x05]), Some(12));
assert_eq!(frame_len([0x40, 0x00, 0x00, 0x08]), Some(12));
assert_eq!(frame_len([0x80, 0x00, 0x00, 0x00]), None);
assert!(webrtc::ice::agent::turn_tcp::is_http_reply(*b"HTTP"));
assert!(!webrtc::ice::agent::turn_tcp::is_http_reply([0x40, 0x00, 0x00, 0x05]));
}
#[tokio::test]
async fn turn_tcp_connects_through_the_proxy_and_frames_the_stream() {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use webrtc::ice::agent::turn_tcp::{dial, set_relay_transport, RelayTransport};
use webrtc::util::Conn;
let proxy = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let proxy_addr = proxy.local_addr().unwrap();
let server = tokio::spawn(async move {
let (mut socket, _) = proxy.accept().await.unwrap();
let mut head = Vec::new();
while !head.ends_with(b"\r\n\r\n") { let mut b = [0u8; 1]; socket.read_exact(&mut b).await.unwrap(); head.push(b[0]); }
assert!(String::from_utf8_lossy(&head).starts_with("CONNECT 192.0.2.1:2483 HTTP/1.1\r\n"));
socket.write_all(b"HTTP/1.1 200 Connection established\r\n\r\n").await.unwrap();
let mut frames = [0u8; 20 + 12];
socket.read_exact(&mut frames).await.unwrap();
socket.write_all(&frames).await.unwrap();
});
set_relay_transport(RelayTransport { http_proxy: Some(proxy_addr.to_string()) });
let target: std::net::SocketAddr = "192.0.2.1:2483".parse().unwrap();
let conn = dial("192.0.2.1", 2483, target, false).await.unwrap();
let mut stun = [0u8; 20]; stun[1] = 0x01;
let channel = [0x40, 0x00, 0x00, 0x05, 1, 2, 3, 4, 5, 0, 0, 0];
conn.send_to(&stun, target).await.unwrap();
conn.send_to(&channel, target).await.unwrap();
let mut buf = [0u8; 64];
assert_eq!(conn.recv_from(&mut buf).await.unwrap(), (20, target));
assert_eq!(conn.recv_from(&mut buf).await.unwrap(), (12, target));
assert_eq!(&buf[..12], &channel);
server.await.unwrap();
}
} }
+74 -20
View File
@@ -11,11 +11,15 @@
//! (`loginctl unlock-session`, allowed for the session owner), which avoids remote keystrokes //! (`loginctl unlock-session`, allowed for the session owner), which avoids remote keystrokes
//! and gives an exact wrong-password result. The password is never logged or stored. //! and gives an exact wrong-password result. The password is never logged or stored.
use std::process::Command; use std::process::{Command, Stdio};
use std::path::{Path, PathBuf};
use std::sync::OnceLock; use std::sync::OnceLock;
use std::time::Duration; use std::time::Duration;
use tokio::sync::watch; use tokio::sync::watch;
mod logind;
/// Official UnlockResult cases (LockScreenManager). /// Official UnlockResult cases (LockScreenManager).
#[derive(Debug, Clone, Copy, PartialEq, Eq)] #[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum UnlockResult { Success, WrongPassword, NoLoggedInUser, NoPermission, Failed } pub enum UnlockResult { Success, WrongPassword, NoLoggedInUser, NoPermission, Failed }
@@ -29,10 +33,44 @@ extern "C" {
fn uu_pam_check(service: *const libc::c_char, user: *const libc::c_char, password: *const libc::c_char) -> libc::c_int; fn uu_pam_check(service: *const libc::c_char, user: *const libc::c_char, password: *const libc::c_char) -> libc::c_int;
} }
// Resolve once: execvp's unsuccessful PATH candidates are also recorded by auditd.
fn loginctl_path() -> Option<&'static Path> {
static PATH: OnceLock<Option<PathBuf>> = OnceLock::new();
PATH.get_or_init(|| {
std::env::var_os("PATH").into_iter().flat_map(|p| std::env::split_paths(&p).collect::<Vec<_>>())
.map(|dir| dir.join("loginctl"))
.find(|path| path.is_file() && std::ffi::CString::new(path.as_os_str().as_encoded_bytes())
.map(|p| unsafe { libc::access(p.as_ptr(), libc::X_OK) == 0 }).unwrap_or(false))
.and_then(|path| std::fs::canonicalize(path).ok())
}).as_deref()
}
#[cfg(test)]
static COMMAND_STARTS: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
fn bounded_command(path: &Path, args: &[&str], timeout: Duration) -> Option<String> {
use std::io::Read;
#[cfg(test)]
COMMAND_STARTS.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
let mut child = Command::new(path).args(args).stdin(Stdio::null()).stdout(Stdio::piped())
.stderr(Stdio::null()).spawn().ok()?;
let deadline = std::time::Instant::now() + timeout;
loop {
match child.try_wait() {
Ok(Some(status)) => {
if !status.success() { return None; }
let mut text = String::new();
child.stdout.take()?.take(4096).read_to_string(&mut text).ok()?;
return Some(text.trim().to_owned());
}
Ok(None) if std::time::Instant::now() < deadline => std::thread::sleep(Duration::from_millis(10)),
_ => { let _ = child.kill(); let _ = child.wait(); return None; }
}
}
}
fn loginctl(args: &[&str]) -> Option<String> { fn loginctl(args: &[&str]) -> Option<String> {
let out = Command::new("loginctl").args(args).output().ok()?; bounded_command(loginctl_path()?, args, Duration::from_secs(3)).filter(|s| !s.is_empty())
if !out.status.success() { return None; }
Some(String::from_utf8_lossy(&out.stdout).trim().to_string()).filter(|s| !s.is_empty())
} }
/// The logind session that owns this user's graphical display. /// The logind session that owns this user's graphical display.
@@ -44,7 +82,7 @@ fn display_session() -> Option<String> {
pub fn locked_now() -> Option<bool> { display_session().as_deref().and_then(session_locked) } pub fn locked_now() -> Option<bool> { display_session().as_deref().and_then(session_locked) }
fn session_locked(session: &str) -> Option<bool> { fn session_locked(session: &str) -> Option<bool> {
loginctl(&["show-session", session, "-p", "LockedHint", "--value"]).map(|v| v == "yes") loginctl(&["show-session", session, "-p", "LockedHint", "--value"]).and_then(|v| match v.as_str() { "yes" => Some(true), "no" => Some(false), _ => None })
} }
fn user_name() -> Option<String> { fn user_name() -> Option<String> {
@@ -78,31 +116,28 @@ pub fn supported() -> bool {
*SUPPORTED.get_or_init(|| pam_available() && display_session().is_some()) *SUPPORTED.get_or_init(|| pam_available() && display_session().is_some())
} }
/// Current lock state (None = unknown), refreshed every second by one background thread. /// Current lock state (None = unknown), shared by all desktop connections.
pub fn watch_locked() -> watch::Receiver<Option<bool>> { pub fn watch_locked() -> watch::Receiver<Option<bool>> {
static STATE: OnceLock<watch::Sender<Option<bool>>> = OnceLock::new(); static STATE: OnceLock<watch::Sender<Option<bool>>> = OnceLock::new();
STATE.get_or_init(|| { STATE.get_or_init(|| {
let (tx, _) = watch::channel(None); let (tx, _) = watch::channel(None);
let sender = tx.clone(); let sender = tx.clone();
std::thread::Builder::new().name("uu-lock-state".into()).spawn(move || { std::thread::Builder::new().name("uu-lock-state".into()).spawn(move || {
let mut session = None; tokio::runtime::Builder::new_current_thread().enable_all().build()
loop { .expect("lock monitor runtime").block_on(logind::monitor(sender));
if session.is_none() { session = display_session(); }
let locked = session.as_deref().and_then(session_locked);
if locked.is_none() { session = None; } // session ended or changed: look it up again
sender.send_if_modified(|current| if *current != locked {
log::info!("Desktop lock state: {}", match locked { Some(true) => "locked", Some(false) => "unlocked", None => "unknown" });
// 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)"); }
*current = locked; true
} else { false });
std::thread::sleep(Duration::from_secs(1));
}
}).expect("spawn lock state thread"); }).expect("spawn lock state thread");
tx tx
}).subscribe() }).subscribe()
} }
fn publish_lock_state(sender: &watch::Sender<Option<bool>>, locked: Option<bool>) {
sender.send_if_modified(|current| if *current != locked {
log::info!("Desktop lock state: {}", match locked { Some(true) => "locked", Some(false) => "unlocked", None => "unknown" });
if locked == Some(true) { log::info!("Desktop is locked; capture continues while the compositor supplies frames"); }
*current = locked; true
} else { false });
}
/// Verifies the session user's password and unlocks the display session. Blocking (PAM may /// Verifies the session user's password and unlocks the display session. Blocking (PAM may
/// delay a failure by seconds); call from spawn_blocking. Consumes and wipes the password. /// delay a failure by seconds); call from spawn_blocking. Consumes and wipes the password.
pub fn unlock(password: String) -> UnlockResult { pub fn unlock(password: String) -> UnlockResult {
@@ -118,7 +153,7 @@ fn unlock_with(password: &str) -> UnlockResult {
let Some(user) = user_name() else { return UnlockResult::NoLoggedInUser }; let Some(user) = user_name() else { return UnlockResult::NoLoggedInUser };
if password.is_empty() || password.contains('\0') { return UnlockResult::WrongPassword; } if password.is_empty() || password.contains('\0') { return UnlockResult::WrongPassword; }
match pam_check(&user, password) { 0 => {}, 1 => return UnlockResult::WrongPassword, _ => return UnlockResult::Failed } match pam_check(&user, password) { 0 => {}, 1 => return UnlockResult::WrongPassword, _ => return UnlockResult::Failed }
if Command::new("loginctl").args(["unlock-session", &session]).status().map(|s| !s.success()).unwrap_or(true) { if loginctl_path().and_then(|path| bounded_command(path, &["unlock-session", &session], Duration::from_secs(3))).is_none() {
return UnlockResult::NoPermission; return UnlockResult::NoPermission;
} }
if let Err(error) = crate::capture::keep_display_awake() { if let Err(error) = crate::capture::keep_display_awake() {
@@ -205,6 +240,25 @@ pub fn password_from_args(args: &[u8]) -> Option<String> {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
#[test]
fn unknown_state_is_preserved_and_repeated_states_do_not_notify() {
let (tx, mut rx) = watch::channel(Some(true));
publish_lock_state(&tx, None);
assert_eq!(*rx.borrow_and_update(), None);
publish_lock_state(&tx, None);
assert!(!rx.has_changed().unwrap());
publish_lock_state(&tx, Some(false));
assert!(rx.has_changed().unwrap());
assert_eq!(*rx.borrow_and_update(), Some(false));
}
#[test]
fn hung_fallback_is_killed_and_reaped() {
let start = std::time::Instant::now();
assert_eq!(bounded_command(Path::new("/bin/sleep"), &["10"], Duration::from_millis(30)), None);
assert!(start.elapsed() < Duration::from_secs(2));
}
#[test] #[test]
fn password_comes_from_the_official_key_field() { fn password_comes_from_the_official_key_field() {
assert_eq!(password_from_args(br#"{"key":"p@ss word"}"#).as_deref(), Some("p@ss word")); assert_eq!(password_from_args(br#"{"key":"p@ss word"}"#).as_deref(), Some("p@ss word"));
Loaded 100 of 217 files, more files were not shown because too many files have changed in this diff. Show more