Reduce notification capture latency

Author: nakorndev

WindowsNotificationListener.cs

@@ -1,4 +1,5 @@
 using System.Runtime.InteropServices;
+using System.Threading;
 using System.Windows.Threading;
 using Windows.UI.Notifications;
 using Windows.UI.Notifications.Management;
@@ -7,12 +8,16 @@ namespace ToastDesk;
 
 public sealed class WindowsNotificationListener : IDisposable
 {
+    private static readonly TimeSpan EventBackupPollInterval = TimeSpan.FromSeconds(5);
+    private static readonly TimeSpan FastPollInterval = TimeSpan.FromMilliseconds(500);
     private readonly NotificationStore store;
     private readonly Dispatcher dispatcher;
     private readonly HashSet<uint> capturedNotificationIds = [];
     private readonly DispatcherTimer syncTimer;
     private UserNotificationListener? listener;
+    private int isCapturing;
     private bool isDisposed;
+    private bool isEventSubscriptionEnabled;
 
     public string LastStatusMessage { get; private set; } = "Not started.";
     public bool IsEnabled { get; private set; }
@@ -23,7 +28,7 @@ public WindowsNotificationListener(NotificationStore store, Dispatcher dispatche
         this.dispatcher = dispatcher;
         syncTimer = new DispatcherTimer(DispatcherPriority.Background, dispatcher)
         {
-            Interval = TimeSpan.FromSeconds(2)
+            Interval = FastPollInterval
         };
         syncTimer.Tick += async (_, _) => await CaptureCurrentNotificationsAsync();
     }
@@ -64,6 +69,7 @@ public async Task<WindowsNotificationListenerResult> StartAsync(bool forcePrompt
         }
 
         await SeedExistingNotificationsAsync();
+        ConfigureNotificationChangeMode();
         syncTimer.Start();
 
         if (isDisposed)
@@ -86,17 +92,72 @@ public void Dispose()
         isDisposed = true;
         syncTimer.Stop();
 
+        UnsubscribeNotificationChanged();
         listener = null;
     }
 
     public void Stop()
     {
         syncTimer.Stop();
+        UnsubscribeNotificationChanged();
         listener = null;
         IsEnabled = false;
         LastStatusMessage = "Windows notification capture is disabled.";
     }
 
+    private void ConfigureNotificationChangeMode()
+    {
+        UnsubscribeNotificationChanged();
+
+        if (listener is null)
+        {
+            syncTimer.Interval = FastPollInterval;
+            return;
+        }
+
+        try
+        {
+            listener.NotificationChanged += OnNotificationChanged;
+            isEventSubscriptionEnabled = true;
+            syncTimer.Interval = EventBackupPollInterval;
+        }
+        catch (COMException)
+        {
+            isEventSubscriptionEnabled = false;
+            syncTimer.Interval = FastPollInterval;
+        }
+    }
+
+    private void UnsubscribeNotificationChanged()
+    {
+        if (!isEventSubscriptionEnabled || listener is null)
+        {
+            isEventSubscriptionEnabled = false;
+            return;
+        }
+
+        try
+        {
+            listener.NotificationChanged -= OnNotificationChanged;
+        }
+        catch (COMException)
+        {
+            // Ignore unsubscribe failures during shutdown or fallback transitions.
+        }
+
+        isEventSubscriptionEnabled = false;
+    }
+
+    private async void OnNotificationChanged(UserNotificationListener sender, UserNotificationChangedEventArgs args)
+    {
+        if (args.ChangeKind != UserNotificationChangedKind.Added)
+        {
+            return;
+        }
+
+        await CaptureCurrentNotificationsAsync();
+    }
+
     private async Task SeedExistingNotificationsAsync()
     {
         if (isDisposed || listener is null)
@@ -113,38 +174,45 @@ private async Task SeedExistingNotificationsAsync()
 
     private async Task CaptureCurrentNotificationsAsync()
     {
-        if (isDisposed || listener is null)
+        if (isDisposed || listener is null || Interlocked.Exchange(ref isCapturing, 1) == 1)
         {
             return;
         }
 
-        var notifications = await GetCurrentNotificationsAsync();
-
-        foreach (var notification in notifications)
+        try
         {
-            if (isDisposed || dispatcher.HasShutdownStarted)
-            {
-                return;
-            }
+            var notifications = await GetCurrentNotificationsAsync();
 
-            if (!capturedNotificationIds.Add(notification.Id))
+            foreach (var notification in notifications)
             {
-                continue;
-            }
+                if (isDisposed || dispatcher.HasShutdownStarted)
+                {
+                    return;
+                }
 
-            var details = ExtractDetails(notification);
-            _ = dispatcher.InvokeAsync(() =>
-            {
-                if (!isDisposed)
+                if (!capturedNotificationIds.Add(notification.Id))
                 {
-                    store.Add(
-                        details.Title,
-                        details.Message,
-                        NotificationOrigin.Windows,
-                        details.SourceAppName,
-                        details.SourceAppUserModelId);
+                    continue;
                 }
-            });
+
+                var details = ExtractDetails(notification);
+                _ = dispatcher.InvokeAsync(() =>
+                {
+                    if (!isDisposed)
+                    {
+                        store.Add(
+                            details.Title,
+                            details.Message,
+                            NotificationOrigin.Windows,
+                            details.SourceAppName,
+                            details.SourceAppUserModelId);
+                    }
+                });
+            }
+        }
+        finally
+        {
+            Interlocked.Exchange(ref isCapturing, 0);
         }
     }
 
@@ -196,6 +264,13 @@ private WindowsNotificationListenerResult SetStatus(bool isEnabled, string messa
     {
         IsEnabled = isEnabled;
         LastStatusMessage = message;
-        return new WindowsNotificationListenerResult(isEnabled, message);
+        if (isEnabled && !string.IsNullOrWhiteSpace(message))
+        {
+            LastStatusMessage = isEventSubscriptionEnabled
+                ? $"{message} Using Windows change events with polling backup."
+                : $"{message} Using fast polling because Windows change events are unavailable.";
+        }
+
+        return new WindowsNotificationListenerResult(isEnabled, LastStatusMessage);
     }
 }

docs/production-readiness.md

@@ -12,6 +12,7 @@
 - Improve lifecycle behavior: startup, minimized tray launch, graceful exit, duplicate process handling, and clean shutdown while capture is active.
 - Improve notification behavior: capture filtering, deduplication, do-not-disturb behavior, overlay queue limits, and action handling.
 - Toast cards now use explicit `Open` and `Dismiss` actions. `Open` attempts to launch the source app by AppUserModelID when Windows exposes one, with ToastDesk as fallback.
+- Notification capture prefers Windows change events when available. If WinRT event subscription fails in the unpackaged desktop app, ToastDesk falls back to guarded 500ms polling to keep latency low without overlapping capture calls.
 - Improve settings: durable migration, clear defaults, restore defaults, notification sound presets/custom audio, and direct links to Windows notification permissions.
 - Prepare packaging: self-contained `.exe`, installer path, icon, versioning, and uninstall cleanup.
 - Add diagnostics: local logs for notification permission, shortcut registration, startup registration, and capture polling failures.