added accuracy and distance traveled

lib/services/tracking_service.dart

@@ -1,4 +1,5 @@
 import 'dart:async';
+import 'dart:math' as math;
 
 import 'package:fforte/l10n/app_localizations.dart';
 import 'package:fforte/services/notification_service.dart';
@@ -12,35 +13,58 @@ class TrackingService {
   TrackingService._internal();
 
   List<LatLng> pathList = [];
+  List<double> accuracyList = [];
   StreamSubscription<Position>? positionStream;
   bool isTracking = false;
   final _positionController = StreamController<Position>.broadcast();
+  final _statsController = StreamController<TrackingStats>.broadcast();
 
   Stream<Position> get positionStream$ => _positionController.stream;
+  Stream<TrackingStats> get statsStream$ => _statsController.stream;
 
+  double? currentAccuracy;
+  
+  double _calculateMedianAccuracy(List<double> accuracies) {
+    if (accuracies.isEmpty) return 0;
+    if (accuracies.length == 1) return accuracies.first;
+    
+    // Kopiere die Liste, um die Originaldaten nicht zu verändern
+    var sorted = List<double>.from(accuracies)..sort();
+    
+    if (sorted.length % 2 == 0) {
+      // Bei gerader Anzahl: Durchschnitt der beiden mittleren Werte
+      int midIndex = sorted.length ~/ 2;
+      return (sorted[midIndex - 1] + sorted[midIndex]) / 2;
+    } else {
+      // Bei ungerader Anzahl: Der mittlere Wert
+      return sorted[sorted.length ~/ 2];
+    }
+  }
+  
   Future<void> startTracking(BuildContext context) async {
     if (isTracking) return;
 
     await NotificationService().initNotification();
-    if (context.mounted) {
     NotificationService().showNotification(
       title: AppLocalizations.of(context)!.trackingRunningInBackground,
     );
-    }
 
     positionStream = Geolocator.getPositionStream(
       locationSettings: AndroidSettings(
         accuracy: LocationAccuracy.high,
         distanceFilter: 0,
         foregroundNotificationConfig: ForegroundNotificationConfig(
-          notificationTitle: context.mounted ? AppLocalizations.of(context)!.trackingRunningInBackground : "Tracking",
+          notificationTitle: AppLocalizations.of(context)!.trackingRunningInBackground,
           notificationText: "",
         ),
       ),
     ).listen((Position? position) {
       if (position != null) {
         pathList.add(LatLng(position.latitude, position.longitude));
+        accuracyList.add(position.accuracy);
+        currentAccuracy = position.accuracy;
         _positionController.add(position);
+        _updateStats();
       }
     });
 
@@ -52,6 +76,60 @@ class TrackingService {
     isTracking = true;
   }
 
+  TrackingStats? _lastStats;
+  TrackingStats? get currentStats => _lastStats;
+
+  void _updateStats() {
+    if (pathList.isEmpty) {
+      _lastStats = TrackingStats(
+        currentAccuracy: currentAccuracy ?? 0,
+        averageAccuracy: 0,
+        totalDistanceMeters: 0
+      );
+      _statsController.add(_lastStats!);
+      return;
+    }
+    
+    double totalDistance = 0;
+    for (int i = 1; i < pathList.length; i++) {
+      totalDistance += _calculateDistance(
+        pathList[i-1].latitude,
+        pathList[i-1].longitude,
+        pathList[i].latitude,
+        pathList[i].longitude
+      );
+    }
+
+    double medianAccuracy = _calculateMedianAccuracy(accuracyList);
+
+    _lastStats = TrackingStats(
+      currentAccuracy: currentAccuracy ?? 0,
+      averageAccuracy: medianAccuracy,
+      totalDistanceMeters: totalDistance
+    );
+    _statsController.add(_lastStats!);
+  }
+
+  void requestStatsUpdate() {
+    _updateStats();
+  }
+
+  double _calculateDistance(double lat1, double lon1, double lat2, double lon2) {
+    const double earthRadius = 6371000; // Erdradius in Metern
+    
+    double lat1Rad = lat1 * math.pi / 180;
+    double lat2Rad = lat2 * math.pi / 180;
+    double deltaLat = (lat2 - lat1) * math.pi / 180;
+    double deltaLon = (lon2 - lon1) * math.pi / 180;
+
+    double a = math.sin(deltaLat/2) * math.sin(deltaLat/2) +
+        math.cos(lat1Rad) * math.cos(lat2Rad) *
+        math.sin(deltaLon/2) * math.sin(deltaLon/2);
+    
+    double c = 2 * math.atan2(math.sqrt(a), math.sqrt(1-a));
+    return earthRadius * c;
+  }
+
   void pauseTracking() {
     positionStream?.pause();
     isTracking = false;
@@ -66,10 +144,15 @@ class TrackingService {
     positionStream?.cancel();
     NotificationService().deleteNotification();
     isTracking = false;
+    accuracyList.clear();
+    currentAccuracy = null;
   }
 
   void clearPath() {
     pathList.clear();
+    accuracyList.clear();
+    currentAccuracy = null;
+    _updateStats();
   }
 
   String getPathAsString() {
@@ -79,5 +162,18 @@ class TrackingService {
   void dispose() {
     stopTracking();
     _positionController.close();
+    _statsController.close();
   }
+}
+
+class TrackingStats {
+  final double currentAccuracy;
+  final double averageAccuracy;
+  final double totalDistanceMeters;
+
+  TrackingStats({
+    required this.currentAccuracy,
+    required this.averageAccuracy,
+    required this.totalDistanceMeters,
+  });
 }