PE-4994: Prompt Users to Create a Snapshot

lib/blocs/drives/drives_cubit.dart

@@ -2,6 +2,8 @@ import 'dart:async';
 
 import 'package:ardrive/authentication/ardrive_auth.dart';
 import 'package:ardrive/blocs/blocs.dart';
+import 'package:ardrive/blocs/prompt_to_snapshot/prompt_to_snapshot_bloc.dart';
+import 'package:ardrive/blocs/prompt_to_snapshot/prompt_to_snapshot_event.dart';
 import 'package:ardrive/core/activity_tracker.dart';
 import 'package:ardrive/models/models.dart';
 import 'package:ardrive/utils/user_utils.dart';
@@ -17,6 +19,7 @@ part 'drives_state.dart';
 /// It works even if the user profile is unavailable.
 class DrivesCubit extends Cubit<DrivesState> {
   final ProfileCubit _profileCubit;
+  final PromptToSnapshotBloc _promptToSnapshotBloc;
   final DriveDao _driveDao;
   final ArDriveAuth _auth;
 
@@ -26,9 +29,11 @@ class DrivesCubit extends Cubit<DrivesState> {
     required ArDriveAuth auth,
     this.initialSelectedDriveId,
     required ProfileCubit profileCubit,
+    required PromptToSnapshotBloc promptToSnapshotBloc,
     required DriveDao driveDao,
     required ActivityTracker activityTracker,
   })  : _profileCubit = profileCubit,
