Minor improvements

lib/application/game_codes/game_codes_bloc.dart

@@ -4,6 +4,7 @@ import 'package:bloc/bloc.dart';
 import 'package:freezed_annotation/freezed_annotation.dart';
 import 'package:genshindb/domain/models/models.dart';
 import 'package:genshindb/domain/services/genshin_service.dart';
+import 'package:genshindb/domain/services/telemetry_service.dart';
 import 'package:meta/meta.dart';
 
 part 'game_codes_bloc.freezed.dart';
@@ -12,20 +13,25 @@ part 'game_codes_state.dart';
 
 class GameCodesBloc extends Bloc<GameCodesEvent, GameCodesState> {
   final GenshinService _genshinService;
+  final TelemetryService _telemetryService;
 
-  GameCodesBloc(this._genshinService) : super(const GameCodesState.loading());
+  GameCodesBloc(this._genshinService, this._telemetryService) : super(const GameCodesState.loading());
 
   @override
   Stream<GameCodesState> mapEventToState(GameCodesEvent event) async* {
-    final s = event.when(
-      init: () {
+    final s = await event.when(
+      init: () async {
         final gameCodes = _genshinService.getAllGameCodes();
 
         return GameCodesState.loaded(
           workingGameCodes: gameCodes.where((code) => !code.isExpired).toList(),
           expiredGameCodes: gameCodes.where((code) => code.isExpired).toList(),
         );
       },
+      opened: () async {
+        await _telemetryService.trackGameCodesOpened();
+        return state;
+      },
     );
 
     yield s;

lib/application/game_codes/game_codes_event.dart

@@ -3,4 +3,6 @@ part of 'game_codes_bloc.dart';
 @freezed
 abstract class GameCodesEvent with _$GameCodesEvent {
   const factory GameCodesEvent.init() = _Init;
+
+  const factory GameCodesEvent.opened() = _Opened;
 }

lib/application/tierlist/tier_list_bloc.dart

@@ -4,6 +4,7 @@ import 'package:bloc/bloc.dart';
 import 'package:freezed_annotation/freezed_annotation.dart';
 import 'package:genshindb/domain/models/models.dart';
 import 'package:genshindb/domain/services/genshin_service.dart';
+import 'package:genshindb/domain/services/logging_service.dart';
 import 'package:genshindb/domain/services/telemetry_service.dart';
 import 'package:meta/meta.dart';
 
@@ -14,6 +15,7 @@ part 'tier_list_state.dart';
 class TierListBloc extends Bloc<TierListEvent, TierListState> {
   final GenshinService _genshinService;
   final TelemetryService _telemetryService;
+  final LoggingService _loggingService;
   final List<int> defaultColors = [
     0xfff44336,
     0xffff9800,
@@ -24,7 +26,7 @@ class TierListBloc extends Bloc<TierListEvent, TierListState> {
 
   _LoadedState get currentState => state as _LoadedState;
 
-  TierListBloc(this._genshinService, this._telemetryService) : super(const TierListState.loading());
+  TierListBloc(this._genshinService, this._telemetryService, this._loggingService) : super(const TierListState.loading());
 
   @override
   Stream<TierListState> mapEventToState(TierListEvent event) async* {
@@ -44,6 +46,15 @@ class TierListBloc extends Bloc<TierListEvent, TierListState> {
       addCharacterToRow: (e) async => _addCharacterToRow(e.index, e.charImg),
       deleteCharacterFromRow: (e) async => _deleteCharacterFromRow(e.index, e.charImg),
       readyToSave: (e) async => currentState.copyWith.call(readyToSave: e.ready),
+      screenshotTaken: (e) async {
+        if (e.succeed) {
+          await _telemetryService.trackTierListBuilderScreenShootTaken();
+        } else {
+          _loggingService.error(runtimeType, 'Something went wrong while taking the tier list builder screenshot', e.ex, e.trace);
+        }
+
+        return currentState;
+      },
     );
 
     yield s;

lib/application/tierlist/tier_list_event.dart

@@ -45,4 +45,10 @@ abstract class TierListEvent with _$TierListEvent {
   }) = _DeleteCharacterFromRow;
 
   const factory TierListEvent.readyToSave({@required bool ready}) = _ReadyToSave;
+
+  const factory TierListEvent.screenshotTaken({
+    @required bool succeed,
+    dynamic ex,
+    StackTrace trace,
+  }) = _ScreenshotTaken;
 }

lib/domain/services/telemetry_service.dart

@@ -29,4 +29,8 @@ abstract class TelemetryService {
   Future<void> trackTierListOpened();
 
   Future<void> trackInit(AppSettings settings);
+
+  Future<void> trackGameCodesOpened();
+
+  Future<void> trackTierListBuilderScreenShootTaken();
 }

lib/infrastructure/telemetry/telemetry_service.dart

@@ -81,9 +81,7 @@ class TelemetryServiceImpl implements TelemetryService {
   }
 
   @override
-  Future<void> trackTierListOpened() async {
-    await trackEventAsync('TierList-Opened');
-  }
+  Future<void> trackTierListOpened() => trackEventAsync('TierList-Opened');
 
   @override
   Future<void> trackInit(AppSettings settings) async {
@@ -97,4 +95,10 @@ class TelemetryServiceImpl implements TelemetryService {
       'ServerResetTime': EnumToString.convertToString(settings.serverResetTime),
     });
   }
+
+  @override
+  Future<void> trackGameCodesOpened() => trackEventAsync('GameCodes-Opened');
+
+  @override
+  Future<void> trackTierListBuilderScreenShootTaken() => trackEventAsync('TierListBuilder-ScreenShootTaken');
 }

lib/main.dart

@@ -96,7 +96,8 @@ class MyApp extends StatelessWidget {
         BlocProvider(
           create: (ctx) {
             final genshinService = getIt<GenshinService>();
-            return GameCodesBloc(genshinService);
+            final telemetryService = getIt<TelemetryService>();
+            return GameCodesBloc(genshinService, telemetryService);
           },
         ),
         BlocProvider(
@@ -142,7 +143,8 @@ class MyApp extends StatelessWidget {
           create: (_) {
             final genshinService = getIt<GenshinService>();
             final telemetryService = getIt<TelemetryService>();
-            return TierListBloc(genshinService, telemetryService);
+            final loggingService = getIt<LoggingService>();
+            return TierListBloc(genshinService, telemetryService, loggingService);
           },
         ),
       ],

lib/presentation/game_codes/game_codes_page.dart

@@ -23,22 +23,25 @@ class GameCodesPage extends StatelessWidget {
       appBar: AppBar(title: Text(s.gameCodes)),
       body: SafeArea(
         child: SingleChildScrollView(
-          child: Column(
-            crossAxisAlignment: CrossAxisAlignment.stretch,
-            children: [
-              BlocBuilder<GameCodesBloc, GameCodesState>(
-                builder: (ctx, state) => state.map(
-                  loading: (_) => const Loading(useScaffold: false),
-                  loaded: (state) => _buildTableCard(s.workingCodes, state.workingGameCodes, context),
+          child: Padding(
+            padding: Styles.edgeInsetAll10,
+            child: Column(
+              crossAxisAlignment: CrossAxisAlignment.stretch,
+              children: [
+                BlocBuilder<GameCodesBloc, GameCodesState>(
+                  builder: (ctx, state) => state.map(
+                    loading: (_) => const Loading(useScaffold: false),
+                    loaded: (state) => _buildTableCard(s.workingCodes, state.workingGameCodes, context),
+                  ),
                 ),
-              ),
-              BlocBuilder<GameCodesBloc, GameCodesState>(
-                builder: (ctx, state) => state.map(
-                  loading: (_) => const Loading(useScaffold: false),
-                  loaded: (state) => _buildTableCard(s.expiredCodes, state.expiredGameCodes, context),
+                BlocBuilder<GameCodesBloc, GameCodesState>(
+                  builder: (ctx, state) => state.map(
+                    loading: (_) => const Loading(useScaffold: false),
+                    loaded: (state) => _buildTableCard(s.expiredCodes, state.expiredGameCodes, context),
+                  ),
                 ),
-              ),
-            ],
+              ],
+            ),
           ),
         ),
       ),

lib/presentation/settings/widgets/other_settings.dart

@@ -110,6 +110,7 @@ class OtherSettings extends StatelessWidget {
   }
 
   Future<void> _showGameCodesDialog(BuildContext context) async {
+    context.read<GameCodesBloc>().add(const GameCodesEvent.opened());
     await Navigator.push(context, MaterialPageRoute(fullscreenDialog: true, builder: (ctx) => const GameCodesPage()));
   }
 }

lib/presentation/tierlist/tier_list_page.dart

@@ -118,6 +118,7 @@ class _TierListPageState extends State<TierListPage> {
 
   Future<void> _takeScreenshot() async {
     final s = S.of(context);
+    final bloc = context.read<TierListBloc>();
     try {
       if (!await Permission.storage.request().isGranted) {
         ToastUtils.showInfoToast(s.acceptToSaveImg);
@@ -127,8 +128,10 @@ class _TierListPageState extends State<TierListPage> {
       final bytes = await screenshotController.capture(pixelRatio: 1.5);
       ImageGallerySaver.saveImage(bytes, quality: 100);
       ToastUtils.showSucceedToast(s.imgSavedSuccessfully);
-    } catch (e) {
+      bloc.add(const TierListEvent.screenshotTaken(succeed: true));
+    } catch (e, trace) {
       ToastUtils.showErrorToast(s.unknownError);
+      bloc.add(TierListEvent.screenshotTaken(succeed: false, ex: e, trace: trace));
     }
   }
 }