Add HealthService for managing health data and caching mechanisms (#79)

This pull request includes significant changes to the health data
handling and device information retrieval in the repository. The most
important changes involve refactoring the `BaseLocalHealthImpl` class,
updating the `DeviceInfoRepositoryImpl` class, and modifying the
`StreakRepositoryImpl` class to use a new health service.

Refactoring and improvements to health data handling:

*
[`lib/data/repositories/base_local_health_impl.dart`](diffhunk://#diff-d65e3fe018d4f55ec02d268560a3058f224079bd55bcebd461a01bbc171e4abbR1-R171):
Introduced the `BaseLocalHealthRepoImpl` class with improved methods for
fetching health data, handling overlaps, and writing tracking data to
health. This includes methods like `getHealthDataInInterval`,
`getDistanceOfWorkoutsInInterval`, and `writeTrackingToHealth`.
*
[`lib/data/repositories/local_health_impl.dart`](diffhunk://#diff-99442f8cf53d535dc947e240c47d72949d679badbe5c1f253d9d99974446d774L1-L300):
Removed the old `LocalHealthRepoImpl` class and its methods, which have
been replaced by the new `BaseLocalHealthRepoImpl` class.

Updates to device information retrieval:

*
[`lib/data/repositories/device_info_repository_impl.dart`](diffhunk://#diff-43201840425b81fa4da9d0288f18d570d606c925360655e6a514648e699d9696L15-R15):
Changed the logic for setting the installation date and getting the last
opened date to use the current date instead of a date 30 days ago.
[[1]](diffhunk://#diff-43201840425b81fa4da9d0288f18d570d606c925360655e6a514648e699d9696L15-R15)
[[2]](diffhunk://#diff-43201840425b81fa4da9d0288f18d570d606c925360655e6a514648e699d9696L33-R33)

Modifications to streak repository:

*
[`lib/data/repositories/streak_repository_impl.dart`](diffhunk://#diff-a37166ebc82c76ca34e48751e335bc8caf6c49f725d4e09b45f8bbed14f169c1L5-L7):
Replaced the `LocalHealthRepository` dependency with `HealthServiceImpl`
and updated the logic to use this new service for fetching steps and
other health data.
[[1]](diffhunk://#diff-a37166ebc82c76ca34e48751e335bc8caf6c49f725d4e09b45f8bbed14f169c1L5-L7)
[[2]](diffhunk://#diff-a37166ebc82c76ca34e48751e335bc8caf6c49f725d4e09b45f8bbed14f169c1L21-R22)
[[3]](diffhunk://#diff-a37166ebc82c76ca34e48751e335bc8caf6c49f725d4e09b45f8bbed14f169c1L138-R136)
[[4]](diffhunk://#diff-a37166ebc82c76ca34e48751e335bc8caf6c49f725d4e09b45f8bbed14f169c1L163-R162)
[[5]](diffhunk://#diff-a37166ebc82c76ca34e48751e335bc8caf6c49f725d4e09b45f8bbed14f169c1L255-R254)

- Replace current local_health_impl.dart with a new caching approach
- Add healthService, that either requests flutter health data from
local_health or returns the cached data

Author: Jozys

lib/data/repositories/base_local_health_impl.dart

@@ -0,0 +1,171 @@
+import 'package:activity_tracking/model/activity.dart' as tracking_activity;
+import 'package:activity_tracking/model/activity_type.dart';
+import 'package:health/health.dart';
+import 'package:logging/logging.dart';
+import 'package:movetopia/data/model/activity.dart';
+import 'package:movetopia/domain/repositories/local_health.dart';
+import 'package:package_info_plus/package_info_plus.dart';
+import 'package:riverpod/riverpod.dart';
+
+final localHealthRepositoryProvider =
+    Provider<BaseLocalHealthRepository>((ref) => BaseLocalHealthRepoImpl());
+
+interface class BaseLocalHealthRepoImpl extends BaseLocalHealthRepository {
+  final log = Logger('LocalHealthRepoImpl');
+
+  @override
+  Future<List<HealthDataPoint>?> getHealthDataInInterval(
+      DateTime start, DateTime end, List<HealthDataType> types) async {
+    try {
+      _compareDate(start, end);
+
+      List<HealthDataPoint> dataPoints = await Health()
+          .getHealthDataFromTypes(types: types, startTime: start, endTime: end);
+
+      // Remove duplicates from the data points - with proper overlap handling
+      List<HealthDataPoint> uniqueDataPoints = [];
+      Map<String, List<HealthDataPoint>> dataByType = {};
+
+      // Group data points by type only (not by time)
+      for (var point in dataPoints) {
+        final key = point.typeString;
+
+        if (!dataByType.containsKey(key)) {
+          dataByType[key] = [];
+        }
+        dataByType[key]!.add(point);
+      }
+
+      // Process each type group to handle overlaps
+      for (var typePoints in dataByType.values) {
+        // Sort by start time to make overlap detection easier
+        typePoints.sort((a, b) => a.dateFrom.compareTo(b.dateFrom));
+
+        List<HealthDataPoint> nonOverlapping = [];
+
+        for (var point in typePoints) {
+          // Check if this point overlaps with any already accepted point
+          bool hasOverlap = false;
+          int overlapIndex = -1;
+
+          for (int i = 0; i < nonOverlapping.length; i++) {
+            var existing = nonOverlapping[i];
+
+            // Check for time overlap
+            if ((point.dateFrom.isBefore(existing.dateTo) ||
+                    point.dateFrom.isAtSameMomentAs(existing.dateTo)) &&
+                (point.dateTo.isAfter(existing.dateFrom) ||
+                    point.dateTo.isAtSameMomentAs(existing.dateFrom))) {
+              hasOverlap = true;
+              overlapIndex = i;
+
+              // If this is from movetopia, prioritize it
+              if (point.sourceName.startsWith('de.movetopia') &&
+                  point.type == HealthDataType.WORKOUT) {
+                nonOverlapping[i] = point;
+                break;
+              }
+
+              // Otherwise, take the one with longer duration
+              if (point.dateTo.difference(point.dateFrom) >
+                  existing.dateTo.difference(existing.dateFrom)) {
+                nonOverlapping[i] = point;
+              }
+
+              break;
+            }
+          }
+
+          if (!hasOverlap) {
+            nonOverlapping.add(point);
+          }
+        }
+
+        uniqueDataPoints.addAll(nonOverlapping);
+      }
+
+      dataPoints = uniqueDataPoints;
+
+      return dataPoints;
+    } catch (e) {
+      log.info(e);
+    }
+    return null;
+  }
+
+  bool _compareDate(DateTime start, DateTime end) {
+    if (start.compareTo(end) < 0) {
+      return true;
+    } else {
+      throw Exception("Start date is greater than end date");
+    }
+  }
+
+  Future<double> getDistanceOfWorkoutsInInterval(DateTime start, DateTime end,
+      List<HealthWorkoutActivityType> workoutTypes) async {
+    try {
+      var workouts = await getHealthDataInInterval(start, end, [
+        HealthDataType.WORKOUT,
+      ]);
+      if (workouts == null || workouts.isEmpty) {
+        return 0;
+      } else {
+        workouts = workouts
+            .where((element) => workoutTypes.contains(
+                (element.value as WorkoutHealthValue).workoutActivityType))
+            .toList();
+        double distance = 0;
+        for (var workout in workouts) {
+          distance += (workout.value as WorkoutHealthValue).totalDistance ?? 0;
+        }
+        return distance;
+      }
+    } catch (e) {
+      log.info(e);
+    }
+    return 0;
+  }
+
+  @override
+  Future<ActivityPreview?> writeTrackingToHealth(
+      tracking_activity.Activity preview) async {
+    final startTime =
+        DateTime.fromMillisecondsSinceEpoch(preview.startDateTime ?? 0);
+    final endTime =
+        DateTime.fromMillisecondsSinceEpoch(preview.endDateTime ?? 0);
+    var success = true;
+    try {
+      if (preview.steps! > 0) {
+        success = await Health().writeHealthData(
+            value: (preview.steps ?? 0).toDouble(),
+            type: HealthDataType.STEPS,
+            startTime: startTime,
+            endTime: endTime);
+      } else if (preview.activityType == ActivityType.walking ||
+          preview.activityType == ActivityType.running) {
+        return null;
+      }
+      success = await Health().writeWorkoutData(
+          activityType: HealthWorkoutActivityType.values.firstWhere(
+              (element) => element.name == preview.activityType?.name),
+          start: startTime,
+          end: endTime,
+          totalDistance: (preview.distance ?? 0).toInt() * 1000,
+          totalDistanceUnit: HealthDataUnit.METER);
+    } catch (e) {
+      log.info(e);
+    }
+    if (success) {
+      var appPackage = await PackageInfo.fromPlatform();
+      return ActivityPreview(
+          activityType: HealthWorkoutActivityType.values.firstWhere(
+              (element) => element.name == preview.activityType?.name),
+          start: startTime,
+          end: endTime,
+          distance: preview.distance ?? 0,
+          sourceId: appPackage.packageName,
+          caloriesBurnt: 0);
+    }
+    return null;
+  }
+}