Fix Shake Detector not working when app in background (#40)

* feat: update shake detection settings to reduce cooldown and feedback options

* fix: shake detector not detecting in background

* enhance shake action handling to avoid unnecessary feedback

* disable shake detector when player not playing anything

* refactor: remove outdated TODO regarding shake detection optimization

* refactor: comment out notifyListeners call in restartTimer method for clarity

lib/features/shake_detection/providers/shake_detector.dart

@@ -19,73 +19,111 @@ Logger _logger = Logger('ShakeDetector');
 
 @riverpod
 class ShakeDetector extends _$ShakeDetector {
+  bool wasPlayerLoaded = false;
+
   @override
   core.ShakeDetector? build() {
     final appSettings = ref.watch(appSettingsProvider);
     final shakeDetectionSettings = appSettings.shakeDetectionSettings;
 
     if (!shakeDetectionSettings.isEnabled) {
-      _logger.fine('Shake detection is disabled');
-      return null;
-    }
-    final player = ref.watch(audiobookPlayerProvider);
-    if (!player.playing && !shakeDetectionSettings.isActiveWhenPaused) {
-      _logger.fine(
-        'Shake detection is disabled when paused and player is not playing',
-      );
-      return null;
-    }
-    // if sleep timer is not enabled, shake detection should not be enabled
-    final sleepTimer = ref.watch(sleepTimerProvider);
-    if (!shakeDetectionSettings.isPlaybackManagementEnabled &&
-        sleepTimer == null) {
-      _logger.fine('No playback management is enabled and sleep timer is off, '
-          'so shake detection is disabled');
+      _logger.config('Shake detection is disabled');
       return null;
     }
 
-    _logger.fine('Creating shake detector');
+    // if no book is loaded, shake detection should not be enabled
+    final player = ref.watch(simpleAudiobookPlayerProvider);
+    player.playerStateStream.listen((event) {
+      if (event.processingState == ProcessingState.idle && wasPlayerLoaded) {
+        _logger.config('Player is now not loaded, invalidating');
+        wasPlayerLoaded = false;
+        ref.invalidateSelf();
+      }
+      if (event.processingState != ProcessingState.idle && !wasPlayerLoaded) {
+        _logger.config('Player is now loaded, invalidating');
+        wasPlayerLoaded = true;
+        ref.invalidateSelf();
+      }
+    });
+
+    if (player.book == null) {
+      _logger.config('No book is loaded, disabling shake detection');
+      wasPlayerLoaded = false;
+      return null;
+    } else {
+      _logger.finer('Book is loaded, marking player as loaded');
+      wasPlayerLoaded = true;
+    }
+
+    // if sleep timer is not enabled, shake detection should not be enabled
+    final sleepTimer = ref.watch(sleepTimerProvider);
+    if (!shakeDetectionSettings.shakeAction.isPlaybackManagementEnabled &&
+        sleepTimer == null) {
+      _logger
+          .config('No playback management is enabled and sleep timer is off, '
+              'so shake detection is disabled');
+      return null;
+    }
+
+    _logger.config('Creating shake detector');
     final detector = core.ShakeDetector(
       shakeDetectionSettings,
       () {
-        doShakeAction(
+        final wasActionComplete = doShakeAction(
           shakeDetectionSettings.shakeAction,
           ref: ref,
         );
-        shakeDetectionSettings.feedback.forEach(postShakeFeedback);
+        if (wasActionComplete) {
+          shakeDetectionSettings.feedback.forEach(postShakeFeedback);
+        }
       },
     );
     ref.onDispose(detector.dispose);
     return detector;
   }
 
-  void doShakeAction(
+  /// Perform the shake action and return whether the action was successful
+  bool doShakeAction(
     ShakeAction shakeAction, {
     required Ref ref,
   }) {
-    final player = ref.watch(simpleAudiobookPlayerProvider);
+    final player = ref.read(simpleAudiobookPlayerProvider);
+    if (player.book == null && shakeAction.isPlaybackManagementEnabled) {
+      _logger.warning('No book is loaded');
+      return false;
+    }
     switch (shakeAction) {
       case ShakeAction.resetSleepTimer:
         _logger.fine('Resetting sleep timer');
-        ref.read(sleepTimerProvider.notifier).restartTimer();
-        break;
+        var sleepTimer = ref.read(sleepTimerProvider);
+        if (sleepTimer == null || !sleepTimer.isActive) {
+          _logger.warning('No sleep timer is running');
+          return false;
+        }
+        sleepTimer.restartTimer();
+        return true;
       case ShakeAction.fastForward:
         _logger.fine('Fast forwarding');
+        if (!player.playing) {
+          _logger.warning('Player is not playing');
+          return false;
+        }
         player.seek(player.position + const Duration(seconds: 30));
-        break;
+        return true;
       case ShakeAction.rewind:
         _logger.fine('Rewinding');
-        player.seek(player.position - const Duration(seconds: 30));
-        break;
-      case ShakeAction.playPause:
-        if (player.book == null) {
-          _logger.warning('No book is loaded');
-          break;
+        if (!player.playing) {
+          _logger.warning('Player is not playing');
+          return false;
         }
+        player.seek(player.position - const Duration(seconds: 30));
+        return true;
+      case ShakeAction.playPause:
+        _logger.fine('Toggling play/pause');
         player.togglePlayPause();
-        break;
+        return true;
       default:
-        break;
+        return false;
     }
   }
 
@@ -121,18 +159,18 @@ class ShakeDetector extends _$ShakeDetector {
   }
 }
 
-extension on ShakeDetectionSettings {
+extension on ShakeAction {
   bool get isActiveWhenPaused {
     // If the shake action is play/pause, it should be required when not playing
-    return shakeAction == ShakeAction.playPause;
+    return this == ShakeAction.playPause;
   }
 
   bool get isPlaybackManagementEnabled {
     return {ShakeAction.playPause, ShakeAction.fastForward, ShakeAction.rewind}
-        .contains(shakeAction);
+        .contains(this);
   }
 
   bool get shouldActOnSleepTimer {
-    return {ShakeAction.resetSleepTimer}.contains(shakeAction);
+    return {ShakeAction.resetSleepTimer}.contains(this);
   }
 }