无法通过AlarmManager移除FusedLocationAPI位置更新的技术求助

Hey, let's clarify a key point first: AlarmManager isn't meant to remove location updates from FusedLocationProviderClient—that's a job for the FusedLocationProviderClient itself. AlarmManager only schedules tasks to run at a specific time. So the right approach is to use AlarmManager to trigger a task that calls the FusedLocationProviderClient's remove method. Let's walk through the solution step by step:

1. First, Fix the Core Misunderstanding #

You mentioned trying to use AlarmManager to remove location updates, but that mixes up two components' roles:

• FusedLocationProviderClient: This is the only class that can start and stop location updates.
• AlarmManager: It just schedules when a task (like stopping updates) should run.

The correct flow is: Use AlarmManager to schedule a task, and in that task, tell FusedLocationProviderClient to stop the updates.

2. Step-by-Step Implementation #

Step 1: Keep a Reference to Your LocationCallback #

To successfully stop location updates, you must use the exact same LocationCallback instance that you passed when requesting updates. Make it a member variable of your LocationProvider class:

public class LocationProvider extends LocationCallback {
    private static FusedLocationProviderClient mFusedLocationClient;
    private LocationRequest mLocationRequest;
    private Context mContext;
    // Hold onto the callback instance for both request and remove operations
    private LocationCallback mActiveCallback;

    public LocationProvider(Context context) {
        mContext = context;
        mActiveCallback = this; // Since this class extends LocationCallback, we can use 'this'
        initLocationClient();
    }

    private void initLocationClient() {
        if(mFusedLocationClient == null) {
            mFusedLocationClient = LocationServices.getFusedLocationProviderClient(mContext);
            // Use our saved callback when requesting updates
            mFusedLocationClient.requestLocationUpdates(mLocationRequest, mActiveCallback, null /* Looper */);
        }
    }
}

Step 2: Add a Method to Stop Updates #

Add a public method to your LocationProvider that calls FusedLocationProviderClient's remove method, using the saved callback:

public void stopLocationUpdates() {
    if (mFusedLocationClient != null && mActiveCallback != null) {
        mFusedLocationClient.removeLocationUpdates(mActiveCallback)
            .addOnSuccessListener(aVoid -> {
                Log.d("LocationProvider", "Location updates stopped successfully");
            })
            .addOnFailureListener(e -> {
                Log.e("LocationProvider", "Failed to stop location updates: " + e.getMessage());
            });
    }
}

Step 3: Use AlarmManager to Trigger the Stop #

If you need to stop updates at a specific time, use AlarmManager to trigger a BroadcastReceiver (or WorkManager for newer apps) that calls your stop method:

Example with BroadcastReceiver

1. Create the receiver:

public class StopLocationReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        // Get your LocationProvider instance (assuming it's a singleton)
        LocationProvider locationProvider = LocationProvider.getInstance(context);
        locationProvider.stopLocationUpdates();
    }
}

2. Register it in your AndroidManifest.xml:

<receiver android:name=".StopLocationReceiver" />

3. Schedule the alarm:

AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
Intent stopIntent = new Intent(context, StopLocationReceiver.class);
PendingIntent pendingIntent = PendingIntent.getBroadcast(
    context, 
    0, 
    stopIntent, 
    PendingIntent.FLAG_IMMUTABLE // Use FLAG_UPDATE_CURRENT if targeting older APIs
);

// Schedule to stop updates 1 hour from now
long triggerTime = System.currentTimeMillis() + 3600 * 1000;
alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, triggerTime, pendingIntent);

3. Common Pitfalls to Avoid #

• Same Callback Instance: If you used an anonymous LocationCallback when requesting updates, you won't be able to reference it later to stop updates—always keep a global reference.
• Permissions: Make sure your app still holds ACCESS_FINE_LOCATION or ACCESS_COARSE_LOCATION permission when trying to stop updates; lost permissions will cause the remove call to fail.
• Client Instance: Keep your FusedLocationProviderClient instance alive (using a singleton pattern for LocationProvider helps here) so it doesn't get garbage collected before you can call stop.

内容的提问来源于stack exchange，提问作者ME-DEV