Fix windows scheduler & notificaiton services

justcoding121 · justcoding121 · commit 1a8567979d86 · 2025-11-22T20:15:33.000-06:00
diff --git a/src/Bible.Alarm/App.xaml.cs b/src/Bible.Alarm/App.xaml.cs
@@ -86,6 +86,13 @@ protected override void OnStart()
 
                 var mediaIndexService = _serviceProvider.GetRequiredService<MediaIndexService>();
                 await mediaIndexService.UpdateIndexIfAvailable();
+
+#if WINDOWS
+                // Reschedule any enabled alarms that may have fired while app was closed
+                // This is a fallback for WinUI 3 which doesn't have background tasks
+                var schedulerService = _serviceProvider.GetRequiredService<Services.Scheduler.Interfaces.ISchedulerService>();
+                await schedulerService.HandleAsync();
+#endif
             }
             catch (Exception e)
             {
@@ -119,6 +126,13 @@ protected override void OnResume()
 
                 var mediaIndexService = _serviceProvider.GetRequiredService<MediaIndexService>();
                 await mediaIndexService.UpdateIndexIfAvailable();
+
+#if WINDOWS
+                // Reschedule any enabled alarms that may have fired while app was in background
+                // This is a fallback for WinUI 3 which doesn't have background tasks
+                var schedulerService = _serviceProvider.GetRequiredService<Services.Scheduler.Interfaces.ISchedulerService>();
+                await schedulerService.HandleAsync();
+#endif
             }
             catch (Exception e)
             {
diff --git a/src/Bible.Alarm/Platforms/Windows/App.xaml.cs b/src/Bible.Alarm/Platforms/Windows/App.xaml.cs
@@ -106,6 +106,11 @@ private static void HandleActivation(string arguments)
 
                             var alarmHandler = MauiAppHolder.Services.GetRequiredService<WindowsAlarmHandler>();
                             await alarmHandler.HandleAsync(scheduleId, true);
+
+                            // Reschedule the next occurrence for recurring alarms
+                            // WinUI 3 doesn't have background tasks, so we reschedule immediately when notification fires
+                            var schedulerService = MauiAppHolder.Services.GetRequiredService<Bible.Alarm.Services.Scheduler.Interfaces.ISchedulerService>();
+                            await schedulerService.RescheduleNextOccurrenceAsync(scheduleId);
                         }
                         catch (Exception e)
                         {
diff --git a/src/Bible.Alarm/Platforms/Windows/Services/UI/WindowsNotificationService.cs b/src/Bible.Alarm/Platforms/Windows/Services/UI/WindowsNotificationService.cs
@@ -1,8 +1,13 @@
+#nullable enable
+
 using Bible.Alarm.Common.Interfaces.UI;
 using Bible.Alarm.Models.Schedule;
 using Bible.Alarm.Platforms.Windows.Helpers;
 using Bible.Alarm.Platforms.Windows.Services.Handlers;
-// Removed UWP toast notification APIs - using WinUI 3 alternatives
+using System.Linq;
+using Windows.ApplicationModel;
+using Windows.Data.Xml.Dom;
+using Windows.UI.Notifications;
 
 namespace Bible.Alarm.Platforms.Windows.Services.UI
 {
@@ -18,37 +23,235 @@ public async Task ShowNotificationAsync(int scheduleId)
         public Task ScheduleNotificationAsync(AlarmSchedule schedule,
             string title, string body)
         {
-            // For WinUI 3 desktop apps, we can't use UWP toast notifications
-            // This functionality would need to be implemented using alternative approaches
-            // such as Windows Task Scheduler, Windows Notifications API, or a custom solution
-            // For now, we'll return a completed task without scheduling
-            // TODO: Implement proper notification scheduling for WinUI 3 desktop apps
+            try
+            {
+                var scheduleId = schedule.Id;
+                var time = schedule.NextFireDate();
+
+                if (time <= DateTimeOffset.Now)
+                {
+                    Serilog.Log.Warning("Cannot schedule notification for schedule {ScheduleId}: time {Time} is in the past", scheduleId, time);
+                    return Task.CompletedTask;
+                }
+
+                Serilog.Log.Information("Scheduling notification for schedule {ScheduleId} at {Time}", scheduleId, time);
+
+                var notifier = GetToastNotifier();
+                if (notifier == null)
+                {
+                    Serilog.Log.Error("Failed to create toast notifier for schedule {ScheduleId}. App may not be properly registered for notifications.", scheduleId);
+                    return Task.CompletedTask;
+                }
+
+                var toast = CreateScheduledToast(scheduleId, title, body, time);
+                notifier.AddToSchedule(toast);
+                
+                if (IsNotificationScheduled(notifier, scheduleId))
+                {
+                    Serilog.Log.Information("Successfully scheduled notification for schedule {ScheduleId} at {Time}", scheduleId, time);
+                }
+                else
+                {
+                    Serilog.Log.Warning("Notification may not have been scheduled for schedule {ScheduleId}. Check Windows notification settings.", scheduleId);
+                }
+            }
+            catch (Exception ex)
+            {
+                Serilog.Log.Error(ex, "Error scheduling notification for schedule {ScheduleId}", schedule.Id);
+            }
+
             return Task.CompletedTask;
         }
 
         public Task RemoveAsync(int scheduleId)
         {
-            // For WinUI 3 desktop apps, we can't use UWP toast notifications
-            // This functionality would need to be implemented using alternative approaches
-            // For now, we'll return a completed task without removing
-            // TODO: Implement proper notification removal for WinUI 3 desktop apps
+            try
+            {
+                var notifier = GetToastNotifier();
+                if (notifier == null) return Task.CompletedTask;
+                
+                var toRemove = FindScheduledToast(notifier, scheduleId);
+                if (toRemove != null)
+                {
+                    notifier.RemoveFromSchedule(toRemove);
+                }
+            }
+            catch (Exception ex)
+            {
+                Serilog.Log.Error(ex, "Error removing notification for schedule {ScheduleId}", scheduleId);
+            }
+
             return Task.CompletedTask;
         }
 
         public Task<bool> IsScheduledAsync(int scheduleId)
         {
-            // For WinUI 3 desktop apps, we can't use UWP toast notifications
-            // This functionality would need to be implemented using alternative approaches
-            // For now, we'll return false
-            // TODO: Implement proper notification checking for WinUI 3 desktop apps
-            return Task.FromResult(false);
+            try
+            {
+                var notifier = GetToastNotifier();
+                if (notifier == null) return Task.FromResult(false);
+                
+                return Task.FromResult(IsNotificationScheduled(notifier, scheduleId));
+            }
+            catch (Exception ex)
+            {
+                Serilog.Log.Error(ex, "Error checking if notification is scheduled for schedule {ScheduleId}", scheduleId);
+                return Task.FromResult(false);
+            }
         }
 
         public Task<bool> CanScheduleAsync()
         {
             return Task.FromResult(WindowsBootstrapHelper.IsBackgroundTaskEnabled);
         }
 
+        private static ScheduledToastNotification CreateScheduledToast(int scheduleId, string title, string body, DateTimeOffset time)
+        {
+            var toastXml = CreateToastXml(title, body, scheduleId);
+            return new ScheduledToastNotification(toastXml, time)
+            {
+                Id = scheduleId.ToString()
+            };
+        }
+
+        private static XmlDocument CreateToastXml(string title, string body, int scheduleId)
+        {
+            var toastXml = ToastNotificationManager.GetTemplateContent(ToastTemplateType.ToastText02);
+            
+            var textElements = toastXml.GetElementsByTagName("text");
+            if (textElements.Length > 0)
+            {
+                textElements[0].AppendChild(toastXml.CreateTextNode(title));
+            }
+
+            if (textElements.Length > 1)
+            {
+                textElements[1].AppendChild(toastXml.CreateTextNode(body));
+            }
+
+            var toastNode = toastXml.SelectSingleNode("/toast");
+            if (toastNode?.Attributes != null)
+            {
+                var launchAttribute = toastXml.CreateAttribute("launch");
+                launchAttribute.Value = scheduleId.ToString();
+                toastNode.Attributes.SetNamedItem(launchAttribute);
+            }
+
+            var audioNode = toastXml.CreateElement("audio");
+            audioNode.SetAttribute("src", "ms-winsoundevent:Notification.Default");
+            toastNode?.AppendChild(audioNode);
+
+            return toastXml;
+        }
+
+        private static bool IsNotificationScheduled(ToastNotifier notifier, int scheduleId)
+        {
+            var scheduledToasts = notifier.GetScheduledToastNotifications();
+            return scheduledToasts.Any(t => t.Id == scheduleId.ToString());
+        }
+
+        private static ScheduledToastNotification? FindScheduledToast(ToastNotifier notifier, int scheduleId)
+        {
+            var scheduledToasts = notifier.GetScheduledToastNotifications();
+            return scheduledToasts.FirstOrDefault(t => t.Id == scheduleId.ToString());
+        }
+
+        private static ToastNotifier? GetToastNotifier()
+        {
+            var notifier = TryCreateNotifierWithoutParameters();
+            if (notifier != null) return notifier;
+
+            notifier = TryCreateNotifierWithAumid();
+            if (notifier != null) return notifier;
+
+            Serilog.Log.Error(
+                "Unable to create toast notifier. Scheduled notifications will not work. " +
+                "This is common in debug mode. Try running the app from an installed package instead of Visual Studio.");
+            
+            return null;
+        }
+
+        private static ToastNotifier? TryCreateNotifierWithoutParameters()
+        {
+            try
+            {
+                Serilog.Log.Debug("Attempting to create toast notifier without parameters...");
+                var notifier = ToastNotificationManager.CreateToastNotifier();
+                if (notifier != null)
+                {
+                    Serilog.Log.Debug("Successfully created toast notifier without parameters");
+                    return notifier;
+                }
+                Serilog.Log.Warning("ToastNotificationManager.CreateToastNotifier() returned null");
+            }
+            catch (System.Runtime.InteropServices.COMException ex) when (ex.HResult == unchecked((int)0x80070490))
+            {
+                Serilog.Log.Warning("Failed to create toast notifier without parameters (0x80070490). Trying with AUMID...");
+            }
+            catch (Exception ex)
+            {
+                Serilog.Log.Warning(ex, "Exception creating toast notifier without parameters. HResult: 0x{HR:X8}", ex.HResult);
+            }
+            return null;
+        }
+
+        private static ToastNotifier? TryCreateNotifierWithAumid()
+        {
+            try
+            {
+                var package = Package.Current;
+                var packageId = package.Id;
+                
+                var aumidFormats = new[]
+                {
+                    $"{packageId.FamilyName}!App",
+                    packageId.FamilyName,
+                    packageId.Name,
+                };
+
+                foreach (var aumid in aumidFormats)
+                {
+                    var notifier = TryCreateNotifierWithAumid(aumid);
+                    if (notifier != null) return notifier;
+                }
+
+                Serilog.Log.Warning(
+                    "Failed to create toast notifier with any AUMID format. " +
+                    "Package: {PackageName}, FamilyName: {FamilyName}, Publisher: {Publisher}",
+                    packageId.Name, packageId.FamilyName, packageId.Publisher);
+            }
+            catch (InvalidOperationException)
+            {
+                Serilog.Log.Warning(
+                    "Package.Current is not available. This is expected in debug mode or unpackaged WinUI 3 apps. " +
+                    "Scheduled notifications require the app to be properly packaged and installed.");
+            }
+            catch (Exception ex)
+            {
+                Serilog.Log.Error(ex, "Exception while trying to create toast notifier with AUMID");
+            }
+            return null;
+        }
+
+        private static ToastNotifier? TryCreateNotifierWithAumid(string aumid)
+        {
+            try
+            {
+                Serilog.Log.Debug("Trying to create toast notifier with AUMID: {AUMID}", aumid);
+                var notifier = ToastNotificationManager.CreateToastNotifier(aumid);
+                if (notifier != null)
+                {
+                    Serilog.Log.Information("Successfully created toast notifier with AUMID: {AUMID}", aumid);
+                    return notifier;
+                }
+            }
+            catch (Exception ex)
+            {
+                Serilog.Log.Debug(ex, "Failed to create toast notifier with AUMID '{AUMID}'. HResult: 0x{HR:X8}", aumid, ex.HResult);
+            }
+            return null;
+        }
+
         public void Dispose()
         {
         }
diff --git a/src/Bible.Alarm/Platforms/Windows/Services/UI/WindowsToastService.cs b/src/Bible.Alarm/Platforms/Windows/Services/UI/WindowsToastService.cs
@@ -1,4 +1,6 @@
-﻿using System.Linq;
+﻿#nullable enable
+
+using System.Linq;
 using Bible.Alarm.Services.UI;
 using Microsoft.Maui.ApplicationModel;
 using Microsoft.Maui.Controls;
@@ -15,7 +17,7 @@ public class WindowsToastService : ToastService
     {
         private static readonly SemaphoreSlim Lock = new SemaphoreSlim(1);
 
-        private static TaskCompletionSource<bool> clearRequest;
+        private static TaskCompletionSource<bool>? clearRequest;
         private readonly TaskScheduler _taskScheduler;
 
         public WindowsToastService(TaskScheduler taskScheduler)
@@ -161,7 +163,14 @@ private static async Task ShowFlyoutAsync(Flyout flyout, FrameworkElement target
             flyout.OverlayInputPassThroughElement = targetElement;
             flyout.ShowAt(targetElement);
 
-            await Task.WhenAny(clearRequest.Task, Task.Delay((int)(seconds * 1000))).ConfigureAwait(true);
+            if (clearRequest != null)
+            {
+                await Task.WhenAny(clearRequest.Task, Task.Delay((int)(seconds * 1000))).ConfigureAwait(true);
+            }
+            else
+            {
+                await Task.Delay((int)(seconds * 1000));
+            }
             flyout.Hide();
         }
 
diff --git a/src/Bible.Alarm/Services/Scheduler/Interfaces/ISchedulerService.cs b/src/Bible.Alarm/Services/Scheduler/Interfaces/ISchedulerService.cs
@@ -4,4 +4,5 @@ public interface ISchedulerService
 {
     Task ProcessScheduledTasksAsync();
     Task<bool> HandleAsync();
+    Task RescheduleNextOccurrenceAsync(int scheduleId);
 }
diff --git a/src/Bible.Alarm/Services/Scheduler/SchedulerService.cs b/src/Bible.Alarm/Services/Scheduler/SchedulerService.cs
@@ -76,6 +76,43 @@ public async Task<bool> HandleAsync()
         return downloaded;
     }
 
+    /// <summary>
+    /// Reschedules the next occurrence of a recurring alarm.
+    /// This is necessary for WinUI 3 which doesn't support UWP background tasks.
+    /// </summary>
+    public async Task RescheduleNextOccurrenceAsync(int scheduleId)
+    {
+        try
+        {
+            using var scope = _scopeFactory.CreateScope();
+            var scheduleDbContext = scope.ServiceProvider.GetRequiredService<ScheduleDbContext>();
+            var alarmService = scope.ServiceProvider.GetRequiredService<IAlarmService>();
+            var notificationService = scope.ServiceProvider.GetRequiredService<INotificationService>();
+
+            // Load the schedule with all includes
+            var schedule = await scheduleDbContext.AlarmSchedules
+                .Include(x => x.BibleReadingSchedule)
+                .Include(x => x.Music)
+                .FirstOrDefaultAsync(x => x.Id == scheduleId);
+
+            if (schedule != null && schedule.IsEnabled)
+            {
+                // Check if notification is already scheduled (shouldn't be, but check anyway)
+                var isScheduled = await notificationService.IsScheduledAsync(scheduleId);
+                if (!isScheduled)
+                {
+                    // Reschedule the next occurrence
+                    await alarmService.Create(schedule);
+                    _logger.Information("Rescheduled next occurrence for schedule {ScheduleId}", scheduleId);
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.Error(ex, "Error rescheduling next occurrence for schedule {ScheduleId}", scheduleId);
+        }
+    }
+
     public void Dispose()
     {
         // Note: DbContext is now created via IServiceScopeFactory and disposed by the scope

Original file line number	Diff line number	Diff line change
`@@ -106,6 +106,11 @@ private static void HandleActivation(string arguments)`
`106`	`106`
`107`	`107`	`var alarmHandler = MauiAppHolder.Services.GetRequiredService<WindowsAlarmHandler>();`
`108`	`108`	`await alarmHandler.HandleAsync(scheduleId, true);`
	`109`	`+`
	`110`	`+ // Reschedule the next occurrence for recurring alarms`
	`111`	`+ // WinUI 3 doesn't have background tasks, so we reschedule immediately when notification fires`
	`112`	`+ var schedulerService = MauiAppHolder.Services.GetRequiredService<Bible.Alarm.Services.Scheduler.Interfaces.ISchedulerService>();`
	`113`	`+ await schedulerService.RescheduleNextOccurrenceAsync(scheduleId);`
`109`	`114`	`}`
`110`	`115`	`catch (Exception e)`
`111`	`116`	`{`
Original file line number	Diff line number	Diff line change
`@@ -4,4 +4,5 @@ public interface ISchedulerService`
`4`	`4`	`{`
`5`	`5`	`Task ProcessScheduledTasksAsync();`
`6`	`6`	`Task<bool> HandleAsync();`
	`7`	`+ Task RescheduleNextOccurrenceAsync(int scheduleId);`
`7`	`8`	`}`