Portal: map scaled GNOME input through EIS regions (#24)

* fix(portal): map scaled GNOME input through EIS regions

Keep unsupported portals on legacy input and leave capture/uinput independent of EIS. Cache logical geometry without the native handle lock and reject geometry changes during recovery.

Add native capability, handshake, geometry and lifecycle regression coverage with sanitizer checks; preserve existing non-portal paths. Refs #23.

* fix(portal): keep version 4 capture settings in pixel coordinates

Keep native, selectable and current screen rectangles in pixels with DPR 1 so legacy setting requests cannot implicitly downscale a scaled desktop. Leave Portal and EIS coordinate mapping local and unchanged.

Add inventory/request/ack/sync roundtrip regression coverage, including repeated settings changes and restoring native output. Refs #23.
This commit is contained in:
wanglz111 authored and GitHub committed 2026-10-16 21:45:17 +08:00
1 parent 51b489b1e2
commit b20fd6ccef
14 files changed
+1134 -41

No files matched your search

+167
View File
@@ -0,0 +1,167 @@
/* All access is serialized by PortalSession's handle mutex, including close.
* ConnectToEIS disables every legacy Notify* input method on this session. */
enum { PORTAL_EIS_UNSUPPORTED = 13 };
static void portal_eis_log(struct ei *ei, enum ei_log_priority priority,
const char *message, struct ei_log_context *context) {
/* Library error text can include input values. Keep diagnostics numeric. */
static atomic_uint count;
if (atomic_fetch_add(&count, 1) < 12)
fprintf(stderr, "Portal EIS library diagnostic: priority=%d\n", priority);
}
static int portal_eis_dispatch(struct uu_portal *p) {
ei_dispatch(p->ei);
struct ei_event *event;
while ((event = ei_get_event(p->ei))) {
struct ei_device *device = ei_event_get_device(event);
switch (ei_event_get_type(event)) {
case EI_EVENT_SEAT_ADDED:
ei_seat_bind_capabilities(ei_event_get_seat(event),
EI_DEVICE_CAP_POINTER, EI_DEVICE_CAP_POINTER_ABSOLUTE,
EI_DEVICE_CAP_BUTTON, EI_DEVICE_CAP_SCROLL, EI_DEVICE_CAP_KEYBOARD, NULL);
break;
case EI_EVENT_DEVICE_RESUMED:
if (!g_list_find(p->ei_devices, device)) {
p->ei_devices = g_list_append(p->ei_devices, ei_device_ref(device));
ei_device_start_emulating(device, ++p->ei_sequence);
}
break;
case EI_EVENT_DEVICE_PAUSED:
case EI_EVENT_DEVICE_REMOVED:
if (g_list_find(p->ei_devices, device)) {
p->ei_devices = g_list_remove(p->ei_devices, device);
ei_device_unref(device);
}
break;
case EI_EVENT_DISCONNECT:
p->ei_failed = 1;
break;
default: break;
}
ei_event_unref(event);
}
return p->ei_failed ? 9 : 0;
}
static struct ei_device *portal_eis_device(struct uu_portal *p, enum ei_device_capability capability) {
for (GList *item = p->ei_devices; item; item = item->next)
if (ei_device_has_capability(item->data, capability)) return item->data;
return NULL;
}
static struct ei_region *portal_eis_region(struct uu_portal *p, struct ei_device *device) {
for (size_t i = 0; ; i++) {
struct ei_region *region = ei_device_get_region(device, i);
if (!region) return NULL;
const char *id = ei_region_get_mapping_id(region);
if (id && p->mapping_id && !strcmp(id, p->mapping_id) &&
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) {
for (GList *item = p->ei_devices; item; item = item->next) {
struct ei_device *device = item->data;
if (ei_device_has_capability(device, EI_DEVICE_CAP_POINTER_ABSOLUTE) &&
(*region = portal_eis_region(p, device))) return device;
}
return NULL;
}
static void portal_eis_close(struct uu_portal *p) {
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;
if (p->ei) p->ei = ei_unref(p->ei);
}
static int portal_eis_open(struct uu_portal *p) {
if (!p->mapping_id) return PORTAL_EIS_UNSUPPORTED;
GUnixFDList *fds = NULL;
GError *error = NULL;
GVariant *reply = g_dbus_connection_call_with_unix_fd_list_sync(p->bus, DEST, PATH, REMOTE,
"ConnectToEIS", g_variant_new("(o@a{sv})", p->session, empty_options()),
G_VARIANT_TYPE("(h)"), G_DBUS_CALL_FLAGS_NONE, 3000, NULL, &fds, NULL, &error);
if (!reply) {
int unsupported = g_error_matches(error, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD) ||
g_error_matches(error, G_DBUS_ERROR, G_DBUS_ERROR_NOT_SUPPORTED);
g_clear_error(&error); g_clear_object(&fds);
return unsupported ? PORTAL_EIS_UNSUPPORTED : 9;
}
gint32 index; g_variant_get(reply, "(h)", &index);
int fd = fds && index >= 0 && index < g_unix_fd_list_get_length(fds) ?
g_unix_fd_list_get(fds, index, NULL) : -1;
g_variant_unref(reply); g_clear_object(&fds);
if (fd < 0) return 9;
p->ei = ei_new_sender(NULL);
if (!p->ei) { close(fd); return 8; }
ei_log_set_handler(p->ei, portal_eis_log);
ei_configure_name(p->ei, "uu-remote-linux");
if (ei_setup_backend_fd(p->ei, fd)) return 9;
gint64 deadline = g_get_monotonic_time() + 3000000;
while (!portal_eis_dispatch(p)) {
struct ei_region *region = NULL;
if (portal_eis_absolute(p, &region) &&
portal_eis_device(p, EI_DEVICE_CAP_POINTER) &&
portal_eis_device(p, EI_DEVICE_CAP_BUTTON) &&
portal_eis_device(p, EI_DEVICE_CAP_SCROLL) &&
portal_eis_device(p, EI_DEVICE_CAP_KEYBOARD)) {
fprintf(stderr, "Portal EIS input ready: region=%ux%u\n",
ei_region_get_width(region), ei_region_get_height(region));
return 0;
}
gint64 remaining = deadline - g_get_monotonic_time();
if (remaining <= 0) break;
struct pollfd pending = {.fd = ei_get_fd(p->ei), .events = POLLIN};
int result = poll(&pending, 1, (int)((remaining + 999) / 1000));
if (result < 0 && errno != EINTR) break;
}
fprintf(stderr, "Portal EIS input initialization failed\n");
return 9;
}
static int portal_eis_available(struct uu_portal *p) {
if (!uu_portal_alive(p)) return 9;
return portal_eis_dispatch(p);
}
static int portal_eis_frame(struct uu_portal *p, struct ei_device *device) {
ei_device_frame(device, ei_now(p->ei));
return portal_eis_dispatch(p);
}
static int portal_eis_move(struct uu_portal *p, double x, double y, int relative) {
if (portal_eis_available(p)) return 9;
struct ei_device *device;
if (relative) {
device = portal_eis_device(p, EI_DEVICE_CAP_POINTER);
if (!device) return 9;
ei_device_pointer_motion(device, x * p->logical_width / p->width,
y * p->logical_height / p->height);
} else {
if (x < 0 || y < 0 || x >= p->width || y >= p->height) return 11;
struct ei_region *region = NULL;
device = portal_eis_absolute(p, &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;
ei_device_pointer_motion_absolute(device, target_x, target_y);
}
return portal_eis_frame(p, device);
}
static int portal_eis_button(struct uu_portal *p, int button, int pressed) {
if (portal_eis_available(p)) return 9;
if (button >= 4 && button <= 7) {
if (!pressed) return 0;
struct ei_device *device = portal_eis_device(p, EI_DEVICE_CAP_SCROLL);
if (!device) return 9;
int step = button == 4 || button == 6 ? -120 : 120;
ei_device_scroll_discrete(device, button <= 5 ? 0 : step, button <= 5 ? step : 0);
return portal_eis_frame(p, device);
}
int code = button == 1 ? 0x110 : button == 2 ? 0x112 : button == 3 ? 0x111 :
button == 8 ? 0x113 : button == 9 ? 0x114 : 0;
if (!code) return 11;
struct ei_device *device = portal_eis_device(p, EI_DEVICE_CAP_BUTTON);
if (!device) return 9;
ei_device_button_button(device, code, !!pressed);
return portal_eis_frame(p, device);
}
static int portal_eis_key(struct uu_portal *p, int code, int pressed) {
if (code < 0 || code > 0x2ff) return 11;
if (portal_eis_available(p)) return 9;
struct ei_device *device = portal_eis_device(p, EI_DEVICE_CAP_KEYBOARD);
if (!device) return 9;
ei_device_keyboard_key(device, (uint32_t)code, !!pressed);
return portal_eis_frame(p, device);
}
+80 -17
View File
@@ -2,6 +2,8 @@
#include "portal_engine.h"
#include <gio/gio.h>
#include <gio/gunixfdlist.h>
#include <libei.h>
#include <poll.h>
#include <pipewire/pipewire.h>
#include <spa/param/video/format-utils.h>
#include <spa/pod/builder.h>
@@ -47,6 +49,12 @@ struct uu_portal {
uint32_t node, width, height;
int logical_width, logical_height;
int absolute_stream_pixels;
struct ei *ei;
GList *ei_devices;
char *mapping_id;
uint32_t ei_sequence;
atomic_int ei_failed;
int ei_unavailable;
enum spa_video_format format;
uint8_t *frame;
size_t frame_length;
@@ -59,6 +67,7 @@ static pthread_once_t pw_once = PTHREAD_ONCE_INIT;
static atomic_uint token_sequence = 1;
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); }
#include "portal_eis.inc"
static void fail(struct uu_portal *p, int error) {
pthread_mutex_lock(&p->lock);
if (!p->error) p->error = error;
@@ -271,6 +280,27 @@ static int connect_pipewire(struct uu_portal *p) {
pthread_mutex_unlock(&p->lock);
return result;
}
static int read_stream_result(struct uu_portal *p, GVariant *results) {
guint devices = 0;
GVariant *streams = g_variant_lookup_value(results, "streams", G_VARIANT_TYPE("a(ua{sv})"));
gboolean has_devices = g_variant_lookup(results, "devices", "u", &devices);
fprintf(stderr, "Portal authorization result: devices_present=%d device_bits=%u stream_count=%zu\n",
has_devices, devices, streams ? (size_t)g_variant_n_children(streams) : 0);
int error = 0;
if (!has_devices || (devices & 3) != 3 || !streams || g_variant_n_children(streams) != 1) {
error = 6;
} else {
GVariant *entry = g_variant_get_child_value(streams, 0), *properties;
g_variant_get(entry, "(u@a{sv})", &p->node, &properties);
/* Optional 'size' is compositor logical coordinates, not frame pixels. */
g_variant_lookup(properties, "size", "(ii)", &p->logical_width, &p->logical_height);
const char *mapping_id = NULL;
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);
}
if (streams) g_variant_unref(streams);
return error;
}
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) {
*error = 0; *width = *height = 0;
struct uu_portal *p = calloc(1, sizeof(*p));
@@ -341,18 +371,7 @@ struct uu_portal *uu_portal_open_persist(const char *restore, void (*save_token)
g_variant_lookup(results,"clipboard_enabled","b",&clipboard_enabled);
p->clipboard_enabled=clipboard_enabled;
fprintf(stderr,"Portal clipboard permission: granted=%d\n",clipboard_enabled);
guint devices = 0; GVariant *streams = g_variant_lookup_value(results, "streams", G_VARIANT_TYPE("a(ua{sv})"));
gboolean has_devices=g_variant_lookup(results, "devices", "u", &devices);
fprintf(stderr,"Portal authorization result: devices_present=%d device_bits=%u stream_count=%zu\n",has_devices,devices,streams?(size_t)g_variant_n_children(streams):0);
if (!has_devices || (devices & 3) != 3 || !streams || g_variant_n_children(streams) != 1) {
*error = 6;
} else {
GVariant *entry = g_variant_get_child_value(streams, 0), *properties;
g_variant_get(entry, "(u@a{sv})", &p->node, &properties);
/* 'size' is compositor logical coordinates, not the pixel frame size. */
g_variant_lookup(properties, "size", "(ii)", &p->logical_width, &p->logical_height);
g_variant_unref(properties); g_variant_unref(entry);
}
*error = read_stream_result(p, results);
if (!*error) {
const char *next = NULL;
if (g_variant_lookup(results, "restore_token", "&s", &next) && next && strlen(next) <= 4096)
@@ -361,7 +380,6 @@ struct uu_portal *uu_portal_open_persist(const char *restore, void (*save_token)
version >= 2, restore && *restore, p->restore_token && *p->restore_token);
}
if (!*error && p->restore_token && save_token) save_token(p->restore_token, data);
if (streams) g_variant_unref(streams);
g_variant_unref(results);
if (*error) goto done;
p->main_loop = g_main_loop_new(p->context, FALSE);
@@ -372,7 +390,7 @@ struct uu_portal *uu_portal_open_persist(const char *restore, void (*save_token)
if (*error) { uu_portal_close(p); return NULL; }
fprintf(stderr, "Portal pointer geometry: frame=%ux%u compositor=%dx%d absolute=%s\n",
p->width, p->height, p->logical_width, p->logical_height,
p->absolute_stream_pixels ? "stream-pixels" : "compositor-logical");
p->absolute_stream_pixels ? "stream-pixels-or-eis" : "compositor-logical");
*width = p->width; *height = p->height;
return p;
done:
@@ -390,6 +408,7 @@ static gboolean quit_dbus_loop(gpointer data) { g_main_loop_quit(data); return G
void uu_portal_close(struct uu_portal *p) {
if (!p) return;
atomic_store(&p->closed, 1);
portal_eis_close(p);
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);
@@ -414,6 +433,7 @@ void uu_portal_close(struct uu_portal *p) {
if (p->main_loop) g_main_loop_unref(p->main_loop);
if (p->context) g_main_context_unref(p->context);
if (p->bus) g_object_unref(p->bus);
g_free(p->mapping_id);
g_free(p->clipboard_text); g_free(p->clipboard_mime); g_free(p->restore_token); free(p->session); free(p->frame);
pthread_cond_destroy(&p->changed); pthread_mutex_destroy(&p->lock); free(p);
}
@@ -440,12 +460,42 @@ int uu_portal_capture_since(struct uu_portal *p, uint8_t *frame, size_t length,
pthread_mutex_unlock(&p->lock); return result;
}
int uu_portal_alive(struct uu_portal *p) {
if (!p || atomic_load(&p->closed)) return 0;
if (!p || atomic_load(&p->closed) || atomic_load(&p->ei_failed)) return 0;
pthread_mutex_lock(&p->lock);
int alive = !p->error;
pthread_mutex_unlock(&p->lock);
return alive;
}
void uu_portal_input_dispatch(struct uu_portal *p) {
if (p->ei) portal_eis_dispatch(p);
}
static int prepare_input(struct uu_portal *p) {
if (!uu_portal_alive(p)) return 9;
/* xdg-desktop-portal 1.21 checks Notify absolute positions against logical
* stream size, while GNOME 50 forwards them into Mutter's pixel transform.
* Initialize EIS only when native input is used, leaving capture/uinput
* independent of EIS support. ConnectToEIS disables all Notify* methods. */
if (!p->ei && !p->ei_unavailable && p->absolute_stream_pixels &&
p->logical_width > 0 && p->logical_height > 0 &&
(p->width != (uint32_t)p->logical_width || p->height != (uint32_t)p->logical_height)) {
int result = portal_eis_open(p);
if (result == PORTAL_EIS_UNSUPPORTED) {
p->ei_unavailable = 1;
fprintf(stderr, "Portal EIS unavailable; retaining legacy input\n");
return 0;
}
if (result) {
/* A timeout may have committed ConnectToEIS at the portal. Any
* failure except explicit lack of support needs a fresh session. */
atomic_store(&p->ei_failed, 1);
static atomic_uint failures;
if (atomic_fetch_add(&failures, 1) < 12)
fprintf(stderr, "Portal EIS input initialization failed: code=%d\n", result);
return result;
}
}
return 0;
}
static int notify(struct uu_portal *p, const char *method, GVariant *parameters) {
if (!uu_portal_alive(p)) { g_variant_ref_sink(parameters); g_variant_unref(parameters); return 9; }
GError *error = NULL;
@@ -462,18 +512,29 @@ static int notify(struct uu_portal *p, const char *method, GVariant *parameters)
}
g_variant_unref(reply); return 0;
}
void uu_portal_logical_size(struct uu_portal *p, uint32_t *width, uint32_t *height) {
/* Stream size is optional; unknown logical geometry keeps the existing
* pixel-sized inventory without preventing capture or uinput. */
int known = p->logical_width > 0 && p->logical_height > 0;
*width = known ? (uint32_t)p->logical_width : p->width;
*height = known ? (uint32_t)p->logical_height : p->height;
}
int uu_portal_move(struct uu_portal *p, double x, double y, int relative) {
if (!p || !isfinite(x) || !isfinite(y)) return 11;
if (p->logical_width <= 0 || p->logical_height <= 0 || !p->width || !p->height) return 11;
if (!relative && (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_move(p, x, y, relative);
if (relative) return notify(p, "NotifyPointerMotion", g_variant_new("(o@a{sv}dd)", p->session, empty_options(),
x * p->logical_width / p->width, y * p->logical_height / p->height));
if (x < 0 || y < 0 || x >= p->width || y >= p->height) return 11;
return notify(p, "NotifyPointerMotionAbsolute", g_variant_new("(o@a{sv}udd)", p->session, empty_options(), p->node,
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_button(struct uu_portal *p, int button, int pressed) {
if (!p) return 11;
int result = prepare_input(p); if (result) return result;
if (p->ei) return portal_eis_button(p, button, pressed);
if (button >= 4 && button <= 7) {
if (!pressed) return 0;
return notify(p, "NotifyPointerAxisDiscrete", g_variant_new("(o@a{sv}ui)", p->session, empty_options(),
@@ -483,7 +544,9 @@ int uu_portal_button(struct uu_portal *p, int button, int pressed) {
if (!code) return 11;
return notify(p, "NotifyPointerButton", g_variant_new("(o@a{sv}iu)", p->session, empty_options(), code, (guint)!!pressed));
}
int uu_portal_key(struct uu_portal *p, uint32_t symbol, 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;
int result = prepare_input(p); if (result) return result;
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));
}
+3 -1
View File
@@ -14,10 +14,12 @@ 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_poll(struct uu_portal *portal, uint8_t *text, size_t capacity);
int uu_portal_alive(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_reset_frame(struct uu_portal *portal);
int uu_portal_capture(struct uu_portal *portal, uint8_t *bgra, size_t length);
int uu_portal_capture_since(struct uu_portal *portal, uint8_t *bgra, size_t length, uint64_t *revision);
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_key(struct uu_portal *portal, uint32_t keysym, int pressed);
int uu_portal_key(struct uu_portal *portal, uint32_t keysym, int keycode, int pressed);
#endif