Theme cleanup

analysis_options.yaml

@@ -0,0 +1,20 @@
+# This file configures the analyzer to use the lint rule set from `package:lint`
+
+# For apps, use the default set
+include: package:lint/analysis_options.yaml
+
+# You might want to exclude auto-generated files from dart analysis
+analyzer:
+  exclude:
+    - "**.g.dart"
+
+# You can customize the lint rules set to your own liking. A list of all rules
+# can be found at https://dart-lang.github.io/linter/lints/options/options.html
+linter:
+  rules:
+    constant_identifier_names: false
+    avoid_print: false
+    avoid_positional_boolean_parameters: false
+    use_build_context_synchronously: false
+    parameter_assignments: false
+    avoid_setters_without_getters: false

lib/common/appstart/app_initializer.dart

@@ -5,13 +5,13 @@ import 'package:dhbwstudentapp/common/appstart/localization_initialize.dart';
 import 'package:dhbwstudentapp/common/appstart/notification_schedule_changed_initialize.dart';
 import 'package:dhbwstudentapp/common/appstart/notifications_initialize.dart';
 import 'package:dhbwstudentapp/common/appstart/service_injector.dart';
+import 'package:dhbwstudentapp/common/data/preferences/preferences_provider.dart';
 import 'package:dhbwstudentapp/common/iap/in_app_purchase_manager.dart';
 import 'package:dhbwstudentapp/native/widget/widget_update_callback.dart';
 import 'package:dhbwstudentapp/schedule/background/calendar_synchronizer.dart';
+import 'package:dhbwstudentapp/schedule/business/schedule_provider.dart';
 import 'package:dhbwstudentapp/schedule/business/schedule_source_provider.dart';
 import 'package:kiwi/kiwi.dart';
-import 'package:dhbwstudentapp/schedule/business/schedule_provider.dart';
-import 'package:dhbwstudentapp/common/data/preferences/preferences_provider.dart';
 import 'package:timezone/data/latest.dart' as tz;
 
 bool isInitialized = false;
