Add a setting to keep update notifications on screen until dismissed (#5681)

Author: GabrielDuf

src/Languages/lang_en.json

@@ -973,6 +973,7 @@
   "Show a silent notification when an operation is running": "Show a silent notification when an operation is running",
   "Show a notification when an operation fails": "Show a notification when an operation fails",
   "Show a notification when an operation finishes successfully": "Show a notification when an operation finishes successfully",
+  "Keep update notifications on screen until they are dismissed": "Keep update notifications on screen until they are dismissed",
   "Concurrency and execution": "Concurrency and execution",
   "Choose how many operations should be performed in parallel": "Choose how many operations should be performed in parallel",
   "Clear successful operations from the operation list after a 5 second delay": "Clear successful operations from the operation list after a 5 second delay",

src/UniGetUI.Avalonia/Infrastructure/AvaloniaAutoUpdater.cs

@@ -107,6 +107,8 @@ private static void DismissUpdateBanner()
     {
         var info = new UpdateStatusInfo("", "", InfoBarSeverity.Informational, IsClosable: true, IsOpen: false);
         Dispatcher.UIThread.Post(() => StatusChanged?.Invoke(info));
+        if (OperatingSystem.IsWindows())
+            WindowsAppNotificationBridge.RemoveSelfUpdateAvailableNotification();
     }
 
     // ------------------------------------------------------------------ per-attempt log
@@ -541,6 +543,8 @@ bool IsChannelObsolete() =>
                         InfoBarSeverity.Success,
                         isClosable: true);
                 }
+                if (OperatingSystem.IsWindows())
+                    WindowsAppNotificationBridge.RemoveSelfUpdateAvailableNotification();
                 MarkAttemptFinished("no update available");
                 return true;
             }
@@ -1038,6 +1042,7 @@ private static async Task LaunchInstallerAsync(
         }
 
         LogUpdateInfo($"Installer process started (PID {p.Id}). The installer is expected to terminate UniGetUI before file replacement.");
