mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 16:50:41 +01:00
* feat(portal): follow the viewer's mouse mode with the embedded cursor The portal stream hides the compositor cursor. A viewer that drives the pointer with relative motion (UU's controlled-end mouse, also the Mac trackpad mode) has no absolute position to draw its own pointer at, and the game's cursor never reaches the picture, so the mouse can be moved and clicked but not seen. Request cursor_mode=embedded while relative motion arrives, and keep it hidden while absolute motion arrives: there the viewer draws its own pointer and an embedded copy would trail it. The portal reads cursor_mode only when the session is created, so switch by rebuilding the session with the saved consent, the same path the privacy screen uses. A run has to last five events and 200 ms before it counts, so a burst at connect or an alternating controller does not rebuild; a failed rebuild backs off for five seconds. The rebuilt session is checked against the monitor the previous one captured, so a restored consent cannot silently move the share. The engine keeps the mode for later opens (recovery, privacy, monitor switches) and skips the switch when an older libuu-portal.so lacks uu_portal_set_cursor_mode. UU_PORTAL_CURSOR_MODE=embedded sets the startup default. * fix(portal): keep the cursor rebuild off locks and held input Do not rebuild while the desktop is locked, and cancel an open that is already waiting when it locks: GNOME closes the portal session on lock, so the request would wait for consent that cannot be answered while holding `recovery` against the post-unlock recovery. Keys and buttons held through the portal input path are dropped when the session is replaced, so wait for their release. Monitor selection takes the same `recovery` lock, so it cannot install a stale source over the cursor rebuild or the other way round, and the rebuilt session is revalidated against the source it started from. * fix(portal): carry the clipboard across cursor rebuilds The engine keeps the viewer's text only in the session that provided it, and the host re-sends it only for a new viewer update. A replacement session therefore had no clipboard ownership, so changing the mouse mode made previously synchronized text unpasteable until the viewer sent it again. Offer the text to the replacement before the old session closes, but only while that session still owns the selection: a local copy that has taken the clipboard since is left alone. Touch consent upgrades replace the handle too, so they take the same `recovery` lock as recovery, monitor selection and the cursor rebuild and cannot install a handle opened under an older cursor mode. * fix(portal): serialize clipboard writes with the cursor swap The clipboard bridge calls clipboard_set from its own thread. Installing the replacement handle and then carrying the old text over left a window where an update could land on the new session and be overwritten by the older text, with no pending update left to restore it. Take a clipboard write lock before the handle is installed and hold it until the carry-over finishes; clipboard_set takes the same lock. A write that starts before the swap is included in the text carried over, a write that starts after waits and wins. * fix(portal): cancel a waiting rebuild when the desktop ends The desktop ends its share when the last controller leaves (end_idle), but an open that is still waiting for consent is not the installed handle, so it survived that shutdown and installed a live share afterwards. Bump an end generation in Session::end(), snapshot it before the open, and cancel the request when it moves. The generation is checked again under the handle lock before installing, so an end that races the swap either aborts the rebuild or ends the handle it just installed. * fix(portal): keep session swaps consistent with the viewer's state Addresses the ownership race reported on the previous commit and the paths that share its failure mode. uu_portal_clipboard_set publishes the new text before SetSelection so a transfer during the call serves it, restores the old text when the call fails, and ignores a stale revision so a newer owner wins. The engine reports the cursor mode it actually requested and the modes the backend advertised; the host follows that instead of assuming the request was applied and stops retrying where an embedded cursor is unavailable. The end generation is sampled before the rebuild queues for `recovery`, a rebuild refuses to start while the session is no longer alive, and cancellation now covers virtual output opens. Portal-bound keys and buttons are tracked separately, so an input held through the portal defers the swap on every routing path, and the check is repeated after the open. Every handle replacement (privacy screen, monitor switch, touch consent, recovery after lock or stream loss) carries the viewer's clipboard under the clipboard write lock, and the rebuilt session is checked against the captured geometry. * fix(portal): stop the swap bookkeeping from outliving a deferred rebuild open_inner publishes the replacement's cursor mode before the swap. When held input defers the rebuild, that session is never installed, so the host belief described the discarded handle and later motion looked like it already matched. Restore the belief from the installed session on every abort path. The extra portal releases in release_held now stop at the first failure like the sweep above; with a dead portal bus each remaining input waited out the three-second timeout while the input and desktop-owner locks were held. * fix(portal): invalidate clipboard ownership when a session ends A closed session stops receiving owner changes, so a cached clipboard_owns survived into the recovery paths and could republish old viewer text over a newer local copy. Clear the claim in uu_portal_end and the Closed handler, and let uu_portal_clipboard_copy refuse a source that is no longer alive. Mark the embedded cursor unavailable when the engine did not apply it: with AvailableCursorModes unreadable the session opens hidden, and retrying on every motion run rebuilt it every 200 ms without changing the mode. * fix(portal): retire held portal input when the devices are replaced A key or button held through the native portal path is recorded when its injection succeeds. If the session dies first, the key-up fails and the record survives; recovery then installs new devices while the tracker still says an input is held, so pointer-mode detection keeps deferring. Keep the tracker in module state and clear it whenever the portal replaces or ends its devices: the rebuild, both recovery paths and Session::end. * fix(portal): scope held-input retirement to the retired handle A press delivered to the replacement after the swap could be recorded while the old handle was still being retired, and the unconditional reset then deleted it. Hold the recording lock from before the swap until the reset finishes, so only inputs sent to the retired devices are dropped. A portal touchscreen contact was not tracked at all: the swap retired the active contact while TouchDrag stayed down, so the following move reached a session that never saw the press. Track contact down/up and include it in the deferral state. * fix(portal): serialize touch injection with handle replacement inject_touch wrote the contact state outside the recording lock the handle swap holds, so a contact delivered to the replacement between the swap and the reset could be cleared, and the following phase-1 would fail on new devices that never saw the press. Take the same lock across the injection and the state update. * fix(portal): decide the swap under the held-input lock The final held-input check ran before install_replacement() took the serial lock, so an input could be injected and recorded against the old handle while the install waited for the clipboard lock. The install then retired the records and swapped, destroying a contact the new devices never saw. Repeat the check under the serial lock that recording uses, and defer the rebuild when it hits. * fix(portal): hold the input lock across native injection, refresh privacy geometry inject_button and inject_key injected through the portal and only took the recording lock afterwards, so a swap could take the lock, see no held input and replace the devices that had just received the press. Take the serial lock across the injection and its record, as the touch path does; the record helpers no longer take it themselves. A cursor rebuild that replaces the privacy virtual output invalidates the cached pointer region: recompute it from the settled layout so absolute input keeps landing inside the captured share.
62 lines
4.8 KiB
C
62 lines
4.8 KiB
C
#ifndef UU_PORTAL_ENGINE_H
|
|
#define UU_PORTAL_ENGINE_H
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
#include "dmabuf_frame.h"
|
|
struct uu_portal;
|
|
typedef int (*uu_portal_cancelled_fn)(void *data);
|
|
typedef void (*uu_portal_save_detailed_fn)(const char *token, void *data, int has_position, int32_t x, int32_t y);
|
|
/* Reports the granted position alongside the rotated token before video initialization. */
|
|
struct uu_portal *uu_portal_open_detailed(const char *restore, uu_portal_save_detailed_fn save_token, void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data, int prefer_dmabuf, uint32_t source_types, int *error, uint32_t *width, uint32_t *height);
|
|
/* One object owns one consent/session and one PipeWire stream. */
|
|
struct uu_portal *uu_portal_open(int *error, uint32_t *width, uint32_t *height);
|
|
/* Saves the rotated token immediately after Start, before video initialization. */
|
|
struct uu_portal *uu_portal_open_virtual(const char *restore, void (*save_token)(const char *, void *), void *data, int *error, uint32_t *width, uint32_t *height);
|
|
struct uu_portal *uu_portal_open_persist(const char *restore, void (*save_token)(const char *, void *), void *data, int *error, uint32_t *width, uint32_t *height);
|
|
/* The cancellation callback and data are used only until this call returns. */
|
|
struct uu_portal *uu_portal_open_persist_cancellable(const char *restore, void (*save_token)(const char *, void *), void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data, int *error, uint32_t *width, uint32_t *height);
|
|
/* Select the capture transport before connecting, including on same-process recovery. */
|
|
struct uu_portal *uu_portal_open_persist_capture(const char *restore, void (*save_token)(const char *, void *), void *save_data, uu_portal_cancelled_fn cancelled, void *cancel_data, int prefer_dmabuf, int *error, uint32_t *width, uint32_t *height);
|
|
struct uu_portal *uu_portal_open_restore(const char *restore, int *error, uint32_t *width, uint32_t *height);
|
|
/* Cursor mode for subsequent sessions: 1 hidden, 2 embedded (the compositor draws the pointer
|
|
* into the stream). -1 restores the UU_PORTAL_CURSOR_MODE default. The host switches this at
|
|
* runtime because the viewer cannot draw a pointer of its own during relative motion. */
|
|
void uu_portal_set_cursor_mode(int mode);
|
|
/* What the last session requested and what the backend offered, for host bookkeeping. */
|
|
int uu_portal_cursor_mode(struct uu_portal *portal);
|
|
int uu_portal_cursor_modes(struct uu_portal *portal);
|
|
const char *uu_portal_restore_token(struct uu_portal *portal);
|
|
void uu_portal_close(struct uu_portal *portal);
|
|
int uu_portal_clipboard_ready(struct uu_portal *portal);
|
|
int uu_portal_clipboard_set(struct uu_portal *portal, const uint8_t *text, size_t length);
|
|
/* Offers the text `from` still owns to `to`; 0 transferred, 1 nothing to transfer. */
|
|
int uu_portal_clipboard_copy(struct uu_portal *from, struct uu_portal *to);
|
|
int uu_portal_clipboard_poll(struct uu_portal *portal, uint8_t *text, size_t capacity);
|
|
int uu_portal_alive(struct uu_portal *portal);
|
|
int uu_portal_capture_alive(struct uu_portal *portal);
|
|
/* Wait for a new frame or status change with a timeout in microseconds.
|
|
* Returns 1 if a new frame or status change occurred, 0 on timeout, <0 on closed/error. */
|
|
int uu_portal_wait_frame(struct uu_portal *portal, int64_t timeout_us);
|
|
void uu_portal_input_dispatch(struct uu_portal *portal);
|
|
void uu_portal_logical_size(struct uu_portal *portal, uint32_t *width, uint32_t *height);
|
|
void uu_portal_reset_frame(struct uu_portal *portal);
|
|
int uu_portal_capture(struct uu_portal *portal, uint8_t *bgra, size_t length);
|
|
int uu_portal_capture_since(struct uu_portal *portal, uint8_t *bgra, size_t length, uint64_t *revision);
|
|
/* acquire holds the PipeWire loop until release, including GPU completion.
|
|
* 0/12 = leased new/unchanged frame, 10 = pending, 15 = neutral black.
|
|
* CPU fallback: 14 layout/disabled, 16 shared memory, 17 timeout, 18 explicit sync, 19 modifier. */
|
|
int uu_portal_dmabuf_acquire(struct uu_portal *portal, UuDmaFrame *frame, uint64_t *revision);
|
|
void uu_portal_dmabuf_release(struct uu_portal *portal);
|
|
void uu_portal_dmabuf_disable(struct uu_portal *portal);
|
|
int uu_portal_move(struct uu_portal *portal, double x, double y, int relative);
|
|
int uu_portal_button(struct uu_portal *portal, int button, int pressed);
|
|
int uu_portal_scroll(struct uu_portal *portal, double dx, double dy, int finish);
|
|
int uu_portal_touch_supported(struct uu_portal *portal);
|
|
int uu_portal_touch_available(struct uu_portal *portal);
|
|
int uu_portal_touch(struct uu_portal *portal, int phase, double x, double y);
|
|
int uu_portal_key(struct uu_portal *portal, uint32_t keysym, int keycode, int pressed);
|
|
int uu_portal_stream_position(struct uu_portal *portal, int32_t *x, int32_t *y);
|
|
int uu_portal_monitors(char *out, size_t length);
|
|
void uu_portal_end(struct uu_portal *portal);
|
|
#endif
|