@@ -52,20 +52,21 @@ Future<void> initializeApp(bool isBackground) async {
   WidgetUpdateCallback(KiwiContainer().resolve())
       .registerCallback(KiwiContainer().resolve());
 
-  NotificationsInitialize().setupNotifications();
-  BackgroundInitialize().setupBackgroundScheduling();
-  NotificationScheduleChangedInitialize().setupNotification();
+  const NotificationsInitialize().setupNotifications();
+  const BackgroundInitialize().setupBackgroundScheduling();
+  const NotificationScheduleChangedInitialize().setupNotification();
 
   if (isBackground) {
-    var setup = KiwiContainer().resolve<ScheduleSourceProvider>();
+    final setup = KiwiContainer().resolve<ScheduleSourceProvider>();
     setup.setupScheduleSource();
   }
 
   // Callback-Function for synchronizing the device calendar with the schedule, when schedule is updated
-  CalendarSynchronizer calendarSynchronizer = new CalendarSynchronizer(
-      KiwiContainer().resolve<ScheduleProvider>(),
-      KiwiContainer().resolve<ScheduleSourceProvider>(),
-      KiwiContainer().resolve<PreferencesProvider>());
+  final CalendarSynchronizer calendarSynchronizer = CalendarSynchronizer(
+    KiwiContainer().resolve<ScheduleProvider>(),
+    KiwiContainer().resolve<ScheduleSourceProvider>(),
+    KiwiContainer().resolve<PreferencesProvider>(),
+  );
 
   calendarSynchronizer.registerSynchronizationCallback();
   calendarSynchronizer.scheduleSyncInAFewSeconds();

lib/common/appstart/background_initialize.dart

@@ -12,6 +12,8 @@ import 'package:kiwi/kiwi.dart';
 /// Note: More or less reliable background scheduling only works on android
 ///
 class BackgroundInitialize {
+  const BackgroundInitialize();
+
   Future<void> setupBackgroundScheduling() async {
     WorkSchedulerService scheduler;
     if (Platform.isAndroid) {
@@ -22,7 +24,7 @@ class BackgroundInitialize {
 
     KiwiContainer().registerInstance<WorkSchedulerService>(scheduler);
 
-    var tasks = [
+    final tasks = [
       BackgroundScheduleUpdate(
         KiwiContainer().resolve(),
         KiwiContainer().resolve(),
@@ -37,7 +39,7 @@ class BackgroundInitialize {
       ),
     ];
 
-    for (var task in tasks) {
+    for (final task in tasks) {
       scheduler.registerTask(task);
 
       KiwiContainer().registerInstance(

lib/common/appstart/localization_initialize.dart

@@ -9,24 +9,28 @@ import 'package:kiwi/kiwi.dart';
 /// correct language
 ///
 class LocalizationInitialize {
-  PreferencesProvider _preferencesProvider;
-  String _languageCode;
+  final PreferencesProvider? _preferencesProvider;
+  final String? _languageCode;
 
   ///
   /// Initialize the localization using the provided language code
   ///
-  LocalizationInitialize.fromLanguageCode(this._languageCode);
+  const LocalizationInitialize.fromLanguageCode(this._languageCode)
+      : _preferencesProvider = null;
 
   ///
   /// Initialize the localization using the locale from the preferences provider
   ///
-  LocalizationInitialize.fromPreferences(this._preferencesProvider);
+  const LocalizationInitialize.fromPreferences(this._preferencesProvider)
+      : _languageCode = null;
 
   Future<void> setupLocalizations() async {
-    var localization = L(Locale(
-      _languageCode ??
-          (await _preferencesProvider?.getLastUsedLanguageCode() ?? "en"),
-    ));
+    final localization = L(
+      Locale(
+        _languageCode ??
+            (await _preferencesProvider?.getLastUsedLanguageCode() ?? "en"),
+      ),
+    );
     KiwiContainer().registerInstance(localization);
   }
 }

lib/common/appstart/notification_schedule_changed_initialize.dart

@@ -8,19 +8,21 @@ import 'package:kiwi/kiwi.dart';
 /// Initializes the notification for when the schedule changed
 ///
 class NotificationScheduleChangedInitialize {
+  const NotificationScheduleChangedInitialize();
+
   void setupNotification() {
-    var provider = KiwiContainer().resolve<ScheduleProvider>();
+    final provider = KiwiContainer().resolve<ScheduleProvider>();
 
     provider.addScheduleEntryChangedCallback(_scheduleChangedCallback);
   }
 
   Future<void> _scheduleChangedCallback(ScheduleDiff scheduleDiff) async {
-    PreferencesProvider preferences = KiwiContainer().resolve();
-    var doNotify = await preferences.getNotifyAboutScheduleChanges();
+    final PreferencesProvider preferences = KiwiContainer().resolve();
+    final doNotify = await preferences.getNotifyAboutScheduleChanges();
 
     if (!doNotify) return;
 
-    var notification = ScheduleChangedNotification(
+    final notification = ScheduleChangedNotification(
       KiwiContainer().resolve(),
       KiwiContainer().resolve(),
     );

lib/common/appstart/notifications_initialize.dart

@@ -9,15 +9,18 @@ import 'package:kiwi/kiwi.dart';
 /// won't show the notification
 ///
 class NotificationsInitialize {
+  const NotificationsInitialize();
+
   Future<void> setupNotifications() async {
     if (Platform.isAndroid) {
-      var notificationApi = NotificationApi();
+      final notificationApi = NotificationApi();
 
       KiwiContainer().registerInstance(notificationApi);
 
       await notificationApi.initialize();
     } else {
-      KiwiContainer().registerInstance<NotificationApi>(VoidNotificationApi());
+      KiwiContainer()
+          .registerInstance<NotificationApi>(const VoidNotificationApi());
     }
   }
 }

lib/common/appstart/service_injector.dart

@@ -28,46 +28,62 @@ bool _isInjected = false;
 void injectServices(bool isBackground) {
   if (_isInjected) return;
 
-  KiwiContainer c = KiwiContainer();
-  c.registerInstance(PreferencesProvider(
-    PreferencesAccess(),
-    SecureStorageAccess(),
-  ));
-  c.registerInstance(DatabaseAccess());
-  c.registerInstance(ScheduleEntryRepository(
-    c.resolve(),
-  ));
-  c.registerInstance(ScheduleFilterRepository(
-    c.resolve(),
-  ));
-  c.registerInstance(ScheduleQueryInformationRepository(
-    c.resolve(),
-  ));
-  c.registerInstance(ScheduleSourceProvider(
-    c.resolve(),
-    isBackground,
-    c.resolve(),
-    c.resolve(),
-  ));
-  c.registerInstance(ScheduleProvider(
-    c.resolve(),
-    c.resolve(),
-    c.resolve(),
-    c.resolve(),
-    c.resolve(),
-  ));
+  final KiwiContainer c = KiwiContainer();
+  c.registerInstance(
+    const PreferencesProvider(
+      PreferencesAccess(),
+      SecureStorageAccess(),
+    ),
+  );
+  c.registerInstance(const DatabaseAccess());
+  c.registerInstance(
+    ScheduleEntryRepository(
+      c.resolve(),
+    ),
+  );
+  c.registerInstance(
+    ScheduleFilterRepository(
+      c.resolve(),
+    ),
+  );
+  c.registerInstance(
+    ScheduleQueryInformationRepository(
+      c.resolve(),
+    ),
+  );
+  c.registerInstance(
+    ScheduleSourceProvider(
+      c.resolve(),
+      isBackground,
+      c.resolve(),
+      c.resolve(),
+    ),
+  );
+  c.registerInstance(
+    ScheduleProvider(
+      c.resolve(),
+      c.resolve(),
+      c.resolve(),
+      c.resolve(),
+      c.resolve(),
+    ),
+  );
   c.registerInstance<DualisScraper>(
     FakeAccountDualisScraperDecorator(DualisScraper()),
   );
-  c.registerInstance<DualisService>(CacheDualisServiceDecorator(
-    DualisServiceImpl(
-      c.resolve(),
+  c.registerInstance<DualisService>(
+    CacheDualisServiceDecorator(
+      DualisServiceImpl(
+        c.resolve(),
+      ),
     ),
-  ));
-  c.registerInstance(DateEntryProvider(
-    DateManagementService(),
-    DateEntryRepository(c.resolve()),
-  ));
+  );
+  c.registerInstance(
+    DateEntryProvider(
+      const DateManagementService(),
+      DateEntryRepository(c.resolve()),
+    ),
+  );
   c.registerInstance(WidgetHelper());
   c.registerInstance(ListDateEntries30d(List<DateEntry>.empty(growable: true)));
 

lib/common/background/background_work_scheduler.dart

@@ -23,7 +23,10 @@ class BackgroundWorkScheduler extends WorkSchedulerService {
   ///
   @override
   Future<void> scheduleOneShotTaskIn(
-      Duration delay, String id, String name) async {
+    Duration delay,
+    String id,
+    String name,
+  ) async {
     print(
       "Scheduling one shot task: $id. With a delay of ${delay.inMinutes} minutes.",
     );
@@ -103,13 +106,16 @@ class BackgroundWorkScheduler extends WorkSchedulerService {
   ///
   /// Entry point for when a background task is executed
   ///
-  static Future<bool> backgroundTaskMain(taskId, inputData) async {
+  static Future<bool> backgroundTaskMain(
+    String taskId,
+    Map<String, dynamic>? inputData,
+  ) async {
     try {
       print("Background task started: $taskId with data: $inputData");
 
       await initializeApp(true);
 
-      WorkSchedulerService scheduler = KiwiContainer().resolve();
+      final WorkSchedulerService scheduler = KiwiContainer().resolve();
 
       await scheduler.executeTask(taskId);
     } catch (e, trace) {
@@ -129,7 +135,6 @@ class BackgroundWorkScheduler extends WorkSchedulerService {
 
     await workmanager.initialize(
       callbackDispatcher,
-      isInDebugMode: false,
     );
   }
 

lib/common/background/task_callback.dart

@@ -2,6 +2,8 @@
 /// Override this class in order to receive a background callback
 ///
 abstract class TaskCallback {
+  const TaskCallback();
+
   Future<void> run();
 
   Future<void> schedule();

lib/common/background/work_scheduler_service.dart

@@ -1,6 +1,8 @@
 import 'package:dhbwstudentapp/common/background/task_callback.dart';
 
 abstract class WorkSchedulerService {
+  const WorkSchedulerService();
+
   Future<void> scheduleOneShotTaskIn(Duration delay, String id, String name);
 
   Future<void> scheduleOneShotTaskAt(