Enhance SignalR connection handling and listener recovery

.gitignore

@@ -31,7 +31,7 @@ localResourcesCache/
 backend/FwLite/FwLiteShared/wwwroot/viewer
 
 *.csproj.user
-backend/Directory.Build.props.user
+*.props.user
 *.log
 failedSyncs/
 

backend/.editorconfig

@@ -96,7 +96,7 @@ csharp_style_deconstructed_variable_declaration = true:suggestion
 csharp_prefer_simple_default_expression = true:suggestion
 csharp_style_prefer_local_over_anonymous_function = true:suggestion
 csharp_style_inlined_variable_declaration = true:suggestion
-# Remove unnecessary using directives 
+# Remove unnecessary using directives
 dotnet_diagnostic.IDE0005.severity = warning
 ###############################
 # C# Formatting Rules         #
@@ -134,6 +134,11 @@ dotnet_diagnostic.VSTHRD200.severity = none
 # "Expression value is never used"
 dotnet_diagnostic.IDE0058.severity = suggestion
 
+# IDE0061: Use block body for local function
+dotnet_diagnostic.IDE0061.severity = silent
+# IDE0022: Use block body for method
+dotnet_diagnostic.IDE0022.severity = silent
+
 [{*Kernel}.cs]
 dotnet_diagnostic.IDE0058.severity = none
 
@@ -146,4 +151,4 @@ indent_size = unset
 indent_style = unset
 insert_final_newline = false
 tab_width = unset
-trim_trailing_whitespace = false
+trim_trailing_whitespace = false

backend/FwLite/FwLiteMaui.Tests/ConnectivitySyncTriggerTests.cs

@@ -0,0 +1,18 @@
+using FwLiteMaui.Services;
+
+namespace FwLiteMaui.Tests;
+
+public class ConnectivitySyncTriggerTests
+{
+    [Theory]
+    [InlineData(NetworkAccess.None, NetworkAccess.Internet, true)]
+    [InlineData(NetworkAccess.Unknown, NetworkAccess.Internet, true)]
+    [InlineData(NetworkAccess.ConstrainedInternet, NetworkAccess.Internet, true)]
+    [InlineData(NetworkAccess.Internet, NetworkAccess.Internet, false)] // already online — don't re-run
+    [InlineData(NetworkAccess.Internet, NetworkAccess.None, false)]     // going offline
+    [InlineData(NetworkAccess.None, NetworkAccess.Local, false)]        // local network only, no internet
+    public void ShouldRecover_OnlyOnTransitionIntoInternet(NetworkAccess previous, NetworkAccess current, bool expected)
+    {
+        ConnectivitySyncTrigger.ShouldRecover(previous, current).Should().Be(expected);
+    }
+}

backend/FwLite/FwLiteMaui/App.xaml.cs

@@ -1,3 +1,6 @@
+using FwLiteShared.Projects;
+using FwLiteShared.Services;
+using Microsoft.Extensions.Logging;
 
 namespace FwLiteMaui;
 
@@ -6,11 +9,20 @@ public partial class App : Application
     public IServiceProvider ServiceProvider { get; }
     private readonly MainPage _mainPage;
     public static string? OverrideStartupUrl { get; set; }
+    private readonly LexboxProjectChangeListener _lexboxProjectChangeListener;
+    private readonly ILogger<App> _logger;
 
-    public App(MainPage mainPage, IServiceProvider serviceProvider)
+    public App(MainPage mainPage, IPreferencesService preferences, LexboxProjectChangeListener lexboxProjectChangeListener, ILogger<App> logger, IServiceProvider serviceProvider)
     {
         ServiceProvider = serviceProvider;
         _mainPage = mainPage;
+        _lexboxProjectChangeListener = lexboxProjectChangeListener;
+        _logger = logger;
+        var lastUrl = preferences.Get(nameof(PreferenceKey.AppLastUrl));
+        if (lastUrl?.StartsWith('/') == true)
+        {
+            mainPage.StartPath = lastUrl;
+        }
         InitializeComponent();
     }
 
