Add inactivity safeguard and speaker diagnostics

MeetingAssistant/Recording/WindowsMeetingInactivityPromptService.Windows.cs

@@ -0,0 +1,214 @@
+#if WINDOWS
+using System.Collections.Concurrent;
+using CommunityToolkit.WinUI.Notifications;
+
+namespace MeetingAssistant.Recording;
+
+public sealed class WindowsMeetingInactivityPromptService : IMeetingInactivityPromptService, IDisposable
+{
+    private const string NotificationSource = "meeting-inactivity-safeguard";
+    private const string NotificationGroup = "meeting-inactivity";
+    private readonly ConcurrentDictionary<string, PendingPrompt> pendingPrompts = new(StringComparer.OrdinalIgnoreCase);
+    private readonly ILogger<WindowsMeetingInactivityPromptService> logger;
+    private readonly object registrationGate = new();
+    private bool registered;
+
+    public WindowsMeetingInactivityPromptService(ILogger<WindowsMeetingInactivityPromptService> logger)
+    {
+        this.logger = logger;
+    }
+
+    public Task ShowStopPromptAsync(
+        MeetingInactivityPromptRequest request,
+        Func<MeetingInactivityPromptResponse, CancellationToken, Task> handleResponseAsync,
+        CancellationToken cancellationToken)
+    {
+        if (!OperatingSystem.IsWindowsVersionAtLeast(10, 0, 17763))
+        {
+            logger.LogWarning("Windows app notifications require Windows 10 version 1809 or later");
+            return Task.CompletedTask;
+        }
+
+        if (cancellationToken.IsCancellationRequested)
+        {
+            return Task.FromCanceled(cancellationToken);
+        }
+
+        try
+        {
+            EnsureRegistered();
+            var promptId = Guid.NewGuid().ToString("N");
+            pendingPrompts[promptId] = new PendingPrompt(handleResponseAsync);
+            var notification = BuildNotification(promptId, request);
+            notification.Show(toast =>
+            {
+                toast.Group = NotificationGroup;
+                toast.Tag = promptId;
+                toast.ExpirationTime = DateTimeOffset.Now.AddMinutes(15);
+            });
+            logger.LogInformation(
+                "Displayed native Windows inactivity notification {PromptId} at threshold {Threshold}",
+                promptId,
+                request.Threshold);
+        }
+        catch (Exception exception)
+        {
+            logger.LogError(exception, "Failed to display native Windows inactivity notification");
+        }
+
+        return Task.CompletedTask;
+    }
+
+    public void Dispose()
+    {
+        if (!registered)
+        {
+            return;
+        }
+
+        try
+        {
+            ToastNotificationManagerCompat.OnActivated -= OnNotificationInvoked;
+            ToastNotificationManagerCompat.Uninstall();
+        }
+        catch (Exception exception)
+        {
+            logger.LogWarning(exception, "Failed to unregister native Windows toast notifications");
+        }
+    }
+
+    private void EnsureRegistered()
+    {
+        if (registered)
+        {
+            return;
+        }
+
+        lock (registrationGate)
+        {
+            if (registered)
+            {
+                return;
+            }
+
+            ToastNotificationManagerCompat.OnActivated += OnNotificationInvoked;
+            registered = true;
+            logger.LogInformation("Registered native Windows toast notification activation handler");
+        }
+    }
+
+    private static ToastContentBuilder BuildNotification(
+        string promptId,
+        MeetingInactivityPromptRequest request)
+    {
+        var yesButton = new ToastButton()
+            .SetContent("Yes")
+            .AddArgument("source", NotificationSource)
+            .AddArgument("promptId", promptId)
+            .AddArgument("response", "stop")
+            .SetBackgroundActivation();
+
+        var noButton = new ToastButton()
+            .SetContent("No")
+            .AddArgument("source", NotificationSource)
+            .AddArgument("promptId", promptId)
+            .AddArgument("response", "continue")
+            .SetBackgroundActivation();
+
+        return new ToastContentBuilder()
+            .AddArgument("source", NotificationSource)
+            .AddArgument("promptId", promptId)
+            .AddText("Stop meeting?")
+            .AddText($"No transcript text has arrived for {FormatDuration(request.InactivityDuration)}.")
+            .AddButton(yesButton)
+            .AddButton(noButton);
+    }
+
+    private void OnNotificationInvoked(ToastNotificationActivatedEventArgsCompat args)
+    {
+        var arguments = ParseArguments(args.Argument);
+        if (!TryGetArgument(arguments, "source", out var source) ||
+            !string.Equals(source, NotificationSource, StringComparison.OrdinalIgnoreCase) ||
+            !TryGetArgument(arguments, "promptId", out var promptId) ||
+            !pendingPrompts.TryRemove(promptId, out var pendingPrompt))
+        {
+            return;
+        }
+
+        var response = TryGetArgument(arguments, "response", out var responseValue) &&
+            string.Equals(responseValue, "stop", StringComparison.OrdinalIgnoreCase)
+                ? MeetingInactivityPromptResponse.Stop
+                : MeetingInactivityPromptResponse.Continue;
+        _ = Task.Run(async () =>
+        {
+            try
+            {
+                logger.LogInformation(
+                    "Native Windows inactivity notification {PromptId} activated with response {Response}",
+                    promptId,
+                    response);
+                await pendingPrompt.HandleResponseAsync(response, CancellationToken.None);
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(
+                    exception,
+                    "Failed to handle native Windows inactivity notification response {Response}",
+                    response);
+            }
+        });
+    }
+
+    private static IReadOnlyDictionary<string, string> ParseArguments(string argumentText)
+    {
+        if (string.IsNullOrWhiteSpace(argumentText))
+        {
+            return new Dictionary<string, string>();
+        }
+
+        var arguments = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        foreach (var pair in argumentText.Split('&', StringSplitOptions.RemoveEmptyEntries))
+        {
+            var separatorIndex = pair.IndexOf('=');
+            if (separatorIndex < 0)
+            {
+                arguments[Uri.UnescapeDataString(pair)] = "";
+                continue;
+            }
+
+            var key = Uri.UnescapeDataString(pair[..separatorIndex]);
+            var value = Uri.UnescapeDataString(pair[(separatorIndex + 1)..]);
+            arguments[key] = value;
+        }
+
+        return arguments;
+    }
+
+    private static bool TryGetArgument(
+        IReadOnlyDictionary<string, string> arguments,
+        string key,
+        out string value)
+    {
+        if (arguments.TryGetValue(key, out value!))
+        {
+            return true;
+        }
+
+        value = "";
+        return false;
+    }
+
+    private static string FormatDuration(TimeSpan duration)
+    {
+        if (duration.TotalMinutes >= 1)
+        {
+            return $"{Math.Round(duration.TotalMinutes):0} minutes";
+        }
+
+        return $"{Math.Max(1, Math.Round(duration.TotalSeconds)):0} seconds";
+    }
+
+    private sealed record PendingPrompt(
+        Func<MeetingInactivityPromptResponse, CancellationToken, Task> HandleResponseAsync);
+}
+#endif