+        _promptToSnapshotBloc = promptToSnapshotBloc,
         _driveDao = driveDao,
         _auth = auth,
         super(DrivesLoadInProgress()) {
@@ -71,6 +76,8 @@ class DrivesCubit extends Cubit<DrivesState> {
       final sharedDrives =
           drives.where((d) => !isDriveOwner(auth, d.ownerAddress)).toList();
 
+      _promptToSnapshotBloc.add(SelectedDrive(driveId: selectedDriveId));
+
       emit(
         DrivesLoadSuccess(
           selectedDriveId: selectedDriveId,
@@ -90,15 +97,26 @@ class DrivesCubit extends Cubit<DrivesState> {
 
   void selectDrive(String driveId) {
     final canCreateNewDrive = _profileCubit.state is ProfileLoggedIn;
-    final state = this.state is DrivesLoadSuccess
-        ? (this.state as DrivesLoadSuccess).copyWith(selectedDriveId: driveId)
-        : DrivesLoadedWithNoDrivesFound(canCreateNewDrive: canCreateNewDrive);
+    final DrivesState state;
+    if (this.state is DrivesLoadSuccess) {
+      state = (this.state as DrivesLoadSuccess).copyWith(
+        selectedDriveId: driveId,
+      );
+      _promptToSnapshotBloc.add(SelectedDrive(driveId: driveId));
+    } else {
+      state = DrivesLoadedWithNoDrivesFound(
+        canCreateNewDrive: canCreateNewDrive,
+      );
+      _promptToSnapshotBloc.add(const SelectedDrive(driveId: null));
+    }
     emit(state);
   }
 
   void cleanDrives() {
     initialSelectedDriveId = null;
 
+    _promptToSnapshotBloc.add(const SelectedDrive(driveId: null));
+
     final state = DrivesLoadSuccess(
         selectedDriveId: null,
         userDrives: const [],
@@ -121,10 +139,13 @@ class DrivesCubit extends Cubit<DrivesState> {
               ? state.sharedDrives.first.id
               : null;
       if (firstOrNullDrive != null) {
+        _promptToSnapshotBloc.add(SelectedDrive(driveId: firstOrNullDrive));
         emit(state.copyWith(selectedDriveId: firstOrNullDrive));
         return;
       }
     }
+
+    _promptToSnapshotBloc.add(const SelectedDrive(driveId: null));
     emit(DrivesLoadedWithNoDrivesFound(canCreateNewDrive: canCreateNewDrive));
   }
 

lib/blocs/feedback_survey/feedback_survey_cubit.dart

@@ -12,7 +12,6 @@ class FeedbackSurveyCubit extends Cubit<FeedbackSurveyState> {
 
   FeedbackSurveyCubit(
     FeedbackSurveyState initialState, {
-
     /// takes a KeyValueStore for testing purposes
     KeyValueStore? store,
   }) : super(initialState) {

lib/blocs/prompt_to_snapshot/prompt_to_snapshot_bloc.dart

@@ -0,0 +1,169 @@
+import 'package:ardrive/blocs/prompt_to_snapshot/prompt_to_snapshot_event.dart';
+import 'package:ardrive/blocs/prompt_to_snapshot/prompt_to_snapshot_state.dart';
+import 'package:ardrive/utils/debouncer.dart';
+import 'package:ardrive/utils/key_value_store.dart';
+import 'package:ardrive/utils/local_key_value_store.dart';
+import 'package:ardrive/utils/logger/logger.dart';
+import 'package:ardrive_utils/ardrive_utils.dart';
+import 'package:collection/collection.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+
+const int secondsBeforePrompting = 20;
+const int numberOfTxsBeforeSnapshot = 1000;
+
+class PromptToSnapshotBloc
+    extends Bloc<PromptToSnapshotEvent, PromptToSnapshotState> {
+  final Debouncer _debouncer = Debouncer(
+    delay: const Duration(seconds: secondsBeforePrompting),
+  );
+  static KeyValueStore? _maybeStore;
+  // Should be per-drive?
+  static const storeKey = 'dont-ask-to-snapshot-again';
+
+  PromptToSnapshotBloc({
+    /// takes a KeyValueStore for testing purposes
+    KeyValueStore? store,
+  }) : super(const PromptToSnapshotIdle(driveId: null)) {
+    on<CountSyncedTxs>(_onCountSyncedTxs);
+    on<SelectedDrive>(_onDriveSelected);
+    on<DriveSnapshotting>(_onDriveSnapshotting);
+    on<DriveSnapshotted>(_onDriveSnapshotted);
+    on<DismissDontAskAgain>(_onDismissDontAskAgain);
+
+    _maybeStore ??= store;
+  }
+
+  Future<KeyValueStore> get _store async {
+    /// lazily initialize KeyValueStore
+    _maybeStore ??= await LocalKeyValueStore.getInstance();
+    return _maybeStore!;
+  }
+
+  Future<void> _onCountSyncedTxs(
+    CountSyncedTxs event,
+    Emitter<PromptToSnapshotState> emit,
+  ) async {
+    CountOfTxsSyncedWithGql.countForDrive(
+      event.driveId,
+      event.txsSyncedWithGqlCount,
+    );
+  }
+
+  Future<void> _onDriveSelected(
+    SelectedDrive event,
+    Emitter<PromptToSnapshotState> emit,
+  ) async {
+    logger.d('Selected drive: ${event.driveId}');
+
+    if (event.driveId == null) {
+      if (state is PromptToSnapshotIdle) {
+        emit(const PromptToSnapshotIdle(driveId: null));
+      }
+      return;
+    }
+
+    final wouldDriveBenefitFromSnapshot =
+        CountOfTxsSyncedWithGql.wouldDriveBenefitFromSnapshot(event.driveId!);
+
+    logger.d(
+      'Debouncing prompt to snapshot (${event.driveId}): '
+      'should prompt: $wouldDriveBenefitFromSnapshot, is closed: $isClosed',
+    );
+
+    await _debouncer.run(() async {
+      final shouldAskAgain = await _shouldAskToSnapshotAgain();
+      if (shouldAskAgain &&
+          wouldDriveBenefitFromSnapshot &&
+          !isClosed &&
+          state is PromptToSnapshotIdle) {
+        logger.d('Prompting to snapshot for ${event.driveId}');
+        emit(PromptToSnapshotPrompting(driveId: event.driveId!));
+      }
+    }).catchError((e) {
+      logger.d('Debouncer cancelled: $e');
+    });
+  }
+
+  Future<void> _onDriveSnapshotting(
+    DriveSnapshotting event,
+    Emitter<PromptToSnapshotState> emit,
+  ) async {
+    emit(PromptToSnapshotPrompting(driveId: event.driveId));
+  }
+
+  Future<void> _onDriveSnapshotted(
+    DriveSnapshotted event,
+    Emitter<PromptToSnapshotState> emit,
+  ) async {
+    CountOfTxsSyncedWithGql.resetForDrive(event.driveId);
+    emit(PromptToSnapshotIdle(driveId: event.driveId));
+  }
+
+  Future<void> _onDismissDontAskAgain(
+    DismissDontAskAgain event,
+    Emitter<PromptToSnapshotState> emit,
+  ) async {
+    await _dontAskToSnapshotAgain();
+    emit(PromptToSnapshotIdle(driveId: event.driveId));
+  }
+
+  Future<void> _dontAskToSnapshotAgain() async {
+    await (await _store).putBool(storeKey, true);
+  }
+
+  Future<bool> _shouldAskToSnapshotAgain() async {
+    final store = await _store;
+    final value = await store.getBool(storeKey);
+    return value != true;
+  }
+}
+
+abstract class CountOfTxsSyncedWithGql {
+  static final List<CountOfTxsSyncedWithGqlOfDrive>
+      _countOfTxsSynceWithGqlOfDrive = [];
+
+  static int _getForDrive(DriveID driveId) {
+    return _countOfTxsSynceWithGqlOfDrive
+            .firstWhereOrNull((e) => e.driveId == driveId)
+            ?.count ??
+        0;
+  }
+
+  static void countForDrive(DriveID driveId, int count) {
+    final currentCount = _getForDrive(driveId);
+    _countOfTxsSynceWithGqlOfDrive.removeWhere((e) => e.driveId == driveId);
+    _countOfTxsSynceWithGqlOfDrive.add(CountOfTxsSyncedWithGqlOfDrive(
+      count: currentCount + count,
+      driveId: driveId,
+    ));
+    logger.d(
+      'Count of txs synced with gql for $driveId: $count,'
+      ' total: ${currentCount + count}}',
+    );
+  }
+
+  static void resetForDrive(DriveID driveId) {
+    _countOfTxsSynceWithGqlOfDrive.removeWhere((e) => e.driveId == driveId);
+    logger.d('Reset count of txs synced with gql for $driveId');
+  }
+
+  static bool wouldDriveBenefitFromSnapshot(DriveID driveId) {
+    final count = _getForDrive(driveId);
+    final wouldBenefit = count >= numberOfTxsBeforeSnapshot;
+    logger.d(
+      'Would drive $driveId benefit from snapshot? $wouldBenefit,'
+      ' count: $count',
+    );
+    return wouldBenefit;
+  }
+}
+
+class CountOfTxsSyncedWithGqlOfDrive {
+  final int count;
+  final DriveID driveId;
+
+  const CountOfTxsSyncedWithGqlOfDrive({
+    required this.count,
+    required this.driveId,
+  });
+}

lib/blocs/prompt_to_snapshot/prompt_to_snapshot_event.dart

@@ -0,0 +1,57 @@
+import 'package:ardrive_utils/ardrive_utils.dart';
+import 'package:equatable/equatable.dart';
+
+abstract class PromptToSnapshotEvent extends Equatable {
+  final DriveID? driveId;
+  const PromptToSnapshotEvent({required this.driveId});
+
+  @override
+  List<Object> get props => [];
+}
+
+class CountSyncedTxs extends PromptToSnapshotEvent {
+  final int txsSyncedWithGqlCount;
+  final bool wasDeepSync;
+
+  @override
+  String get driveId => super.driveId!;
+
+  const CountSyncedTxs({
+    required DriveID driveId,
+    required this.txsSyncedWithGqlCount,
+    required this.wasDeepSync,
+  }) : super(driveId: driveId);
+
+  @override
+  List<Object> get props => [driveId, txsSyncedWithGqlCount, wasDeepSync];
+}
+
+class SelectedDrive extends PromptToSnapshotEvent {
+  const SelectedDrive({required super.driveId});
+}
+
+class DriveSnapshotting extends PromptToSnapshotEvent {
+  @override
+  String get driveId => super.driveId!;
+
+  const DriveSnapshotting({required DriveID driveId}) : super(driveId: driveId);
+}
+
+class DriveSnapshotted extends PromptToSnapshotEvent {
+  final int txsSyncedWithGqlCount;
+
+  @override
+  String get driveId => super.driveId!;
+
+  const DriveSnapshotted({
+    required DriveID driveId,
+    this.txsSyncedWithGqlCount = 0,
+  }) : super(driveId: driveId);
+
+  @override
+  List<Object> get props => [driveId, txsSyncedWithGqlCount];
+}
+
+class DismissDontAskAgain extends PromptToSnapshotEvent {
+  const DismissDontAskAgain() : super(driveId: null);
+}

lib/blocs/prompt_to_snapshot/prompt_to_snapshot_state.dart

@@ -0,0 +1,44 @@
+import 'package:ardrive_utils/ardrive_utils.dart';
+import 'package:equatable/equatable.dart';
+
+abstract class PromptToSnapshotState extends Equatable {
+  final DriveID? driveId;
+
+  const PromptToSnapshotState({
+    required this.driveId,
+  });
+
+  @override
+  List<Object> get props => [driveId ?? ''];
+}
+
+class PromptToSnapshotIdle extends PromptToSnapshotState {
+  const PromptToSnapshotIdle({
+    required super.driveId,
+  });
+
+  PromptToSnapshotIdle copyWith({
+    DriveID? driveId,
+  }) {
+    return PromptToSnapshotIdle(
+      driveId: driveId ?? this.driveId,
+    );
+  }
+}
+
+class PromptToSnapshotPrompting extends PromptToSnapshotState {
+  @override
+  String get driveId => super.driveId!;
+
+  const PromptToSnapshotPrompting({
+    required DriveID driveId,
+  }) : super(driveId: driveId);
+
+  PromptToSnapshotPrompting copyWith({
+    String? driveId,
+  }) {
+    return PromptToSnapshotPrompting(
+      driveId: driveId ?? this.driveId,
+    );
+  }
+}