location_service.dart

Go to the documentation of this file.

import 'dart:async';
import 'package:flutter/foundation.dart';
import 'package:geolocator/geolocator.dart';
 
import '../api/api_client.dart';
import '../api/api_endpoints.dart';
import 'service_locator.dart';
 
class LocationService {
  final _apiClient = sl<ApiClient>();
  static final LocationService _instance = LocationService._internal();
  StreamSubscription<Position>? _positionStream;
 
  int? _currentPoId;
  String? _currentPoStatus;
  int? _driverId;
 
  factory LocationService() {
    return _instance;
  }
 
  LocationService._internal();
 
  void updateDeliveryContext({int? poId, String? poStatus}) {
    _currentPoId = poId;
    _currentPoStatus = poStatus;
  }
 
  void setDriverId(int driverId) {
    _driverId = driverId;
  }
 
  Future<void> startLocationTracking() async {
    bool serviceEnabled;
    LocationPermission permission;
 
    serviceEnabled = await Geolocator.isLocationServiceEnabled();
    if (!serviceEnabled) {
      return;
    }
 
    permission = await Geolocator.checkPermission();
    if (permission == LocationPermission.denied) {
      permission = await Geolocator.requestPermission();
      if (permission == LocationPermission.denied) {
        return;
      }
    }
 
    if (permission == LocationPermission.deniedForever) {
      return;
    }
 
    LocationSettings locationSettings = LocationSettings(
      accuracy: LocationAccuracy.high,
      distanceFilter: 10,
    );
 
    if (defaultTargetPlatform == TargetPlatform.android) {
      locationSettings = AndroidSettings(
        accuracy: LocationAccuracy.high,
        distanceFilter: 10,
        forceLocationManager: true,
        intervalDuration: const Duration(seconds: 30),
        foregroundNotificationConfig: const ForegroundNotificationConfig(
          notificationText: "Driver app is tracking your location in the background",
          notificationTitle: "Background tracking",
          enableWakeLock: true,
        ),
      );
    } else if (defaultTargetPlatform == TargetPlatform.iOS) {
      locationSettings = AppleSettings(
        pauseLocationUpdatesAutomatically: false,
        accuracy: LocationAccuracy.high,
        activityType: ActivityType.automotiveNavigation,
        allowBackgroundLocationUpdates: true,
        distanceFilter: 10,
        showBackgroundLocationIndicator: true,
      );
    }
 
    Timer? locationTimer;
 
    _positionStream = Geolocator.getPositionStream(locationSettings: locationSettings).listen(
      (Position? position) {
        if (position != null) {
          if (defaultTargetPlatform == TargetPlatform.iOS) {
            if (locationTimer == null || !locationTimer!.isActive) {
              _sendLocationToServer(
                driverId: _driverId ?? 0,
                poId: _currentPoId,
                poStatus: _currentPoStatus,
                latitude: position.latitude,
                longitude: position.longitude,
              );
 
              locationTimer = Timer(const Duration(seconds: 30), () {
                locationTimer = null;
              });
            }
          } else {
            _sendLocationToServer(
              driverId: _driverId ?? 0,
              poId: _currentPoId,
              poStatus: _currentPoStatus,
              latitude: position.latitude,
              longitude: position.longitude,
            );
          }
        }
      },
    );
  }
 
  Future<bool> _sendLocationToServer({
    required int driverId,
    required double latitude,
    required double longitude,
    int? poId,
    String? poStatus,
  }) async {
    try {
      final data = {
        "driverId": driverId,
        "lag": latitude.toString(),
        "longitude": longitude.toString(),
        "poId": poId,
        "poStatus": poStatus,
      };
 
      final response = await _apiClient.post(
        url: ApiEndpoints.sendGeoLocation,
        data: data,
      );
 
      return response.isNotEmpty;
    } catch (e) {
      return false;
    }
  }
 
  void stopLocationTracking() {
    if (_positionStream != null) {
      _positionStream!.cancel();
      _positionStream = null;
    }
  }
}