关于后台位置发送服务启停控制及代码实现的技术问询

Alright, let's break down how to implement your required background location tracking logic properly, considering Android's latest lifecycle restrictions. Here's a step-by-step solution tailored to your needs:

Key Requirements Recap #

• Stop the background service immediately when location tracking is no longer needed.
• Keep the service running in the background to track the driver’s location until the vehicle reaches its destination, then auto-stop the service.

Step 1: Create the Location Tracking Service #

We’ll use Google’s FusedLocationProviderClient (the recommended way for reliable location updates) and implement a foreground service to comply with Android O+ background restrictions (since plain background services are heavily limited in newer OS versions).

import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.Service;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.location.Location;
import android.os.Build;
import android.os.IBinder;
import androidx.core.app.ActivityCompat;
import com.google.android.gms.location.FusedLocationProviderClient;
import com.google.android.gms.location.LocationCallback;
import com.google.android.gms.location.LocationRequest;
import com.google.android.gms.location.LocationResult;
import com.google.android.gms.location.LocationServices;

public class LocationTrackingService extends Service {
    private static final String CHANNEL_ID = "DriverLocationTracking";
    private FusedLocationProviderClient fusedLocationClient;
    private LocationCallback locationUpdateCallback;
    // Replace with your actual target destination coordinates
    private final double TARGET_LAT = 37.7749;
    private final double TARGET_LNG = -122.4194;
    private static final float ARRIVAL_THRESHOLD = 50; // 50 meters radius

    @Override
    public void onCreate() {
        super.onCreate();
        fusedLocationClient = LocationServices.getFusedLocationProviderClient(this);
        createNotificationChannel();

        // Set up callback to receive location updates
        locationUpdateCallback = new LocationCallback() {
            @Override
            public void onLocationResult(LocationResult locationResult) {
                if (locationResult == null) return;
                
                for (Location location : locationResult.getLocations()) {
                    // Send location data to your backend server here
                    sendLocationToServer(location);
                    
                    // Check if driver has reached the destination
                    if (hasReachedDestination(location)) {
                        // Auto-stop service once arrived
                        stopSelf();
                    }
                }
            }
        };
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // Start foreground service with a notification (required for API 26+)
        Notification trackingNotification = new Notification.Builder(this, CHANNEL_ID)
                .setContentTitle("Tracking Driver Location")
                .setContentText("Running in background")
                .setSmallIcon(R.drawable.ic_location_pin)
                .build();
        startForeground(1, trackingNotification);

        // Request continuous location updates
        startLocationUpdates();

        // Restart service if it's killed by the system (adjust based on your needs)
        return START_STICKY;
    }

    private void startLocationUpdates() {
        LocationRequest locationRequest = LocationRequest.create();
        locationRequest.setInterval(10000); // Update every 10 seconds
        locationRequest.setFastestInterval(5000); // Faster update if available
        locationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);

        // Check for location permissions before requesting updates
        if (ActivityCompat.checkSelfPermission(this, android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            // Permissions not granted - stop service and handle permission request in your activity
            stopSelf();
            return;
        }
        fusedLocationClient.requestLocationUpdates(locationRequest, locationUpdateCallback, null);
    }

    private boolean hasReachedDestination(Location currentLocation) {
        Location targetLocation = new Location("");
        targetLocation.setLatitude(TARGET_LAT);
        targetLocation.setLongitude(TARGET_LNG);
        // Return true if current location is within arrival threshold
        return currentLocation.distanceTo(targetLocation) <= ARRIVAL_THRESHOLD;
    }

    private void sendLocationToServer(Location location) {
        // Implement your network call here (e.g., Retrofit, Volley)
        double currentLat = location.getLatitude();
        double currentLng = location.getLongitude();
        // Example: driverLocationApi.sendLocation(currentLat, currentLng);
    }

    private void createNotificationChannel() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            NotificationChannel serviceChannel = new NotificationChannel(
                    CHANNEL_ID,
                    "Driver Location Tracking",
                    NotificationManager.IMPORTANCE_LOW
            );
            NotificationManager manager = getSystemService(NotificationManager.class);
            manager.createNotificationChannel(serviceChannel);
        }
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        // Clean up location updates to save battery
        fusedLocationClient.removeLocationUpdates(locationUpdateCallback);
    }

    @Override
    public IBinder onBind(Intent intent) {
        return null; // Not using bound service, return null
    }
}

Step 2: Start/Stop the Service #

Start Tracking (e.g., When a Trip Begins) #

Use startForegroundService() for API 26+ (since startService() is deprecated), otherwise fall back to startService():

Intent trackingIntent = new Intent(getApplicationContext(), LocationTrackingService.class);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
    getApplicationContext().startForegroundService(trackingIntent);
} else {
    getApplicationContext().startService(trackingIntent);
}

Stop Tracking Manually (e.g., When Location is No Longer Needed) #

Call stopService() to immediately halt the service and location updates:

Intent trackingIntent = new Intent(getApplicationContext(), LocationTrackingService.class);
getApplicationContext().stopService(trackingIntent);

Step 3: Update the Android Manifest #

Add these permissions and declare the service in your AndroidManifest.xml:

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<!-- Required for background location access on API 29+ -->
<uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
<!-- Required for foreground service with location -->
<uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION" />

<application ...>
    <service android:name=".LocationTrackingService" />
</application>

Critical Notes for Reliability #

• Runtime Permissions: You must request ACCESS_FINE_LOCATION (and ACCESS_BACKGROUND_LOCATION for API 29+) from the user at runtime before starting the service. Without these, location updates will fail.
• Battery Optimization: Ask users to exclude your app from battery optimization (Settings > Battery > Battery Optimization) to avoid interruptions from Doze mode.
• Interval Tuning: Adjust setInterval() and setFastestInterval() based on your needs—shorter intervals use more battery but provide more frequent updates.

内容的提问来源于stack exchange，提问作者Manasvi