Feat/pause tracking (#77)

This pull request introduces several changes to enhance the activity
tracking functionality, including the addition of pause/resume
capabilities, updates to the tracking state, and improvements to the
user interface.

### Enhancements to Activity Tracking Functionality:

* Added a new `ActivityBroadcastReceiver` in `AndroidManifest.xml` to
handle pause and stop actions for activity tracking.
* Updated the tracking state to include `isPaused` and `durationMillis`
fields in `TrackingState` and modified the `copyWith` method
accordingly.
[[1]](diffhunk://#diff-202d7e63825d16c2b083b05352b9ccfb46fb57a08232c695758033f3a56df224L9-R23)
[[2]](diffhunk://#diff-202d7e63825d16c2b083b05352b9ccfb46fb57a08232c695758033f3a56df224L29-R41)
* Introduced a `togglePauseTracking` method in `TrackingViewModel` to
handle pausing and resuming of activities, replacing the previous
`pauseTracking` method.
* Modified the `startTimer` and `updateDuration` methods in
`TrackingViewModel` to work with `durationMillis` instead of a string
duration.

### User Interface Improvements:

* Updated `ActiveTracking` widget to display `durationMillis` and handle
paused state, including changes to the pause button icon.
[[1]](diffhunk://#diff-d49adc2b4b389d095be8fde161b0fcba63a3d310f235e93716a2360f5be45da9L12-R23)
[[2]](diffhunk://#diff-d49adc2b4b389d095be8fde161b0fcba63a3d310f235e93716a2360f5be45da9L42-R74)
* Enhanced `TrackingRecording` widget to show the elapsed time and
current speed, considering the paused state.
[[1]](diffhunk://#diff-6321dbec87c91b717c14f686f4ba1bc8f0adb34ea26bce120c9630fd5d3093eeR9-R20)
[[2]](diffhunk://#diff-6321dbec87c91b717c14f686f4ba1bc8f0adb34ea26bce120c9630fd5d3093eeL29-R42)
[[3]](diffhunk://#diff-6321dbec87c91b717c14f686f4ba1bc8f0adb34ea26bce120c9630fd5d3093eeL48-R52)
[[4]](diffhunk://#diff-6321dbec87c91b717c14f686f4ba1bc8f0adb34ea26bce120c9630fd5d3093eeL81-R101)
* Adjusted `TrackingFinished` widget to display the total duration in
milliseconds.
[[1]](diffhunk://#diff-8e932347020831edfb689603f2cd801760565ebfe1a13041289556cf0f781148R14-R26)
[[2]](diffhunk://#diff-8e932347020831edfb689603f2cd801760565ebfe1a13041289556cf0f781148L73-R76)
[[3]](diffhunk://#diff-8e932347020831edfb689603f2cd801760565ebfe1a13041289556cf0f781148L89-R93)

### Code Refactoring:

* Updated various files to replace string duration with `durationMillis`
and to include `isPaused` state where necessary.
[[1]](diffhunk://#diff-70a7a11b1888ccd7f44bd2466497659e9b19eb98003d549efd994b23d5c7f566L50-R50)
[[2]](diffhunk://#diff-70a7a11b1888ccd7f44bd2466497659e9b19eb98003d549efd994b23d5c7f566L172-R177)
[[3]](diffhunk://#diff-e9fe2cd457ace53e850809c195f8fa463087c0b63e124a31541a255b5493a965R58-R67)
[[4]](diffhunk://#diff-2315f9fe656582eb216ac6a4ebc0d82ccd82b493eabba1af6a7bafa63a5475e3R11-R41)
* Simplified event handling in `TrackingViewModel` by using constants
from the `Event` class.

Author: Jozys

android/app/src/main/AndroidManifest.xml

@@ -91,6 +91,14 @@
             android:exported="false"
             android:foregroundServiceType="location|health" />
 
+        <receiver
+            android:name="de.buseslaar.tracking.activity_tracking.notification.receiver.ActivityBroadcastReceiver"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="de.buseslaar.tracking.PAUSE" />
+                <action android:name="de.buseslaar.tracking.STOP" />
+            </intent-filter>
+        </receiver>
     </application>
     <!-- Required to query activities that can process text, see:
          https://developer.android.com/training/package-visibility and

lib/presentation/activities/details/widget/detail_stats_card.dart

@@ -21,14 +21,20 @@ class DetailStatsCardEntry extends StatelessWidget {
                   displayName,
                   style: TextStyle(
                       fontSize: 14,
-                      color: Theme.of(context).colorScheme.onSurfaceVariant),
+                      color: Theme
+                          .of(context)
+                          .colorScheme
+                          .onSurfaceVariant),
                 ),
               ]),
               Text(value,
                   textAlign: TextAlign.right,
                   style: TextStyle(
                       fontSize: 18,
-                      color: Theme.of(context).colorScheme.onSurface))
+                      color: Theme
+                          .of(context)
+                          .colorScheme
+                          .onSurface))
             ],
           ),
           if (child != null) child!

lib/presentation/today/screen/today_screen.dart

@@ -47,7 +47,7 @@ class TodayScreen extends HookConsumerWidget {
     }
 
     Future<void> pauseTracking() async {
-      await ref.read(trackingViewModelProvider.notifier).pauseTracking();
+      await ref.read(trackingViewModelProvider.notifier).togglePauseTracking();
       context.push("/tracking");
     }
 
@@ -165,14 +165,16 @@ void _onCardClick(BuildContext context) {
 }
 
 Widget _buildCurrentTracking(
-    BuildContext context,
-    WidgetRef ref,
-    TrackingState state,
-    Future<void> Function() stopTracking,
-    Future<void> Function() pauseTracking) {
+  BuildContext context,
+  WidgetRef ref,
+  TrackingState state,
+  Future<void> Function() stopTracking,
+  Future<void> Function() pauseTracking,
+) {
   return ActiveTracking(
     activity: state.activity,
-    duration: state.duration,
+    durationMillis: state.durationMillis,
+    paused: state.isPaused,
     onCardClick: () => _onCardClick(context),
     onPause: pauseTracking,
     onStop: stopTracking,

lib/presentation/today/widgets/tracking_active.dart

@@ -9,16 +9,18 @@ class ActiveTracking extends StatelessWidget {
   const ActiveTracking(
       {super.key,
       required this.activity,
-      required this.duration,
+      required this.durationMillis,
       required this.onStop,
       required this.onPause,
+      required this.paused,
       required this.onCardClick});
 
   final Activity activity;
-  final String duration;
+  final int durationMillis;
   final Future<void> Function() onStop;
   final Future<void> Function() onPause;
   final Function onCardClick;
+  final bool paused;
 
   @override
   Widget build(BuildContext context) {
@@ -39,29 +41,37 @@ class ActiveTracking extends StatelessWidget {
                         getIcon(activity.activityType ?? ActivityType.unknown,
                             color: Theme.of(context).colorScheme.onPrimary),
                         const SizedBox(width: 8),
-                        Text(
-                          getTranslatedActivityType(
-                              context,
-                              HealthWorkoutActivityType.values.firstWhere(
-                                  (element) =>
-                                      element.name ==
-                                      activity.activityType?.name)),
-                          style: const TextStyle(
-                              color: Colors.white, fontSize: 20),
-                        ),
+                        Container(
+                            width: 120,
+                            child: Text(
+                              getTranslatedActivityType(
+                                  context,
+                                  HealthWorkoutActivityType.values.firstWhere(
+                                      (element) =>
+                                          element.name ==
+                                          activity.activityType?.name)),
+                              style: const TextStyle(
+                                color: Colors.white,
+                                fontSize: 20,
+                                overflow: TextOverflow.ellipsis,
+                              ),
+                            )),
                       ],
                     ),
                     const SizedBox(width: 8),
                     // Center with distance
                     Text(
-                      duration,
+                      getDuration(durationMillis),
                       style: const TextStyle(color: Colors.white, fontSize: 20),
                     ),
 
                     // Right side with buttons
                     Row(mainAxisAlignment: MainAxisAlignment.end, children: [
-                      _buildActionButton(context, onPause,
-                          Theme.of(context).colorScheme.outline, Icons.pause),
+                      _buildActionButton(
+                          context,
+                          onPause,
+                          Theme.of(context).colorScheme.outline,
+                          paused ? Icons.play_arrow : Icons.pause),
                       _buildActionButton(context, onStop,
                           Theme.of(context).colorScheme.error, Icons.stop)
                     ]),

lib/presentation/tracking/screen/tracking.dart

@@ -55,10 +55,16 @@ class TrackingScreen extends HookConsumerWidget {
                           .read(trackingViewModelProvider.notifier)
                           .stopTracking();
                     },
+                    onPause: () {
+                      ref
+                          .read(trackingViewModelProvider.notifier)
+                          .togglePauseTracking();
+                    },
                     startTimer:
                         ref.read(trackingViewModelProvider.notifier).startTimer,
-                    duration: trackingState.duration,
-                    isRecording: trackingState!.isRecording,
+                    durationMillis: trackingState.durationMillis,
+                    isRecording: trackingState.isRecording,
+                    isPaused: trackingState.isPaused,
                   )));
   }
 }

lib/presentation/tracking/view_model/tracking_state.dart

@@ -6,18 +6,21 @@ import 'package:logging/logging.dart';
 class TrackingState {
   Activity activity;
   bool isRecording = false;
-  String duration = "--";
+  bool isPaused = false;
+  int durationMillis = 0;
   final log = Logger('trackingState');
 
   TrackingState(
       {required this.activity,
       required this.isRecording,
-      required this.duration});
+      required this.isPaused,
+      required this.durationMillis});
 
   factory TrackingState.initial() {
     return TrackingState(
         isRecording: false,
-        duration: "--",
+        isPaused: false,
+        durationMillis: 0,
         activity: Activity(
             activityType: ActivityType.unknown,
             distance: 0.0,
@@ -26,10 +29,15 @@ class TrackingState {
   }
 
   TrackingState copyWith(
-      {Activity? newActivity, bool? newIsRecording, String? newDuration}) {
+      {Activity? newActivity,
+      bool? newIsRecording,
+      bool? newIsPaused,
+      int? newDurationMillis}) {
     return TrackingState(
-        isRecording: newIsRecording ?? isRecording,
-        duration: newDuration ?? duration,
-        activity: newActivity ?? activity);
+      isRecording: newIsRecording ?? isRecording,
+      activity: newActivity ?? activity,
+      isPaused: newIsPaused ?? isPaused,
+      durationMillis: newDurationMillis ?? durationMillis,
+    );
   }
 }

lib/presentation/tracking/view_model/tracking_view_model.dart

@@ -4,6 +4,7 @@ import 'dart:convert';
 import 'package:activity_tracking/activity_tracking.dart';
 import 'package:activity_tracking/model/activity.dart';
 import 'package:activity_tracking/model/activity_type.dart';
+import 'package:activity_tracking/model/event.dart';
 import 'package:activity_tracking/model/message.dart';
 import 'package:logging/logging.dart';
 import 'package:movetopia/data/repositories/local_health_impl.dart';
@@ -33,19 +34,33 @@ class TrackingViewModel extends StateNotifier<TrackingState?> {
         await activityTrackingPlugin.startActivity(activityType);
     state = state?.copyWith(newActivity: startedActivity, newIsRecording: true);
     activityStreamSubscription =
-        activityTrackingPlugin.getNativeEvents().listen(_onActivityUpdate);
+        activityTrackingPlugin.getNativeEvents().listen((e) {
+      _onActivityUpdate(e);
+    });
   }
 
-  pauseTracking() async {
-    print("pauseTracking");
+  togglePauseTracking() async {
+    if (state!.isRecording) {
+      // result indicates whether the toggle was successful or not
+      var result = await activityTrackingPlugin.togglePauseActivity();
+      if (result != null && result) {
+        state = state?.copyWith(newIsPaused: !state!.isPaused);
+
+        log.info("Activity paused: ${state?.isPaused}");
+        if (state?.isPaused == false) {
+          startTimer();
+        }
+      } else {
+        log.warning("Failed to pause activity");
+      }
+    }
   }
 
   stopTracking() async {
     await activityStreamSubscription.cancel();
     var finalResult = await activityTrackingPlugin.stopCurrentActivity();
     if (finalResult != null) {
-      state = state?.copyWith(
-          newActivity: finalResult, newIsRecording: false, newDuration: "");
+      state = state?.copyWith(newActivity: finalResult, newIsRecording: false);
 
       await ref
           .read(localHealthRepositoryProvider)
@@ -55,19 +70,19 @@ class TrackingViewModel extends StateNotifier<TrackingState?> {
 
   void startTimer() {
     Future.delayed(const Duration(seconds: 1), () {
-      ref.read(trackingViewModelProvider.notifier).updateDuration(getDuration(
-          state?.activity.startDateTime ?? 0,
-          DateTime.now().millisecondsSinceEpoch));
-      if (state?.isRecording == true) {
+      ref
+          .read(trackingViewModelProvider.notifier)
+          .updateDuration(state!.durationMillis + 1000);
+      if (state?.isRecording == true && state?.isPaused == false) {
         startTimer();
       } else {
         return;
       }
     });
   }
 
-  updateDuration(String duration) {
-    state = state?.copyWith(newDuration: duration);
+  updateDuration(int durationMillis) {
+    state = state?.copyWith(newDurationMillis: durationMillis);
   }
 
   clearState() {
@@ -77,24 +92,43 @@ class TrackingViewModel extends StateNotifier<TrackingState?> {
   _onActivityUpdate(dynamic e) {
     var eventMessage = Message.fromJson(jsonDecode(e));
     switch (eventMessage.type) {
-      case "step":
+      case Event.step:
         state?.activity.steps =
             ((state?.activity.steps ?? 0) + (eventMessage.data ?? 0)) as int?;
         state =
             state?.copyWith(newActivity: state?.activity, newIsRecording: true);
-      case "location":
+      case Event.location:
         if (eventMessage.data != null) {
           state?.activity.locations?.addAll(eventMessage.data);
           state = state?.copyWith(
               newActivity: state?.activity, newIsRecording: true);
         }
 
-      case "distance":
+      case Event.distance:
         if (eventMessage.data != null && eventMessage.data != 0) {
           state?.activity.distance = eventMessage.data;
           state = state?.copyWith(
               newActivity: state?.activity, newIsRecording: true);
         }
+      case Event.pause:
+        if (eventMessage.data != null) {
+          state = state?.copyWith(
+              newActivity: eventMessage.data as Activity, newIsPaused: false);
+        }
+      case Event.resume:
+        if (eventMessage.data != null) {
+          state = state?.copyWith(
+              newActivity: eventMessage.data as Activity, newIsPaused: true);
+          startTimer();
+        }
+      case Event.stop:
+        if (eventMessage.data != null) {
+          state = state?.copyWith(
+              newActivity: eventMessage.data as Activity,
+              newIsRecording: false);
+        }
+      case null:
+        log.info("Event is null");
     }
   }
 }

lib/presentation/tracking/widgets/current_activity.dart

@@ -8,28 +8,36 @@ class CurrentActivity extends StatelessWidget {
 
   final Function onStop;
 
+  final Function onPause;
+
   final bool isRecording;
 
-  final String duration;
+  final bool isPaused;
+
+  final int durationMillis;
 
   final Function startTimer;
 
   const CurrentActivity(
       {super.key,
       required this.activity,
       required this.onStop,
+      required this.onPause,
       required this.isRecording,
       required this.startTimer,
-      required this.duration});
+      required this.durationMillis,
+      required this.isPaused});
 
   @override
   Widget build(BuildContext context) {
     return isRecording
         ? TrackingRecording(
             activity: activity,
             onStop: onStop,
-            duration: duration,
+            durationMillis: durationMillis,
+            isPaused: isPaused,
+            onPause: onPause,
           )
-        : TrackingFinished(activity: activity);
+        : TrackingFinished(activity: activity, durationMillis: durationMillis);
   }
 }