@@ -21,7 +33,25 @@ internal void LoadAppUrl(string url)
 
     protected override Window CreateWindow(IActivationState? activationState)
     {
-        return CreateWindow(_mainPage);
+        var window = CreateWindow(_mainPage);
+        // An OS-frozen app (e.g. Android Doze/Standby) can come back with its push listener down and no connectivity
+        // transition to recover on; resume is when the user is watching, so recover immediately instead of
+        // waiting for the periodic backstop.
+        window.Resumed += (_, _) => _ = EnsureListenersAfterResume();
+        return window;
+    }
+
+    private async Task EnsureListenersAfterResume()
+    {
+        try
+        {
+            _logger.LogInformation("App resumed; ensuring push listeners");
+            await _lexboxProjectChangeListener.EnsureListenersForTrackedProjects(kickReconnecting: true);
+        }
+        catch (Exception e)
+        {
+            _logger.LogWarning(e, "Failed to ensure push listeners after app resume");
+        }
     }
 
     public static Window CreateWindow(MainPage mainPage, int? width = null)

backend/FwLite/FwLiteMaui/FwLiteMauiKernel.cs

@@ -132,6 +132,8 @@ public static void AddFwLiteMauiServices(this IServiceCollection services,
         services.AddSingleton(_ => Preferences.Default);
         services.AddSingleton(_ => VersionTracking.Default);
         services.AddSingleton(_ => Connectivity.Current);
+        services.AddSingleton<IHostedService, ConnectivitySyncTrigger>();
+        services.AddSingleton<INetworkStatus, ConnectivityNetworkStatus>();
         services.AddSingleton(_ => Launcher.Default);
         services.AddSingleton(_ => Browser.Default);
         services.AddSingleton(_ => Share.Default);

backend/FwLite/FwLiteMaui/Services/ConnectivityNetworkStatus.cs

@@ -0,0 +1,9 @@
+using FwLiteShared.Services;
+
+namespace FwLiteMaui.Services;
+
+public class ConnectivityNetworkStatus(IConnectivity connectivity) : INetworkStatus
+{
+    // ConstrainedInternet (e.g. captive portal) counts as offline, matching ConnectivitySyncTrigger.
+    public bool IsOnline => connectivity.NetworkAccess == NetworkAccess.Internet;
+}

backend/FwLite/FwLiteMaui/Services/ConnectivitySyncTrigger.cs

@@ -0,0 +1,62 @@
+using FwLiteShared.Projects;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace FwLiteMaui.Services;
+
+// Primary use case: app started offline should start syncing if the device comes online
+public sealed class ConnectivitySyncTrigger(
+    IConnectivity connectivity,
+    LexboxProjectChangeListener lexboxProjectChangeListener,
+    ILogger<ConnectivitySyncTrigger> logger) : IHostedService
+{
+    private NetworkAccess _lastAccess;
+
+    public Task StartAsync(CancellationToken cancellationToken)
+    {
+        _lastAccess = connectivity.NetworkAccess;
+        connectivity.ConnectivityChanged += OnConnectivityChanged;
+        logger.LogInformation("Watching device connectivity to re-establish push listeners (current access: {NetworkAccess})", _lastAccess);
+        return Task.CompletedTask;
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken)
+    {
+        connectivity.ConnectivityChanged -= OnConnectivityChanged;
+        return Task.CompletedTask;
+    }
+
+    private void OnConnectivityChanged(object? sender, ConnectivityChangedEventArgs e)
+    {
+        var previous = _lastAccess;
+        var current = _lastAccess = e.NetworkAccess;
+
+        logger.LogInformation("Device connectivity changed: {Previous} -> {Current} (profiles: {Profiles})",
+            previous, current, string.Join(", ", e.ConnectionProfiles));
+
+        if (!ShouldRecover(previous, current)) return;
+
+        logger.LogInformation("Connectivity regained (internet access); ensuring push listeners");
+        _ = EnsureListeners();
+    }
+
+    private async Task EnsureListeners(CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            await lexboxProjectChangeListener.EnsureListenersForTrackedProjects(kickReconnecting: true, cancellationToken);
+        }
+        catch (Exception e)
+        {
+            logger.LogWarning(e, "Failed to ensure push listeners after connectivity change");
+        }
+    }
+
+    // Only react to a transition INTO internet access, so recovery doesn't re-run on every connectivity
+    // change (e.g. wifi<->cellular) while already online. Idempotent recovery makes a missed edge harmless;
+    // this just keeps the common flapping case quiet.
+    public static bool ShouldRecover(NetworkAccess previous, NetworkAccess current)
+    {
+        return current == NetworkAccess.Internet && previous != NetworkAccess.Internet;
+    }
+}

