Use atomic init for Dependency Injection on all entry points

Author: justcoding121

src/Bible.Alarm/Common/DI.cs

@@ -0,0 +1,33 @@
+#nullable enable
+
+namespace Bible.Alarm.Common;
+
+/// <summary>
+/// Convenience helper for accessing services from the global DI container.
+/// Uses MauiAppHolder internally for thread-safe access.
+/// </summary>
+public static class DI
+{
+    /// <summary>
+    /// Gets a service from the global service provider.
+    /// </summary>
+    /// <typeparam name="T">The type of service to get</typeparam>
+    /// <returns>The service instance</returns>
+    /// <exception cref="InvalidOperationException">Thrown if MauiApp has not been initialized</exception>
+    public static T Get<T>() where T : notnull
+    {
+        return MauiAppHolder.Services.GetRequiredService<T>();
+    }
+
+    /// <summary>
+    /// Safely gets a service from the global service provider, returns null if not initialized.
+    /// </summary>
+    /// <typeparam name="T">The type of service to get</typeparam>
+    /// <returns>The service instance or null if MauiApp has not been initialized</returns>
+    public static T? GetSafe<T>() where T : class
+    {
+        if (!MauiAppHolder.IsInitialized) return null;
+        return MauiAppHolder.Services.GetRequiredService<T>();
+    }
+}
+

src/Bible.Alarm/Common/MauiAppHolder.cs

@@ -0,0 +1,60 @@
+#nullable enable
+
+namespace Bible.Alarm.Common;
+
+/// <summary>
+/// Thread-safe holder for the single MauiApp instance.
+/// Ensures CreateMauiApp() is called exactly once, regardless of entry point.
+/// This is the official Microsoft-recommended pattern for .NET MAUI 9+ apps with multiple entry points.
+/// </summary>
+public static class MauiAppHolder
+{
+    private static readonly object Lock = new();
+    private static MauiApp? _app;
+
+    /// <summary>
+    /// Gets the MauiApp instance. Throws if not created yet.
+    /// </summary>
+    public static MauiApp App
+    {
+        get
+        {
+            if (_app == null)
+                throw new InvalidOperationException(
+                    "MauiApp has not been created. Call CreateAndStore() first from an entry point.");
+            return _app;
+        }
+    }
+
+    /// <summary>
+    /// Gets the IServiceProvider from the MauiApp. Throws if not created yet.
+    /// </summary>
+    public static IServiceProvider Services => App.Services;
+
+    /// <summary>
+    /// Creates and stores the MauiApp instance exactly once.
+    /// Thread-safe and can be called from any entry point (MainApplication, AppDelegate, background service, etc.)
+    /// </summary>
+    /// <returns>The MauiApp instance (existing if already created, or newly created)</returns>
+    public static MauiApp CreateAndStore()
+    {
+        lock (Lock)
+        {
+            if (_app != null)
+            {
+                // Already created → return existing
+                return _app;
+            }
+
+            // Create new MauiApp instance
+            _app = MauiProgram.CreateMauiApp();
+            return _app;
+        }
+    }
+
+    /// <summary>
+    /// Checks if the MauiApp has been created.
+    /// </summary>
+    public static bool IsInitialized => _app != null;
+}
+

src/Bible.Alarm/Common/ServiceProviderManager.cs

@@ -5,75 +5,68 @@ namespace Bible.Alarm.Common;
 /// <summary>
 /// Manages the global service provider for the application.
 /// This allows access to services from multiple entry points (direct launch, background service, alarm trigger, etc.)
+/// 
+/// NOTE: This class now uses MauiAppHolder internally for thread-safe, single-instance MauiApp creation.
+/// For new code, prefer using MauiAppHolder directly.
 /// </summary>
 public static class ServiceProviderManager
 {
-    private static IServiceProvider? serviceProvider;
-    private static readonly object Lock = new();
-
     /// <summary>
     /// Gets the global service provider. Throws if not initialized.
+    /// Now uses MauiAppHolder internally.
     /// </summary>
-    public static IServiceProvider ServiceProvider
-    {
-        get
-        {
-            if (serviceProvider == null)
-                throw new InvalidOperationException(
-                    "Service provider has not been initialized. Call Initialize() first.");
-            return serviceProvider;
-        }
-    }
+    public static IServiceProvider ServiceProvider => MauiAppHolder.Services;
 
     /// <summary>
     /// Initializes the global service provider. Can only be called once.
+    /// NOTE: This is now a no-op as MauiAppHolder handles initialization.
+    /// Kept for backward compatibility.
     /// </summary>
     /// <param name="serviceProvider">The service provider to use globally</param>
+    [Obsolete("ServiceProviderManager now uses MauiAppHolder. Call MauiAppHolder.CreateAndStore() instead.")]
     public static void Initialize(IServiceProvider serviceProvider)
     {
-        if (serviceProvider == null) throw new ArgumentNullException(nameof(serviceProvider));
-
-        lock (Lock)
-        {
-            if (ServiceProviderManager.serviceProvider != null)
-                throw new InvalidOperationException("Service provider has already been initialized.");
-            ServiceProviderManager.serviceProvider = serviceProvider;
-        }
+        // No-op - MauiAppHolder handles initialization
+        // This method is kept for backward compatibility
     }
 
     /// <summary>
     /// Gets a service from the global service provider.
+    /// Now uses MauiAppHolder internally.
     /// </summary>
     /// <typeparam name="T">The type of service to get</typeparam>
     /// <returns>The service instance</returns>
     public static T GetService<T>() where T : notnull
     {
-        return ServiceProvider.GetRequiredService<T>();
+        return MauiAppHolder.Services.GetRequiredService<T>();
     }
 
     /// <summary>
     /// Safely gets a service from the global service provider, returns null if not initialized.
+    /// Now uses MauiAppHolder internally.
     /// </summary>
     /// <typeparam name="T">The type of service to get</typeparam>
     /// <returns>The service instance or null if not initialized</returns>
     public static T? GetServiceSafe<T>() where T : class
     {
-        if (!IsInitialized) return null;
-        return ServiceProvider.GetRequiredService<T>();
+        if (!MauiAppHolder.IsInitialized) return null;
+        return MauiAppHolder.Services.GetRequiredService<T>();
     }
 
     /// <summary>
     /// Gets a service from the global service provider.
+    /// Now uses MauiAppHolder internally.
     /// </summary>
     /// <param name="serviceType">The type of service to get</param>
     /// <returns>The service instance</returns>
     public static object GetService(Type serviceType)
     {
-        return ServiceProvider.GetRequiredService(serviceType);
+        return MauiAppHolder.Services.GetRequiredService(serviceType);
     }
 
     /// <summary>
     /// Checks if the service provider has been initialized.
+    /// Now uses MauiAppHolder internally.
     /// </summary>
-    public static bool IsInitialized => serviceProvider != null;
+    public static bool IsInitialized => MauiAppHolder.IsInitialized;
 }

