refactor(app): implement stable startup with full-screen status pages

- Introduce a new stable startup architecture using BlocBuilder
- Add full-screen status pages for maintenance, update required, and config fetching states
- Move main app UI build to a more stable point in the app lifecycle
- Simplify theme and localization setup in MaterialApp
- Update StatusPage to use new localization approach

Author: fulleni

lib/app/view/app.dart

@@ -9,7 +9,7 @@ import 'package:flutter_news_app_mobile_client_full_source_code/app/config/app_e
 import 'package:flutter_news_app_mobile_client_full_source_code/app/services/app_status_service.dart';
 import 'package:flutter_news_app_mobile_client_full_source_code/app/services/demo_data_migration_service.dart';
 import 'package:flutter_news_app_mobile_client_full_source_code/authentication/bloc/authentication_bloc.dart';
-import 'package:flutter_news_app_mobile_client_full_source_code/l10n/app_localizations.dart';
+import 'package:flutter_news_app_mobile_client_full_source_code/l10n/l10n.dart';
 import 'package:flutter_news_app_mobile_client_full_source_code/router/router.dart';
 import 'package:flutter_news_app_mobile_client_full_source_code/status/view/view.dart';
 import 'package:go_router/go_router.dart';
@@ -191,132 +191,68 @@ class _AppViewState extends State<_AppView> {
       listener: (context, state) {
         _statusNotifier.value = state.status;
       },
+      // The BlocBuilder is the core of the new stable startup architecture.
+      // It acts as a high-level switch that determines which UI to show based
+      // on the application's status.
       child: BlocBuilder<AppBloc, AppState>(
-        // Rebuild the UI based on AppBloc's state (theme, locale, and critical app statuses)
         builder: (context, state) {
-          // Defer l10n access until inside a MaterialApp context
+          // --- Full-Screen Status Pages ---
+          // The following states represent critical, app-wide conditions that
+          // must be handled before the main router and UI are displayed.
+          // By returning a dedicated widget here, we ensure these pages are
+          // full-screen and exist outside the main app's navigation shell.
 
-          // Handle critical RemoteConfig loading states globally
-          // These checks have the highest priority and will lock the entire UI.
-          //
-          // Check for Maintenance Mode.
           if (state.status == AppStatus.underMaintenance) {
-            return const MaterialApp(
+            // The app is in maintenance mode. Show the MaintenancePage.
+            // It's wrapped in a basic MaterialApp to provide theme and l10n.
+            return MaterialApp(
               debugShowCheckedModeBanner: false,
-              home: MaintenancePage(),
+              theme: lightTheme(),
+              darkTheme: darkTheme(),
+              themeMode: state.themeMode,
+              localizationsDelegates: AppLocalizations.localizationsDelegates,
+              supportedLocales: AppLocalizations.supportedLocales,
+              home: const MaintenancePage(),
             );
           }
 
-          // Check for a Required Update.
           if (state.status == AppStatus.updateRequired) {
-            return const MaterialApp(
-              debugShowCheckedModeBanner: false,
-              home: UpdateRequiredPage(),
-            );
-          }
-
-          // Check for Config Fetching state.
-          if (state.status == AppStatus.configFetching) {
+            // A mandatory update is required. Show the UpdateRequiredPage.
             return MaterialApp(
               debugShowCheckedModeBanner: false,
-              theme: lightTheme(
-                scheme: FlexScheme.material,
-                appTextScaleFactor: AppTextScaleFactor.medium,
-                appFontWeight: AppFontWeight.regular,
-                fontFamily: null,
-              ),
-              darkTheme: darkTheme(
-                scheme: FlexScheme.material,
-                appTextScaleFactor: AppTextScaleFactor.medium,
-                appFontWeight: AppFontWeight.regular,
-                fontFamily: null, // System default font
-              ),
-              themeMode: state
-                  .themeMode, // Still respect light/dark if available from system
-              localizationsDelegates: const [
-                ...AppLocalizations.localizationsDelegates,
-                ...UiKitLocalizations.localizationsDelegates,
-              ],
-              supportedLocales: const [
-                ...AppLocalizations.supportedLocales,
-                ...UiKitLocalizations.supportedLocales,
-              ],
-              home: Scaffold(
-                body: Builder(
-                  // Use Builder to get context under MaterialApp
-                  builder: (innerContext) {
-                    return LoadingStateWidget(
-                      icon: Icons.settings_applications_outlined,
-                      headline: AppLocalizations.of(
-                        innerContext,
-                      ).headlinesFeedLoadingHeadline,
-                      subheadline: AppLocalizations.of(innerContext).pleaseWait,
-                    );
-                  },
-                ),
-              ),
+              theme: lightTheme(),
+              darkTheme: darkTheme(),
+              themeMode: state.themeMode,
+              localizationsDelegates: AppLocalizations.localizationsDelegates,
+              supportedLocales: AppLocalizations.supportedLocales,
+              home: const UpdateRequiredPage(),
             );
           }
 
-          if (state.status == AppStatus.configFetchFailed) {
+          if (state.status == AppStatus.configFetching ||
+              state.status == AppStatus.configFetchFailed) {
+            // The app is in the process of fetching its initial remote
+            // configuration or has failed to do so. The StatusPage handles
+            // both the loading indicator and the retry mechanism.
             return MaterialApp(
               debugShowCheckedModeBanner: false,
-              theme: lightTheme(
-                scheme: FlexScheme.material,
-                appTextScaleFactor: AppTextScaleFactor.medium,
-                appFontWeight: AppFontWeight.regular,
-                fontFamily: null,
-              ),
-              darkTheme: darkTheme(
-                scheme: FlexScheme.material,
-                appTextScaleFactor: AppTextScaleFactor.medium,
-                appFontWeight: AppFontWeight.regular,
-                fontFamily: null,
-              ),
+              theme: lightTheme(),
+              darkTheme: darkTheme(),
               themeMode: state.themeMode,
-              localizationsDelegates: const [
-                ...AppLocalizations.localizationsDelegates,
-                ...UiKitLocalizations.localizationsDelegates,
-              ],
-              supportedLocales: const [
-                ...AppLocalizations.supportedLocales,
-                ...UiKitLocalizations.supportedLocales,
-              ],
-              home: Scaffold(
-                body: Builder(
-                  // Use Builder to get context under MaterialApp
-                  builder: (innerContext) {
-                    return FailureStateWidget(
-                      exception: const NetworkException(),
-                      retryButtonText: UiKitLocalizations.of(
-                        innerContext,
-                      )!.retryButtonText,
-                      onRetry: () {
-                        // Use outer context for BLoC access
-                        context.read<AppBloc>().add(
-                          const AppConfigFetchRequested(),
-                        );
-                      },
-                    );
-                  },
-                ),
-              ),
+              localizationsDelegates: AppLocalizations.localizationsDelegates,
+              supportedLocales: AppLocalizations.supportedLocales,
+              home: const StatusPage(),
             );
           }
 
-          // If config is loaded (or not in a failed/fetching state for config), proceed with main app UI
-          // It's safe to access l10n here if needed for print statements,
-          // as this path implies we are about to build the main MaterialApp.router
-          // which provides localizations.
-          // final l10n = context.l10n;
-          print('[_AppViewState] Building MaterialApp.router');
-          print('[_AppViewState] state.fontFamily: ${state.fontFamily}');
-          print(
-            '[_AppViewState] state.settings.displaySettings.fontFamily: ${state.settings.displaySettings.fontFamily}',
-          );
-          print(
-            '[_AppViewState] state.settings.displaySettings.fontWeight: ${state.settings.displaySettings.fontWeight}',
-          );
+          // --- Main Application UI ---
+          // If none of the critical states above are met, the app is ready
+          // to display its main UI. We build the MaterialApp.router here.
+          //
+          // This is the STABLE root of the main application. Because it is
+          // only built when the app is in a "running" state, it will not be
+          // destroyed and rebuilt during startup, which fixes the
+          // `BuildContext` instability and related crashes.
           return MaterialApp.router(
             debugShowCheckedModeBanner: false,
             themeMode: state.themeMode,

lib/status/view/status_page.dart

@@ -1,4 +1,4 @@
-import 'package:core/core.dart' hide AppStatus;
+import 'package:core/core.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:flutter_news_app_mobile_client_full_source_code/app/bloc/app_bloc.dart';
@@ -24,7 +24,7 @@ class StatusPage extends StatelessWidget {
     return Scaffold(
       body: BlocBuilder<AppBloc, AppState>(
         builder: (context, state) {
-          final l10n = AppLocalizationsX(context).l10n;
+          final l10n = context.l10n;
 
           if (state.status == AppStatus.configFetching) {
             // While fetching configuration, display a clear loading indicator.
@@ -40,7 +40,7 @@ class StatusPage extends StatelessWidget {
           // This allows the user to recover from transient network issues.
           return FailureStateWidget(
             exception: const NetworkException(), // A generic network error
-            retryButtonText: 'l10n.retryButtonText', //TODO(fulleni): localize me.
+            retryButtonText: l10n.retryButtonText,
             onRetry: () {
               // Dispatch the event to AppBloc to re-trigger the fetch.
               context.read<AppBloc>().add(const AppConfigFetchRequested());