Feat/gps tracker

lib/locator.dart

@@ -18,6 +18,8 @@ import 'package:thingsboard_app/utils/services/loading_service/i_loading_service
 import 'package:thingsboard_app/utils/services/loading_service/loading_service.dart';
 import 'package:thingsboard_app/utils/services/local_database/i_local_database_service.dart';
 import 'package:thingsboard_app/utils/services/local_database/local_database_service.dart';
+import 'package:thingsboard_app/utils/services/location/i_location_service.dart';
+import 'package:thingsboard_app/utils/services/location/location_service.dart';
 import 'package:thingsboard_app/utils/services/notification_service.dart';
 import 'package:thingsboard_app/utils/services/overlay_service/i_overlay_service.dart';
 import 'package:thingsboard_app/utils/services/overlay_service/overlay_service.dart';
@@ -54,6 +56,9 @@ Future<void> setUpRootDependencies() async {
     ..registerLazySingleton<ITbImageGalleryService>(() => TbImageGalleryService())
       ..registerLazySingleton<ThingsboardAppRouter>(() => ThingsboardAppRouter(overlayService: getIt()))
     ..registerLazySingleton<IDeviceInfoService>(() => deviceInfoService)
+    ..registerLazySingleton<ILocationService>(
+      () => LocationService(logger: getIt()),
+    )
     // ..registerLazySingleton(() => TbContext())
     ..registerSingletonAsync<ITbClientService>(() async {
       final client = TbClientService();

lib/utils/services/location/i_location_service.dart

@@ -0,0 +1,22 @@
+import 'package:thingsboard_app/utils/services/location/model/location_fix.dart';
+
+/// Single entry point for GPS access across the app. Implementations own all
+/// permission / service-enabled handling so callers never touch the geolocator
+/// plugin directly.
+abstract interface class ILocationService {
+  /// Resolves a single current position, performing the full permission and
+  /// service-enabled checks internally.
+  Future<LocationFix> getCurrentPosition();
+
+  /// Foreground live position updates. Pre-checks availability, then relays
+  /// each update as a [LocationSuccess]. Emits a terminal failure [LocationFix]
+  /// (and stops) if location is unavailable. Subscribers must cancel their
+  /// [StreamSubscription] when done (Riverpod/Bloc disposal handles this).
+  Stream<LocationFix> positionStream({double distanceFilterMeters = 0});
+
+  /// Opens the OS location settings screen. Returns true if it was opened.
+  Future<bool> openLocationSettings();
+
+  /// Opens this app's settings screen (for permanently-denied permission).
+  Future<bool> openAppSettings();
+}

lib/utils/services/location/location_service.dart

@@ -0,0 +1,98 @@
+import 'dart:async';
+
+import 'package:geolocator/geolocator.dart';
+import 'package:thingsboard_app/core/logger/tb_logger.dart';
+import 'package:thingsboard_app/utils/services/location/i_location_service.dart';
+import 'package:thingsboard_app/utils/services/location/model/geo_position.dart';
+import 'package:thingsboard_app/utils/services/location/model/location_fix.dart';
+
+class LocationService implements ILocationService {
+  LocationService({required TbLogger logger, GeolocatorPlatform? geolocator})
+    : _log = logger,
+      _geolocator = geolocator ?? GeolocatorPlatform.instance;
+
+  final TbLogger _log;
+  final GeolocatorPlatform _geolocator;
+
+  @override
+  Future<LocationFix> getCurrentPosition() async {
+    try {
+      final unavailable = await _ensureAvailable();
+      if (unavailable != null) {
+        return unavailable;
+      }
+
+      final position = await _geolocator.getCurrentPosition(
+        locationSettings: const LocationSettings(
+          accuracy: LocationAccuracy.high,
+        ),
+      );
+      return LocationSuccess(_toGeoPosition(position));
+    } catch (e, s) {
+      _log.error('LocationService.getCurrentPosition failed', e, s);
+      return LocationFixError(e.toString());
+    }
+  }
+
+  @override
+  Stream<LocationFix> positionStream({double distanceFilterMeters = 0}) async* {
+    final unavailable = await _ensureAvailable();
+    if (unavailable != null) {
+      yield unavailable;
+      return;
+    }
+
+    final raw = _geolocator.getPositionStream(
+      locationSettings: LocationSettings(
+        accuracy: LocationAccuracy.high,
+        distanceFilter: distanceFilterMeters.round(),
+      ),
+    );
+
+    yield* raw.transform(
+      StreamTransformer<Position, LocationFix>.fromHandlers(
+        handleData:
+            (position, sink) =>
+                sink.add(LocationSuccess(_toGeoPosition(position))),
+        handleError: (e, s, sink) {
+          _log.error('LocationService.positionStream error', e, s);
+          sink.add(LocationFixError(e.toString()));
+        },
+      ),
+    );
+  }
+
+  @override
+  Future<bool> openLocationSettings() => _geolocator.openLocationSettings();
+
+  @override
+  Future<bool> openAppSettings() => _geolocator.openAppSettings();
+
+  /// Returns `null` when location is available, otherwise a failure
+  /// [LocationFix] describing why it is not.
+  Future<LocationFix?> _ensureAvailable() async {
+    final serviceEnabled = await _geolocator.isLocationServiceEnabled();
+    if (!serviceEnabled) {
+      return const LocationServicesDisabled();
+    }
+
+    var permission = await _geolocator.checkPermission();
+    if (permission == LocationPermission.denied) {
+      permission = await _geolocator.requestPermission();
+      if (permission == LocationPermission.denied) {
+        return const LocationPermissionDenied();
+      }
+    }
+    if (permission == LocationPermission.deniedForever) {
+      return const LocationPermissionDeniedForever();
+    }
+    return null;
+  }
+
+  GeoPosition _toGeoPosition(Position p) => GeoPosition(
+    latitude: p.latitude,
+    longitude: p.longitude,
+    accuracy: p.accuracy,
+    timestamp: p.timestamp,
+  );
+}

lib/utils/services/location/model/geo_position.dart

@@ -0,0 +1,15 @@
+import 'package:freezed_annotation/freezed_annotation.dart';
+
+part 'geo_position.freezed.dart';
+
+/// Plugin-agnostic GPS position. Keeps `package:geolocator`'s `Position`
+/// type from leaking past the location service boundary.
+@freezed
+abstract class GeoPosition with _$GeoPosition {
+  const factory GeoPosition({
+    required double latitude,
+    required double longitude,
+    required double accuracy,
+    DateTime? timestamp,
+  }) = _GeoPosition;
+}