Merge pull request #130 from Wolfteam/feature/code_improvements

feature/code_improvements
Wolfteam · Jan 1, 2022 · 9387d1d · 9387d1d
2 parents 8353f98 + 21d1692
commit 9387d1d
Show file tree

Hide file tree

Showing 47 changed files with 442 additions and 529 deletions.
diff --git a/lib/application/artifact/artifact_bloc.dart b/lib/application/artifact/artifact_bloc.dart
@@ -1,7 +1,7 @@
 import 'dart:async';
 
+import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:freezed_annotation/freezed_annotation.dart';
-import 'package:shiori/application/common/pop_bloc.dart';
 import 'package:shiori/domain/models/models.dart';
 import 'package:shiori/domain/services/genshin_service.dart';
 import 'package:shiori/domain/services/telemetry_service.dart';
@@ -10,15 +10,12 @@ part 'artifact_bloc.freezed.dart';
 part 'artifact_event.dart';
 part 'artifact_state.dart';
 
-class ArtifactBloc extends PopBloc<ArtifactEvent, ArtifactState> {
+class ArtifactBloc extends Bloc<ArtifactEvent, ArtifactState> {
   final GenshinService _genshinService;
   final TelemetryService _telemetryService;
 
   ArtifactBloc(this._genshinService, this._telemetryService) : super(const ArtifactState.loading());
 
-  @override
-  ArtifactEvent getEventForPop(String? key) => ArtifactEvent.loadFromKey(key: key!, addToQueue: false);
-
   @override
   Stream<ArtifactState> mapEventToState(ArtifactEvent event) async* {
     yield const ArtifactState.loading();
@@ -32,10 +29,7 @@ class ArtifactBloc extends PopBloc<ArtifactEvent, ArtifactState> {
         final images = _genshinService.getArtifactRelatedParts(artifact.fullImagePath, artifact.image, translation.bonus.length);
         final bonus = _genshinService.getArtifactBonus(translation);
 
-        if (e.addToQueue) {
-          await _telemetryService.trackArtifactLoaded(e.key);
-          currentItemsInStack.add(artifact.key);
-        }
+        await _telemetryService.trackArtifactLoaded(e.key);
 
         return ArtifactState.loaded(
           name: translation.name,

diff --git a/lib/application/artifact/artifact_event.dart b/lib/application/artifact/artifact_event.dart
@@ -2,8 +2,5 @@ part of 'artifact_bloc.dart';
 
 @freezed
 class ArtifactEvent with _$ArtifactEvent {
-  const factory ArtifactEvent.loadFromKey({
-    required String key,
-    @Default(true) bool addToQueue,
-  }) = _LoadArtifact;
+  const factory ArtifactEvent.loadFromKey({required String key}) = _LoadArtifact;
 }
diff --git a/lib/application/character/character_bloc.dart b/lib/application/character/character_bloc.dart
@@ -1,7 +1,7 @@
 import 'dart:async';
 
+import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:freezed_annotation/freezed_annotation.dart';
-import 'package:shiori/application/common/pop_bloc.dart';
 import 'package:shiori/domain/app_constants.dart';
 import 'package:shiori/domain/assets.dart';
 import 'package:shiori/domain/enums/enums.dart';
@@ -15,7 +15,7 @@ part 'character_bloc.freezed.dart';
 part 'character_event.dart';
 part 'character_state.dart';
 
-class CharacterBloc extends PopBloc<CharacterEvent, CharacterState> {
+class CharacterBloc extends Bloc<CharacterEvent, CharacterState> {
   final GenshinService _genshinService;
   final TelemetryService _telemetryService;
   final LocaleService _localeService;
@@ -29,39 +29,31 @@ class CharacterBloc extends PopBloc<CharacterEvent, CharacterState> {
   ) : super(const CharacterState.loading());
 
   @override
-  CharacterEvent getEventForPop(String? key) => CharacterEvent.loadFromKey(key: key!, addToQueue: false);
-
-  @override
-  Stream<CharacterState> mapEventToState(
-    CharacterEvent event,
-  ) async* {
-    if (event is! _AddedToInventory) {
-      yield const CharacterState.loading();
-    }
-
+  Stream<CharacterState> mapEventToState(CharacterEvent event) async* {
     final s = await event.when(
-      loadFromKey: (key, addToQueue) async {
+      loadFromKey: (key) async {
         final char = _genshinService.getCharacter(key);
         final translation = _genshinService.getCharacterTranslation(key);
 
-        if (addToQueue) {
-          await _telemetryService.trackCharacterLoaded(key);
-          currentItemsInStack.add(char.key);
-        }
+        await _telemetryService.trackCharacterLoaded(key);
         return _buildInitialState(char, translation);
       },
-      addedToInventory: (key, wasAdded) async {
-        if (state is! _LoadedState) {
-          return state;
-        }
-
-        final currentState = state as _LoadedState;
-        if (currentState.key != key) {
-          return state;
-        }
-
-        return currentState.copyWith.call(isInInventory: wasAdded);
-      },
+      addToInventory: (key) async => state.map(
+        loading: (state) async => state,
+        loaded: (state) async {
+          await _telemetryService.trackItemAddedToInventory(key, 1);
+          await _dataService.addCharacterToInventory(key);
+          return state.copyWith.call(isInInventory: true);
+        },
+      ),
+      deleteFromInventory: (key) async => state.map(
+        loading: (state) async => state,
+        loaded: (state) async {
+          await _telemetryService.trackItemDeletedFromInventory(key);
+          await _dataService.deleteCharacterFromInventory(key);
+          return state.copyWith.call(isInInventory: false);
+        },
+      ),
     );
 
     yield s;

diff --git a/lib/application/character/character_event.dart b/lib/application/character/character_event.dart
@@ -2,13 +2,9 @@ part of 'character_bloc.dart';
 
 @freezed
 class CharacterEvent with _$CharacterEvent {
-  const factory CharacterEvent.loadFromKey({
-    required String key,
-    @Default(true) bool addToQueue,
-  }) = _LoadCharacterFroName;
+  const factory CharacterEvent.loadFromKey({required String key}) = _LoadCharacterFroName;
 
-  const factory CharacterEvent.addedToInventory({
-    required String key,
-    required bool wasAdded,
-  }) = _AddedToInventory;
+  const factory CharacterEvent.addToInventory({required String key}) = _AddToInventory;
+
+  const factory CharacterEvent.deleteFromInventory({required String key}) = _DeleteFromInventory;
 }
diff --git a/lib/application/common/pop_bloc.dart b/lib/application/common/pop_bloc.dart
diff --git a/lib/application/inventory/inventory_bloc.dart b/lib/application/inventory/inventory_bloc.dart
@@ -3,7 +3,6 @@ import 'dart:async';
 import 'package:bloc/bloc.dart';
 import 'package:freezed_annotation/freezed_annotation.dart';
 import 'package:meta/meta.dart';
-import 'package:shiori/application/bloc.dart';
 import 'package:shiori/domain/enums/enums.dart';
 import 'package:shiori/domain/models/models.dart';
 import 'package:shiori/domain/services/data_service.dart';
@@ -18,16 +17,20 @@ class InventoryBloc extends Bloc<InventoryEvent, InventoryState> {
   final GenshinService _genshinService;
   final DataService _dataService;
   final TelemetryService _telemetryService;
-  final CharacterBloc _characterBloc;
-  final WeaponBloc _weaponBloc;
+
+  late final List<StreamSubscription> _streamSubscriptions;
 
   InventoryBloc(
     this._genshinService,
     this._dataService,
     this._telemetryService,
-    this._characterBloc,
-    this._weaponBloc,
-  ) : super(const InventoryState.loading());
+  ) : super(const InventoryState.loaded(characters: [], weapons: [], materials: [])) {
+    _streamSubscriptions = [
+      _dataService.itemAddedToInventory.stream.listen((type) => add(InventoryEvent.refresh(type: type))),
+      _dataService.itemDeletedFromInventory.stream.listen((type) => add(InventoryEvent.refresh(type: type))),
+      _dataService.itemUpdatedInInventory.stream.listen((type) => add(InventoryEvent.refresh(type: type))),
+    ];
+  }
 
   @override
   Stream<InventoryState> mapEventToState(InventoryEvent event) async* {
@@ -41,86 +44,69 @@ class InventoryBloc extends Bloc<InventoryEvent, InventoryState> {
       },
       addCharacter: (e) async {
         await _telemetryService.trackItemAddedToInventory(e.key, 1);
-        await _dataService.addItemToInventory(e.key, ItemType.character, 1);
-        _characterBloc.add(CharacterEvent.addedToInventory(key: e.key, wasAdded: true));
-
-        return state.map(
-          loading: (state) => state,
-          loaded: (state) => state.copyWith.call(characters: _dataService.getAllCharactersInInventory()),
-        );
+        await _dataService.addCharacterToInventory(e.key, raiseEvent: false);
+        return _refreshItems(ItemType.character);
       },
       addWeapon: (e) async {
         await _telemetryService.trackItemAddedToInventory(e.key, 1);
-        await _dataService.addItemToInventory(e.key, ItemType.weapon, 1);
-        _weaponBloc.add(WeaponEvent.addedToInventory(key: e.key, wasAdded: true));
-
-        return state.map(
-          loading: (state) => state,
-          loaded: (state) => state.copyWith.call(weapons: _dataService.getAllWeaponsInInventory()),
-        );
+        await _dataService.addWeaponToInventory(e.key, raiseEvent: false);
+        return _refreshItems(ItemType.weapon);
       },
       deleteCharacter: (e) async {
         await _telemetryService.trackItemDeletedFromInventory(e.key);
-        await _dataService.deleteItemFromInventory(e.key, ItemType.character);
-        _characterBloc.add(CharacterEvent.addedToInventory(key: e.key, wasAdded: false));
-
-        return state.map(
-          loading: (state) => state,
-          loaded: (state) => state.copyWith.call(characters: _dataService.getAllCharactersInInventory()),
-        );
+        await _dataService.deleteCharacterFromInventory(e.key, raiseEvent: false);
+        return _refreshItems(ItemType.character);
       },
       deleteWeapon: (e) async {
         await _telemetryService.trackItemDeletedFromInventory(e.key);
-        await _dataService.deleteItemFromInventory(e.key, ItemType.weapon);
-        _weaponBloc.add(WeaponEvent.addedToInventory(key: e.key, wasAdded: false));
-
-        return state.map(
-          loading: (state) => state,
-          loaded: (state) => state.copyWith.call(weapons: _dataService.getAllWeaponsInInventory()),
-        );
+        await _dataService.deleteWeaponFromInventory(e.key, raiseEvent: false);
+        return _refreshItems(ItemType.weapon);
       },
       updateMaterial: (e) async {
         await _telemetryService.trackItemUpdatedInInventory(e.key, e.quantity);
-        await _dataService.updateItemInInventory(e.key, ItemType.material, e.quantity);
-
-        return state.map(
-          loading: (state) => state,
-          loaded: (state) => state.copyWith.call(materials: _dataService.getAllMaterialsInInventory()),
-        );
+        await _dataService.updateItemInInventory(e.key, ItemType.material, e.quantity, raiseEvent: false);
+        return _refreshItems(ItemType.material);
       },
-      close: (_) async => const InventoryState.loaded(characters: [], weapons: [], materials: []),
       clearAllCharacters: (_) async {
         await _telemetryService.trackItemsDeletedFromInventory(ItemType.character);
-        await _dataService.deleteItemsFromInventory(ItemType.character);
-
-        return state.map(
-          loading: (state) => state,
-          loaded: (state) => state.copyWith.call(characters: []),
-        );
+        await _dataService.deleteItemsFromInventory(ItemType.character, raiseEvent: false);
+        return state.copyWith.call(characters: []);
       },
       clearAllWeapons: (_) async {
         await _telemetryService.trackItemsDeletedFromInventory(ItemType.weapon);
-        await _dataService.deleteItemsFromInventory(ItemType.weapon);
-
-        return state.map(
-          loading: (state) => state,
-          loaded: (state) => state.copyWith.call(weapons: []),
-        );
+        await _dataService.deleteItemsFromInventory(ItemType.weapon, raiseEvent: false);
+        return state.copyWith.call(weapons: []);
       },
       clearAllMaterials: (_) async {
         await _telemetryService.trackItemsDeletedFromInventory(ItemType.material);
-        await _dataService.deleteItemsFromInventory(ItemType.material);
-
-        return state.map(
-          loading: (state) => state,
-          loaded: (state) => state.copyWith.call(materials: _dataService.getAllMaterialsInInventory()),
-        );
+        await _dataService.deleteItemsFromInventory(ItemType.material, raiseEvent: false);
+        return _refreshItems(ItemType.material);
       },
+      refresh: (e) async => _refreshItems(e.type),
     );
 
     yield s;
   }
 
+  @override
+  Future<void> close() async {
+    await Future.wait(_streamSubscriptions.map((e) => e.cancel()));
+    await super.close();
+  }
+
+  InventoryState _refreshItems(ItemType type) {
+    switch (type) {
+      case ItemType.character:
+        return state.copyWith.call(characters: _dataService.getAllCharactersInInventory());
+      case ItemType.weapon:
+        return state.copyWith.call(weapons: _dataService.getAllWeaponsInInventory());
+      case ItemType.artifact:
+        throw Exception('Not implemented');
+      case ItemType.material:
+        return state.copyWith.call(materials: _dataService.getAllMaterialsInInventory());
+    }
+  }
+
   List<String> getItemsKeysToExclude() {
     final upcoming = _genshinService.getUpcomingKeys();
     return state.maybeMap(

diff --git a/lib/application/inventory/inventory_event.dart b/lib/application/inventory/inventory_event.dart
@@ -25,11 +25,11 @@ class InventoryEvent with _$InventoryEvent {
     required int quantity,
   }) = _AddMaterial;
 
-  const factory InventoryEvent.close() = _Close;
-
   const factory InventoryEvent.clearAllCharacters() = _ClearAllCharacters;
 
   const factory InventoryEvent.clearAllWeapons() = _ClearAllWeapons;
 
   const factory InventoryEvent.clearAllMaterials() = _ClearAllMaterials;
+
+  const factory InventoryEvent.refresh({required ItemType type}) = _Refresh;
 }
diff --git a/lib/application/inventory/inventory_state.dart b/lib/application/inventory/inventory_state.dart
@@ -2,8 +2,6 @@ part of 'inventory_bloc.dart';
 
 @freezed
 class InventoryState with _$InventoryState {
-  const factory InventoryState.loading() = _LoadingState;
-
   const factory InventoryState.loaded({
     required List<CharacterCardModel> characters,
     required List<WeaponCardModel> weapons,

diff --git a/lib/application/material/material_bloc.dart b/lib/application/material/material_bloc.dart
@@ -2,9 +2,9 @@ import 'dart:async';
 
 import 'package:darq/darq.dart';
 import 'package:flutter/cupertino.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:freezed_annotation/freezed_annotation.dart';
 import 'package:meta/meta.dart';
-import 'package:shiori/application/common/pop_bloc.dart';
 import 'package:shiori/domain/enums/enums.dart';
 import 'package:shiori/domain/models/models.dart';
 import 'package:shiori/domain/services/genshin_service.dart';
@@ -14,23 +14,20 @@ part 'material_bloc.freezed.dart';
 part 'material_event.dart';
 part 'material_state.dart';
 
-class MaterialBloc extends PopBloc<MaterialEvent, MaterialState> {
+class MaterialBloc extends Bloc<MaterialEvent, MaterialState> {
   final GenshinService _genshinService;
   final TelemetryService _telemetryService;
 
   MaterialBloc(this._genshinService, this._telemetryService) : super(const MaterialState.loading());
 
   @override
-  MaterialEvent getEventForPop(String? key) => MaterialEvent.loadFromKey(key: key!, addToQueue: false);
-
   @override
   Stream<MaterialState> mapEventToState(MaterialEvent event) async* {
     final s = await event.map(
       loadFromKey: (e) async {
         final material = _genshinService.getMaterial(e.key);
         if (e.addToQueue) {
           await _telemetryService.trackMaterialLoaded(e.key);
-          currentItemsInStack.add(material.key);
         }
         return _buildInitialState(material);
       },