backend/FwLite/FwLiteShared.Tests/Projects/AdaptiveRetryPolicyTests.cs

@@ -0,0 +1,84 @@
+using FwLiteShared.Projects;
+using FwLiteShared.Services;
+using Microsoft.AspNetCore.SignalR.Client;
+
+namespace FwLiteShared.Tests.Projects;
+
+public class AdaptiveRetryPolicyTests
+{
+    private class FakeNetworkStatus(bool isOnline) : INetworkStatus
+    {
+        public bool IsOnline => isOnline;
+    }
+
+    private static RetryContext Context(long previousRetryCount) => new()
+    {
+        PreviousRetryCount = previousRetryCount,
+        ElapsedTime = TimeSpan.Zero,
+        RetryReason = new Exception("test"),
+    };
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void FirstTwoAttemptsAreImmediateRegardlessOfNetwork(bool isOnline)
+    {
+        var policy = new LexboxHubConnection.AdaptiveRetryPolicy(new FakeNetworkStatus(isOnline));
+
+        policy.NextRetryDelay(Context(0)).Should().Be(TimeSpan.Zero);
+        policy.NextRetryDelay(Context(1)).Should().Be(TimeSpan.FromSeconds(5));
+    }
+
+    [Theory]
+    [InlineData(2)]
+    [InlineData(10)]
+    [InlineData(1000)]
+    public void WhileOnline_RetriesQuickly(long previousRetryCount)
+    {
+        var policy = new LexboxHubConnection.AdaptiveRetryPolicy(new FakeNetworkStatus(isOnline: true));
+
+        policy.NextRetryDelay(Context(previousRetryCount)).Should().Be(TimeSpan.FromSeconds(10));
+    }
+
+    [Theory]
+    [InlineData(2)]
+    [InlineData(10)]
+    [InlineData(1000)]
+    public void WhileOffline_BacksOff(long previousRetryCount)
+    {
+        var policy = new LexboxHubConnection.AdaptiveRetryPolicy(new FakeNetworkStatus(isOnline: false));
+
+        policy.NextRetryDelay(Context(previousRetryCount)).Should().Be(TimeSpan.FromSeconds(60));
+    }
+
+    [Fact]
+    public void ReevaluatesNetworkStatusPerAttempt()
+    {
+        var online = false;
+        var status = new ToggleNetworkStatus(() => online);
+        var policy = new LexboxHubConnection.AdaptiveRetryPolicy(status);
+
+        policy.NextRetryDelay(Context(5)).Should().Be(TimeSpan.FromSeconds(60));
+        online = true;
+        policy.NextRetryDelay(Context(6)).Should().Be(TimeSpan.FromSeconds(10));
+    }
+
+    private class ToggleNetworkStatus(Func<bool> isOnline) : INetworkStatus
+    {
+        public bool IsOnline => isOnline();
+    }
+
+    // Returning null would end SignalR's retry loop permanently; the deliberate stop on logout belongs to
+    // HandleReconnecting, never the policy.
+    [Theory]
+    [InlineData(0, true)]
+    [InlineData(1, false)]
+    [InlineData(50, true)]
+    [InlineData(50, false)]
+    public void NeverGivesUp(long previousRetryCount, bool isOnline)
+    {
+        var policy = new LexboxHubConnection.AdaptiveRetryPolicy(new FakeNetworkStatus(isOnline));
+
+        policy.NextRetryDelay(Context(previousRetryCount)).Should().NotBeNull();
+    }
+}