236 lines
10 KiB
Dart
236 lines
10 KiB
Dart
import 'dart:async';
|
|
import 'package:aitrainer_app/push_notifications.dart';
|
|
import 'package:aitrainer_app/repository/customer_repository.dart';
|
|
import 'package:aitrainer_app/repository/workout_tree_repository.dart';
|
|
import 'package:aitrainer_app/util/session.dart';
|
|
import 'package:aitrainer_app/view/account.dart';
|
|
import 'package:aitrainer_app/view/custom_exercise_page.dart';
|
|
import 'package:aitrainer_app/view/customer_bodytype_page.dart';
|
|
import 'package:aitrainer_app/view/customer_exercise_device.dart';
|
|
import 'package:aitrainer_app/view/customer_fitness_page.dart';
|
|
import 'package:aitrainer_app/view/customer_goal_page.dart';
|
|
import 'package:aitrainer_app/view/customer_modify_page.dart';
|
|
import 'package:aitrainer_app/view/customer_welcome_page.dart';
|
|
import 'package:aitrainer_app/view/exercise_control_page.dart';
|
|
import 'package:aitrainer_app/view/exercise_execute_page.dart';
|
|
import 'package:aitrainer_app/view/exercise_execute_plan_add_page.dart';
|
|
import 'package:aitrainer_app/view/exercise_log_page.dart';
|
|
import 'package:aitrainer_app/view/exercise_plan_custom_page.dart';
|
|
import 'package:aitrainer_app/view/exercise_plan_custom_detail_add_page.dart';
|
|
import 'package:aitrainer_app/view/exercise_type_description.dart';
|
|
import 'package:aitrainer_app/view/gdpr.dart';
|
|
import 'package:aitrainer_app/view/login.dart';
|
|
import 'package:aitrainer_app/view/exercise_new_page.dart';
|
|
import 'package:aitrainer_app/view/menu_page.dart';
|
|
import 'package:aitrainer_app/view/mydevelopment_body_page.dart';
|
|
import 'package:aitrainer_app/view/mydevelopment_muscle_page.dart';
|
|
import 'package:aitrainer_app/view/mydevelopment_page.dart';
|
|
import 'package:aitrainer_app/view/myexcercise_plan_page.dart';
|
|
import 'package:aitrainer_app/view/registration.dart';
|
|
import 'package:aitrainer_app/view/reset_password.dart';
|
|
import 'package:aitrainer_app/view/settings.dart';
|
|
import 'package:aitrainer_app/widgets/home.dart';
|
|
import 'package:flurry/flurry.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter/services.dart';
|
|
import 'package:flutter/widgets.dart';
|
|
import 'package:flutter_bloc/flutter_bloc.dart';
|
|
import 'package:flutter_localizations/flutter_localizations.dart';
|
|
import 'package:aitrainer_app/localization/app_localization.dart';
|
|
import 'package:google_fonts/google_fonts.dart';
|
|
import 'package:sentry/sentry.dart';
|
|
import 'bloc/account/account_bloc.dart';
|
|
import 'bloc/body_development/body_development_bloc.dart';
|
|
import 'bloc/development_by_muscle/development_by_muscle_bloc.dart';
|
|
import 'bloc/exercise_execute_plan/exercise_execute_plan_bloc.dart';
|
|
import 'bloc/exercise_plan/exercise_plan_bloc.dart';
|
|
import 'bloc/menu/menu_bloc.dart';
|
|
import 'bloc/session/session_bloc.dart';
|
|
import 'bloc/settings/settings_bloc.dart';
|
|
|
|
final SentryClient _sentry = new SentryClient(dsn: 'https://5fac40cbfcfb4c15aa80c7a8638d7310@o418565.ingest.sentry.io/5322520');
|
|
|
|
/// Whether the VM is running in debug mode.
|
|
///
|
|
/// This is useful to decide whether a report should be sent to sentry. Usually
|
|
/// reports from dev mode are not very useful, as these happen on developers'
|
|
/// workspaces rather than on users' devices in production.
|
|
bool get isInDebugMode {
|
|
bool inDebugMode = false;
|
|
assert(inDebugMode = true);
|
|
return inDebugMode;
|
|
}
|
|
|
|
/// Reports [error] along with its [stackTrace] to Sentry.io.
|
|
Future<Null> _reportError(dynamic error, dynamic stackTrace) async {
|
|
print('Caught error: $error');
|
|
|
|
// Errors thrown in development mode are unlikely to be interesting. You can
|
|
// check if you are running in dev mode using an assertion and omit sending
|
|
// the report.
|
|
if (isInDebugMode) {
|
|
print(stackTrace);
|
|
print('In dev mode. Not sending report to Sentry.io.');
|
|
return;
|
|
}
|
|
|
|
print('Reporting to Sentry.io...');
|
|
|
|
final SentryResponse response = await _sentry.captureException(
|
|
exception: error,
|
|
stackTrace: stackTrace,
|
|
);
|
|
|
|
if (response.isSuccessful) {
|
|
print('Success! Event ID: ${response.eventId}');
|
|
} else {
|
|
print('Failed to report to Sentry.io: ${response.error}');
|
|
}
|
|
}
|
|
|
|
Future<Null> main() async {
|
|
// This captures errors reported by the Flutter framework.
|
|
FlutterError.onError = (FlutterErrorDetails details) async {
|
|
if (isInDebugMode) {
|
|
// In development mode simply print to console.
|
|
FlutterError.dumpErrorToConsole(details);
|
|
} else {
|
|
// In production mode report to the application zone to report to
|
|
// Sentry.
|
|
Zone.current.handleUncaughtError(details.exception, details.stack);
|
|
}
|
|
};
|
|
|
|
// This creates a [Zone] that contains the Flutter application and stablishes
|
|
// an error handler that captures errors and reports them.
|
|
//
|
|
// Using a zone makes sure that as many errors as possible are captured,
|
|
// including those thrown from [Timer]s, microtasks, I/O, and those forwarded
|
|
// from the `FlutterError` handler.
|
|
//
|
|
// More about zones:
|
|
//
|
|
// - https://api.dartlang.org/stable/1.24.2/dart-async/Zone-class.html
|
|
// - https://www.dartlang.org/articles/libraries/zones
|
|
runZonedGuarded<Future<Null>>(() async {
|
|
final WorkoutTreeRepository menuTreeRepository = WorkoutTreeRepository();
|
|
runApp(MultiBlocProvider(
|
|
providers: [
|
|
BlocProvider<SessionBloc>(
|
|
create: (BuildContext context) => SessionBloc(session: Session()),
|
|
),
|
|
BlocProvider<MenuBloc>(
|
|
create: (BuildContext context) => MenuBloc(menuTreeRepository: menuTreeRepository),
|
|
),
|
|
BlocProvider<SettingsBloc>(
|
|
create: (BuildContext context) => SettingsBloc(),
|
|
),
|
|
BlocProvider<AccountBloc>(
|
|
create: (BuildContext context) => AccountBloc(customerRepository: CustomerRepository()),
|
|
),
|
|
BlocProvider<ExercisePlanBloc>(
|
|
create: (BuildContext context) => ExercisePlanBloc(menuTreeRepository: menuTreeRepository),
|
|
),
|
|
BlocProvider<ExerciseExecutePlanBloc>(
|
|
create: (BuildContext context) => ExerciseExecutePlanBloc(menuTreeRepository: menuTreeRepository),
|
|
),
|
|
BlocProvider<DevelopmentByMuscleBloc>(
|
|
create: (BuildContext context) => DevelopmentByMuscleBloc(workoutTreeRepository: menuTreeRepository),
|
|
),
|
|
BlocProvider<BodyDevelopmentBloc>(
|
|
create: (BuildContext context) => BodyDevelopmentBloc(workoutTreeRepository: menuTreeRepository),
|
|
),
|
|
],
|
|
child: WorkoutTestApp(),
|
|
));
|
|
}, (error, stackTrace) async {
|
|
await _reportError(error, stackTrace);
|
|
});
|
|
}
|
|
|
|
Future<void> initFlurry() async {
|
|
await Flurry.initialize(androidKey: "JNYCTCWBT34FM3J8TV36", iosKey: "3QBG7BSMGPDH24S8TRQP", enableLog: true);
|
|
//await Flurry.setUserId("userId");
|
|
//await Flurry.logEvent("eventName");
|
|
}
|
|
|
|
class WorkoutTestApp extends StatelessWidget {
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
SystemChrome.setPreferredOrientations([DeviceOrientation.portraitUp]);
|
|
//final FirebaseAnalytics analytics = FirebaseAnalytics();
|
|
initFlurry();
|
|
PushNotificationsManager().init();
|
|
return MaterialApp(
|
|
localizationsDelegates: [
|
|
// ... app-specific localization delegate[s] here
|
|
AppLocalizations.delegate,
|
|
GlobalMaterialLocalizations.delegate,
|
|
GlobalCupertinoLocalizations.delegate,
|
|
],
|
|
supportedLocales: [
|
|
const Locale('en', "US"), // English
|
|
const Locale('hu', "HU"), // Hungarian
|
|
// ... other locales the app supports
|
|
],
|
|
localeResolutionCallback: (Locale locale, Iterable<Locale> supportedLocales) {
|
|
//myLocale = deviceLocale ;
|
|
// here you make your app language similar to device language ,
|
|
// but you should check whether the localization is supported by your app
|
|
Locale realSupportedLocale = Locale('en', "US");
|
|
supportedLocales.forEach((supportedLocale) {
|
|
if (locale != null && supportedLocale != null && supportedLocale.countryCode == locale.countryCode) {
|
|
realSupportedLocale = supportedLocale;
|
|
}
|
|
});
|
|
if (locale != null && realSupportedLocale.countryCode != locale.countryCode) {
|
|
//print ("Locale " + locale.countryCode + " not supported on this device :(");
|
|
}
|
|
return realSupportedLocale;
|
|
},
|
|
routes: {
|
|
'home': (context) => AitrainerHome(),
|
|
'customerModifyPage': (context) => CustomerModifyPage(),
|
|
'customerGoalPage': (context) => CustomerGoalPage(),
|
|
'customerFitnessPage': (context) => CustomerFitnessPage(),
|
|
'customerBodyTypePage': (context) => CustomerBodyTypePage(),
|
|
'customerWelcomePage': (context) => CustomerWelcomePage(),
|
|
'customerExerciseDevicePage': (context) => CustomerExerciseDevicePage(),
|
|
'exerciseNewPage': (context) => ExerciseNewPage(),
|
|
'exerciseCustomPage': (context) => CustomExercisePage(),
|
|
'exerciseControlPage': (context) => ExerciseControlPage(),
|
|
'login': (context) => LoginPage(),
|
|
'resetPassword': (context) => ResetPasswordPage(),
|
|
'registration': (context) => RegistrationPage(),
|
|
'gdpr': (context) => Gdpr(),
|
|
'menu_page': (context) => MenuPage(),
|
|
'account': (context) => AccountPage(),
|
|
'settings': (context) => SettingsPage(),
|
|
'exerciseTypeDescription': (context) => ExerciseTypeDescription(),
|
|
'myDevelopment': (context) => MyDevelopmentPage(),
|
|
'myExercisePlan': (context) => MyExercisePlanPage(),
|
|
'exerciseLogPage': (context) => ExerciseLogPage(),
|
|
'exercisePlanCustomPage': (context) => ExercisePlanCustomPage(),
|
|
'exercisePlanDetailAdd': (context) => ExercisePlanDetailAddPage(),
|
|
'exerciseExecutePlanPage': (context) => ExerciseExecutePage(),
|
|
'exerciseExecuteAddPage': (context) => ExerciseExecutePlanAddPage(),
|
|
'mydevelopmentMusclePage': (context) => MyDevelopmentMusclePage(),
|
|
'mydevelopmentBodyPage': (context) => MyDevelopmentBodyPage(),
|
|
},
|
|
initialRoute: 'home',
|
|
title: 'WorkoutTest',
|
|
theme: ThemeData(
|
|
brightness: Brightness.light,
|
|
//primarySwatch: Colors.transparent,
|
|
//fontFamily: 'Arial',
|
|
textTheme: TextTheme(
|
|
bodyText1: GoogleFonts.openSans(textStyle: TextStyle(fontSize: 14.0)),
|
|
)),
|
|
navigatorObservers: [
|
|
//FirebaseAnalyticsObserver(analytics: analytics),
|
|
],
|
|
home: AitrainerHome(),
|
|
);
|
|
}
|
|
}
|