feat: Add LocationHistoryUpdater.dart

lib/app_wrappers/LocationHistoryUpdater.dart

@@ -0,0 +1,46 @@
+import 'dart:async';
+
+import 'package:flutter/material.dart';
+import 'package:locus/services/current_location_service.dart';
+import 'package:locus/services/location_history_service/index.dart';
+import 'package:locus/services/location_point_service.dart';
+import 'package:provider/provider.dart';
+
+/// Makes sure that the [LocationHistory] is updated with the current location
+/// from the [CurrentLocationService].
+class LocationHistoryUpdater extends StatefulWidget {
+  const LocationHistoryUpdater({super.key});
+
+  @override
+  State<LocationHistoryUpdater> createState() => _LocationHistoryUpdaterState();
+}
+
+class _LocationHistoryUpdaterState extends State<LocationHistoryUpdater> {
+  late final CurrentLocationService _currentLocation;
+  late final StreamSubscription _subscription;
+  late final LocationHistory _locationHistory;
+
+  @override
+  void initState() {
+    super.initState();
+
+    _currentLocation = context.read<CurrentLocationService>();
+    _subscription = _currentLocation.stream.listen((position) async {
+      final location = await LocationPointService.fromPosition(position);
+
+      _locationHistory.add(location);
+    });
+  }
+
+  @override
+  void dispose() {
+    _subscription.cancel();
+
+    super.dispose();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return const SizedBox.shrink();
+  }
+}

lib/main.dart

@@ -7,12 +7,12 @@ import 'package:flutter_local_notifications/flutter_local_notifications.dart';
 import 'package:flutter_logs/flutter_logs.dart';
 import 'package:flutter_secure_storage/flutter_secure_storage.dart';
 import 'package:locus/App.dart';
-import 'package:locus/api/get-relays-meta.dart';
+import 'package:locus/app_wrappers/LocationHistoryUpdater.dart';
 import 'package:locus/screens/locations_overview_screen_widgets/LocationFetchers.dart';
 import 'package:locus/services/app_update_service.dart';
 import 'package:locus/services/current_location_service.dart';
+import 'package:locus/services/location_history_service/index.dart';
 import 'package:locus/services/log_service.dart';
-import 'package:locus/services/manager_service/background_fetch.dart';
 import 'package:locus/services/settings_service/index.dart';
 import 'package:locus/services/task_service/index.dart';
 import 'package:locus/services/view_service/index.dart';
@@ -67,12 +67,14 @@ void main() async {
     SettingsService.restore(),
     LogService.restore(),
     AppUpdateService.restore(),
+    LocationHistory.restore(),
   ]);
   final TaskService taskService = futures[0];
   final ViewService viewService = futures[1];
   final SettingsService settingsService = futures[2];
   final LogService logService = futures[3];
   final AppUpdateService appUpdateService = futures[4];
+  final LocationHistory locationHistory = futures[5];
 
   await logService.deleteOldLogs();
 
@@ -91,8 +93,14 @@ void main() async {
             create: (_) => LocationFetchers(viewService.views)),
         ChangeNotifierProvider<CurrentLocationService>(
             create: (_) => CurrentLocationService()),
+        ChangeNotifierProvider<LocationHistory>(create: (_) => locationHistory),
       ],
-      child: const App(),
+      child: const Stack(
+        children: [
+          LocationHistoryUpdater(),
+          App(),
+        ],
+      ),
     ),
   );
 }

lib/services/location_history_service/constants.dart

@@ -0,0 +1,4 @@
+import 'package:flutter_secure_storage/flutter_secure_storage.dart';
+
+const storage = FlutterSecureStorage();
+const KEY = "_locus_own_location_history_v1";

lib/services/location_history_service/index.dart

@@ -0,0 +1 @@
+export "./location_history.dart";

lib/services/location_history_service/location_history.dart

@@ -0,0 +1,65 @@
+import 'package:flutter/cupertino.dart';
+
+import "./constants.dart";
+import '../location_point_service.dart';
+
+class LocationHistory extends ChangeNotifier {
+  late final List<LocationPointService> locations;
+
+  LocationHistory(
+    final List<LocationPointService>? locations,
+  ) : locations = locations ?? [];
+
+  factory LocationHistory.fromJSON(final Map<String, dynamic> data) =>
+      LocationHistory(
+        data["locations"] != null
+            ? List<LocationPointService>.from(
+                data["locations"].map(
+                  (location) => LocationPointService.fromJSON(location),
+                ),
+              )
+            : null,
+      );
+
+  static Future<LocationHistory> restore() async {
+    final data = await storage.read(key: KEY);
+
+    if (data == null) {
+      return LocationHistory(null);
+    }
+
+    return LocationHistory.fromJSON(data as Map<String, dynamic>);
+  }
+
+  // To avoid too many crumbled locations, we only save locations that are at
+  // least one minute apart
+  bool _canAdd(final LocationPointService location) {
+    if (locations.isEmpty) {
+      return true;
+    }
+
+    return locations.last.createdAt
+            .difference(location.createdAt)
+            .inMinutes
+            .abs() >
+        1;
+  }
+
+  void add(final LocationPointService location) {
+    if (!_canAdd(location)) {
+      return;
+    }
+
+    locations.add(location);
+    notifyListeners();
+  }
+
+  void clear() {
+    locations.clear();
+    notifyListeners();
+  }
+
+  void toJSON() => {
+        "locations": locations.map((location) => location.toJSON()).toList(),
+      };
+}