267 lines
11 KiB
Dart
267 lines
11 KiB
Dart
import 'dart:async';
|
|
import 'dart:developer';
|
|
import 'dart:io';
|
|
import 'dart:ui';
|
|
|
|
import 'package:firebase_core/firebase_core.dart';
|
|
import 'package:firebase_messaging/firebase_messaging.dart';
|
|
import 'package:flutter/foundation.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter/services.dart';
|
|
import 'package:flutter_bloc/flutter_bloc.dart';
|
|
import 'package:flutter_localizations/flutter_localizations.dart';
|
|
import 'package:hydrated_bloc/hydrated_bloc.dart';
|
|
import 'package:jiffy/jiffy.dart';
|
|
import 'package:loader_overlay/loader_overlay.dart';
|
|
import 'package:path_provider/path_provider.dart';
|
|
import 'package:persistent_bottom_nav_bar_v2/persistent_bottom_nav_bar_v2.dart';
|
|
import 'package:shared_preferences/shared_preferences.dart';
|
|
|
|
import 'api/mhsl/breaker/get_breakers/get_breakers_response.dart';
|
|
import 'app.dart';
|
|
import 'firebase_options.dart';
|
|
import 'model/account_data.dart';
|
|
import 'state/app/modules/account/bloc/account_bloc.dart';
|
|
import 'state/app/modules/account/bloc/account_state.dart';
|
|
import 'state/app/modules/breaker/bloc/breaker_bloc.dart';
|
|
import 'state/app/modules/chat/bloc/chat_bloc.dart';
|
|
import 'state/app/modules/chat_list/bloc/chat_list_bloc.dart';
|
|
import 'state/app/modules/settings/bloc/settings_cubit.dart';
|
|
import 'state/app/modules/timetable/bloc/timetable_bloc.dart';
|
|
import 'storage/settings.dart';
|
|
import 'theming/dark_app_theme.dart';
|
|
import 'theming/light_app_theme.dart';
|
|
import 'view/login/login.dart';
|
|
import 'widget/app_progress_indicator.dart';
|
|
import 'widget/breaker/breaker.dart';
|
|
import 'widget/debug/cache_view.dart';
|
|
|
|
Future<void> main() async {
|
|
log('MarianumMobile started');
|
|
WidgetsFlutterBinding.ensureInitialized();
|
|
|
|
void addCertificateAsTrusted(ByteData certificate) =>
|
|
SecurityContext.defaultContext.setTrustedCertificatesBytes(certificate.buffer.asUint8List());
|
|
|
|
final initialisationTasks = [
|
|
Firebase.initializeApp(options: DefaultFirebaseOptions.currentPlatform)
|
|
.then<void>((_) {})
|
|
.onError((error, _) => log('Error initializing Firebase: $error')),
|
|
PlatformAssetBundle().load('assets/ca/lets-encrypt-r3.pem').then(addCertificateAsTrusted),
|
|
PlatformAssetBundle().load('assets/ca/lets-encrypt-r10.pem').then(addCertificateAsTrusted),
|
|
PlatformAssetBundle().load('assets/ca/lets-encrypt-r13.pem').then(addCertificateAsTrusted),
|
|
Future(() async {
|
|
final storage = await HydratedStorage.build(
|
|
storageDirectory: HydratedStorageDirectory((await getTemporaryDirectory()).path),
|
|
);
|
|
HydratedBloc.storage = storage;
|
|
}),
|
|
AccountData().waitForPopulation(),
|
|
];
|
|
|
|
log('starting app initialisation...');
|
|
await Future.wait(initialisationTasks);
|
|
log('app initialisation done!');
|
|
|
|
unawaited(
|
|
FirebaseMessaging.instance.getToken().then(
|
|
(token) => log('Firebase token: ${token ?? "Error: no Firebase token!"}'),
|
|
),
|
|
);
|
|
|
|
if (kReleaseMode) {
|
|
ErrorWidget.builder = (error) => Material(
|
|
color: Colors.white,
|
|
child: Center(
|
|
child: Padding(
|
|
padding: const EdgeInsets.all(24),
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
const Icon(Icons.phonelink_erase_rounded, size: 40),
|
|
const SizedBox(height: 12),
|
|
Text(error.toStringShort(), textAlign: TextAlign.center),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
// Capture uncaught Flutter and platform errors so they show up in logs
|
|
// instead of being silently swallowed.
|
|
FlutterError.onError = (details) {
|
|
log('Uncaught Flutter error: ${details.exception}', stackTrace: details.stack);
|
|
FlutterError.presentError(details);
|
|
};
|
|
PlatformDispatcher.instance.onError = (error, stack) {
|
|
log('Uncaught platform error: $error', stackTrace: stack);
|
|
return true;
|
|
};
|
|
|
|
log('running app...');
|
|
runApp(
|
|
MultiBlocProvider(
|
|
providers: [
|
|
BlocProvider<SettingsCubit>(create: (_) => SettingsCubit()),
|
|
BlocProvider<AccountBloc>(create: (_) => AccountBloc(
|
|
initialStatus: AccountData().isPopulated() ? AccountStatus.loggedIn : AccountStatus.loggedOut,
|
|
)),
|
|
BlocProvider<BreakerBloc>(create: (_) => BreakerBloc()),
|
|
BlocProvider<ChatListBloc>(create: (_) => ChatListBloc()),
|
|
BlocProvider<ChatBloc>(create: (_) => ChatBloc()),
|
|
BlocProvider<TimetableBloc>(create: (_) => TimetableBloc()),
|
|
],
|
|
child: const Main(),
|
|
),
|
|
);
|
|
}
|
|
|
|
class Main extends StatefulWidget {
|
|
const Main({super.key});
|
|
|
|
static PersistentTabController bottomNavigator = PersistentTabController(initialIndex: 0);
|
|
|
|
@override
|
|
State<Main> createState() => _MainState();
|
|
}
|
|
|
|
class _MainState extends State<Main> {
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
Jiffy.setLocale('de');
|
|
|
|
AccountData().waitForPopulation().then((value) {
|
|
if (!mounted) return;
|
|
context.read<AccountBloc>().setStatus(value ? AccountStatus.loggedIn : AccountStatus.loggedOut);
|
|
});
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) => Directionality(
|
|
textDirection: TextDirection.ltr,
|
|
child: BlocBuilder<SettingsCubit, Settings>(
|
|
builder: (context, settings) {
|
|
final devToolsSettings = settings.devToolsSettings;
|
|
return MaterialApp(
|
|
showPerformanceOverlay: devToolsSettings.showPerformanceOverlay,
|
|
checkerboardOffscreenLayers: devToolsSettings.checkerboardOffscreenLayers,
|
|
checkerboardRasterCacheImages: devToolsSettings.checkerboardRasterCacheImages,
|
|
debugShowCheckedModeBanner: false,
|
|
localizationsDelegates: const [
|
|
...GlobalMaterialLocalizations.delegates,
|
|
GlobalWidgetsLocalizations.delegate,
|
|
],
|
|
supportedLocales: const [Locale('de'), Locale('en')],
|
|
locale: const Locale('de'),
|
|
title: 'Marianum Fulda',
|
|
themeMode: settings.appTheme,
|
|
theme: LightAppTheme.theme,
|
|
darkTheme: DarkAppTheme.theme,
|
|
// Brand-colored backdrop behind every route. During the logout
|
|
// home-swap and route pop animations the framework can briefly
|
|
// expose the layer below the topmost Scaffold; without this
|
|
// the dark Material default shows through and the user sees a
|
|
// black flash.
|
|
builder: (context, child) => ColoredBox(
|
|
color: LightAppTheme.marianumRed,
|
|
child: child ?? const SizedBox.shrink(),
|
|
),
|
|
home: LoaderOverlay(
|
|
child: Breaker(
|
|
breaker: BreakerArea.global,
|
|
child: BlocConsumer<AccountBloc, AccountState>(
|
|
listenWhen: (previous, current) => previous.status != current.status,
|
|
listener: (context, accountState) {
|
|
if (accountState.status != AccountStatus.loggedOut) return;
|
|
// Routes pushed via AppRoutes (e.g. Settings) live on the
|
|
// root navigator and survive the home swap below, so they
|
|
// would still cover the Login screen after logout. Pop
|
|
// them here so the user immediately sees Login.
|
|
final navigator = Navigator.of(context);
|
|
if (navigator.canPop()) {
|
|
navigator.popUntil((route) => route.isFirst);
|
|
}
|
|
// Capture bloc references before the post-frame callback
|
|
// — by the time it runs the dialog/Settings context is
|
|
// gone but this listener context is still valid.
|
|
final settingsCubit = context.read<SettingsCubit>();
|
|
final timetableBloc = context.read<TimetableBloc>();
|
|
final chatListBloc = context.read<ChatListBloc>();
|
|
final chatBloc = context.read<ChatBloc>();
|
|
final breakerBloc = context.read<BreakerBloc>();
|
|
// Defer the actual wipe until after this frame so the
|
|
// App tree (TimetableBloc/ChatListBloc watchers etc.)
|
|
// is already torn down. Resetting blocs while App is
|
|
// still in front caused a black-frame race.
|
|
WidgetsBinding.instance.addPostFrameCallback((_) {
|
|
unawaited(_wipeUserState(
|
|
settingsCubit: settingsCubit,
|
|
timetableBloc: timetableBloc,
|
|
chatListBloc: chatListBloc,
|
|
chatBloc: chatBloc,
|
|
breakerBloc: breakerBloc,
|
|
));
|
|
});
|
|
},
|
|
builder: (context, accountState) {
|
|
switch (accountState.status) {
|
|
case AccountStatus.loggedIn:
|
|
return const App();
|
|
case AccountStatus.loggedOut:
|
|
return const Login();
|
|
case AccountStatus.undefined:
|
|
return Scaffold(
|
|
backgroundColor: LightAppTheme.marianumRed,
|
|
body: const Center(
|
|
child: Column(
|
|
mainAxisAlignment: MainAxisAlignment.center,
|
|
children: [
|
|
AppProgressIndicator.large(color: Colors.white),
|
|
SizedBox(height: 16),
|
|
Text('Konto wird geladen…',
|
|
style: TextStyle(color: Colors.white)),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
},
|
|
),
|
|
),
|
|
),
|
|
);
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
Future<void> _wipeUserState({
|
|
required SettingsCubit settingsCubit,
|
|
required TimetableBloc timetableBloc,
|
|
required ChatListBloc chatListBloc,
|
|
required ChatBloc chatBloc,
|
|
required BreakerBloc breakerBloc,
|
|
}) async {
|
|
try {
|
|
// Reset user-data blocs whose tree is no longer mounted after the
|
|
// home swap. We do NOT touch SettingsCubit here — its outer BlocBuilder
|
|
// wraps MaterialApp, so emit'ing a fresh state would tear down the
|
|
// freshly-mounted Login tree and leave the user with a blank screen
|
|
// (the MaterialApp.builder backdrop) until the next interaction.
|
|
await Future.wait([
|
|
timetableBloc.reset(),
|
|
chatListBloc.reset(),
|
|
chatBloc.reset(),
|
|
breakerBloc.reset(),
|
|
]);
|
|
final prefs = await SharedPreferences.getInstance();
|
|
await prefs.clear();
|
|
await HydratedBloc.storage.clear();
|
|
await const CacheView().clear();
|
|
} catch (e, s) {
|
|
log('User state wipe failed: $e', stackTrace: s);
|
|
}
|
|
}
|