Minor improvements

lib/application/main/main_bloc.dart

@@ -2,15 +2,14 @@ import 'dart:async';
 
 import 'package:bloc/bloc.dart';
 import 'package:freezed_annotation/freezed_annotation.dart';
-import 'package:genshindb/application/utils/app_path_utils.dart';
 import 'package:genshindb/domain/enums/enums.dart';
 import 'package:genshindb/domain/models/models.dart';
+import 'package:genshindb/domain/services/device_info_service.dart';
 import 'package:genshindb/domain/services/genshin_service.dart';
 import 'package:genshindb/domain/services/locale_service.dart';
 import 'package:genshindb/domain/services/logging_service.dart';
 import 'package:genshindb/domain/services/settings_service.dart';
 import 'package:genshindb/domain/services/telemetry_service.dart';
-import 'package:package_info/package_info.dart';
 
 import '../bloc.dart';
 
@@ -24,6 +23,7 @@ class MainBloc extends Bloc<MainEvent, MainState> {
   final SettingsService _settingsService;
   final LocaleService _localeService;
   final TelemetryService _telemetryService;
+  final DeviceInfoService _deviceInfoService;
 
   final CharactersBloc _charactersBloc;
   final WeaponsBloc _weaponsBloc;
@@ -36,6 +36,7 @@ class MainBloc extends Bloc<MainEvent, MainState> {
     this._settingsService,
     this._localeService,
     this._telemetryService,
+    this._deviceInfoService,
     this._charactersBloc,
     this._weaponsBloc,
     this._homeBloc,
@@ -49,33 +50,17 @@ class MainBloc extends Bloc<MainEvent, MainState> {
     MainEvent event,
   ) async* {
     final s = await event.when(
-      init: () async {
-        return _init(init: true);
-      },
-      themeChanged: (theme) async {
-        return _loadThemeData(currentState.appTitle, theme, _settingsService.accentColor);
-      },
-      accentColorChanged: (accentColor) async {
-        return _loadThemeData(currentState.appTitle, _settingsService.appTheme, accentColor);
-      },
-      languageChanged: (language) async {
-        return _init(languageChanged: true);
-      },
+      init: () async => _init(init: true),
+      themeChanged: (theme) async => _loadThemeData(theme, _settingsService.accentColor),
+      accentColorChanged: (accentColor) async => _loadThemeData(_settingsService.appTheme, accentColor),
+      languageChanged: (language) async => _init(languageChanged: true),
     );
 
     yield s;
   }
 
   Future<MainState> _init({bool languageChanged = false, bool init = false}) async {
     _logger.info(runtimeType, '_init: Initializing all..');
-    await _settingsService.init();
-
-    _logger.info(runtimeType, '_init: Deleting old logs...');
-    try {
-      await AppPathUtils.deleteOlLogs();
-    } catch (e, s) {
-      _logger.error(runtimeType, '_init: Unknown error while trying to delete old logs', e, s);
-    }
     await _genshinService.init(_settingsService.language);
 
     if (languageChanged) {
@@ -86,27 +71,27 @@ class MainBloc extends Bloc<MainEvent, MainState> {
       _artifactsBloc.add(const ArtifactsEvent.init());
     }
 
-    final packageInfo = await PackageInfo.fromPlatform();
     final settings = _settingsService.appSettings;
     await _telemetryService.trackInit(settings);
 
+    final state = _loadThemeData(settings.appTheme, settings.accentColor);
+
     if (init) {
       await Future.delayed(const Duration(milliseconds: 600));
     }
 
-    return _loadThemeData(packageInfo.appName, settings.appTheme, settings.accentColor);
+    return state;
   }
 
   Future<MainState> _loadThemeData(
-    String appTitle,
     AppThemeType theme,
     AppAccentColorType accentColor, {
     bool isInitialized = true,
   }) async {
     _logger.info(runtimeType, '_init: Is first install = ${_settingsService.isFirstInstall}');
 
     return MainState.loaded(
-      appTitle: appTitle,
+      appTitle: _deviceInfoService.appName,
       accentColor: accentColor,
       language: _localeService.getLocaleWithoutLang(),
       initialized: isInitialized,

lib/application/settings/settings_bloc.dart

@@ -29,7 +29,6 @@ class SettingsBloc extends Bloc<SettingsEvent, SettingsState> {
   ) async* {
     final s = await event.map(
       init: (_) async {
-        await _settingsService.init();
         final settings = _settingsService.appSettings;
         return SettingsState.loaded(
           currentTheme: settings.appTheme,

lib/domain/services/device_info_service.dart

@@ -1,6 +1,8 @@
 abstract class DeviceInfoService {
   Map<String, String> get deviceInfo;
 
+  String get appName;
+
   String get version;
 
   Future<void> init();

lib/infrastructure/device_info_service.dart

@@ -5,10 +5,14 @@ import 'package:package_info/package_info.dart';
 class DeviceInfoServiceImpl implements DeviceInfoService {
   Map<String, String> _deviceInfo;
   String _version;
+  String _appName;
 
   @override
   Map<String, String> get deviceInfo => _deviceInfo;
 
+  @override
+  String get appName => _appName;
+
   @override
   String get version => _version;
 
@@ -19,14 +23,15 @@ class DeviceInfoServiceImpl implements DeviceInfoService {
       final androidInfo = await deviceInfo.androidInfo;
       final packageInfo = await PackageInfo.fromPlatform();
       _version = packageInfo.version;
+      _appName = packageInfo.appName;
       _deviceInfo = {
         'Model': androidInfo.model,
         'OsVersion': '${androidInfo.version.sdkInt}',
         'AppVersion': '${packageInfo.version}+${packageInfo.buildNumber}'
       };
     } catch (ex) {
       _deviceInfo = {'Model': 'N/A', 'OsVersion': 'N/A', 'AppVersion': 'N/A'};
-      _version = 'N/A';
+      _version = _appName = 'N/A';
     }
   }
 }

lib/infrastructure/settings_service.dart

@@ -83,7 +83,7 @@ class SettingsServiceImpl extends SettingsService {
       return;
     }
 
-    _logger.info(runtimeType, 'Getting shared prefs instance...');
+    _logger.info(runtimeType, 'Initializing settings... Getting shared prefs instance...');
 
     _prefs = await SharedPreferences.getInstance();
 

lib/injection.dart

@@ -26,7 +26,9 @@ Future<void> initInjection() async {
   final loggingService = LoggingServiceImpl(getIt<TelemetryService>(), deviceInfoService);
 
   getIt.registerSingleton<LoggingService>(loggingService);
-  getIt.registerSingleton<SettingsService>(SettingsServiceImpl(loggingService));
+  final settingsService = SettingsServiceImpl(loggingService);
+  await settingsService.init();
+  getIt.registerSingleton<SettingsService>(settingsService);
   getIt.registerSingleton<LocaleService>(LocaleServiceImpl(getIt<SettingsService>()));
   getIt.registerSingleton<GenshinService>(GenshinServiceImpl(getIt<LocaleService>()));
   getIt.registerSingleton<CalculatorService>(CalculatorServiceImpl(getIt<GenshinService>()));

lib/main.dart

@@ -114,12 +114,14 @@ class MyApp extends StatelessWidget {
             final settingsService = getIt<SettingsService>();
             final localeService = getIt<LocaleService>();
             final telemetryService = getIt<TelemetryService>();
+            final deviceInfoService = getIt<DeviceInfoService>();
             return MainBloc(
               loggingService,
               genshinService,
               settingsService,
               localeService,
               telemetryService,
+              deviceInfoService,
               ctx.read<CharactersBloc>(),
               ctx.read<WeaponsBloc>(),
               ctx.read<HomeBloc>(),