relatica/lib/main.dart

import 'package:flutter/material.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart' as fr;
import 'package:go_router/go_router.dart';
import 'package:logging/logging.dart';
import 'package:media_kit/media_kit.dart';
import 'package:multi_trigger_autocomplete/multi_trigger_autocomplete.dart';
import 'package:package_info_plus/package_info_plus.dart';
import 'package:provider/provider.dart';
import 'package:shared_preferences/shared_preferences.dart';

import 'app_theme.dart';
import 'di_initialization.dart';
import 'globals.dart';
import 'riverpod_controllers/settings_services.dart';
import 'riverpod_controllers/shared_prefs.dart';
import 'routes.dart';
import 'services/auth_service.dart';
import 'services/connections_manager.dart';
import 'services/entry_manager_service.dart';
import 'services/follow_requests_manager.dart';
import 'services/gallery_service.dart';
import 'services/interactions_manager.dart';
import 'services/notifications_manager.dart';
import 'services/timeline_entry_filter_service.dart';
import 'services/timeline_manager.dart';
import 'update_timer_initialization.dart';
import 'utils/active_profile_selector.dart';
import 'utils/app_scrolling_behavior.dart';
import 'utils/old_android_letsencrypte_cert.dart';

final preInitializationLogEventQueue = <LogRecord>[];

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

  // await dotenv.load(fileName: '.env');
  Logger.root.level = Level.OFF;
  await fixLetsEncryptCertOnOldAndroid();
  await dependencyInjectionInitialization();
  await setupPackageInfoAndUserAgent();

  final prefs = await SharedPreferences.getInstance();

  // TODO Add back Device Preview once supported in Flutter 3.22+
  // runApp(DevicePreview(
  //   enabled: !kReleaseMode && enablePreview,
  //   builder: (context) => const App(),
  // ));
  runApp(fr.ProviderScope(overrides: [
    sharedPreferencesProvider.overrideWithValue(prefs),
  ], child: App()));
}

Future<void> setupPackageInfoAndUserAgent() async {
  PackageInfo packageInfo = await PackageInfo.fromPlatform();
  appVersion = packageInfo.version;
  userAgent = 'Relatica/$appVersion';
}

class App extends fr.ConsumerStatefulWidget {
  const App({super.key});

  // This widget is the root of your application.
  @override
  fr.ConsumerState<App> createState() => _AppState();
}

class _AppState extends fr.ConsumerState<App> {
  @override
  void initState() {
    super.initState();
    setupUpdateTimers(ref);
  }

  @override
  Widget build(BuildContext context) {
    final authService = getIt<AccountsService>();

    if (rootRiverpodProviderContainer == null) {
      var root = fr.ProviderScope.containerOf(context);
      rootRiverpodProviderContainer ??= root;
    }

    final appRouter = GoRouter(
      initialLocation: ScreenPaths.timelines,
      debugLogDiagnostics: true,
      refreshListenable: authService,
      redirect: (context, state) async {
        final loggedIn = authService.loggedIn;

        if (!loggedIn && authService.initializing) {
          return ScreenPaths.splash;
        }

        if (!loggedIn && !allowedLoggedOut.contains(state.uri.toString())) {
          return ScreenPaths.signin;
        }

        if (loggedIn && allowedLoggedOut.contains(state.uri.toString())) {
          return ScreenPaths.timelines;
        }

        return null;
      },
      routes: routes,
    );
    Logger.root.level = ref.read(logLevelSettingProvider);
    return Portal(
      child: MultiProvider(
        providers: [
          ChangeNotifierProvider<AccountsService>(
            create: (_) => getIt<AccountsService>(),
            lazy: true,
          ),
          ChangeNotifierProvider<ActiveProfileSelector<ConnectionsManager>>(
            create: (_) => getIt<ActiveProfileSelector<ConnectionsManager>>(),
            lazy: true,
          ),
          ChangeNotifierProvider<ActiveProfileSelector<EntryManagerService>>(
            create: (_) => getIt<ActiveProfileSelector<EntryManagerService>>(),
            lazy: true,
          ),
          ChangeNotifierProvider<ActiveProfileSelector<GalleryService>>(
            create: (_) => getIt<ActiveProfileSelector<GalleryService>>(),
            lazy: true,
          ),
          ChangeNotifierProvider<ActiveProfileSelector<TimelineManager>>(
            create: (_) => getIt<ActiveProfileSelector<TimelineManager>>(),
          ),
          ChangeNotifierProvider<ActiveProfileSelector<NotificationsManager>>(
            create: (_) => getIt<ActiveProfileSelector<NotificationsManager>>(),
          ),
          ChangeNotifierProvider<ActiveProfileSelector<FollowRequestsManager>>(
            create: (_) =>
                getIt<ActiveProfileSelector<FollowRequestsManager>>(),
          ),
          ChangeNotifierProvider<ActiveProfileSelector<InteractionsManager>>(
            create: (_) => getIt<ActiveProfileSelector<InteractionsManager>>(),
          ),
          ChangeNotifierProvider<
              ActiveProfileSelector<TimelineEntryFilterService>>(
            create: (_) =>
                getIt<ActiveProfileSelector<TimelineEntryFilterService>>(),
          ),
        ],
        child: MaterialApp.router(
          // TODO Add back Device Preview once supported in Flutter 3.22+
          // locale: DevicePreview.locale(context),
          // builder: DevicePreview.appBuilder,
          theme: buildTheme(
            brightness: Brightness.light,
            blindnessType: ref.watch(colorBlindnessTestingModeSettingProvider),
          ),
          darkTheme: buildTheme(
            brightness: Brightness.dark,
            blindnessType: ref.watch(colorBlindnessTestingModeSettingProvider),
          ),
          themeMode: ref.watch(themeModeSettingProvider),
          debugShowCheckedModeBanner: false,
          scrollBehavior: AppScrollingBehavior(),
          routerDelegate: appRouter.routerDelegate,
          routeInformationProvider: appRouter.routeInformationProvider,
          routeInformationParser: appRouter.routeInformationParser,
        ),
      ),
    );
  }
}