Cleanup. (#90)

Author: bitbound

ControlR.DesktopClient.Linux/Services/DisplayManagerWayland.cs

@@ -16,7 +16,7 @@ internal interface IDisplayManagerWayland : IDisplayManager
 {
   bool HasAnyCaptureSizes { get; }
 
-  Task<IReadOnlyDictionary<string, PipeWireStream>> CreatePipeWireStreams(bool forcePortalReinitialize = false, CancellationToken cancellationToken = default);
+  Task<IReadOnlyDictionary<string, PipeWireStream>> CreatePipeWireStreams(CancellationToken cancellationToken = default);
   bool TryGetCaptureSize(string deviceName, out Size size);
   void UpdateCaptureSize(string deviceName, int physicalWidth, int physicalHeight);
 }
@@ -49,13 +49,11 @@ internal class DisplayManagerWayland(
 
   public bool HasAnyCaptureSizes => !_captureSizes.IsEmpty;
 
-  public async Task<IReadOnlyDictionary<string, PipeWireStream>> CreatePipeWireStreams(bool forcePortalReinitialize = false, CancellationToken cancellationToken = default)
+  public async Task<IReadOnlyDictionary<string, PipeWireStream>> CreatePipeWireStreams(CancellationToken cancellationToken = default)
   {
     var result = new Dictionary<string, PipeWireStream>();
     try
     {
-      await _portalService.Initialize(forcePortalReinitialize);
-
       var connection = await _portalService.GetPipeWireConnection();
       if (connection is null || _streamFactory is null)
       {

ControlR.DesktopClient.Linux/Services/InputSimulatorWayland.cs

@@ -171,16 +171,16 @@ public async Task MovePointer(PointerCoordinates coordinates, MovePointerType mo
             // pixel space (0 to stream width/height), not global virtual screen coordinates.
             var clampedX = Math.Clamp(coordinates.NormalizedX, 0, 1);
             var clampedY = Math.Clamp(coordinates.NormalizedY, 0, 1);
-            var maxX = Math.Max(0, coordinates.Display.CapturePixelSize.Width - 1);
-            var maxY = Math.Max(0, coordinates.Display.CapturePixelSize.Height - 1);
-            var physicalX = maxX * clampedX;
-            var physicalY = maxY * clampedY;
+            var maxX = Math.Max(0, coordinates.Display.LayoutBounds.Width - 1);
+            var maxY = Math.Max(0, coordinates.Display.LayoutBounds .Height - 1);
+            var logicalX = maxX * clampedX;
+            var logicalY = maxY * clampedY;
 
             await _desktopPortal.NotifyPointerMotionAbsoluteAsync(
               _sessionHandle,
               streamInfo.NodeId,
-              physicalX,
-              physicalY);
+              logicalX,
+              logicalY);
             break;
           }
 

ControlR.DesktopClient.Linux/Services/ScreenGrabberWayland.cs

@@ -1,6 +1,7 @@
 using ControlR.DesktopClient.Common.Models;
 using ControlR.DesktopClient.Common.ServiceInterfaces;
 using ControlR.Libraries.NativeInterop.Linux;
+using ControlR.Libraries.Shared.Extensions;
 using Microsoft.Extensions.Logging;
 using SkiaSharp;
 using System.Collections.Concurrent;
@@ -34,22 +35,18 @@ internal class ScreenGrabberWayland(
   ILogger<ScreenGrabberWayland> logger) : IScreenGrabber
 {
   private const string CaptureModePipeWire = "WaylandPipeWire";
-  private const int StreamStartPollingIntervalMs = 100;
-  private const int StreamStartTimeoutMs = 3_000;
-  private static readonly TimeSpan _recoveryCooldown = TimeSpan.FromSeconds(2);
-  private static readonly TimeSpan _streamStaleThreshold = TimeSpan.FromSeconds(2);
 
   private readonly IDisplayManagerWayland _displayManager = displayManager;
   private readonly SemaphoreSlim _initLock = new(1, 1);
   private readonly ILogger<ScreenGrabberWayland> _logger = logger;
+  private readonly TimeSpan _streamStartPollingInterval = TimeSpan.FromMilliseconds(100);
+  private readonly TimeSpan _streamStartTimeout = TimeSpan.FromSeconds(3);
   private readonly TimeProvider _timeProvider = timeProvider;
 
   private bool _disposed;
   private bool _isInitialized;
-  private long _lastRecoveryAttemptUtcTicks;
   private ConcurrentDictionary<string, PipeWireStream> _streams = new();
 
-
   public async Task<CaptureResult> CaptureAllDisplays(bool captureCursor = true)
   {
     try
@@ -217,37 +214,13 @@ public async Task Initialize(CancellationToken cancellationToken)
     }
   }
 
-  internal static bool ShouldRecoverStream(
-    DateTime nowUtc,
-    DateTime createdUtc,
-    DateTime? lastFrameReceivedUtc,
-    TimeSpan staleThreshold,
-    DateTime? lastRecoveryAttemptUtc,
-    TimeSpan recoveryCooldown)
-  {
-    var mostRecentActivityUtc = lastFrameReceivedUtc ?? createdUtc;
-    if (nowUtc - mostRecentActivityUtc < staleThreshold)
-    {
-      return false;
-    }
-
-    if (lastRecoveryAttemptUtc is not null && nowUtc - lastRecoveryAttemptUtc < recoveryCooldown)
-    {
-      return false;
-    }
-
-    return true;
-  }
-
   private async Task<CaptureResult> CaptureStream(
     string deviceName,
     PipeWireStream stream,
     CancellationToken cancellationToken)
   {
     try
     {
-      stream = await RefreshStreamIfStale(deviceName, stream, cancellationToken);
-
       if (!stream.TryGetLatestFrame(out var frameData))
       {
         return CaptureResult.NoChanges(CaptureModePipeWire);
@@ -306,47 +279,6 @@ private void DisposeStreams()
     _streams.Clear();
   }
 
-  private DateTime? GetLastRecoveryAttemptUtc()
-  {
-    var ticks = Interlocked.Read(ref _lastRecoveryAttemptUtcTicks);
-    return ticks > 0
-      ? new DateTime(ticks, DateTimeKind.Utc)
-      : null;
-  }
-
-  private async Task<PipeWireStream> RefreshStreamIfStale(
-    string deviceName,
-    PipeWireStream stream,
-    CancellationToken cancellationToken)
-  {
-    var nowUtc = _timeProvider.GetUtcNow().UtcDateTime;
-    if (!ShouldRecoverStream(
-          nowUtc,
-          stream.CreatedUtc,
-          stream.LastFrameReceivedUtc,
-          _streamStaleThreshold,
-          GetLastRecoveryAttemptUtc(),
-          _recoveryCooldown))
-    {
-      return stream;
-    }
-
-    if (!await TryRefreshStreams(
-          deviceName,
-          $"stream has not produced a new frame since {(stream.LastFrameReceivedUtc ?? stream.CreatedUtc):O}",
-          cancellationToken))
-    {
-      return stream;
-    }
-
-    if (_streams.TryGetValue(deviceName, out var refreshedStream))
-    {
-      return refreshedStream;
-    }
-
-    return _streams.Values.FirstOrDefault() ?? stream;
-  }
-
   private void ReplaceStreams(IReadOnlyDictionary<string, PipeWireStream> replacementStreams)
   {
     var newStreams = new ConcurrentDictionary<string, PipeWireStream>(replacementStreams);
@@ -371,77 +303,6 @@ private void ReplaceStreams(IReadOnlyDictionary<string, PipeWireStream> replacem
     originalStreams.Clear();
   }
 
-  private async Task<bool> TryRefreshStreams(
-    string deviceName,
-    string reason,
-    CancellationToken cancellationToken)
-  {
-    if (_disposed)
-    {
-      return false;
-    }
-
-    await _initLock.WaitAsync(cancellationToken);
-    try
-    {
-      var nowUtc = _timeProvider.GetUtcNow().UtcDateTime;
-      if (GetLastRecoveryAttemptUtc() is { } lastRecoveryAttemptUtc &&
-          nowUtc - lastRecoveryAttemptUtc < _recoveryCooldown)
-      {
-        return false;
-      }
-
-      Interlocked.Exchange(ref _lastRecoveryAttemptUtcTicks, nowUtc.Ticks);
-
-      _logger.LogWarning(
-        "Refreshing Wayland PipeWire streams for display {DeviceName} because {Reason}.",
-        deviceName,
-        reason);
-
-      var replacementStreams = await _displayManager.CreatePipeWireStreams(
-        forcePortalReinitialize: true,
-        cancellationToken: cancellationToken);
-
-      if (replacementStreams.Count == 0)
-      {
-        _logger.LogWarning("Failed to refresh Wayland PipeWire streams. No replacement streams were created.");
-        return false;
-      }
-
-      try
-      {
-        await WaitForStreamsReady(replacementStreams, cancellationToken);
-        ReplaceStreams(replacementStreams);
-        _isInitialized = !_streams.IsEmpty;
-
-        _logger.LogInformation("Wayland PipeWire streams refreshed successfully.");
-        return true;
-      }
-      catch
-      {
-        foreach (var stream in replacementStreams.Values)
-        {
-          stream.Dispose();
-        }
-
-        throw;
-      }
-    }
-    catch (OperationCanceledException)
-    {
-      throw;
-    }
-    catch (Exception ex)
-    {
-      _logger.LogWarning(ex, "Error while refreshing Wayland PipeWire streams.");
-      return false;
-    }
-    finally
-    {
-      _initLock.Release();
-    }
-  }
-
   private async Task WaitForStreamsReady(
     IReadOnlyDictionary<string, PipeWireStream> streams,
     CancellationToken cancellationToken)
@@ -451,15 +312,19 @@ private async Task WaitForStreamsReady(
       var deviceName = kv.Key;
       var stream = kv.Value;
 
-      for (var j = 0; j < StreamStartTimeoutMs / StreamStartPollingIntervalMs; j++)
+      using var timer = new PeriodicTimer(_streamStartPollingInterval, _timeProvider);
+      using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+      cts.CancelAfter(_streamStartTimeout);
+
+      while (await timer.WaitForNextTick(throwOnCancellation: false, cts.Token))
       {
         if (stream.IsStreaming && stream.TryGetLatestFrame(out var frameData))
         {
           frameData.Dispose();
           break;
         }
 
-        await Task.Delay(StreamStartPollingIntervalMs, cancellationToken);
+        await Task.Delay(_streamStartPollingInterval, cancellationToken);
       }
 
       if (stream.Width > 0 && stream.Height > 0)

ControlR.DesktopClient.Linux/XdgPortal/XdgDesktopPortal.cs

@@ -13,7 +13,7 @@ public interface IXdgDesktopPortal : IDisposable
   Task<(SafeFileHandle Fd, string SessionHandle)?> GetPipeWireConnection();
   Task<string?> GetRemoteDesktopSessionHandle();
   Task<List<PipeWireStreamInfo>> GetScreenCastStreams();
-  Task Initialize(bool forceReinitialization = false, bool bypassRestoreToken = false);
+  Task Initialize(bool bypassRestoreToken = false);
   Task NotifyKeyboardKeycodeAsync(string sessionHandle, int keycode, bool pressed);
   Task NotifyKeyboardKeysymAsync(string sessionHandle, int keysym, bool pressed);
   Task NotifyPointerAxisAsync(string sessionHandle, double dx, double dy, bool finish = true);
@@ -79,9 +79,9 @@ public async Task<List<PipeWireStreamInfo>> GetScreenCastStreams()
     return _streams ?? throw new InvalidOperationException("ScreenCast streams are not initialized.");
   }
 
-  public async Task Initialize(bool forceReinitialization = false, bool bypassRestoreToken = false)
+  public async Task Initialize(bool bypassRestoreToken = false)
   {
-    await EnsureInitializedAsync(forceReinitialization, bypassRestoreToken);
+    await EnsureInitializedAsync(bypassRestoreToken);
   }
 
   public async Task NotifyKeyboardKeycodeAsync(string sessionHandle, int keycode, bool pressed)
@@ -250,26 +250,21 @@ private async Task<Result<string>> CreateRemoteDesktopSessionAsync(CancellationT
     }
   }
 
-  private async Task EnsureInitializedAsync(bool forceReinitialization = false, bool bypassRestoreToken = false)
+  private async Task EnsureInitializedAsync(bool bypassRestoreToken = false)
   {
-    if (_initialized && !forceReinitialization)
+    if (_initialized)
     {
       return;
     }
 
     await _initLock.WaitAsync();
     try
     {
-      if (_initialized && !forceReinitialization)
+      if (_initialized)
       {
         return;
       }
 
-      if (forceReinitialization)
-      {
-        ResetState();
-      }
-
       await ConnectAsync();
 
       var sessionResult = await CreateRemoteDesktopSessionAsync();
@@ -382,17 +377,6 @@ private async Task<Result<SafeFileHandle>> OpenPipeWireRemoteAsync(string sessio
     }
   }
 
-  private void ResetState()
-  {
-    _pipewireFd?.Dispose();
-    _connection?.Dispose();
-    _pipewireFd = null;
-    _connection = null;
-    _sessionHandle = null;
-    _streams = null;
-    _initialized = false;
-  }
-
   private void SaveRestoreToken(string token)
   {
     try

ControlR.Web.Server/Services/Users/UserSettingsProviderServer.cs

@@ -27,14 +27,14 @@ public Task<KeyboardInputMode> GetKeyboardInputMode()
     return GetPref(UserPreferenceNames.KeyboardInputMode, KeyboardInputMode.Auto);
   }
 
-  public Task<bool> GetOpenDeviceInNewTab()
+  public Task<bool> GetNotifyUserOnSessionStart()
   {
-    return GetPref(UserPreferenceNames.OpenDeviceInNewTab, true);
+    return GetPref(UserPreferenceNames.NotifyUserOnSessionStart, true);
   }
 
-  public Task<bool> GetNotifyUserOnSessionStart()
+  public Task<bool> GetOpenDeviceInNewTab()
   {
-    return GetPref(UserPreferenceNames.NotifyUserOnSessionStart, true);
+    return GetPref(UserPreferenceNames.OpenDeviceInNewTab, true);
   }
 
   public Task<ThemeMode> GetThemeMode()
@@ -62,14 +62,14 @@ public Task SetKeyboardInputMode(KeyboardInputMode value)
     return SetPref(UserPreferenceNames.KeyboardInputMode, value);
   }
 
-  public Task SetOpenDeviceInNewTab(bool value)
+  public Task SetNotifyUserOnSessionStart(bool value)
   {
-    return SetPref(UserPreferenceNames.OpenDeviceInNewTab, value);
+    return SetPref(UserPreferenceNames.NotifyUserOnSessionStart, value);
   }
 
-  public Task SetNotifyUserOnSessionStart(bool value)
+  public Task SetOpenDeviceInNewTab(bool value)
   {
-    return SetPref(UserPreferenceNames.NotifyUserOnSessionStart, value);
+    return SetPref(UserPreferenceNames.OpenDeviceInNewTab, value);
   }
 
   public Task SetThemeMode(ThemeMode value)