xianyan/lib/main.dart

// ============================================================
// 闲言APP — 应用入口
// 创建时间: 2026-04-20
// 更新时间: 2026-05-25
// 作用: main 函数，初始化存储 + 液态玻璃 + 异常捕获 + 启动 App
// 上次更新: 集成CrashMonitor+BackgroundTaskService+ConnectivityService初始化
// ============================================================

import 'dart:async';
import 'dart:isolate' if (dart.library.js) 'core/utils/platform/isolate_stub.dart';

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:liquid_glass_widgets/liquid_glass_widgets.dart';
import 'package:flutter/services.dart';

import 'app/app.dart';
import 'core/services/network/connectivity_service.dart';
import 'core/services/network/deep_link_service.dart';
import 'core/services/notification/local_notification_service.dart';
import 'core/services/device/screen_wake_service.dart';
import 'core/services/readlater/sharing_receiver_service.dart';
import 'core/services/device/battery_optimization_service.dart';
import 'core/services/performance/performance_orchestrator.dart';
import 'core/services/notification/readlater_reminder_service.dart';
import 'core/services/data/home_widget_service.dart';
import 'core/services/clipboard_monitor_service.dart';
import 'core/services/background/background_task_service.dart';
import 'core/services/error/crash_monitor.dart';
import 'core/storage/kv_storage.dart';
import 'core/services/error/global_error_handler.dart';
import 'core/utils/logger.dart';
import 'core/utils/platform/platform_utils.dart' as pu;
import 'core/registry/page_registry.dart';
import 'core/router/app_router.dart';
import 'core/services/catcher2_config_service.dart';
import 'editor/services/3d/platform_3d_service.dart';
import 'features/tool_center/inspiration/services/chat_migration_service.dart';
import 'features/template/services/wallpaper_favorite_service.dart';
import 'features/template/services/wallpaper_health_service.dart';
import 'features/mine/settings/services/settings_change_logger.dart';

bool kvStorageReady = false;
bool _liquidGlassReady = false;

bool get liquidGlassReady => _liquidGlassReady;

