Android Oreo后台定位服务启动异常问题求助

Hey there, I’ve battled this exact IllegalStateException when setting up background location tracking on Android Oreo—let’s break down what’s going wrong and how to fix it step by step.

First, let’s recap the root cause: Android Oreo (API 26+) introduced strict background service limits. You can’t just start a regular background service anymore, and even when using a foreground service, there are non-negotiable rules you have to follow to avoid that error.

Here’s the actionable fix:

1. Get Your Permissions & Manifest Setup Right #

First, make sure your AndroidManifest.xml has all the required permissions and service declarations:

<!-- Location permissions -->
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<!-- Required for foreground services on Oreo+ -->
<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />

<!-- Declare your foreground service -->
<service
    android:name=".LocationTrackingForegroundService"
    android:foregroundServiceType="location" /> <!-- Explicitly mark as location type (safe to add for Oreo) -->

2. Create a Notification Channel (Oreo+) #

Oreo requires all notifications to be tied to a channel. If you skip this, your foreground service notification won’t show up, and the system will kill your service with that IllegalStateException.

Add this code somewhere early in your app (like your Application class or before starting the service):

private fun createLocationNotificationChannel(context: Context) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        val channel = NotificationChannel(
            "LOCATION_TRACKING_CHANNEL",
            "Location Tracking",
            NotificationManager.IMPORTANCE_LOW // Low priority so it doesn't intrude
        )
        channel.description = "Used to show location tracking is active"
        
        val notificationManager = context.getSystemService(NotificationManager::class.java)
        notificationManager.createNotificationChannel(channel)
    }
}

3. Build a Valid Foreground Notification #

Your foreground service must show a persistent notification. Here’s a simple implementation:

private fun buildForegroundNotification(context: Context): Notification {
    val launchIntent = Intent(context, MainActivity::class.java)
    val pendingIntent = PendingIntent.getActivity(
        context,
        0,
        launchIntent,
        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
    )

    return NotificationCompat.Builder(context, "LOCATION_TRACKING_CHANNEL")
        .setSmallIcon(R.drawable.ic_location) // Use your own app icon
        .setContentTitle("Tracking Your Location")
        .setContentText("We're collecting location data for 3 minutes")
        .setContentIntent(pendingIntent)
        .setPriority(NotificationCompat.PRIORITY_LOW)
        .build()
}

4. Implement the Foreground Service Correctly #

The key mistake many developers make is either using startService() instead of startForegroundService() (for Oreo+) or not calling startForeground() immediately in the service.

Here’s a complete service implementation that handles 3 minutes of location tracking:

class LocationTrackingForegroundService : Service() {
    private lateinit var fusedLocationClient: FusedLocationProviderClient
    private var locationCallback: LocationCallback? = null
    private var countdownTimer: CountDownTimer? = null

    override fun onCreate() {
        super.onCreate()
        fusedLocationClient = LocationServices.getFusedLocationProviderClient(this)
        createLocationNotificationChannel(this)
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        // Critical: Call startForeground within 5 seconds of starting the service
        val notification = buildForegroundNotification(this)
        startForeground(1, notification)

        // Start location updates
        startLocationTracking()

        // Auto-stop after 3 minutes
        countdownTimer = object : CountDownTimer(3 * 60 * 1000, 1000) {
            override fun onTick(millisUntilFinished: Long) {}
            override fun onFinish() {
                stopLocationTracking()
                stopForeground(STOP_FOREGROUND_REMOVE) // Remove the notification
                stopSelf() // Shut down the service
            }
        }.start()

        return START_STICKY
    }

    private fun startLocationTracking() {
        val locationRequest = LocationRequest.create().apply {
            interval = 10000 // Update every 10 seconds (adjust as needed)
            fastestInterval = 5000
            priority = LocationRequest.PRIORITY_HIGH_ACCURACY
        }

        locationCallback = object : LocationCallback() {
            override fun onLocationResult(locationResult: LocationResult) {
                locationResult.lastLocation?.let { location ->
                    // Do something with the location data
                    Log.d("LocationService", "Lat: ${location.latitude}, Lng: ${location.longitude}")
                }
            }
        }

        // Check permissions before requesting updates
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
            == PackageManager.PERMISSION_GRANTED
        ) {
            fusedLocationClient.requestLocationUpdates(
                locationRequest,
                locationCallback!!,
                Looper.getMainLooper()
            )
        }
    }

    private fun stopLocationTracking() {
        locationCallback?.let { fusedLocationClient.removeLocationUpdates(it) }
        countdownTimer?.cancel()
    }

    override fun onBind(intent: Intent): IBinder? = null

    override fun onDestroy() {
        stopLocationTracking()
        super.onDestroy()
    }
}

5. Start the Service the Right Way #

When launching the service, use startForegroundService() for Oreo+ devices (fall back to startService() for older versions):

fun startLocationTracking(context: Context) {
    val serviceIntent = Intent(context, LocationTrackingForegroundService::class.java)
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        ContextCompat.startForegroundService(context, serviceIntent)
    } else {
        context.startService(serviceIntent)
    }
}

Common Pitfalls to Avoid #

• Forgetting startForeground(): If you don’t call this within 5 seconds of starting the service, the system will throw that IllegalStateException.
• Missing Notification Channel: Without a channel, Oreo won’t display your notification, and the service will be killed.
• Using startService() Instead of startForegroundService(): Oreo blocks background service starts with startService()—you must use the foreground variant.
• Permission Issues: Always check that you’ve requested and been granted ACCESS_FINE_LOCATION (or ACCESS_COARSE_LOCATION) before starting location updates.

That should get your 3-minute background location tracking working on Oreo without hitting that exception.

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