mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 08:50:40 +01:00
main
9
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
661263fe37 |
fix(portal): capture the lock screen on locked cold connections (#229)
* fix(portal): capture the lock screen on locked cold connections KWin keeps the Portal screencast alive while the session is locked, but maintain() refused to open a session until unlock, so a cold connection only received synthetic black frames. Allow capture during lock on KDE and keep the black-frame fallback for compositors that close the session. A consent failure behind the lock screen and auto privacy now wait for the local unlock. * docs: document the KDE lock-screen capture default Cover the new default, the UU_LOCKED_CAPTURE opt-out and the desktop-detection fallback in both READMEs, as requested in #229. |
||
|
|
21e9e690ae |
feat(portal): follow the viewer's mouse mode with the embedded cursor (#203)
* feat(portal): follow the viewer's mouse mode with the embedded cursor The portal stream hides the compositor cursor. A viewer that drives the pointer with relative motion (UU's controlled-end mouse, also the Mac trackpad mode) has no absolute position to draw its own pointer at, and the game's cursor never reaches the picture, so the mouse can be moved and clicked but not seen. Request cursor_mode=embedded while relative motion arrives, and keep it hidden while absolute motion arrives: there the viewer draws its own pointer and an embedded copy would trail it. The portal reads cursor_mode only when the session is created, so switch by rebuilding the session with the saved consent, the same path the privacy screen uses. A run has to last five events and 200 ms before it counts, so a burst at connect or an alternating controller does not rebuild; a failed rebuild backs off for five seconds. The rebuilt session is checked against the monitor the previous one captured, so a restored consent cannot silently move the share. The engine keeps the mode for later opens (recovery, privacy, monitor switches) and skips the switch when an older libuu-portal.so lacks uu_portal_set_cursor_mode. UU_PORTAL_CURSOR_MODE=embedded sets the startup default. * fix(portal): keep the cursor rebuild off locks and held input Do not rebuild while the desktop is locked, and cancel an open that is already waiting when it locks: GNOME closes the portal session on lock, so the request would wait for consent that cannot be answered while holding `recovery` against the post-unlock recovery. Keys and buttons held through the portal input path are dropped when the session is replaced, so wait for their release. Monitor selection takes the same `recovery` lock, so it cannot install a stale source over the cursor rebuild or the other way round, and the rebuilt session is revalidated against the source it started from. * fix(portal): carry the clipboard across cursor rebuilds The engine keeps the viewer's text only in the session that provided it, and the host re-sends it only for a new viewer update. A replacement session therefore had no clipboard ownership, so changing the mouse mode made previously synchronized text unpasteable until the viewer sent it again. Offer the text to the replacement before the old session closes, but only while that session still owns the selection: a local copy that has taken the clipboard since is left alone. Touch consent upgrades replace the handle too, so they take the same `recovery` lock as recovery, monitor selection and the cursor rebuild and cannot install a handle opened under an older cursor mode. * fix(portal): serialize clipboard writes with the cursor swap The clipboard bridge calls clipboard_set from its own thread. Installing the replacement handle and then carrying the old text over left a window where an update could land on the new session and be overwritten by the older text, with no pending update left to restore it. Take a clipboard write lock before the handle is installed and hold it until the carry-over finishes; clipboard_set takes the same lock. A write that starts before the swap is included in the text carried over, a write that starts after waits and wins. * fix(portal): cancel a waiting rebuild when the desktop ends The desktop ends its share when the last controller leaves (end_idle), but an open that is still waiting for consent is not the installed handle, so it survived that shutdown and installed a live share afterwards. Bump an end generation in Session::end(), snapshot it before the open, and cancel the request when it moves. The generation is checked again under the handle lock before installing, so an end that races the swap either aborts the rebuild or ends the handle it just installed. * fix(portal): keep session swaps consistent with the viewer's state Addresses the ownership race reported on the previous commit and the paths that share its failure mode. uu_portal_clipboard_set publishes the new text before SetSelection so a transfer during the call serves it, restores the old text when the call fails, and ignores a stale revision so a newer owner wins. The engine reports the cursor mode it actually requested and the modes the backend advertised; the host follows that instead of assuming the request was applied and stops retrying where an embedded cursor is unavailable. The end generation is sampled before the rebuild queues for `recovery`, a rebuild refuses to start while the session is no longer alive, and cancellation now covers virtual output opens. Portal-bound keys and buttons are tracked separately, so an input held through the portal defers the swap on every routing path, and the check is repeated after the open. Every handle replacement (privacy screen, monitor switch, touch consent, recovery after lock or stream loss) carries the viewer's clipboard under the clipboard write lock, and the rebuilt session is checked against the captured geometry. * fix(portal): stop the swap bookkeeping from outliving a deferred rebuild open_inner publishes the replacement's cursor mode before the swap. When held input defers the rebuild, that session is never installed, so the host belief described the discarded handle and later motion looked like it already matched. Restore the belief from the installed session on every abort path. The extra portal releases in release_held now stop at the first failure like the sweep above; with a dead portal bus each remaining input waited out the three-second timeout while the input and desktop-owner locks were held. * fix(portal): invalidate clipboard ownership when a session ends A closed session stops receiving owner changes, so a cached clipboard_owns survived into the recovery paths and could republish old viewer text over a newer local copy. Clear the claim in uu_portal_end and the Closed handler, and let uu_portal_clipboard_copy refuse a source that is no longer alive. Mark the embedded cursor unavailable when the engine did not apply it: with AvailableCursorModes unreadable the session opens hidden, and retrying on every motion run rebuilt it every 200 ms without changing the mode. * fix(portal): retire held portal input when the devices are replaced A key or button held through the native portal path is recorded when its injection succeeds. If the session dies first, the key-up fails and the record survives; recovery then installs new devices while the tracker still says an input is held, so pointer-mode detection keeps deferring. Keep the tracker in module state and clear it whenever the portal replaces or ends its devices: the rebuild, both recovery paths and Session::end. * fix(portal): scope held-input retirement to the retired handle A press delivered to the replacement after the swap could be recorded while the old handle was still being retired, and the unconditional reset then deleted it. Hold the recording lock from before the swap until the reset finishes, so only inputs sent to the retired devices are dropped. A portal touchscreen contact was not tracked at all: the swap retired the active contact while TouchDrag stayed down, so the following move reached a session that never saw the press. Track contact down/up and include it in the deferral state. * fix(portal): serialize touch injection with handle replacement inject_touch wrote the contact state outside the recording lock the handle swap holds, so a contact delivered to the replacement between the swap and the reset could be cleared, and the following phase-1 would fail on new devices that never saw the press. Take the same lock across the injection and the state update. * fix(portal): decide the swap under the held-input lock The final held-input check ran before install_replacement() took the serial lock, so an input could be injected and recorded against the old handle while the install waited for the clipboard lock. The install then retired the records and swapped, destroying a contact the new devices never saw. Repeat the check under the serial lock that recording uses, and defer the rebuild when it hits. * fix(portal): hold the input lock across native injection, refresh privacy geometry inject_button and inject_key injected through the portal and only took the recording lock afterwards, so a swap could take the lock, see no held input and replace the devices that had just received the press. Take the serial lock across the injection and its record, as the touch path does; the record helpers no longer take it themselves. A cursor rebuild that replaces the privacy virtual output invalidates the cached pointer region: recompute it from the settled layout so absolute input keeps landing inside the captured share. |
||
|
|
c489f3056f | fix(privacy): keep new windows and desktop pets on the virtual output (#201) | ||
|
|
101123797a | fix(privacy): accept the Windows viewer's enable=0 encoding (#202) | ||
|
|
9271904be6 |
fix(privacy): accept the iOS screen-off encoding (#199)
The iOS viewer sends PrivateScreenSettingRequest{enable=0, privacy_type=3}
when the user turns the display off: its enable bit is the picture-mode
switch and the explicit type carries the intent. The host treated enable=0
as off, so the screen was restored instead of turned off.
Normalize that combination for iOS controllers only. Android 4.43.0 was
verified with the field-1 semantics, so keep Android and desktop viewers
unchanged. Record the platform after a desktop session is created, update
it on capture_desktop promotion, and cancel a pending UU_PRIVACY_AUTO even
when the switch is refused.
|
||
|
|
f67de7cc7d |
Privacy: recover the input devices after a reboot renumbers them (#173)
* fix(privacy): match recorded input devices after a reboot The recovery record stores KWin's `eventN` sysNames, but udev renumbers them between boots. A record replayed after a reboot (privacy was on at shutdown) then set `enabled` on a device path that no longer exists; the restore failed, kept the record, and every later switch failed at the same step. The device that had been blocked could also stay disabled. Records now keep name/product/vendor next to the sysName, and a restore matches the current device by that identity, falling back to the exact sysName for older string-only records. A device that no longer exists is skipped with a log line instead of failing the restore, so the record, the guard and the outputs are cleaned up; a device that exists but cannot be enabled still fails and keeps the record for the next attempt. Verified by replaying records with the release build on KDE Plasma 6.8: a stale `event14` for a mouse now on `event12` is re-enabled and the record removed; a record for a missing device logs the skip and restores normally. `cargo test --features wayland,portal`: 330 passed, 10 ignored. * fix(privacy): restore every device sharing an identity - enable every current device whose identity matches a record entry, deduplicated by sysName: two record entries can describe one device, and one identity can cover several (identical keyboards, or a receiver exposing several event nodes under the same name) - a failed property read during restore is an error instead of a missing device, so the record and the guard stay for the next attempt; blocking keeps the lenient read - the gone-device warning logs a count only, matching the log-privacy rule * fix(privacy): re-enable readable devices before reporting incomplete enumeration A failed property read during restore no longer aborts enumeration before set_sys runs: the readable matching devices are re-enabled first, then the incomplete read is returned as an error so the record and the guard stay for another attempt. Blocking still skips unreadable devices. |
||
|
|
50ff42e8d7 |
Privacy: keep the cover window out of the task manager (#169)
* fix(privacy): keep the cover window out of the task manager The cover is a plain Wayland toplevel and GTK's skip-taskbar hint is X11 only, so KWin listed it: the task manager showed an unidentified window (class uuremote-server, caption "uu-remote-linux privacy") with the icon theme's generic "wayland" icon, a yellow W in Papirus. Mark the window through KWin scripting after the cover reports ready. The same one-shot script mechanism already moves windows to the virtual output. Failure only logs; the cover itself is unaffected. Verified on KDE Plasma 6.8 Wayland: setting skipTaskbar on the running cover removes the task manager entry immediately, and the entry returns when a new cover window is created without the fix. `cargo test --features wayland,portal`: 320 passed, 10 ignored. * fix(privacy): match every cover window, not just the first caption Picture mode creates one cover per physical monitor with the same title, and KWin appends " <2>" and similar suffixes to duplicate captions, so the exact match skipped every cover after the first on a multi-monitor host. Match the title as a prefix instead. * fix(privacy): report the cover ready only after its windows are mapped The child wrote "ready" before gtk_main(), so the host marked skip-taskbar while KWin may not have listed the cover yet; a cover that mapped later kept the task manager entry. Pump the pending GTK events to map the windows before the handshake, and run the mark script a second time to catch a compositor-side delay. |
||
|
|
4c86c7f782 |
Privacy: auto-enable on desktop connect (UU_PRIVACY_AUTO) (#161)
* feat(privacy): auto-enable the privacy screen on desktop connect `UU_PRIVACY_AUTO=picture` / `screen-off` (or 2 / 3) enables the privacy screen when the first desktop controller connects. Off by default. The switch waits for the portal capture session and retries while it is missing; the viewer's own RPC 7 cancels a pending auto-enable for that session. The privacy state poller that pushes SystemMetrics and SystemStateChange now starts for desktop peers too (it only ran for a tool peer promoted to desktop), and it pushes once on its first tick. A mode the viewer did not request, such as an auto-enable, therefore reaches its menu, and the state message also goes to TEXT, which viewers read for privacy replies. Verified on KDE Plasma Wayland with an iOS viewer: auto picture and auto screen-off both engage, the menu reflects the mode after the push, and a disconnect restores the physical outputs. `cargo test --features wayland,portal`: 320 passed, 10 ignored. * fix(privacy): let a viewer request win against auto-enable races Two paths could still override an explicit choice: - the override was checked before acquiring STATE, so an RPC 7 applied in that window could disable privacy and the auto thread could turn it back on; the check now happens inside the same lock that enters the mode - `session_started` captured the override counter as its baseline, so a request that arrived after CONTROL opened but before the session counter started was treated as unrelated and auto-enable ran anyway; the counter is now a flag set by any RPC 7 and cleared only when the last desktop session ends docs/privacy-screen.md now says remote-assistance (guest) sessions are covered too, and that supported hosts push the current privacy state once on every desktop connect. |
||
|
|
bcde9f967c |
Signaling: keep heartbeat detection alive when delivery stalls (#104)
* Signaling: keep heartbeat detection alive when delivery stalls The receive loop awaited event_sender.send() without a bound. When the main loop was parked in PeerConnection::close after a released peer, the 64-slot event queue filled and the receiver blocked inside the loop body, so the Engine.IO deadline in the same select! never ran. The host stayed online with a half-closed socket for hours. - add a watchdog over the last inbound frame, independent of the receive loop - bound event, pong and control sends with a timeout or try_send - timeout PeerConnection::close so one dead peer cannot stall signaling - regression test with a blocked event consumer Co-Authored-By: Claude Code <[email protected]> * Signaling: always report Disconnected when the receiver stops The receive loop can break without enqueueing Disconnected: event delivery exceeded SEND_STALL_TIMEOUT, or the writer already stopped. receiver_done then lets the watchdog exit, while the main loop's rx_event stays open because the idle-renewal timer holds a sender. The host stays in a dead room until the 15-minute renewal, which is deferred while a peer is connected. Hand a Disconnected off from a detached task after every loop exit. Duplicates are harmless: the main loop breaks on the first one and drops the old receiver. The new test keeps the consumer blocked past SEND_STALL_TIMEOUT, then drains the queue and expects Disconnected. Co-Authored-By: Claude Code <[email protected]> --------- Co-authored-by: Claude Code <[email protected]> |