void main() async {
  runZonedGuarded(
    () async {
      WidgetsFlutterBinding.ensureInitialized();

      if (pu.isOhos) Log.i('🟢 [OHOS] main() 开始执行');

      FlutterError.onError = (FlutterErrorDetails details) {
        FlutterError.presentError(details);
        Log.e(
          '🔥 FlutterError.onError',
          details.exceptionAsString(),
          details.stack,
        );
      };

      GlobalErrorHandler.init();

      if (!pu.isWeb) {
        Isolate.current.addErrorListener(
          RawReceivePort((Object? pair) {
            final List<dynamic> errorAndStacktrace = pair as List<dynamic>;
            Log.e(
              '🔥 Isolate uncaught error',
              errorAndStacktrace.first,
              StackTrace.fromString(errorAndStacktrace.last.toString()),
            );
          }).sendPort,
        );
      }

      if (!pu.isWeb) {
        SystemChrome.setEnabledSystemUIMode(SystemUiMode.edgeToEdge);
      }
      if (pu.isOhos) Log.i('🟢 [OHOS] SystemChrome 配置完成');

      try {
        await KvStorage.init();
        kvStorageReady = true;
        if (pu.isOhos) Log.i('🟢 [OHOS] KvStorage 初始化完成');
      } catch (e, st) {
        Log.e('KV 存储初始化失败', e, st);
      }

      try {
        await WallpaperFavoriteService.init();
        Log.i('壁纸收藏服务初始化完成');
      } catch (e, st) {
        Log.e('壁纸收藏服务初始化失败', e, st);
      }

      try {
        PerformanceOrchestrator.instance.init();
        Log.i('PerformanceOrchestrator 初始化完成');
      } catch (e, st) {
        Log.e('PerformanceOrchestrator 初始化失败', e, st);
      }

      try {
        await LiquidGlassWidgets.initialize();
        _liquidGlassReady = true;
        Log.i('LiquidGlassWidgets 初始化完成 (ohos=${pu.isOhos})');
      } catch (e, st) {
        Log.e('LiquidGlassWidgets 初始化失败', e, st);
      }

      try {
        await Platform3DService.instance.detectDeviceCapability();
        if (pu.isOhos)
          Log.i(
            '🟢 [OHOS] 3D设备检测完成 (lowEnd=${Platform3DService.instance.isLowEnd})',
          );
      } catch (e, st) {
        Log.e('3D平台设备检测失败', e, st);
      }

      try {
        _validatePageRegistry();
      } catch (e, st) {
        Log.e('页面注册表验证失败', e, st);
      }

      if (!pu.isWeb) {
        try {
          await DeepLinkService.init();
          if (pu.isOhos) Log.i('🟢 [OHOS] 深度链接服务初始化完成');
        } catch (e, st) {
          Log.e('深度链接服务初始化失败', e, st);
        }
      }

      if (!pu.isWeb) {
        try {
          SharingReceiverService().init();
          SharingReceiverService().setNavigatorKey(rootNavigatorKey);
          if (pu.isOhos) Log.i('🟢 [OHOS] 分享接收服务初始化完成');
        } catch (e, st) {
          Log.e('分享接收服务初始化失败', e, st);
        }
      }

      if (!pu.isWeb) {
        try {
          await LocalNotificationService.init();
          if (pu.isOhos) Log.i('🟢 [OHOS] 本地通知服务初始化完成');
        } catch (e, st) {
          Log.e('本地通知服务初始化失败', e, st);
        }
      }

      if (!pu.isWeb) {
        try {
          await ScreenWakeService.init();
          if (pu.isOhos) Log.i('🟢 [OHOS] 屏幕常亮服务初始化完成');
        } catch (e, st) {
          Log.e('屏幕常亮服务初始化失败', e, st);
        }
      }

      try {
        // SoundService 初始化已由 SoundNotifier.build() 自动完成
        if (pu.isOhos) Log.i('🟢 [OHOS] 音效服务初始化完成');
      } catch (e, st) {
        Log.e('音效服务初始化失败', e, st);
      }

      if (!pu.isWeb) {
        try {
          await BatteryOptimizationService.init();
          if (pu.isOhos) Log.i('🟢 [OHOS] 电池优化服务初始化完成');
        } catch (e, st) {
          Log.e('电池优化服务初始化失败', e, st);
        }
      }

      if (!pu.isWeb) {
        try {
          await ReadlaterReminderService.startMonitoring();
          if (pu.isOhos) Log.i('🟢 [OHOS] 稍后读提醒服务初始化完成');
        } catch (e, st) {
          Log.e('稍后读提醒服务初始化失败', e, st);
        }
      }

      try {
        await ChatMigrationService.migrateIfNeeded();
        if (pu.isOhos) Log.i('🟢 [OHOS] 聊天数据迁移检查完成');
      } catch (e, st) {
        Log.e('聊天数据迁移检查失败', e, st);
      }

      if (!pu.isWeb) {
        try {
          await HomeWidgetService.instance.init();
          if (pu.isOhos) Log.i('🟢 [OHOS] 桌面小组件服务初始化完成');
        } catch (e, st) {
          Log.e('桌面小组件服务初始化失败', e, st);
        }
      }

      if (!pu.isWeb) {
        try {
          await ClipboardMonitorService.instance.initFromStore();
          if (pu.isOhos) Log.i('🟢 [OHOS] 剪贴板监控服务初始化完成');
        } catch (e, st) {
          Log.e('剪贴板监控服务初始化失败', e, st);
        }
      }

      try {
        await CrashMonitor.instance.init();
        Log.i('崩溃监控服务初始化完成');
      } catch (e, st) {
        Log.e('崩溃监控服务初始化失败', e, st);
      }

      if (!pu.isWeb) {
        try {
          await ConnectivityService.init();
          Log.i('网络状态检测服务初始化完成');
        } catch (e, st) {
          Log.e('网络状态检测服务初始化失败', e, st);
        }
      }

      if (!pu.isWeb) {
        try {
          await BackgroundTaskService.instance.init();
          Log.i('后台任务服务初始化完成');
        } catch (e, st) {
          Log.e('后台任务服务初始化失败', e, st);
        }
      }

      try {
        await WallpaperHealthService.init();
        Log.i('壁纸源健康检测服务初始化完成');
      } catch (e, st) {
        Log.e('壁纸源健康检测服务初始化失败', e, st);
      }

      try {
        await SettingsChangeLogger.init();
        Log.i('设置变更日志服务初始化完成');
      } catch (e, st) {
        Log.e('设置变更日志服务初始化失败', e, st);
      }

      try {
        if (WallpaperHealthService.shouldCheck()) {
          WallpaperHealthService.checkAllSources();
        }
      } catch (e, st) {
        Log.e('壁纸源健康检测启动检查失败', e, st);
      }

      if (pu.isOhos) {
        Log.i('🟢 [OHOS] 所有服务初始化完成，准备 runApp (liquidGlass=$_liquidGlassReady)');
        const app = ProviderScope(child: XianyanApp());
        if (_liquidGlassReady) {
          Catcher2ConfigService.instance.init(
            runAppFunction: () {
              runApp(LiquidGlassWidgets.wrap(child: app));
            },
          );
        } else {
          Catcher2ConfigService.instance.init(
            runAppFunction: () {
              runApp(app);
            },
          );
        }
        Log.i('🟢 [OHOS] runApp() 已调用');
      } else {
        Catcher2ConfigService.instance.init(
          runAppFunction: () {
            const app = ProviderScope(child: XianyanApp());
            runApp(LiquidGlassWidgets.wrap(child: app));
          },
        );
      }
    },
    (Object error, StackTrace stack) {
      GlobalErrorHandler.handleZoneError(error, stack);
      Log.e('🔥 Zone uncaught error', error, stack);
    },
  );
}

void _validatePageRegistry() {
  final errors = PageRegistry.validateAll();
  if (errors.isNotEmpty) {
    for (final e in errors) {
      Log.e('页面注册表验证失败: $e');
    }
  } else {
    Log.i('页面注册表验证通过，共 ${PageRegistry.pageCount} 个页面已注册');
  }

  const route = AppRoutes.home;
  if (!PageRegistry.isRouteRegistered(route)) {
    Log.e('页面注册表验证: 首页路由 $route 未注册！');
  }
}