refactor(apps): 主题系统迁移至 ColorScheme + 扩展架构并支持 Dark Mode

apps/lib/app/app.dart

@@ -1,37 +1,72 @@
+import 'dart:async';
+import 'dart:convert';
+
 import 'package:flutter/material.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:go_router/go_router.dart';
 import 'di/injection.dart';
+import '../data/models/reminder_payload.dart';
+import '../data/services/calendar_service.dart';
+import '../data/services/local_notification_service.dart';
+import '../data/services/reminder_notification_callbacks.dart';
 import '../core/l10n/l10n.dart';
-import '../core/network/i_api_client.dart';
 import '../l10n/app_localizations.dart';
 import '../features/auth/presentation/bloc/auth_bloc.dart';
+import '../features/auth/presentation/bloc/auth_event.dart';
 import '../features/auth/presentation/bloc/auth_state.dart';
-import '../features/chat/presentation/bloc/chat_bloc.dart';
+import '../features/notification/domain/models/reminder_action.dart';
+import '../features/notification/domain/services/reminder_action_executor.dart';
 import 'router/app_router.dart';
 import '../core/theme/app_theme.dart';
 
-class LinksyApp extends StatelessWidget {
-  final AuthBloc authBloc;
+class LinksyApp extends StatefulWidget {
+  const LinksyApp({super.key});
 
-  const LinksyApp({super.key, required this.authBloc});
+  @override
+  State<LinksyApp> createState() => _LinksyAppState();
+}
+
+class _LinksyAppState extends State<LinksyApp> {
+  late final AuthBloc _authBloc;
+  late final GoRouter _router;
+  String? _reminderBootstrapUserId;
+
+  @override
+  void initState() {
+    super.initState();
+    _authBloc = sl<AuthBloc>();
+    _authBloc.add(AuthStarted());
+    _router = createAppRouter(_authBloc);
+    unawaited(_bindNotificationResponseHandler());
+  }
+
+  @override
+  void dispose() {
+    _router.dispose();
+    super.dispose();
+  }
 
   @override
   Widget build(BuildContext context) {
-    return MultiBlocProvider(
-      providers: [
-        BlocProvider<AuthBloc>.value(value: authBloc),
-        BlocProvider<ChatBloc>(
-          create: (_) => ChatBloc(apiClient: sl<IApiClient>()),
-        ),
-      ],
+    return BlocProvider<AuthBloc>.value(
+      value: _authBloc,
       child: BlocListener<AuthBloc, AuthState>(
         listener: (context, state) {
-          // Handle auth state changes if needed
+          if (state is AuthAuthenticated &&
+              state.user.id != _reminderBootstrapUserId) {
+            _reminderBootstrapUserId = state.user.id;
+            unawaited(_rebuildUpcomingReminders());
+          }
+          if (state is AuthUnauthenticated) {
+            _reminderBootstrapUserId = null;
+          }
         },
         child: MaterialApp.router(
           onGenerateTitle: (context) => AppLocalizations.of(context).appTitle,
           debugShowCheckedModeBanner: false,
           theme: AppTheme.light,
+          darkTheme: AppTheme.dark,
+          themeMode: ThemeMode.system,
           locale: const Locale('zh'),
           supportedLocales: AppLocalizations.supportedLocales,
           localizationsDelegates: AppLocalizations.localizationsDelegates,
@@ -39,9 +74,60 @@ class LinksyApp extends StatelessWidget {
             L10n.setLocale(Localizations.localeOf(context));
             return child ?? const SizedBox.shrink();
           },
-          routerConfig: createAppRouter(authBloc),
+          routerConfig: _router,
         ),
       ),
     );
   }
+
+  Future<void> _rebuildUpcomingReminders() async {
+    final now = DateTime.now();
+    final start = now.subtract(const Duration(days: 90));
+    final end = now.add(const Duration(days: 90));
+    try {
+      final events = await sl<CalendarService>().getEventsForRange(start, end);
+      await sl<LocalNotificationService>().rebuildUpcomingReminders(events);
+    } catch (error) {
+      debugPrint('reminder bootstrap skipped: $error');
+    }
+  }
+
+  Future<void> _bindNotificationResponseHandler() async {
+    await ReminderNotificationCallbacks.bindResponseHandler((response) async {
+      final payloadRaw = response.payload;
+      if (payloadRaw == null || payloadRaw.isEmpty) {
+        return;
+      }
+
+      ReminderPayload payload;
+      try {
+        payload = ReminderPayload.fromJson(
+          Map<String, dynamic>.from(jsonDecode(payloadRaw) as Map),
+        );
+      } catch (_) {
+        return;
+      }
+
+      final actionId = response.actionId;
+      ReminderAction? action;
+      if (actionId != null) {
+        try {
+          action = ReminderAction.fromValue(actionId);
+        } catch (_) {
+          action = null;
+        }
+      }
+      if (action == null) {
+        ReminderNotificationCallbacks.onNotificationPayloadReceived?.call(
+          payload,
+        );
+        return;
+      }
+
+      await sl<ReminderActionExecutor>().handleAction(
+        action: action,
+        payload: payload,
+      );
+    });
+  }
 }