+        WindowsAppNotificationBridge.RemoveSelfUpdateAvailableNotification();
         InstallerHandoffs.Complete(handoff);
 
         RaiseStatus(

src/UniGetUI.Avalonia/Infrastructure/SettingsSearchIndex.cs

@@ -73,6 +73,7 @@ private sealed record Entry(
         new("Show a silent notification when an operation is running", ["progress notification", "silent notification"], typeof(Notifications), "ProgressNotificationCard"),
         new("Show a notification when an operation fails", ["error notification", "failure notification"], typeof(Notifications), "ErrorNotificationCard"),
         new("Show a notification when an operation finishes successfully", ["success notification"], typeof(Notifications), "SuccessNotificationCard"),
+        new("Keep update notifications on screen until they are dismissed", ["persistent notification", "reminder", "dismiss"], typeof(Notifications), "PersistentUpdateNotificationsCard", WindowsOnly: true),
         new("Notification preferences", ["notifications"], typeof(Notifications), null),
 
         // ── Updates ──────────────────────────────────────────────────────────

src/UniGetUI.Avalonia/Infrastructure/Win32ToastNotifier.cs

@@ -2,6 +2,7 @@
 using System;
 using System.Runtime.InteropServices;
 using UniGetUI.Core.Logging;
+using UniGetUI.Core.Tools;
 using Windows.Data.Xml.Dom;
 using Windows.UI.Notifications;
 
@@ -24,6 +25,8 @@ internal static class Win32ToastNotifier
     /// <summary>Stable AUMID for UniGetUI. Must match the one stamped on the Start Menu shortcut.</summary>
     public const string AppUserModelId = "Devolutions.UniGetUI";
 
+    private const string ToastGroup = "UniGetUI";
+
     private static bool _availabilityChecked;
     private static bool _isAvailable;
 
@@ -80,19 +83,24 @@ public static bool IsAvailable()
     /// forwarded to the app when the user clicks the toast. Returns <c>false</c> if the
     /// toast could not be shown (caller should fall back to an in-app banner).
     /// </summary>
-    public static bool Show(string title, string message, string launchArgument)
+    public static bool Show(string title, string message, string launchArgument, string? tag = null, bool untilDismissed = false)
     {
         if (!OperatingSystem.IsWindows())
             return false;
 
         try
         {
-            string xml = BuildToastXml(title, message, launchArgument);
+            string xml = BuildToastXml(title, message, launchArgument, untilDismissed);
 
             var xmlDoc = new XmlDocument();
             xmlDoc.LoadXml(xml);
 
             var notification = new ToastNotification(xmlDoc);
+            if (tag is not null)
+            {
+                notification.Tag = tag;
+                notification.Group = ToastGroup;
+            }
             ToastNotificationManager.CreateToastNotifier(AppUserModelId).Show(notification);
             return true;
         }
@@ -104,20 +112,41 @@ public static bool Show(string title, string message, string launchArgument)
         }
     }
 
-    private static string BuildToastXml(string title, string message, string launchArgument)
+    public static void Remove(string tag)
+    {
+        if (!OperatingSystem.IsWindows())
+            return;
+
+        try
+        {
+            ToastNotificationManager.History.Remove(tag, ToastGroup, AppUserModelId);
+        }
+        catch (Exception ex)
+        {
+            Logger.Warn($"Could not remove Windows toast notification '{tag}'");
+            Logger.Warn(ex);
+        }
+    }
+
+    internal static string BuildToastXml(string title, string message, string launchArgument, bool untilDismissed = false)
     {
         string titleEsc = XmlEscape(title);
         string messageEsc = XmlEscape(message);
         string launchEsc = XmlEscape(launchArgument);
+        string scenario = untilDismissed ? "reminder" : "default";
+        string actions = untilDismissed
+            ? $"""<actions><action content="{XmlEscape(CoreTools.Translate("Open UniGetUI"))}" activationType="protocol" arguments="{launchEsc}"/><action content="" activationType="system" arguments="dismiss"/></actions>"""
+            : "";
 
         return $"""
-                <toast activationType="protocol" launch="{launchEsc}" scenario="default">
+                <toast activationType="protocol" launch="{launchEsc}" scenario="{scenario}">
                     <visual>
                         <binding template="ToastGeneric">
                             <text>{titleEsc}</text>
                             <text>{messageEsc}</text>
                         </binding>
                     </visual>
+                    {actions}
                     <audio silent="true"/>
                 </toast>
                 """;

src/UniGetUI.Avalonia/Infrastructure/WindowsAppNotificationBridge.cs

@@ -101,6 +101,26 @@ public static void RemoveProgress(AbstractOperation operation)
 
     // ── updates-available notification ───────────────────────────────────────
 
+    internal const string UpdatesToastTag = "updates-available";
+    internal const string SelfUpdateToastTag = "self-update-available";
+
+    internal static bool KeepsUntilDismissed(string? tag, bool persistentUpdateNotifications)
+        => persistentUpdateNotifications && tag is (UpdatesToastTag or SelfUpdateToastTag);
+
+    public static void RemoveUpdatesAvailableNotification()
+    {
+#if WINDOWS
+        Win32ToastNotifier.Remove(UpdatesToastTag);
+#endif
+    }
+
+    public static void RemoveSelfUpdateAvailableNotification()
+    {
+#if WINDOWS
+        Win32ToastNotifier.Remove(SelfUpdateToastTag);
+#endif
+    }
+
     /// <summary>
     /// Shows a Windows toast notification listing available package updates. No-op on
     /// non-Windows or when notifications are disabled (mirrors the previous bridge's
@@ -125,15 +145,17 @@ public static void ShowUpdatesAvailableNotification(IReadOnlyList<IPackage> upgr
                     CoreTools.Translate("{0} can be updated to version {1}",
                         upgradable[0].Name, upgradable[0].NewVersionString),
                     MainWindow.RuntimeNotificationLevel.Success,
-                    launchAction: NotificationArguments.ShowOnUpdatesTab);
+                    launchAction: NotificationArguments.ShowOnUpdatesTab,
+                    tag: UpdatesToastTag);
             }
             else
             {
                 Show(
                     CoreTools.Translate("Updates found!"),
                     CoreTools.Translate("{0} packages can be updated", upgradable.Count),
                     MainWindow.RuntimeNotificationLevel.Success,
-                    launchAction: NotificationArguments.ShowOnUpdatesTab);
+                    launchAction: NotificationArguments.ShowOnUpdatesTab,
+                    tag: UpdatesToastTag);
             }
         }
         catch (Exception ex)
@@ -200,7 +222,8 @@ public static void ShowSelfUpdateAvailableNotification(string newVersion)
                 CoreTools.Translate("{0} can be updated to version {1}", "UniGetUI", newVersion),
                 CoreTools.Translate("You have currently version {0} installed", CoreData.VersionName),
                 MainWindow.RuntimeNotificationLevel.Success,
