Oreo系统中LocationService无法通过JobScheduler调用的问题

I see you switched from startService() to JobScheduler to get around Oreo's background service restrictions, but your LocationUpdateService isn't even hitting onCreate()—let's break down the issues and fix this.

Key Issues Causing the Problem #

1. Missing BIND_JOB_SERVICE Permission in Manifest #

JobService requires a specific system permission to be invoked by Android. If you don't declare this, the system will completely ignore your job scheduling request, which explains why onCreate() never runs.

2. Invalid Periodic Interval for Oreo+ #

Starting with Android Oreo (API 26), JobScheduler enforces a minimum periodic interval of 15 minutes (900000ms). Your setPeriodic(5000) gets silently adjusted by the system, and the job might not trigger immediately (or at all during testing).

3. JobService Implementation Gaps #

When you return true from onStartJob(), you're telling the system you'll handle the task asynchronously. If you don't start a background thread or call jobFinished() once the task is done, the system might mark the job as stuck and stop scheduling it.

Step-by-Step Fixes #

1. Correctly Declare the JobService in Manifest #

Add the android.permission.BIND_JOB_SERVICE permission to your LocationUpdateService declaration—this is non-negotiable:

<service
    android:name=".LocationUpdateService"
    android:permission="android.permission.BIND_JOB_SERVICE" />

2. Adjust the Job's Periodic Interval #

If you need periodic location updates, set the interval to at least 15 minutes (Oreo's minimum allowed value):

// Replace builder.setPeriodic(5000) with this:
builder.setPeriodic(900000); // 15 minutes in milliseconds

Note: If you need more frequent updates (shorter than 15 mins), JobScheduler isn't the right tool. Use WorkManager (Jetpack's recommended background task library) or a Foreground Service (with a persistent notification) instead.

3. Fix the JobService Implementation #

Update your LocationUpdateService to handle async tasks properly and notify the system when the job is complete:

public class LocationUpdateService extends JobService implements LocationListener, GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener {
    private static final String TAG = "LocationUpdateService";
    private JobParameters params;
    private GoogleApiClient mGoogleApiClient;
    private LocationRequest mLocationRequest;
    private static final long BACKGROUND_INTERVAL = 900000; // Match job interval

    @Override
    public void onCreate() {
        super.onCreate();
        Log.i(TAG, "onCreate: Service initialized");
        if (isGooglePlayServicesAvailable()) {
            mGoogleApiClient = new GoogleApiClient.Builder(this)
                    .addApi(LocationServices.API)
                    .addConnectionCallbacks(this)
                    .addOnConnectionFailedListener(this)
                    .build();
        }
    }

    @Override
    public boolean onStartJob(JobParameters params) {
        Log.i(TAG, "onStartJob: Job triggered");
        this.params = params;

        // Run location logic on a background thread to avoid blocking the main thread
        new Thread(() -> {
            if (mGoogleApiClient != null && !mGoogleApiClient.isConnected()) {
                mGoogleApiClient.connect();
            } else {
                requestLocationUpdates();
            }
        }).start();

        return true; // Indicates we're handling the job asynchronously
    }

    @Override
    public boolean onStopJob(JobParameters params) {
        Log.d(TAG, "onStopJob: Job stopped");
        if (mGoogleApiClient != null && mGoogleApiClient.isConnected()) {
            LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, this);
            mGoogleApiClient.disconnect();
        }
        return true; // True to reschedule the job if needed
    }

    @Override
    public void onConnected(@Nullable Bundle bundle) {
        Log.i(TAG, "onConnected: GoogleApiClient connected");
        requestLocationUpdates();
    }

    private void requestLocationUpdates() {
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            Log.e(TAG, "Location permission not granted");
            jobFinished(params, false); // End job if permissions are missing
            return;
        }

        mLocationRequest = new LocationRequest();
        mLocationRequest.setInterval(BACKGROUND_INTERVAL);
        mLocationRequest.setFastestInterval(BACKGROUND_INTERVAL);
        mLocationRequest.setPriority(LocationRequest.PRIORITY_BALANCED_POWER_ACCURACY);
        LocationServices.FusedLocationApi.requestLocationUpdates(mGoogleApiClient, mLocationRequest, this);
    }

    @Override
    public void onLocationChanged(Location location) {
        Log.i(TAG, "onLocationChanged: Got location - Lat: " + location.getLatitude() + ", Lng: " + location.getLongitude());
        // Handle sending location to server here

        // Notify system that the job is complete
        jobFinished(params, false); // False = don't reschedule immediately (let the periodic trigger handle it)
        // If you want to keep listening for locations, skip jobFinished() but be aware of system restrictions
    }

    // Implement remaining required methods (onConnectionSuspended, onConnectionFailed, isGooglePlayServicesAvailable)
    // ...
}

4. Verify Job Scheduling Success #

Check if the job is scheduled correctly by logging the result of jobScheduler.schedule():

int scheduleResult = jobScheduler.schedule(jobInfo);
if (scheduleResult == JobScheduler.RESULT_SUCCESS) {
    Log.i(TAG, "Job scheduled successfully");
} else {
    Log.e(TAG, "Job scheduling failed - check permissions and service declaration");
}

5. Ensure Proper Location Permissions #

For Android Oreo+, you need to request runtime permissions for location access. For background location (API 29+), you'll also need ACCESS_BACKGROUND_LOCATION:

Manifest:

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" android:maxSdkVersion="33" />

Runtime Permission Request (in MainActivity):

private void requestLocationPermissions() {
    String[] permissions;
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
        permissions = new String[]{Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_BACKGROUND_LOCATION};
    } else {
        permissions = new String[]{Manifest.permission.ACCESS_FINE_LOCATION};
    }
    ActivityCompat.requestPermissions(this, permissions, 1001);
}

Final Notes #

If you need more frequent location updates than 15 minutes, JobScheduler won't work on Oreo+. Instead, use WorkManager for flexible, reliable background tasks, or a Foreground Service (with a visible notification) to run persistent location tracking.

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