src/Bible.Alarm/MauiProgram.cs

@@ -88,9 +88,6 @@ public static MauiApp CreateMauiApp()
         var store = app.Services.GetRequiredService<Fluxor.IStore>();
         ReduxContainer.Store = store;
 
-        // Initialize the global service provider for access from multiple entry points
-        ServiceProviderManager.Initialize(app.Services);
-
         // Create HomeViewModel early to ensure it subscribes before Init message is published
         _ = app.Services.GetRequiredService<HomeViewModel>();
 
@@ -103,20 +100,13 @@ public static MauiApp CreateMauiApp()
     /// <summary>
     /// Ensures the DI container is initialized for background services.
     /// This method is safe to call multiple times and will only initialize once.
+    /// Now uses MauiAppHolder for thread-safe, single-instance creation.
     /// </summary>
     public static void EnsureDiContainerInitialized()
     {
-        if (!ServiceProviderManager.IsInitialized)
-        {
-            System.Diagnostics.Debug.WriteLine("Initializing DI container for background service...");
-            
-            // Create a minimal MauiApp instance to initialize the DI container
-            CreateMauiApp();
-            
-            // The app instance is not used, but the DI container is now initialized
-            // ServiceProviderManager.Initialize() was called in CreateMauiApp()
-            System.Diagnostics.Debug.WriteLine("DI container initialized for background service.");
-        }
+        // MauiAppHolder.CreateAndStore() ensures exactly one MauiApp instance
+        // regardless of which entry point calls it first
+        _ = MauiAppHolder.CreateAndStore();
     }
 
     private static void RegisterServices(IServiceCollection services)

src/Bible.Alarm/Platforms/Android/MainActivity.cs

@@ -83,6 +83,10 @@ private void HandleIncomingIntent()
             {
                 try
                 {
+                    // Ensure MauiApp is created exactly once (thread-safe)
+                    // This handles incoming intents (e.g., from notifications)
+                    MauiAppHolder.CreateAndStore();
+                    
                     _alarmHandler ??= ServiceProviderManager.GetService<IAndroidAlarmHandler>();
                     await _alarmHandler.Handle(scheduleId, true);
                 }

src/Bible.Alarm/Platforms/Android/MainApplication.cs

@@ -1,11 +1,20 @@
 using Android.App;
 using Android.Runtime;
+using Bible.Alarm.Common;
 
 namespace Bible.Alarm.Platforms.Android
 {
     [Application]
     public class MainApplication(nint handle, JniHandleOwnership ownership) : MauiApplication(handle, ownership)
     {
-        protected override MauiApp CreateMauiApp() => MauiProgram.CreateMauiApp();
+        public override void OnCreate()
+        {
+            base.OnCreate();
+            
+            // Ensure MauiApp is created exactly once (thread-safe)
+            MauiAppHolder.CreateAndStore();
+        }
+
+        protected override MauiApp CreateMauiApp() => MauiAppHolder.CreateAndStore();
     }
 }

src/Bible.Alarm/Platforms/Android/Services/AndroidServices/AlarmSetupService.cs

@@ -53,8 +53,9 @@ public override void OnCreate()
     public override StartCommandResult OnStartCommand(Intent intent, [GeneratedEnum] StartCommandFlags flags,
         int startId)
     {
-        // DI container initialization is handled by MauiProgram.EnsureDiContainerInitialized()
-        // when services are accessed through ServiceProviderManager
+        // Ensure MauiApp is created exactly once (thread-safe)
+        // This is a background service entry point
+        MauiAppHolder.CreateAndStore();
 
         try
         {
@@ -72,8 +73,6 @@ public override StartCommandResult OnStartCommand(Intent intent, [GeneratedEnum]
                     break;
                 }
                 case "SetupBackgroundTasks":
-                    // DI container initialization is handled by MauiProgram.EnsureDiContainerInitialized()
-                    // when services are accessed through ServiceProviderManager
                     Task.Run(async () =>
                     {
                         try