-                launchAction: NotificationArguments.Show);
+                launchAction: NotificationArguments.Show,
+                tag: SelfUpdateToastTag);
         }
         catch (Exception ex)
         {
@@ -223,7 +246,8 @@ private static bool Show(
         string message,
         MainWindow.RuntimeNotificationLevel level,
         string launchAction,
-        bool allowInAppFallback = true)
+        bool allowInAppFallback = true,
+        string? tag = null)
     {
 #if WINDOWS
         // Only fire an OS toast when the app is out of sight (minimized or hidden to the tray).
@@ -232,7 +256,8 @@ private static bool Show(
         if (OperatingSystem.IsWindows() && !MainWindow.IsWindowOnScreen && Win32ToastNotifier.IsAvailable())
         {
             string launchArg = BuildLaunchArgument(launchAction);
-            if (Win32ToastNotifier.Show(title, message, launchArg))
+            bool untilDismissed = KeepsUntilDismissed(tag, Settings.Get(Settings.K.PersistentUpdateNotifications));
+            if (Win32ToastNotifier.Show(title, message, launchArg, tag, untilDismissed))
             {
                 // Show-only: the launch action fires only when the user clicks the toast, routed via
                 // the unigetui:// deep-link through the single-instance handler. Raising it on show

src/UniGetUI.Avalonia/ViewModels/Pages/SettingsPages/NotificationsViewModel.cs

@@ -8,7 +8,15 @@ namespace UniGetUI.Avalonia.ViewModels.Pages.SettingsPages;
 public partial class NotificationsViewModel : ViewModelBase
 {
     [ObservableProperty] private bool _isBackgroundModeEnabled;
-    [ObservableProperty] private bool _isNotificationsEnabled;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsPersistentUpdateNotificationsEnabled))]
+    private bool _isNotificationsEnabled;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsPersistentUpdateNotificationsEnabled))]
+    private bool _isUpdatesNotificationsEnabled;
+
+    public bool IsPersistentUpdateNotificationsEnabled => IsNotificationsEnabled && IsUpdatesNotificationsEnabled;
 
     /// <summary>True when closing the window quits UniGetUI, which turns notifications off.</summary>
     public bool IsSystemTrayWarningVisible => !IsBackgroundModeEnabled;
@@ -18,15 +26,24 @@ public partial class NotificationsViewModel : ViewModelBase
     public bool AreNotificationTypesSupported { get; } =
         OperatingSystem.IsWindows() || OperatingSystem.IsMacOS();
 
+    public bool IsPersistentNotificationsSupported { get; } = OperatingSystem.IsWindows();
+
     public NotificationsViewModel()
     {
         _isBackgroundModeEnabled = !CoreSettings.Get(CoreSettings.K.DisableSystemTray);
         _isNotificationsEnabled = !CoreSettings.Get(CoreSettings.K.DisableNotifications);
+        _isUpdatesNotificationsEnabled = !CoreSettings.Get(CoreSettings.K.DisableUpdatesNotifications);
     }
 
     [RelayCommand]
     private void UpdateNotificationsEnabled()
     {
         IsNotificationsEnabled = !CoreSettings.Get(CoreSettings.K.DisableNotifications);
     }
+
+    [RelayCommand]
+    private void UpdateUpdatesNotificationsEnabled()
+    {
+        IsUpdatesNotificationsEnabled = !CoreSettings.Get(CoreSettings.K.DisableUpdatesNotifications);
+    }
 }

src/UniGetUI.Avalonia/Views/Pages/SettingsPages/Notifications.axaml

@@ -55,6 +55,7 @@
                 <settings:CheckboxCard x:Name="NotificationTypesCard"
                                        SettingName="DisableUpdatesNotifications"
                                        Text="{t:Translate Show a notification when there are available updates}"
+                                       StateChangedCommand="{Binding UpdateUpdatesNotificationsEnabledCommand}"
                                        CornerRadius="8,8,0,0"
                                        IsEnabled="{Binding IsNotificationsEnabled}"/>
 
@@ -77,6 +78,14 @@
                                        BorderThickness="1,0,1,1"
                                        CornerRadius="0,0,8,8"
                                        IsEnabled="{Binding IsNotificationsEnabled}"/>
+
+                <settings:CheckboxCard x:Name="PersistentUpdateNotificationsCard"
+                                       SettingName="PersistentUpdateNotifications"
+                                       Text="{t:Translate Keep update notifications on screen until they are dismissed}"
+                                       Margin="0,8,0,0"
+                                       CornerRadius="8"
+                                       IsVisible="{Binding IsPersistentNotificationsSupported}"
+                                       IsEnabled="{Binding IsPersistentUpdateNotificationsEnabled}"/>
             </StackPanel>
 
         </StackPanel>

src/UniGetUI.Avalonia/Views/SoftwarePages/SoftwareUpdatesPage.cs

@@ -54,6 +54,14 @@ public SoftwareUpdatesPage() : base(new PackagesPageData
     })
     {
         ViewModel.PackagesLoaded += reason => { _ = WhenPackagesLoaded(); };
+        if (UpgradablePackagesLoader.Instance is { } upgradableLoader)
+        {
+            upgradableLoader.PackagesChanged += (_, e) =>
+            {
+                if (OperatingSystem.IsWindows() && e.RemovedPackages.Count > 0 && !upgradableLoader.IsLoading && !upgradableLoader.Any())
+                    WindowsAppNotificationBridge.RemoveUpdatesAvailableNotification();
+            };
+        }
     }
 
     protected override void GenerateToolBar(PackagesPageViewModel vm)
