AppFlowy/frontend/app_flowy/lib/startup/tasks/app_widget.dart

import 'package:app_flowy/startup/startup.dart';
import 'package:app_flowy/user/application/user_settings_service.dart';
import 'package:app_flowy/workspace/application/appearance.dart';
import 'package:appflowy_editor/appflowy_editor.dart' hide Log;
import 'package:easy_localization/easy_localization.dart';
import 'package:flowy_infra/theme.dart';
import 'package:flowy_infra_ui/flowy_infra_ui.dart';
import 'package:flowy_sdk/log.dart';
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'package:window_size/window_size.dart';
import 'package:bloc/bloc.dart';

class InitAppWidgetTask extends LaunchTask {
  @override
  LaunchTaskType get type => LaunchTaskType.appLauncher;

  @override
  Future<void> initialize(LaunchContext context) async {
    final widget = context.getIt<EntryPoint>().create();
    final setting = await SettingsFFIService().getAppearanceSetting();
    final appearanceSetting = AppearanceSetting(setting);
    final app = ApplicationWidget(
      appearanceSetting: appearanceSetting,
      child: widget,
    );
    Bloc.observer = ApplicationBlocObserver();
    runApp(
      EasyLocalization(
        supportedLocales: const [
          // In alphabetical order
          Locale('ca', 'ES'),
          Locale('de', 'DE'),
          Locale('en'),
          Locale('es', 'VE'),
          Locale('fr', 'FR'),
          Locale('fr', 'CA'),
          Locale('hu', 'HU'),
          Locale('id', 'ID'),
          Locale('it', 'IT'),
          Locale('ja', 'JP'),
          Locale('ko', 'KR'),
          Locale('pl', 'PL'),
          Locale('pt', 'BR'),
          Locale('ru', 'RU'),
          Locale('sv'),
          Locale('tr', 'TR'),
          Locale('zh', 'CN'),
        ],
        path: 'assets/translations',
        fallbackLocale: const Locale('en'),
        useFallbackTranslations: true,
        saveLocale: false,
        child: app,
      ),
    );

    return Future(() => {});
  }
}

class ApplicationWidget extends StatelessWidget {
  final Widget child;
  final AppearanceSetting appearanceSetting;

  const ApplicationWidget({
    Key? key,
    required this.child,
    required this.appearanceSetting,
  }) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return ChangeNotifierProvider.value(
      value: appearanceSetting,
      builder: (context, _) {
        const ratio = 1.73;
        const minWidth = 600.0;
        setWindowMinSize(const Size(minWidth, minWidth / ratio));
        appearanceSetting.readLocaleWhenAppLaunch(context);
        AppTheme theme = context.select<AppearanceSetting, AppTheme>(
          (value) => value.theme,
        );
        Locale locale = context.select<AppearanceSetting, Locale>(
          (value) => value.locale,
        );

        return MultiProvider(
          providers: [
            Provider.value(value: theme),
            Provider.value(value: locale),
          ],
          builder: (context, _) {
            return MaterialApp(
              builder: overlayManagerBuilder(),
              debugShowCheckedModeBanner: false,
              theme: theme.themeData,
              localizationsDelegates: context.localizationDelegates +
                  [AppFlowyEditorLocalizations.delegate],
              supportedLocales: context.supportedLocales,
              locale: locale,
              navigatorKey: AppGlobals.rootNavKey,
              home: child,
            );
          },
        );
      },
    );
  }
}

class AppGlobals {
  static GlobalKey<NavigatorState> rootNavKey = GlobalKey();
  static NavigatorState get nav => rootNavKey.currentState!;
}

class ApplicationBlocObserver extends BlocObserver {
  @override
  // ignore: unnecessary_overrides
  void onTransition(Bloc bloc, Transition transition) {
    // Log.debug("[current]: ${transition.currentState} \n\n[next]: ${transition.nextState}");
    // Log.debug("${transition.nextState}");
    super.onTransition(bloc, transition);
  }

  @override
  void onError(BlocBase bloc, Object error, StackTrace stackTrace) {
    Log.debug(error);
    super.onError(bloc, error, stackTrace);
  }

  // @override
  // void onEvent(Bloc bloc, Object? event) {
  //   Log.debug("$event");
  //   super.onEvent(bloc, event);
  // }
}