Merge pull request #356 from switchifyapp/fix/remove-connect-auto-hide-355

enaboapps · web-flow · commit a26ad69696c5 · 2026-07-03T14:36:43.000+01:00
Remove connect-time minimize to tray
diff --git a/src/SwitchifyPc.App/App.xaml.cs b/src/SwitchifyPc.App/App.xaml.cs
@@ -371,10 +371,6 @@ private async Task HandleBluetoothMessageAsync(BluetoothMessageEvent message)
             }
         }
 
-        if (result.ShouldAutoHideMainWindow)
-        {
-            HideMainWindowAfterPreviouslyUsedDeviceControl();
-        }
     }
 
     private static string? AuthFailureMessage(string reason)
@@ -515,21 +511,6 @@ private void UpdateMainWindowState(UpdateState state)
         Dispatcher.BeginInvoke(() => mainWindowViewModel.SetUpdateState(state));
     }
 
-    private void HideMainWindowAfterPreviouslyUsedDeviceControl()
-    {
-        if (MainWindow is not { IsVisible: true } window) return;
-
-        if (!MainWindowAutoHidePolicy.ShouldHideAfterPreviouslyUsedDeviceControl(
-            isMainWindowVisible: true,
-            hasPairingApprovals: mainWindowViewModel.HasPairingApprovals,
-            isPreviouslyUsedDeviceSession: true))
-        {
-            return;
-        }
-
-        window.Hide();
-    }
-
     private void UpdateBluetoothState(BluetoothStatus status)
     {
         DesktopUiState desktopState = status.Status switch
diff --git a/src/SwitchifyPc.Core/Bluetooth/BluetoothRemoteFrameProcessor.cs b/src/SwitchifyPc.Core/Bluetooth/BluetoothRemoteFrameProcessor.cs
@@ -12,22 +12,20 @@ public sealed record BluetoothRemoteFrameResult(
     bool MessageComplete,
     string? ErrorReason,
     IReadOnlyList<BluetoothRemoteFrameOutput> OutgoingMessages,
-    bool ShouldAutoHideMainWindow = false,
     string? AuthenticatedConnectionId = null,
     string? AuthenticatedDeviceId = null,
     string? AuthFailureReason = null)
 {
-    public static BluetoothRemoteFrameResult Incomplete(string? reason = null) => new(false, reason, [], false);
+    public static BluetoothRemoteFrameResult Incomplete(string? reason = null) => new(false, reason, []);
 
     public static BluetoothRemoteFrameResult Complete(
         IReadOnlyList<BluetoothRemoteFrameOutput> outgoingMessages,
-        bool shouldAutoHideMainWindow = false,
         string? authenticatedConnectionId = null,
         string? authenticatedDeviceId = null,
         string? authFailureReason = null) =>
-        new(true, null, outgoingMessages, shouldAutoHideMainWindow, authenticatedConnectionId, authenticatedDeviceId, authFailureReason);
+        new(true, null, outgoingMessages, authenticatedConnectionId, authenticatedDeviceId, authFailureReason);
 
-    public static BluetoothRemoteFrameResult Error(string reason) => new(true, reason, [], false);
+    public static BluetoothRemoteFrameResult Error(string reason) => new(true, reason, []);
 }
 
 public sealed class BluetoothRemoteFrameProcessor
@@ -74,7 +72,6 @@ public async Task<BluetoothRemoteFrameResult> AcceptAsync(
             cancellationToken).ConfigureAwait(false);
         return BluetoothRemoteFrameResult.Complete(
             FrameOutgoingMessages(sessionResult),
-            sessionResult.ShouldAutoHideMainWindow,
             sessionResult.AuthenticatedConnectionId,
             sessionResult.AuthenticatedDeviceId,
             sessionResult.AuthFailureReason);
diff --git a/src/SwitchifyPc.Core/Control/RemoteControlSession.cs b/src/SwitchifyPc.Core/Control/RemoteControlSession.cs
@@ -8,14 +8,13 @@ public sealed record RemoteSessionOutgoingMessage(string ConnectionId, string Re
 
 public sealed record RemoteSessionResult(
     IReadOnlyList<RemoteSessionOutgoingMessage> OutgoingMessages,
-    bool ShouldAutoHideMainWindow = false,
     string? AuthenticatedConnectionId = null,
     string? AuthenticatedDeviceId = null,
     string? AuthFailureReason = null)
 {
-    public static RemoteSessionResult None { get; } = new([], false);
+    public static RemoteSessionResult None { get; } = new([]);
 
-    public static RemoteSessionResult One(RemoteSessionOutgoingMessage message) => new([message], false);
+    public static RemoteSessionResult One(RemoteSessionOutgoingMessage message) => new([message]);
 }
 
 public sealed class RemoteControlSession
@@ -25,7 +24,6 @@ public sealed class RemoteControlSession
     private readonly ControlSession commandSession;
     private readonly Action? onPendingPairingRequestsChanged;
     private readonly Dictionary<string, PendingConnection> pendingConnectionsByRequestId = new(StringComparer.Ordinal);
-    private readonly Dictionary<string, bool> autoHideEligibleByConnectionId = new(StringComparer.Ordinal);
 
     public RemoteControlSession(
         PairingManager pairingManager,
@@ -67,12 +65,10 @@ public async Task<RemoteSessionResult> ProcessMessageAsync(
         }
 
         ControlSessionResult commandResult = await commandSession.ProcessMessageAsync(rawMessage, cancellationToken).ConfigureAwait(false);
-        bool shouldAutoHide = ShouldAutoHideForCommandResult(connectionId, commandResult);
         return new RemoteSessionResult(
             commandResult.HasResponse
                 ? [new RemoteSessionOutgoingMessage(connectionId, commandResult.ResponseJson!)]
                 : [],
-            shouldAutoHide,
             commandResult.HasAuthenticatedDevice ? connectionId : null,
             commandResult.AuthenticatedDeviceId,
             commandResult.AuthFailureReason);
@@ -138,7 +134,6 @@ public RemoteSessionResult ExpirePendingPairingRequests()
     public void RemoveConnection(string connectionId)
     {
         _ = commandSession.StopAllRepeatsAsync();
-        autoHideEligibleByConnectionId.Remove(connectionId);
         string[] requestIds = pendingConnectionsByRequestId
             .Where(entry => entry.Value.ConnectionId == connectionId)
             .Select(entry => entry.Key)
@@ -207,22 +202,6 @@ private async Task<RemoteSessionResult> HandlePairingRequestAsync(
         return pendingConnection;
     }
 
-    private bool ShouldAutoHideForCommandResult(string connectionId, ControlSessionResult commandResult)
-    {
-        if (!commandResult.HasAuthenticatedDevice)
-        {
-            return false;
-        }
-
-        if (!autoHideEligibleByConnectionId.TryGetValue(connectionId, out bool eligible))
-        {
-            eligible = commandResult.AuthenticatedDeviceWasPreviouslyUsed;
-            autoHideEligibleByConnectionId[connectionId] = eligible;
-        }
-
-        return eligible;
-    }
-
     private static JsonDocument? TryParse(string rawMessage, out string? errorResponse)
     {
         try
diff --git a/src/SwitchifyPc.Core/Ui/MainWindowAutoHidePolicy.cs b/src/SwitchifyPc.Core/Ui/MainWindowAutoHidePolicy.cs
diff --git a/src/SwitchifyPc.Tests/BluetoothRemoteFrameProcessorTests.cs b/src/SwitchifyPc.Tests/BluetoothRemoteFrameProcessorTests.cs
@@ -31,7 +31,8 @@ public async Task ReassemblesCommandAndFramesAckToSameConnection()
         }
 
         Assert.True(result.MessageComplete);
-        Assert.False(result.ShouldAutoHideMainWindow);
+        Assert.Equal("ble-1", result.AuthenticatedConnectionId);
+        Assert.Equal(DeviceId, result.AuthenticatedDeviceId);
         BluetoothRemoteFrameOutput output = Assert.Single(result.OutgoingMessages);
         Assert.Equal("ble-1", output.ConnectionId);
         Assert.False(output.CloseConnection);
@@ -53,7 +54,6 @@ public async Task PairingRequestCompletesWithoutImmediateResponseAndAcceptFrames
         }
 
         Assert.True(result.MessageComplete);
-        Assert.False(result.ShouldAutoHideMainWindow);
         Assert.Empty(result.OutgoingMessages);
         Assert.Equal("192.168.1.50", Assert.Single(context.ApprovalManager.ListPendingRequestViews()).RemoteAddress);
 
@@ -68,7 +68,7 @@ public async Task PairingRequestCompletesWithoutImmediateResponseAndAcceptFrames
     }
 
     [Fact]
-    public async Task ReassembledCommandFromPreviouslyUsedDeviceRequestsAutoHide()
+    public async Task ReassembledCommandFromPreviouslyUsedDevicePropagatesAuthenticatedConnection()
     {
         TestContext context = CreateContext(lastSeenAt: Now - 500);
         BluetoothRemoteFrameProcessor processor = new(context.Session, maxResponseFramePayloadBytes: 20);
@@ -84,11 +84,15 @@ public async Task ReassembledCommandFromPreviouslyUsedDeviceRequestsAutoHide()
         }
 
         Assert.True(result.MessageComplete);
-        Assert.True(result.ShouldAutoHideMainWindow);
+        Assert.Equal("ble-1", result.AuthenticatedConnectionId);
+        Assert.Equal(DeviceId, result.AuthenticatedDeviceId);
+        BluetoothRemoteFrameOutput output = Assert.Single(result.OutgoingMessages);
+        Assert.Equal("ble-1", output.ConnectionId);
+        AssertResponseType(output.ResponseFrames, "ack");
     }
 
     [Fact]
-    public async Task NewPairedDeviceDoesNotRequestAutoHideForRepeatedMessagesOnSameConnection()
+    public async Task NewPairedDeviceRepeatedMessagesCompleteOnSameConnection()
     {
         TestContext context = CreateContext();
         BluetoothRemoteFrameProcessor processor = new(context.Session);
@@ -104,8 +108,8 @@ public async Task NewPairedDeviceDoesNotRequestAutoHideForRepeatedMessagesOnSame
 
         Assert.True(first.MessageComplete);
         Assert.True(second.MessageComplete);
-        Assert.False(first.ShouldAutoHideMainWindow);
-        Assert.False(second.ShouldAutoHideMainWindow);
+        Assert.Equal("ble-1", first.AuthenticatedConnectionId);
+        Assert.Equal("ble-1", second.AuthenticatedConnectionId);
     }
 
     [Fact]
diff --git a/src/SwitchifyPc.Tests/MainWindowAutoHidePolicyTests.cs b/src/SwitchifyPc.Tests/MainWindowAutoHidePolicyTests.cs
diff --git a/src/SwitchifyPc.Tests/RemoteControlSessionTests.cs b/src/SwitchifyPc.Tests/RemoteControlSessionTests.cs
@@ -24,7 +24,6 @@ public async Task PairingRequestCreatesPendingApprovalWithoutImmediateResponse()
             remoteAddress: "192.168.1.50");
 
         Assert.Empty(result.OutgoingMessages);