@@ -478,7 +486,13 @@ private static async Task WhenPackagesLoaded()
                 .Where(p => p.Tag is not PackageTag.OnQueue and not PackageTag.BeingProcessed)
                 .ToList();
 
-            if (upgradable.Count == 0) return;
+            if (upgradable.Count == 0)
+            {
+                if (OperatingSystem.IsWindows()
+                    && UpgradablePackagesLoader.Instance is { IsLoaded: true, LastLoadReportedFailures: false, AnyManagerReady: true })
+                    WindowsAppNotificationBridge.RemoveUpdatesAvailableNotification();
+                return;
+            }
 
             if (Settings.Get(Settings.K.DisableAUPOnBattery) && PowerConditions.IsOnBattery())
             {

src/UniGetUI.Core.Settings/SettingsEngine_Names.cs

@@ -98,6 +98,7 @@ public enum K
         DisableSuccessNotifications,
         DisableProgressNotifications,
         ShowOperationSummaryNotifications,
+        PersistentUpdateNotifications,
         KillProcessesThatRefuseToDie,
         ManagerPaths,
         GitHubUserLogin,
@@ -260,6 +261,7 @@ public static string ResolveKey(K key)
             K.DisableSuccessNotifications => "DisableSuccessNotifications",
             K.DisableProgressNotifications => "DisableProgressNotifications",
             K.ShowOperationSummaryNotifications => "ShowOperationSummaryNotifications",
+            K.PersistentUpdateNotifications => "PersistentUpdateNotifications",
             K.KillProcessesThatRefuseToDie => "KillProcessesThatRefuseToDie",
             K.ManagerPaths => "ManagerPaths",
             K.GitHubUserLogin => "GitHubUserLogin",

src/UniGetUI.Tests/Win32ToastNotifierTests.cs

@@ -0,0 +1,56 @@
+#if WINDOWS
+using System.Xml.Linq;
+using UniGetUI.Avalonia.Infrastructure;
+
+namespace UniGetUI.Tests;
+
+public sealed class Win32ToastNotifierTests
+{
+    [Fact]
+    public void DefaultToast_UsesTheDefaultScenarioWithoutActions()
+    {
+        XElement toast = XElement.Parse(Win32ToastNotifier.BuildToastXml("Updates found!", "3 packages", "unigetui://showOnUpdatesTab"));
+
+        Assert.Equal("default", (string?)toast.Attribute("scenario"));
+        Assert.Null(toast.Element("actions"));
+        Assert.Equal("true", (string?)toast.Element("audio")!.Attribute("silent"));
+    }
+
+    [Fact]
+    public void PersistentToast_UsesTheReminderScenarioWithAnOpenAndADismissButton()
+    {
+        XElement toast = XElement.Parse(Win32ToastNotifier.BuildToastXml(
+            "Updates & \"fixes\"",
+            "<3 packages>",
+            "unigetui://showOnUpdatesTab",
+            untilDismissed: true));
+
+        Assert.Equal("reminder", (string?)toast.Attribute("scenario"));
+        Assert.Equal("unigetui://showOnUpdatesTab", (string?)toast.Attribute("launch"));
+        Assert.Equal(["Updates & \"fixes\"", "<3 packages>"], toast.Descendants("text").Select(t => t.Value));
+
+        XElement[] actions = toast.Element("actions")!.Elements("action").ToArray();
+        Assert.Equal(2, actions.Length);
+
+        Assert.Equal("Open UniGetUI", (string?)actions[0].Attribute("content"));
+        Assert.Equal("protocol", (string?)actions[0].Attribute("activationType"));
+        Assert.Equal("unigetui://showOnUpdatesTab", (string?)actions[0].Attribute("arguments"));
+
+        Assert.Equal("system", (string?)actions[1].Attribute("activationType"));
+        Assert.Equal("dismiss", (string?)actions[1].Attribute("arguments"));
+        Assert.Equal("true", (string?)toast.Element("audio")!.Attribute("silent"));
+    }
+
+    [Theory]
+    [InlineData(WindowsAppNotificationBridge.UpdatesToastTag, true, true)]
+    [InlineData(WindowsAppNotificationBridge.SelfUpdateToastTag, true, true)]
+    [InlineData(WindowsAppNotificationBridge.UpdatesToastTag, false, false)]
+    [InlineData(WindowsAppNotificationBridge.SelfUpdateToastTag, false, false)]
+    [InlineData(null, true, false)]
+    [InlineData("some-other-tag", true, false)]
+    public void OnlyUpdateNoticesStayUntilDismissed_AndOnlyWhenEnabled(string? tag, bool settingEnabled, bool expected)
+    {
+        Assert.Equal(expected, WindowsAppNotificationBridge.KeepsUntilDismissed(tag, settingEnabled));
+    }
+}
+#endif