mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 16:50:41 +01:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
0b3ac4c78e | ||
|
|
8b6de40605 | ||
|
|
7a0c40af73 | ||
|
|
f67de7cc7d | ||
|
|
b9586f226d |
No files matched your search
@@ -163,6 +163,7 @@ for a new QR login.
|
||||
| `src/privacy_screen/`, `c_engine/privacy_wallpaper.c` | host privacy screen (RPC 7): desktop-independent controller, recovery record, guard and cover processes; `Backend` per desktop (`kde/`: KWin virtual output, kscreen-doctor, KWin input devices). See docs/privacy-screen.md |
|
||||
| `src/session_lock.rs`, `c_engine/pam_check.c` | lock state reporting, auto unlock via PAM + logind |
|
||||
| `src/system_actions.rs`, `src/system_metrics.rs` | SimpleAction system commands, mute, auto-lock, SystemMetrics |
|
||||
| `src/annotation.rs`, `c_engine/annotation_overlay.c` | viewer annotation (RPC 27 `draw_req` → RpcResponse 23): click-through X11 ARGB overlay, needs a compositing manager |
|
||||
| `src/initialization.rs`, `src/control_protocol.rs`, `src/protocol.rs` | protobuf encoders/decoders for CONTROL |
|
||||
| `src/session_ice.rs`, `src/network_diagnostics.rs` | cloud ICE servers, address-free path diagnostics |
|
||||
| `src/desktop_backend.rs`, `src/wayland.rs`, `src/portal*.rs` | backend selection, Hyprland, GNOME/KDE portal |
|
||||
@@ -194,7 +195,7 @@ started a second full host server instead, so check that a subcommand exists in
|
||||
- RPC = Message 21 `RpcRequest {1 header{1 request_id}, <case>}`, answered with Message 22
|
||||
`RpcResponse {1 header (same id), <case>}`. Cases used: 2 capture_setting, 3 fps, 4 video_quality,
|
||||
6 resolution, 8 file transfer, 9 clipboard, 15 send_video_track, 16–20 plugins, 21 virtual audio policy,
|
||||
28/29 terminal.
|
||||
27 draw (annotation; answered on TEXT, a CONTROL reply times out with 9998), 28/29 terminal.
|
||||
- CaptureSettingRequest: field 1 is an **fps option index** (1=30, 2=60, 3=90); the real frame rate is
|
||||
field 18 `fpsCount`. Field 2 quality: 1 Fast, 2 General (高清 2M), 3 HD (超清 8M), 4 Bluray (原画 20M),
|
||||
5 Auto, 6 Custom. Resolution: 16/17 pixel size or 5/6, 10 resolution_type (3 = follow remote).
|
||||
|
||||
Generated
+1
-1
@@ -2804,7 +2804,7 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
|
||||
|
||||
[[package]]
|
||||
name = "uu-remote-linux"
|
||||
version = "0.2.49"
|
||||
version = "0.2.50"
|
||||
dependencies = [
|
||||
"ab_glyph",
|
||||
"async-trait",
|
||||
|
||||
+2
-1
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "uu-remote-linux"
|
||||
version = "0.2.49"
|
||||
version = "0.2.50"
|
||||
edition = "2021"
|
||||
default-run = "uuremote-server"
|
||||
authors = ["uu-remote-linux contributors"]
|
||||
@@ -63,6 +63,7 @@ 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"] }
|
||||
|
||||
@@ -77,6 +77,7 @@ Protocol strings and messages that come from the UU servers are shown as the ser
|
||||
| Mac shortcuts | **Recommended**: turn off 「使用 macOS 快捷键」 (use macOS shortcuts) in the Mac viewer's remote-window menu; then Cmd+C/V/A/F/X/Z work as on a Mac (Cmd+C/V become Ctrl+Shift+C/V in terminals) and Ctrl+C always interrupts. With the option on, the viewer sends Cmd as Ctrl: in a terminal Ctrl+V / Cmd+V paste, Ctrl+C interrupts, copy is Cmd+Shift+C (X11) |
|
||||
| Pointer shape | Remote cursor shape is mirrored to the viewer (X11) |
|
||||
| Clipboard | Two-way text sync; Wayland mobile IME text inputs use clipboard paste fallback (see below) |
|
||||
| Viewer annotation | Strokes drawn with 「批注」 (annotate) in the viewer's watch mode appear on the Linux screen and stream back to the viewer (X11, needs a compositing manager; the overlay lets clicks through); cleared when annotation is turned off or the viewer disconnects. Verified with the Mac viewer 4.42.0; mobile viewers untested |
|
||||
| Quality / frame rate / resolution | Auto, Original 20M, Ultra 8M, HD 2M, custom; 30/60/90/144 fps; on X11 a resolution choice changes the desktop resolution itself like the official Windows host (xrandr, adding the mode when missing; restored for "original" or on disconnect), `UU_DESKTOP_RESIZE=0` scales in the encoder instead; Wayland scales in the encoder |
|
||||
| Sound | System audio captured from PulseAudio / PipeWire and sent as Opus |
|
||||
| File transfer | Upload, download (including folders), create folder, rename, delete |
|
||||
|
||||
@@ -66,6 +66,7 @@ UU_LANG=en uuremote-server
|
||||
| Mac 快捷键 | **推荐**:在 Mac 远控窗口菜单里关闭「使用 macOS 快捷键」,之后和在 Mac 上一样:Cmd+C/V/A/F/X/Z 是复制、粘贴、全选、查找、剪切、撤销(终端里 Cmd+C/V 自动变成 Ctrl+Shift+C/V),Ctrl+C 在终端里始终是中断。保持开启时,客户端会把 Cmd 和 Ctrl 都当成 Ctrl 发送:终端里 Ctrl+V / Cmd+V 自动转成粘贴,Ctrl+C 是中断,复制用 Cmd+Shift+C(X11) |
|
||||
| 鼠标指针样式 | 远端指针形状实时同步(X11) |
|
||||
| 剪贴板 | 双向文本同步;Wayland 手机输入法输入通过剪贴板兜底粘贴,见下文 |
|
||||
| 观看模式批注 | 控制端观看模式下开启「批注」后画的笔迹显示在 Linux 屏幕上,并随画面传回控制端(X11,需要合成器;覆盖层不拦截鼠标);关闭批注或断开连接时清除。已用 Mac 控制端 4.42.0 实测,手机控制端未测 |
|
||||
| 画质 / 帧率 / 分辨率 | 自动、原画 20M、超清 8M、高清 2M、自定义;30/60/90/144 帧;X11 下切换分辨率会像官方 Windows 被控端一样真正修改桌面分辨率(xrandr,缺少该模式时自动添加;选「原始」或断开后恢复),`UU_DESKTOP_RESIZE=0` 改为仅由编码器缩放;Wayland 仍由编码器缩放 |
|
||||
| 声音 | 采集系统声音(PulseAudio / PipeWire),Opus 编码传到控制端 |
|
||||
| 文件传输 | 上传、下载(含文件夹)、新建文件夹、重命名、删除 |
|
||||
|
||||
@@ -3,6 +3,7 @@ fn main() {
|
||||
println!("cargo:rerun-if-changed=c_engine/wayland_transform.h");
|
||||
println!("cargo:rerun-if-changed=c_engine/portal_clipboard.inc");
|
||||
println!("cargo:rerun-if-changed=c_engine/x11_engine.c");
|
||||
println!("cargo:rerun-if-changed=c_engine/annotation_overlay.c");
|
||||
println!("cargo:rerun-if-changed=c_engine/uinput_keymap.c");
|
||||
println!("cargo:rerun-if-changed=c_engine/uinput_keymap.h");
|
||||
println!("cargo:rerun-if-changed=c_engine/nvenc_engine.c");
|
||||
@@ -34,6 +35,7 @@ fn main() {
|
||||
}
|
||||
let mut x11_build = cc::Build::new();
|
||||
x11_build.file("c_engine/x11_engine.c")
|
||||
.file("c_engine/annotation_overlay.c")
|
||||
.file("c_engine/uinput_keymap.c")
|
||||
.file("c_engine/clipboard.c")
|
||||
.file("c_engine/pam_check.c");
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
@@ -594,8 +594,14 @@ static int read_stream_result(struct uu_portal *p, GVariant *results) {
|
||||
if (streams) g_variant_unref(streams);
|
||||
return error;
|
||||
}
|
||||
static void save_restore_token(struct uu_portal *p, void (*save_token)(const char *, void *),
|
||||
uu_portal_save_detailed_fn save_detailed, void *save_data) {
|
||||
if (!p->restore_token) return;
|
||||
if (save_token) save_token(p->restore_token, save_data);
|
||||
if (save_detailed) save_detailed(p->restore_token, save_data, p->has_position, p->position_x, p->position_y);
|
||||
}
|
||||
static struct uu_portal *open_persist(const char *restore, void (*save_token)(const char *, void *),
|
||||
void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data,
|
||||
uu_portal_save_detailed_fn save_detailed, void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data,
|
||||
int prefer_dmabuf, int *error, uint32_t *width, uint32_t *height, uint32_t source_types) {
|
||||
*error = 0; *width = *height = 0;
|
||||
struct uu_portal *p = calloc(1, sizeof(*p));
|
||||
@@ -675,7 +681,7 @@ static struct uu_portal *open_persist(const char *restore, void (*save_token)(co
|
||||
fprintf(stderr, "Portal persistence: requested=%d restore_attempted=%d token_returned=%d\n",
|
||||
version >= 2, restore && *restore, p->restore_token && *p->restore_token);
|
||||
}
|
||||
if (!*error && p->restore_token && save_token) save_token(p->restore_token, save_data);
|
||||
if (!*error) save_restore_token(p, save_token, save_detailed, save_data);
|
||||
g_variant_unref(results);
|
||||
if (*error) goto done;
|
||||
p->main_loop = g_main_loop_new(p->context, FALSE);
|
||||
@@ -708,21 +714,27 @@ struct uu_portal *uu_portal_open_persist_cancellable(const char *restore,
|
||||
void (*save_token)(const char *, void *), void *save_data,
|
||||
uu_portal_cancelled_fn cancelled, void *cancel_data,
|
||||
int *error, uint32_t *width, uint32_t *height) {
|
||||
return open_persist(restore, save_token, save_data, cancelled, cancel_data, 0, error, width, height, 1);
|
||||
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, save_data, cancelled, cancel_data, prefer_dmabuf, error, width, height, 1);
|
||||
return open_persist(restore, save_token, NULL, save_data, cancelled, cancel_data, prefer_dmabuf, error, width, height, 1);
|
||||
}
|
||||
struct uu_portal *uu_portal_open_persist(const char *restore, void (*save_token)(const char *, void *),
|
||||
void *data, int *error, uint32_t *width, uint32_t *height) {
|
||||
return open_persist(restore, save_token, data, NULL, NULL, 0, error, width, height, 1);
|
||||
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, data, NULL, NULL, 0, error, width, height, 4);
|
||||
return open_persist(restore, save_token, NULL, data, NULL, NULL, 0, error, width, height, 4);
|
||||
}
|
||||
struct uu_portal *uu_portal_open_detailed(const char *restore, uu_portal_save_detailed_fn save_token,
|
||||
void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data, int prefer_dmabuf,
|
||||
uint32_t source_types, int *error, uint32_t *width, uint32_t *height) {
|
||||
if (source_types != 1 && source_types != 4) { *error = 3; *width = *height = 0; return NULL; }
|
||||
return open_persist(restore, NULL, save_token, save_data, cancelled, cancel_data, prefer_dmabuf, error, width, height, source_types);
|
||||
}
|
||||
struct uu_portal *uu_portal_open_restore(const char *restore, int *error, uint32_t *width, uint32_t *height) {
|
||||
return uu_portal_open_persist(restore, NULL, NULL, error, width, height);
|
||||
|
||||
@@ -5,6 +5,9 @@
|
||||
#include "dmabuf_frame.h"
|
||||
struct uu_portal;
|
||||
typedef int (*uu_portal_cancelled_fn)(void *data);
|
||||
typedef void (*uu_portal_save_detailed_fn)(const char *token, void *data, int has_position, int32_t x, int32_t y);
|
||||
/* Reports the granted position alongside the rotated token before video initialization. */
|
||||
struct uu_portal *uu_portal_open_detailed(const char *restore, uu_portal_save_detailed_fn save_token, void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data, int prefer_dmabuf, uint32_t source_types, int *error, uint32_t *width, uint32_t *height);
|
||||
/* One object owns one consent/session and one PipeWire stream. */
|
||||
struct uu_portal *uu_portal_open(int *error, uint32_t *width, uint32_t *height);
|
||||
/* Saves the rotated token immediately after Start, before video initialization. */
|
||||
|
||||
@@ -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.**
|
||||
@@ -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]);
|
||||
}
|
||||
}
|
||||
+123
-4
@@ -99,7 +99,7 @@ impl Controller {
|
||||
#[derive(Default)]
|
||||
struct CmdState { held: bool, pending: bool, passthrough: bool, combos: std::collections::BTreeMap<i32, bool> }
|
||||
|
||||
pub struct InputInjector { mac_controller: std::sync::atomic::AtomicBool, cmd: std::sync::Mutex<CmdState>, serial:std::sync::Mutex<()>, owner:std::sync::Mutex<DesktopOwner>, shortcuts: std::sync::Mutex<Shortcuts>, uinput: Option<crate::uinput::Devices>, uinput_pointer: bool, screen: std::sync::Mutex<(u32,u32)>, portal_failures: std::sync::atomic::AtomicUsize, portal_outcomes: [std::sync::atomic::AtomicUsize; 3], portal:std::sync::Mutex<Option<std::sync::Arc<crate::portal::PortalSession>>>, backend: crate::desktop_backend::DesktopBackend, pending: std::sync::Mutex<PendingPointer>, held: std::sync::Mutex<HeldInput>, touch: std::sync::Mutex<TouchDrag> }
|
||||
pub struct InputInjector { mac_controller: std::sync::atomic::AtomicBool, cmd: std::sync::Mutex<CmdState>, serial:std::sync::Mutex<()>, owner:std::sync::Mutex<DesktopOwner>, shortcuts: std::sync::Mutex<Shortcuts>, uinput: Option<crate::uinput::Devices>, uinput_pointer: bool, screen: std::sync::Mutex<(u32,u32)>, portal_failures: std::sync::atomic::AtomicUsize, portal_outcomes: [std::sync::atomic::AtomicUsize; 3], portal:std::sync::Mutex<Option<std::sync::Arc<crate::portal::PortalSession>>>, backend: crate::desktop_backend::DesktopBackend, pending: std::sync::Mutex<PendingPointer>, held: std::sync::Mutex<HeldInput>, touch: std::sync::Mutex<TouchDrag>, pointer_wake: tokio::sync::Notify }
|
||||
|
||||
fn active_output_count(json: &[u8]) -> Option<usize> {
|
||||
let data: serde_json::Value = serde_json::from_slice(json).ok()?;
|
||||
@@ -135,7 +135,7 @@ impl InputInjector {
|
||||
|| (backend == crate::desktop_backend::DesktopBackend::Portal && single_portal_output()));
|
||||
if uinput_pointer { log::info!("Input pointer backend: uinput (motion, buttons and wheel)"); }
|
||||
else if backend == crate::desktop_backend::DesktopBackend::Portal { log::info!("Input pointer backend: portal (monitor-local coordinates)"); }
|
||||
Self { mac_controller: std::sync::atomic::AtomicBool::new(false), cmd: std::sync::Mutex::new(CmdState::default()), serial:std::sync::Mutex::new(()), owner:std::sync::Mutex::new(DesktopOwner::default()), shortcuts: std::sync::Mutex::new(Shortcuts::default()), uinput, uinput_pointer, screen: std::sync::Mutex::new((0,0)), portal_failures: std::sync::atomic::AtomicUsize::new(0), portal_outcomes: std::array::from_fn(|_| std::sync::atomic::AtomicUsize::new(0)), portal:std::sync::Mutex::new(None), backend, pending: std::sync::Mutex::new(PendingPointer::default()), held:std::sync::Mutex::new(HeldInput::default()), touch:std::sync::Mutex::new(TouchDrag::default()) }
|
||||
Self { mac_controller: std::sync::atomic::AtomicBool::new(false), cmd: std::sync::Mutex::new(CmdState::default()), serial:std::sync::Mutex::new(()), owner:std::sync::Mutex::new(DesktopOwner::default()), shortcuts: std::sync::Mutex::new(Shortcuts::default()), uinput, uinput_pointer, screen: std::sync::Mutex::new((0,0)), portal_failures: std::sync::atomic::AtomicUsize::new(0), portal_outcomes: std::array::from_fn(|_| std::sync::atomic::AtomicUsize::new(0)), portal:std::sync::Mutex::new(None), backend, pending: std::sync::Mutex::new(PendingPointer::default()), held:std::sync::Mutex::new(HeldInput::default()), touch:std::sync::Mutex::new(TouchDrag::default()), pointer_wake: tokio::sync::Notify::new() }
|
||||
}
|
||||
|
||||
pub fn bind_portal(&self,session:Option<std::sync::Arc<crate::portal::PortalSession>>) {
|
||||
@@ -153,6 +153,7 @@ impl InputInjector {
|
||||
let mut pending = self.pending.lock().unwrap();
|
||||
pending.absolute = Some(position);
|
||||
pending.relative = (0,0);
|
||||
self.pointer_wake.notify_one();
|
||||
}
|
||||
}
|
||||
pub fn mouse_relative(&self, dx: i32, dy: i32) {
|
||||
@@ -160,6 +161,7 @@ impl InputInjector {
|
||||
let mut pending = self.pending.lock().unwrap();
|
||||
pending.relative.0 = (pending.relative.0 + i64::from(dx)).clamp(-65535,65535);
|
||||
pending.relative.1 = (pending.relative.1 + i64::from(dy)).clamp(-65535,65535);
|
||||
self.pointer_wake.notify_one();
|
||||
}
|
||||
}
|
||||
pub fn mouse_scroll(&self, dx: i32, dy: i32) {
|
||||
@@ -167,15 +169,38 @@ impl InputInjector {
|
||||
let mut pending = self.pending.lock().unwrap();
|
||||
pending.scroll.0 = (pending.scroll.0 + i64::from(dx)).clamp(-12000,12000);
|
||||
pending.scroll.1 = (pending.scroll.1 + i64::from(dy)).clamp(-12000,12000);
|
||||
self.pointer_wake.notify_one();
|
||||
}
|
||||
pub fn start_pointer_worker(self: &std::sync::Arc<Self>) -> tokio::task::JoinHandle<()> {
|
||||
let input = self.clone();
|
||||
tokio::spawn(async move {
|
||||
// Parked until pointer work exists: a fixed 4 ms tick burned ~250 wakeups/s
|
||||
// (≈3% CPU with pow-heavy flush math) even with no viewer connected.
|
||||
// notify_one() stores a permit, so an event racing the park check cannot be lost.
|
||||
let mut tick = tokio::time::interval(std::time::Duration::from_millis(4));
|
||||
tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
|
||||
loop { tick.tick().await; input.flush_pointer(); }
|
||||
loop {
|
||||
input.pointer_wake.notified().await;
|
||||
// The first event is immediate; later events coalesce until the next tick.
|
||||
tick.reset();
|
||||
loop {
|
||||
input.flush_pointer();
|
||||
tick.tick().await;
|
||||
if input.pointer_idle() { break; }
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
/// Whether the worker may park: nothing accumulated, no full scroll notch waiting and no
|
||||
/// touch gesture in flight (`Pending` needs ticks until its hold resolves, `Scroll`/`Select`
|
||||
/// and `down` until release). Sub-notch scroll residue cannot inject alone, so it parks.
|
||||
fn pointer_idle(&self) -> bool {
|
||||
let pending = self.pending.lock().unwrap();
|
||||
let touch = self.touch.lock().unwrap();
|
||||
pending.absolute.is_none() && pending.relative == (0,0)
|
||||
&& pending.scroll.0 / 120 == 0 && pending.scroll.1 / 120 == 0
|
||||
&& !touch.down && touch.finger == Finger::Up
|
||||
}
|
||||
pub fn discard_pointer(&self) { *self.pending.lock().unwrap() = PendingPointer::default(); }
|
||||
pub fn flush_pointer(&self) {
|
||||
let _serial=self.serial.lock().unwrap();
|
||||
@@ -229,6 +254,8 @@ impl InputInjector {
|
||||
}
|
||||
pub fn mouse_button(&self, button: i32, is_press: bool) {
|
||||
let _serial=self.serial.lock().unwrap();
|
||||
// The worker cannot consume the wake and flush until this transition is published.
|
||||
self.pointer_wake.notify_one();
|
||||
self.flush_pointer_locked();
|
||||
if button == 1 && self.touch_button(is_press) { return; }
|
||||
let result = self.inject_button(button,is_press);
|
||||
@@ -841,6 +868,98 @@ mod motion_tests {
|
||||
input.mouse_relative(1,2); input.discard_pointer();
|
||||
assert_eq!(input.pending.lock().unwrap().relative,(0,0));
|
||||
}
|
||||
#[test]
|
||||
fn parks_when_pointer_state_is_idle() {
|
||||
let input = InputInjector::new();
|
||||
assert!(input.pointer_idle());
|
||||
input.mouse_relative(5,5);
|
||||
assert!(!input.pointer_idle());
|
||||
input.flush_pointer();
|
||||
assert!(input.pointer_idle());
|
||||
input.mouse_scroll(0,125); input.flush_pointer();
|
||||
assert!(input.pointer_idle(), "sub-notch scroll residue cannot inject alone");
|
||||
}
|
||||
#[test]
|
||||
fn live_touch_gesture_stays_busy_until_it_resolves() {
|
||||
let input = InputInjector::new();
|
||||
input.touch.lock().unwrap().finger = Finger::Pending { start: (5,5), at: std::time::Instant::now() };
|
||||
assert!(!input.pointer_idle());
|
||||
input.touch.lock().unwrap().finger = Finger::Scroll { last: (9,9) };
|
||||
assert!(!input.pointer_idle());
|
||||
*input.touch.lock().unwrap() = TouchDrag::default();
|
||||
assert!(input.pointer_idle());
|
||||
}
|
||||
#[test]
|
||||
fn button_wake_waits_for_the_serialized_transition() {
|
||||
use futures_util::FutureExt;
|
||||
let input = std::sync::Arc::new(InputInjector::without_desktop());
|
||||
let serial = input.serial.lock().unwrap();
|
||||
let ready = std::sync::Arc::new(std::sync::Barrier::new(2));
|
||||
let pressing = input.clone();
|
||||
let started = ready.clone();
|
||||
let button = std::thread::spawn(move || { started.wait(); pressing.mouse_button(1,true); });
|
||||
ready.wait();
|
||||
let runtime = tokio::runtime::Builder::new_current_thread().enable_time().build().unwrap();
|
||||
let premature = runtime.block_on(async {
|
||||
tokio::time::timeout(std::time::Duration::from_millis(50), input.pointer_wake.notified()).await.is_ok()
|
||||
});
|
||||
drop(serial);
|
||||
button.join().unwrap();
|
||||
assert!(!premature, "a parked worker must not wake before the button owns the serial lock");
|
||||
assert!(input.pointer_wake.notified().now_or_never().is_some());
|
||||
}
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn worker_coalesces_one_ms_motion_on_four_ms_ticks() {
|
||||
let input = std::sync::Arc::new(InputInjector::without_desktop());
|
||||
let worker = input.start_pointer_worker();
|
||||
input.mouse_relative(1,0);
|
||||
tokio::task::yield_now().await;
|
||||
assert_eq!(input.portal_input_counts_for_test()[0],1, "first motion is immediate");
|
||||
for ms in 1..=12 {
|
||||
tokio::time::advance(std::time::Duration::from_millis(1)).await;
|
||||
tokio::task::yield_now().await;
|
||||
input.mouse_relative(1,0);
|
||||
tokio::task::yield_now().await;
|
||||
assert_eq!(input.portal_input_counts_for_test()[0],1+ms/4, "motion at {ms} ms bypassed the cadence");
|
||||
}
|
||||
tokio::time::advance(std::time::Duration::from_millis(4)).await;
|
||||
tokio::task::yield_now().await;
|
||||
assert_eq!(input.portal_input_counts_for_test()[0],5);
|
||||
assert_eq!(input.pending.lock().unwrap().relative,(0,0));
|
||||
worker.abort();
|
||||
assert!(worker.await.unwrap_err().is_cancelled());
|
||||
}
|
||||
#[tokio::test(start_paused = true)]
|
||||
async fn worker_parks_and_resets_the_tick_after_a_quiet_period() {
|
||||
let input = std::sync::Arc::new(InputInjector::without_desktop());
|
||||
let worker = input.start_pointer_worker();
|
||||
tokio::task::yield_now().await;
|
||||
// Without a notification, raw queued state must remain untouched while parked.
|
||||
input.pending.lock().unwrap().relative = (1,0);
|
||||
tokio::time::advance(std::time::Duration::from_secs(1)).await;
|
||||
tokio::task::yield_now().await;
|
||||
assert_eq!(input.portal_input_counts_for_test()[0],0);
|
||||
input.mouse_relative(1,0);
|
||||
tokio::task::yield_now().await;
|
||||
assert_eq!(input.portal_input_counts_for_test()[0],1);
|
||||
tokio::time::advance(std::time::Duration::from_millis(4)).await;
|
||||
tokio::task::yield_now().await;
|
||||
input.pending.lock().unwrap().relative = (1,0);
|
||||
tokio::time::advance(std::time::Duration::from_millis(997)).await;
|
||||
tokio::task::yield_now().await;
|
||||
assert_eq!(input.portal_input_counts_for_test()[0],1, "idle ticks must stop after activity");
|
||||
input.mouse_relative(1,0);
|
||||
tokio::task::yield_now().await;
|
||||
assert_eq!(input.portal_input_counts_for_test()[0],2);
|
||||
input.mouse_relative(1,0);
|
||||
tokio::task::yield_now().await;
|
||||
assert_eq!(input.portal_input_counts_for_test()[0],2, "a stale interval must not flush a second time immediately");
|
||||
tokio::time::advance(std::time::Duration::from_millis(4)).await;
|
||||
tokio::task::yield_now().await;
|
||||
assert_eq!(input.portal_input_counts_for_test()[0],3);
|
||||
worker.abort();
|
||||
assert!(worker.await.unwrap_err().is_cancelled());
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(all(test, target_os = "linux"))]
|
||||
@@ -1088,7 +1207,7 @@ impl InputInjector {
|
||||
portal_outcomes:std::array::from_fn(|_|std::sync::atomic::AtomicUsize::new(0)),
|
||||
portal:std::sync::Mutex::new(None), backend:crate::desktop_backend::DesktopBackend::Portal,
|
||||
pending:std::sync::Mutex::new(PendingPointer::default()), held:std::sync::Mutex::new(HeldInput::default()),
|
||||
touch:std::sync::Mutex::new(TouchDrag::default()) }
|
||||
touch:std::sync::Mutex::new(TouchDrag::default()), pointer_wake: tokio::sync::Notify::new() }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -48,6 +48,7 @@ mod audio;
|
||||
mod virtual_audio;
|
||||
mod privacy_screen;
|
||||
mod system_actions;
|
||||
mod annotation;
|
||||
mod capability;
|
||||
mod protocol;
|
||||
mod control_protocol;
|
||||
|
||||
+73
-39
@@ -41,6 +41,7 @@ mod native {
|
||||
fn uu_portal_open_virtual(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
|
||||
fn uu_portal_open_persist_cancellable(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), save_data: *mut c_void, cancelled: extern "C" fn(*mut c_void) -> i32, cancel_data: *mut c_void, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
|
||||
fn uu_portal_open_persist_capture(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void), save_data: *mut c_void, cancelled: Option<extern "C" fn(*mut c_void) -> i32>, cancel_data: *mut c_void, prefer_dmabuf: i32, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
|
||||
fn uu_portal_open_detailed(restore: *const libc::c_char, save: extern "C" fn(*const libc::c_char, *mut c_void, i32, i32, i32), save_data: *mut c_void, cancelled: Option<extern "C" fn(*mut c_void) -> i32>, cancel_data: *mut c_void, prefer_dmabuf: i32, source_types: u32, error: *mut i32, width: *mut u32, height: *mut u32) -> *mut c_void;
|
||||
fn uu_portal_clipboard_supported(portal: *mut c_void) -> i32;
|
||||
fn uu_portal_clipboard_ready(portal: *mut c_void) -> i32;
|
||||
fn uu_portal_clipboard_set(portal: *mut c_void, text: *const u8, length: usize) -> i32;
|
||||
@@ -153,6 +154,7 @@ mod native {
|
||||
let directory = super::permissions::directory();
|
||||
let key = super::permissions::desktop_key();
|
||||
let wanted = if virtual_output { None } else { monitor.map(str::to_owned).or_else(crate::wayland::portal_monitor) };
|
||||
let wanted_key = wanted.as_deref().map(super::permissions::monitor_key);
|
||||
let virtual_key = format!("{key}-virtual");
|
||||
// One opener at a time: consent tokens are single-use, and two concurrent openers
|
||||
// (privacy virtual-output switch and closure recovery after a quick reconnect) each
|
||||
@@ -163,66 +165,97 @@ mod native {
|
||||
let taken = directory.as_deref().filter(|_| !fresh).and_then(|dir| {
|
||||
let take = |k: String| super::permissions::take(dir, &k).map(|v| (k, v));
|
||||
if virtual_output { return take(virtual_key.clone()); }
|
||||
wanted.as_deref().and_then(|name| take(super::permissions::monitor_key(name))).or_else(|| take(key.to_owned()))
|
||||
wanted_key.as_ref().and_then(|name| take(super::permissions::pending_key(name)).or_else(|| take(name.clone())))
|
||||
.or_else(|| take(super::permissions::pending_key(key))).or_else(|| take(key.to_owned()))
|
||||
});
|
||||
let token = taken.as_ref().and_then(|(_, value)| std::ffi::CString::new(value.as_str()).ok());
|
||||
// The new token is saved once the granted monitor is known (after open).
|
||||
let mut cache: Option<String> = None;
|
||||
extern "C" fn save_token(token: *const libc::c_char, data: *mut c_void) {
|
||||
// Callback is synchronous during open; cache lives through the call.
|
||||
let requested_key = if virtual_output { &virtual_key } else { wanted_key.as_deref().unwrap_or(key) };
|
||||
struct TokenCache { rotation: super::permissions::Rotation, virtual_key: Option<String>, fresh: bool }
|
||||
let mut cache = TokenCache {
|
||||
rotation: super::permissions::Rotation::new(directory.clone(), requested_key),
|
||||
virtual_key: virtual_output.then(|| virtual_key.clone()), fresh,
|
||||
};
|
||||
extern "C" fn save_detailed(token: *const libc::c_char, data: *mut c_void, has_position: i32, x: i32, y: i32) {
|
||||
let result = std::panic::catch_unwind(|| unsafe {
|
||||
let cache = &mut *(data as *mut Option<String>);
|
||||
*cache = std::ffi::CStr::from_ptr(token).to_str().ok().map(str::to_owned);
|
||||
let cache = &mut *(data as *mut TokenCache);
|
||||
if let Ok(token) = std::ffi::CStr::from_ptr(token).to_str() {
|
||||
if cache.fresh { cache.rotation.remember(token); return; }
|
||||
let granted = cache.virtual_key.clone().or_else(||
|
||||
(has_position != 0).then(|| crate::wayland::portal_monitor_at(x, y)).flatten()
|
||||
.map(|name| super::permissions::monitor_key(&name)));
|
||||
if cache.rotation.record(token, granted.as_deref()).is_err() { log::warn!("Portal permission cache could not be saved"); }
|
||||
}
|
||||
});
|
||||
if result.is_err() { log::warn!("Portal permission cache callback failed"); }
|
||||
}
|
||||
// Older plugins lack the position-aware entry point; use the pending slot.
|
||||
extern "C" fn save_token(token: *const libc::c_char, data: *mut c_void) {
|
||||
save_detailed(token, data, 0, 0, 0);
|
||||
}
|
||||
let restore = token.as_ref().map_or(std::ptr::null(), |value| value.as_ptr());
|
||||
// A failed open must not cost the saved consent: put the token back unless the
|
||||
// portal handed out a new one. A stale token only makes the next open ask again.
|
||||
let failed = |code: i32, cache: &Option<String>| {
|
||||
if let (Some(dir), Some((k, value)), None) = (directory.as_deref(), taken.as_ref(), cache.as_ref()) {
|
||||
let failed = |code: i32, cache: &TokenCache| {
|
||||
if let (Some(dir), Some((k, value)), false) = (directory.as_deref(), taken.as_ref(), cache.rotation.received()) {
|
||||
if super::permissions::save(dir, k, value).is_err() { log::warn!("Portal permission cache could not be restored"); }
|
||||
}
|
||||
super::PortalError { code }
|
||||
};
|
||||
// Release packages can temporarily have an older libuu-portal.so than the host.
|
||||
#[cfg(feature = "engine-plugins")]
|
||||
let detailed = crate::engine_plugin::symbol(crate::engine_plugin::Engine::Portal, "uu_portal_open_detailed\0") != 0;
|
||||
#[cfg(not(feature = "engine-plugins"))]
|
||||
let detailed = true;
|
||||
#[allow(unused_mut)]
|
||||
let mut pointer: *mut c_void = std::ptr::null_mut();
|
||||
let mut prefer_dmabuf = false;
|
||||
#[cfg(feature = "inproc-av")]
|
||||
if !virtual_output && crate::video::native_engine_eligible(crate::video_select::selection().encoder, crate::video::NativeDisplayKind::Portal)
|
||||
&& !std::env::var("UU_PORTAL_DMABUF").is_ok_and(|v| v == "0") {
|
||||
let callback = cancelled.map(|_| is_cancelled as extern "C" fn(*mut c_void) -> i32);
|
||||
let cancel_data = cancelled.map_or(std::ptr::null_mut(), |value| value as *const _ as *mut c_void);
|
||||
pointer = unsafe { uu_portal_open_persist_capture(
|
||||
restore, save_token, &mut cache as *mut _ as *mut c_void, callback, cancel_data, 1,
|
||||
&mut error, &mut width, &mut height,
|
||||
) };
|
||||
if pointer.is_null() && error != 0 { return Err(failed(error, &cache)); }
|
||||
if pointer.is_null() { log::warn!("Portal engine lacks DMA-BUF initialization; falling back to legacy initialization"); }
|
||||
prefer_dmabuf = true;
|
||||
}
|
||||
let pointer = if !pointer.is_null() { pointer } else { unsafe {
|
||||
if virtual_output {
|
||||
uu_portal_open_virtual(restore, save_token, &mut cache as *mut _ as *mut c_void, &mut error, &mut width, &mut height)
|
||||
} else if let Some(cancelled) = cancelled {
|
||||
uu_portal_open_persist_cancellable(
|
||||
restore, save_token, &mut cache as *mut _ as *mut c_void,
|
||||
is_cancelled, cancelled as *const _ as *mut c_void,
|
||||
let pointer = if detailed {
|
||||
let cancel = cancelled.filter(|_| !virtual_output);
|
||||
let callback = cancel.map(|_| is_cancelled as extern "C" fn(*mut c_void) -> i32);
|
||||
let cancel_data = cancel.map_or(std::ptr::null_mut(), |value| value as *const _ as *mut c_void);
|
||||
unsafe { uu_portal_open_detailed(
|
||||
restore, save_detailed, &mut cache as *mut _ as *mut c_void, callback, cancel_data,
|
||||
i32::from(prefer_dmabuf), if virtual_output { 4 } else { 1 },
|
||||
&mut error, &mut width, &mut height,
|
||||
) }
|
||||
} else {
|
||||
#[allow(unused_mut)]
|
||||
let mut pointer: *mut c_void = std::ptr::null_mut();
|
||||
#[cfg(feature = "inproc-av")]
|
||||
if prefer_dmabuf {
|
||||
let callback = cancelled.map(|_| is_cancelled as extern "C" fn(*mut c_void) -> i32);
|
||||
let cancel_data = cancelled.map_or(std::ptr::null_mut(), |value| value as *const _ as *mut c_void);
|
||||
pointer = unsafe { uu_portal_open_persist_capture(
|
||||
restore, save_token, &mut cache as *mut _ as *mut c_void, callback, cancel_data, 1,
|
||||
&mut error, &mut width, &mut height,
|
||||
)
|
||||
} else {
|
||||
uu_portal_open_persist(restore, save_token, &mut cache as *mut _ as *mut c_void, &mut error, &mut width, &mut height)
|
||||
) };
|
||||
if pointer.is_null() && error != 0 { return Err(failed(error, &cache)); }
|
||||
if pointer.is_null() { log::warn!("Portal engine lacks DMA-BUF initialization; falling back to legacy initialization"); }
|
||||
}
|
||||
} };
|
||||
let Some(handle) = NonNull::new(pointer) else { return Err(failed(error, &cache)) };
|
||||
if !pointer.is_null() { pointer } else { unsafe {
|
||||
if virtual_output {
|
||||
uu_portal_open_virtual(restore, save_token, &mut cache as *mut _ as *mut c_void, &mut error, &mut width, &mut height)
|
||||
} else if let Some(cancelled) = cancelled {
|
||||
uu_portal_open_persist_cancellable(restore, save_token, &mut cache as *mut _ as *mut c_void,
|
||||
is_cancelled, cancelled as *const _ as *mut c_void, &mut error, &mut width, &mut height)
|
||||
} else {
|
||||
uu_portal_open_persist(restore, save_token, &mut cache as *mut _ as *mut c_void, &mut error, &mut width, &mut height)
|
||||
}
|
||||
} }
|
||||
};
|
||||
let Some(handle) = NonNull::new(pointer) else { return Err(failed(if error == 0 { 15 } else { error }, &cache)) };
|
||||
let (mut x, mut y) = (0, 0);
|
||||
let granted = (!virtual_output && unsafe { uu_portal_stream_position(handle.as_ptr(), &mut x, &mut y) } == 0)
|
||||
.then(|| crate::wayland::portal_monitor_at(x, y)).flatten();
|
||||
if let (Some(dir), Some(token)) = (directory.as_deref(), cache.take()) {
|
||||
let saved = match &granted {
|
||||
_ if virtual_output => virtual_key.clone(),
|
||||
Some(name) => super::permissions::monitor_key(name),
|
||||
None => key.to_owned(),
|
||||
};
|
||||
if super::permissions::save(dir, &saved, &token).is_err() { log::warn!("Portal permission cache could not be saved"); }
|
||||
let saved = match &granted {
|
||||
_ if virtual_output => virtual_key.clone(),
|
||||
Some(name) => super::permissions::monitor_key(name),
|
||||
None => key.to_owned(),
|
||||
};
|
||||
if cache.rotation.finish(&saved, fresh || virtual_output || granted.is_some()).is_err() {
|
||||
log::warn!("Portal permission cache could not be saved");
|
||||
}
|
||||
if wanted.is_some() && granted != wanted { log::warn!("Portal granted a different monitor than requested"); }
|
||||
// Keep a freshly granted compositor frame regardless of lock state. Discarding it
|
||||
@@ -880,6 +913,7 @@ impl PortalSession {
|
||||
static ACTIVE: std::sync::Mutex<Option<std::sync::Weak<PortalSession>>> = std::sync::Mutex::new(None);
|
||||
pub fn permissions_directory() -> Option<std::path::PathBuf> { permissions::directory() }
|
||||
pub fn monitor_key(connector: &str) -> String { permissions::monitor_key(connector) }
|
||||
pub fn permission_exists(dir: &std::path::Path, key: &str) -> bool { permissions::exists(dir, key) }
|
||||
pub fn register(session: &Arc<PortalSession>) {
|
||||
*ACTIVE.lock().unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Arc::downgrade(session));
|
||||
}
|
||||
|
||||
@@ -26,6 +26,58 @@ pub fn desktop_key() -> &'static str {
|
||||
/// Consent for one monitor (Mutter connector); connectors are checked to be file-name safe.
|
||||
pub fn monitor_key(connector: &str) -> String { format!("{}@{}", desktop_key(), connector) }
|
||||
|
||||
/// An unclassified grant is kept separately until its monitor is known.
|
||||
pub fn pending_key(key: &str) -> String { format!("{key}.pending") }
|
||||
|
||||
pub fn exists(dir: &Path, key: &str) -> bool {
|
||||
dir.join(key).exists() || dir.join(pending_key(key)).exists()
|
||||
}
|
||||
|
||||
pub struct Rotation {
|
||||
directory: Option<PathBuf>,
|
||||
pending: String,
|
||||
saved: Option<String>,
|
||||
token: Option<String>,
|
||||
}
|
||||
|
||||
impl Rotation {
|
||||
pub fn new(directory: Option<PathBuf>, requested_key: &str) -> Self {
|
||||
Self { directory, pending: pending_key(requested_key), saved: None, token: None }
|
||||
}
|
||||
|
||||
pub fn received(&self) -> bool { self.token.is_some() }
|
||||
|
||||
/// A fresh request has not consumed the old grant; keep it until the new session opens.
|
||||
pub fn remember(&mut self, token: &str) { self.token = Some(token.to_owned()); }
|
||||
|
||||
/// Persist before PipeWire starts; `known_key` comes from the actual granted source.
|
||||
pub fn record(&mut self, token: &str, known_key: Option<&str>) -> std::io::Result<()> {
|
||||
self.remember(token);
|
||||
let Some(dir) = self.directory.as_deref() else { return Ok(()); };
|
||||
let destination = known_key.unwrap_or(&self.pending);
|
||||
save(dir, destination, token)?;
|
||||
self.saved = Some(destination.to_owned());
|
||||
if let Some(key) = known_key { let _ = fs::remove_file(dir.join(pending_key(key))); }
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Move, rather than copy, so a single-use token never has two cache entries.
|
||||
pub fn finish(&mut self, destination: &str, replace: bool) -> std::io::Result<()> {
|
||||
let (Some(dir), Some(token)) = (self.directory.as_deref(), self.token.as_deref()) else { return Ok(()); };
|
||||
if self.saved.as_deref() == Some(destination) { return Ok(()); }
|
||||
if !replace && dir.join(destination).exists() { return Ok(()); }
|
||||
if let Some(source) = self.saved.as_deref() {
|
||||
fs::rename(dir.join(source), dir.join(destination))?;
|
||||
fs::File::open(dir)?.sync_all()?;
|
||||
} else {
|
||||
save(dir, destination, token)?;
|
||||
}
|
||||
self.saved = Some(destination.to_owned());
|
||||
let _ = fs::remove_file(dir.join(pending_key(destination)));
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
pub fn take(dir: &Path, key: &str) -> Option<String> {
|
||||
let path = dir.join(key);
|
||||
let mut file = OpenOptions::new().read(true).custom_flags(libc::O_NOFOLLOW).open(&path).ok()?;
|
||||
@@ -71,4 +123,61 @@ mod tests {
|
||||
assert!(save(&dir, "gnome", &"x".repeat(4097)).is_err());
|
||||
fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rotated_grant_survives_failure_and_is_moved_after_success() {
|
||||
let dir = std::env::temp_dir().join(format!("uu-rotation-{}", std::process::id()));
|
||||
fs::create_dir_all(&dir).unwrap();
|
||||
save(&dir, "gnome@other", "other-grant").unwrap();
|
||||
let mut rotation = Rotation::new(Some(dir.clone()), "gnome@wanted");
|
||||
rotation.record("new-grant", None).unwrap();
|
||||
// Simulate capture failure: no finish callback runs.
|
||||
assert!(exists(&dir, "gnome@wanted"));
|
||||
assert_eq!(take(&dir, &pending_key("gnome@wanted")).as_deref(), Some("new-grant"));
|
||||
assert!(!exists(&dir, "gnome@wanted"));
|
||||
assert_eq!(take(&dir, "gnome@other").as_deref(), Some("other-grant"));
|
||||
|
||||
let mut rotation = Rotation::new(Some(dir.clone()), "gnome@wanted");
|
||||
rotation.record("newer-grant", None).unwrap();
|
||||
rotation.finish("gnome@actual", true).unwrap();
|
||||
assert!(!dir.join(pending_key("gnome@wanted")).exists());
|
||||
assert_eq!(take(&dir, "gnome@actual").as_deref(), Some("newer-grant"));
|
||||
fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn known_grants_replace_only_their_monitor_and_unknown_grants_do_not_overwrite() {
|
||||
let dir = std::env::temp_dir().join(format!("uu-rotation-known-{}", std::process::id()));
|
||||
fs::create_dir_all(&dir).unwrap();
|
||||
save(&dir, "gnome", "existing-grant").unwrap();
|
||||
save(&dir, "gnome@other", "other-grant").unwrap();
|
||||
let mut unknown = Rotation::new(Some(dir.clone()), "gnome@wanted");
|
||||
unknown.record("unknown-grant", None).unwrap();
|
||||
unknown.finish("gnome", false).unwrap();
|
||||
assert_eq!(take(&dir, "gnome").as_deref(), Some("existing-grant"));
|
||||
assert_eq!(take(&dir, &pending_key("gnome@wanted")).as_deref(), Some("unknown-grant"));
|
||||
let mut known = Rotation::new(Some(dir.clone()), "gnome@wanted");
|
||||
known.record("known-grant", Some("gnome@actual")).unwrap();
|
||||
assert_eq!(take(&dir, "gnome@actual").as_deref(), Some("known-grant"));
|
||||
assert_eq!(take(&dir, "gnome@other").as_deref(), Some("other-grant"));
|
||||
let mut no_token = Rotation::new(Some(dir.clone()), "gnome");
|
||||
no_token.finish("gnome", true).unwrap();
|
||||
assert!(!no_token.received());
|
||||
assert!(!dir.join("gnome").exists());
|
||||
fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fresh_request_keeps_existing_grant_until_open_succeeds() {
|
||||
let dir = std::env::temp_dir().join(format!("uu-rotation-fresh-{}", std::process::id()));
|
||||
fs::create_dir_all(&dir).unwrap();
|
||||
save(&dir, "gnome", "existing-grant").unwrap();
|
||||
let mut fresh = Rotation::new(Some(dir.clone()), "gnome");
|
||||
fresh.remember("fresh-grant");
|
||||
assert_eq!(fs::read_to_string(dir.join("gnome")).unwrap(), "existing-grant");
|
||||
assert!(!dir.join(pending_key("gnome")).exists());
|
||||
fresh.finish("gnome", true).unwrap();
|
||||
assert_eq!(take(&dir, "gnome").as_deref(), Some("fresh-grant"));
|
||||
fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
}
|
||||
+172
-12
@@ -1,24 +1,87 @@
|
||||
//! 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<String>, String> {
|
||||
let list = call("/org/kde/KWin/InputDevice", "org.freedesktop.DBus.Properties.Get", &["org.kde.KWin.InputDeviceManager", "devicesSysNames"])?;
|
||||
let mut blocked = Vec::new();
|
||||
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 Ok(text) = call(&format!("/org/kde/KWin/InputDevice/{sys}"), "org.freedesktop.DBus.Properties.GetAll", &["org.kde.KWin.InputDevice"]) else { continue };
|
||||
let yes = |key| variant(&text, key) == Some("true");
|
||||
let name = variant(&text, "name").unwrap_or_default();
|
||||
if (yes("keyboard") || yes("pointer") || yes("touch")) && !yes("switchDevice") && yes("enabled")
|
||||
&& !name.starts_with("uu-remote-linux") && name != "Power Button" { blocked.push(sys.to_owned()); }
|
||||
}
|
||||
Ok(blocked)
|
||||
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())
|
||||
}
|
||||
pub fn set(devices: &[String], enabled: bool) -> Result<(), String> {
|
||||
|
||||
/// 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 {
|
||||
@@ -28,3 +91,100 @@ pub fn set(devices: &[String], enabled: bool) -> Result<(), String> {
|
||||
}
|
||||
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(¤t.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));
|
||||
}
|
||||
}
|
||||
@@ -16,7 +16,7 @@ pub const NAME: &str = "kde";
|
||||
pub struct Kde;
|
||||
|
||||
#[derive(Default, serde::Serialize, serde::Deserialize)]
|
||||
struct Data { outputs: Vec<String>, #[serde(default)] devices: Vec<String> }
|
||||
struct Data { outputs: Vec<String>, #[serde(default)] devices: Vec<input::Device> }
|
||||
|
||||
impl Kde {
|
||||
pub fn detected() -> bool {
|
||||
@@ -84,8 +84,9 @@ impl Backend for Kde {
|
||||
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.
|
||||
let devices = input::set(&data.devices, true).map_err(|e| format!("enable input devices: {e}"));
|
||||
// controller keeps the recovery record and the guard for the next attempt. A device that
|
||||
// no longer exists is skipped, so a record replayed after a reboot cannot wedge recovery.
|
||||
let devices = input::restore(&data.devices).map_err(|e| format!("enable input devices: {e}"));
|
||||
// Physical outputs first: switching back opens a monitor share, which needs them enabled.
|
||||
// The wait also matters: a share opened before KWin applies the mode got the virtual
|
||||
// output's geometry (seen live: 1920x1080 instead of the panel's 3072x1920).
|
||||
|
||||
+1
-1
@@ -261,7 +261,7 @@ fn portal_outputs()->Vec<Output> {
|
||||
let mut outputs:Vec<Output>=monitors.iter().map(|m|Output {name:m.connector.clone(),width:m.width,height:m.height,fps,x:m.x,y:m.y}).collect();
|
||||
// Screen 0 is the one opened first: the monitor whose consent is already saved, else the primary.
|
||||
let dir=crate::portal::permissions_directory();
|
||||
let granted=|name:&str|dir.as_deref().is_some_and(|d|d.join(crate::portal::monitor_key(name)).exists());
|
||||
let granted=|name:&str|dir.as_deref().is_some_and(|d|crate::portal::permission_exists(d,&crate::portal::monitor_key(name)));
|
||||
let primary=monitors.iter().find(|m|m.primary).map(|m|m.connector.clone()).unwrap_or_default();
|
||||
outputs.sort_by_key(|o|(!granted(&o.name),o.name!=primary,o.x,o.y));
|
||||
outputs.truncate(16);
|
||||
|
||||
@@ -140,6 +140,8 @@ fn track_session(end_pc: Arc<RTCPeerConnection>, actions: Arc<crate::system_acti
|
||||
let closed = matches!(end_pc.connection_state(), State::Closed | State::Failed);
|
||||
let ending = actions.clone();
|
||||
let _ = tokio::task::spawn_blocking(move || ending.session_ended()).await;
|
||||
// Strokes belong to the viewer that drew them: never leave them on the host screen.
|
||||
crate::annotation::reset(crate::annotation::owner(&actions));
|
||||
if closed { return; }
|
||||
}
|
||||
});
|
||||
@@ -1205,6 +1207,16 @@ impl WebRtcSession {
|
||||
let _ = text_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
|
||||
return;
|
||||
}
|
||||
if let Some((header, body)) = rpc_fields.as_deref().and_then(crate::annotation::draw_request) {
|
||||
// A toggle waits for the X overlay to open: keep it off the async workers.
|
||||
let owner = crate::annotation::owner(&actions);
|
||||
let Ok(response) = tokio::task::spawn_blocking(move || crate::annotation::respond(owner, &header, &body)).await else { return };
|
||||
// draw_req arrives on CONTROL, but a CONTROL reply timed out (9998) on Mac 4.42.0:
|
||||
// answer on TEXT like the privacy RPCs above.
|
||||
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
|
||||
let _ = text_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
|
||||
return;
|
||||
}
|
||||
if let Some(response) = rpc_fields.as_deref().and_then(|r| crate::system_actions::plugin_response(r).or_else(|| crate::system_actions::session_rpc_response(r))) {
|
||||
let ts = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap_or_default().as_secs();
|
||||
let _ = rpc_out.send(crate::initialization::envelope(out_sequence.fetch_add(1, std::sync::atomic::Ordering::Relaxed), ts, 22, &response));
|
||||
|
||||
@@ -419,7 +419,24 @@ static void authorization_still_required(void) {
|
||||
g_variant_unref(reply);
|
||||
}
|
||||
}
|
||||
static void saved_token_with_position(const char *token, void *data, int has_position, int32_t x, int32_t y) {
|
||||
int *calls = data;
|
||||
assert(!strcmp(token, "synthetic-grant"));
|
||||
assert(has_position && x == 25 && y == 50);
|
||||
(*calls)++;
|
||||
}
|
||||
static void rotated_token_callback(void) {
|
||||
struct uu_portal p = {0};
|
||||
int calls = 0;
|
||||
save_restore_token(&p, NULL, saved_token_with_position, &calls);
|
||||
assert(calls == 0);
|
||||
p.restore_token = "synthetic-grant";
|
||||
p.has_position = 1; p.position_x = 25; p.position_y = 50;
|
||||
save_restore_token(&p, NULL, saved_token_with_position, &calls);
|
||||
assert(calls == 1);
|
||||
}
|
||||
int main(void) {
|
||||
rotated_token_callback();
|
||||
portal_renegotiation_timeout();
|
||||
portal_renegotiation_recovery();
|
||||
portal_renegotiation_event_order_and_healthy_states();
|
||||
|
||||
Reference in new issue
Block a user