-        Assert.False(result.ShouldAutoHideMainWindow);
         Assert.Null(result.AuthenticatedConnectionId);
         Assert.Null(result.AuthenticatedDeviceId);
         Assert.Null(result.AuthFailureReason);
@@ -142,7 +141,6 @@ public async Task DelegatesAuthenticatedCommandsToCommandSession()
             "ble-1",
             SignedCommand("keyboard.key", new { key = "Meta" }));
 
-        Assert.False(result.ShouldAutoHideMainWindow);
         Assert.Equal("ble-1", result.AuthenticatedConnectionId);
         Assert.Equal(DeviceId, result.AuthenticatedDeviceId);
         Assert.Null(result.AuthFailureReason);
@@ -171,63 +169,18 @@ public async Task UnknownAuthenticatedCommandReportsAuthFailureWithoutMarkingCon
     }
 
     [Fact]
-    public async Task PreviouslyUsedDeviceCommandRequestsAutoHide()
-    {
-        TestContext context = CreateContext(lastSeenAt: Now - 500);
-
-        RemoteSessionResult result = await context.Session.ProcessMessageAsync(
-            "ble-1",
-            SignedCommand("keyboard.key", new { key = "Meta" }));
-
-        Assert.True(result.ShouldAutoHideMainWindow);
-    }
-
-    [Fact]
-    public async Task NewlyPairedDeviceConnectionDoesNotAutoHideDuringFirstSession()
+    public async Task AuthenticatedCommandsUpdateLastSeenAt()
     {
         TestContext context = CreateContext();
 
-        RemoteSessionResult first = await context.Session.ProcessMessageAsync(
+        await context.Session.ProcessMessageAsync(
             "ble-1",
             SignedCommand("keyboard.key", new { key = "Meta" }, id: "command-1"));
-        RemoteSessionResult second = await context.Session.ProcessMessageAsync(
-            "ble-1",
-            SignedCommand("connection.ping", new { }, id: "command-2"));
-
-        Assert.False(first.ShouldAutoHideMainWindow);
-        Assert.False(second.ShouldAutoHideMainWindow);
-        Assert.Equal(Now, (await context.Store.LoadAsync()).PairedDevices[0].LastSeenAt);
-    }
-
-    [Fact]
-    public async Task PreviouslyUsedDeviceReconnectCanAutoHide()
-    {
-        TestContext context = CreateContext();
         await context.Session.ProcessMessageAsync(
             "ble-1",
-            SignedCommand("keyboard.key", new { key = "Meta" }, id: "command-1"));
-        context.Session.RemoveConnection("ble-1");
-
-        RemoteSessionResult result = await context.Session.ProcessMessageAsync(
-            "ble-2",
             SignedCommand("connection.ping", new { }, id: "command-2"));
 
-        Assert.True(result.ShouldAutoHideMainWindow);
-    }
-
-    [Fact]
-    public async Task RemoveConnectionClearsAutoHideEligibility()
-    {
-        TestContext context = CreateContext(lastSeenAt: Now - 500);
-        Assert.True((await context.Session.ProcessMessageAsync(
-            "ble-1",
-            SignedCommand("keyboard.key", new { key = "Meta" }, id: "command-1"))).ShouldAutoHideMainWindow);
-
-        context.Session.RemoveConnection("ble-1");
-
-        Assert.True((await context.Session.ProcessMessageAsync(
-            "ble-1",
-            SignedCommand("connection.ping", new { }, id: "command-2"))).ShouldAutoHideMainWindow);
+        Assert.Equal(Now, (await context.Store.LoadAsync()).PairedDevices[0].LastSeenAt);
     }
 
     [Fact]

Original file line number	Diff line number	Diff line change
`@@ -371,10 +371,6 @@ private async Task HandleBluetoothMessageAsync(BluetoothMessageEvent message)`
`371`	`371`	`}`
`372`	`372`	`}`
`373`	`373`
`374`		`- if (result.ShouldAutoHideMainWindow)`
`375`		`- {`
`376`		`- HideMainWindowAfterPreviouslyUsedDeviceControl();`
`377`		`- }`
`378`	`374`	`}`
`379`	`375`
`380`	`376`	`private static string? AuthFailureMessage(string reason)`
`@@ -515,21 +511,6 @@ private void UpdateMainWindowState(UpdateState state)`
`515`	`511`	`Dispatcher.BeginInvoke(() => mainWindowViewModel.SetUpdateState(state));`
`516`	`512`	`}`
`517`	`513`
`518`		`- private void HideMainWindowAfterPreviouslyUsedDeviceControl()`
`519`		`- {`
`520`		`- if (MainWindow is not { IsVisible: true } window) return;`
`521`		`-`
`522`		`- if (!MainWindowAutoHidePolicy.ShouldHideAfterPreviouslyUsedDeviceControl(`
`523`		`- isMainWindowVisible: true,`
`524`		`- hasPairingApprovals: mainWindowViewModel.HasPairingApprovals,`
`525`		`- isPreviouslyUsedDeviceSession: true))`
`526`		`- {`
`527`		`- return;`
`528`		`- }`
`529`		`-`
`530`		`- window.Hide();`
`531`		`- }`
`532`		`-`
`533`	`514`	`private void UpdateBluetoothState(BluetoothStatus status)`
`534`	`515`	`{`
`535`	`516`	`DesktopUiState desktopState = status.Status switch`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,8 @@ public async Task ReassemblesCommandAndFramesAckToSameConnection()`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`Assert.True(result.MessageComplete);`
`34`		`- Assert.False(result.ShouldAutoHideMainWindow);`
	`34`	`+ Assert.Equal("ble-1", result.AuthenticatedConnectionId);`
	`35`	`+ Assert.Equal(DeviceId, result.AuthenticatedDeviceId);`
`35`	`36`	`BluetoothRemoteFrameOutput output = Assert.Single(result.OutgoingMessages);`
`36`	`37`	`Assert.Equal("ble-1", output.ConnectionId);`
`37`	`38`	`Assert.False(output.CloseConnection);`
`@@ -53,7 +54,6 @@ public async Task PairingRequestCompletesWithoutImmediateResponseAndAcceptFrames`
`53`	`54`	`}`
`54`	`55`
`55`	`56`	`Assert.True(result.MessageComplete);`
`56`		`- Assert.False(result.ShouldAutoHideMainWindow);`
`57`	`57`	`Assert.Empty(result.OutgoingMessages);`
`58`	`58`	`Assert.Equal("192.168.1.50", Assert.Single(context.ApprovalManager.ListPendingRequestViews()).RemoteAddress);`
`59`	`59`
`@@ -68,7 +68,7 @@ public async Task PairingRequestCompletesWithoutImmediateResponseAndAcceptFrames`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`[Fact]`
`71`		`- public async Task ReassembledCommandFromPreviouslyUsedDeviceRequestsAutoHide()`
	`71`	`+ public async Task ReassembledCommandFromPreviouslyUsedDevicePropagatesAuthenticatedConnection()`
`72`	`72`	`{`
`73`	`73`	`TestContext context = CreateContext(lastSeenAt: Now - 500);`
`74`	`74`	`BluetoothRemoteFrameProcessor processor = new(context.Session, maxResponseFramePayloadBytes: 20);`
`@@ -84,11 +84,15 @@ public async Task ReassembledCommandFromPreviouslyUsedDeviceRequestsAutoHide()`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`Assert.True(result.MessageComplete);`
`87`		`- Assert.True(result.ShouldAutoHideMainWindow);`
	`87`	`+ Assert.Equal("ble-1", result.AuthenticatedConnectionId);`
	`88`	`+ Assert.Equal(DeviceId, result.AuthenticatedDeviceId);`
	`89`	`+ BluetoothRemoteFrameOutput output = Assert.Single(result.OutgoingMessages);`
	`90`	`+ Assert.Equal("ble-1", output.ConnectionId);`
	`91`	`+ AssertResponseType(output.ResponseFrames, "ack");`
`88`	`92`	`}`
`89`	`93`
`90`	`94`	`[Fact]`
`91`		`- public async Task NewPairedDeviceDoesNotRequestAutoHideForRepeatedMessagesOnSameConnection()`
	`95`	`+ public async Task NewPairedDeviceRepeatedMessagesCompleteOnSameConnection()`
`92`	`96`	`{`
`93`	`97`	`TestContext context = CreateContext();`
`94`	`98`	`BluetoothRemoteFrameProcessor processor = new(context.Session);`
`@@ -104,8 +108,8 @@ public async Task NewPairedDeviceDoesNotRequestAutoHideForRepeatedMessagesOnSame`
`104`	`108`
`105`	`109`	`Assert.True(first.MessageComplete);`
`106`	`110`	`Assert.True(second.MessageComplete);`
`107`		`- Assert.False(first.ShouldAutoHideMainWindow);`
`108`		`- Assert.False(second.ShouldAutoHideMainWindow);`
	`111`	`+ Assert.Equal("ble-1", first.AuthenticatedConnectionId);`
	`112`	`+ Assert.Equal("ble-1", second.AuthenticatedConnectionId);`
`109`	`113`	`}`
`110`	`114`
`111`	`115`	`[Fact]`