如何让Android应用GPS采集模块在应用被杀后仍后台运行？

Hey Kevin, nice work getting the GPS collection and MySQL storage up and running! Now, to keep that GPS data flowing even when your app is in the background or gets killed, you’ll need to move that GPS logic out of your main Activity and into a Foreground Service—plus navigate some Android background restrictions. Let’s walk through how to do this properly:

1. Move Your GPS Logic to a Foreground Service #

Android has strict background limits starting from Oreo (API 26)—regular Services get killed quickly when the app isn’t in focus. A Foreground Service is designed to run indefinitely because it shows a persistent notification to the user, letting them know your app is actively doing work (like collecting GPS data).

Here’s how to set this up:

• Create a new class extending Service (better for ongoing tasks than IntentService)
• Use FusedLocationProviderClient instead of the old LocationManager—it’s more efficient and battery-friendly
• In onStartCommand(), call startForeground() with a notification (required for API 26+)
• Return START_STICKY to tell the system to restart the service if it gets killed due to low memory

Example Service Code (Kotlin): #

class GPSCollectionService : Service() {
    private lateinit var fusedLocationClient: FusedLocationProviderClient
    private lateinit var locationCallback: LocationCallback

    override fun onCreate() {
        super.onCreate()
        fusedLocationClient = LocationServices.getFusedLocationProviderClient(this)
        // Set up callback to handle location updates
        locationCallback = object : LocationCallback() {
            override fun onLocationResult(locationResult: LocationResult) {
                locationResult.lastLocation?.let { location ->
                    // Call your existing MySQL storage function here
                    saveLocationToDB(location.latitude, location.longitude)
                }
            }
        }
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        // Create notification channel (required for API 26+)
        createNotificationChannel()
        // Build foreground notification
        val notification = NotificationCompat.Builder(this, "GPS_COLLECTION_CHANNEL")
            .setContentTitle("GPS Tracker Running")
            .setContentText("Collecting location data in background")
            .setSmallIcon(R.drawable.ic_gps_icon)
            .setPriority(NotificationCompat.PRIORITY_LOW)
            .build()

        // Start service in foreground mode
        startForeground(101, notification)

        // Configure location update settings
        val locationRequest = LocationRequest.create().apply {
            interval = 10000 // Update every 10 seconds (adjust based on your needs)
            fastestInterval = 5000 // Fastest update interval (avoid setting too low to save battery)
            priority = LocationRequest.PRIORITY_HIGH_ACCURACY
        }

        // Request location updates (ensure permissions are granted first!)
        fusedLocationClient.requestLocationUpdates(
            locationRequest,
            locationCallback,
            Looper.getMainLooper()
        )

        // Tell system to restart service if killed
        return START_STICKY
    }

    private fun createNotificationChannel() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            val channel = NotificationChannel(
                "GPS_COLLECTION_CHANNEL",
                "GPS Collection",
                NotificationManager.IMPORTANCE_LOW
            )
            val notificationManager = getSystemService(NotificationManager::class.java)
            notificationManager.createNotificationChannel(channel)
        }
    }

    override fun onDestroy() {
        super.onDestroy()
        // Clean up location updates to prevent memory leaks
        fusedLocationClient.removeLocationUpdates(locationCallback)
    }

    override fun onBind(intent: Intent?): IBinder? {
        // No binding needed for this service
        return null
    }

    private fun saveLocationToDB(lat: Double, lon: Double) {
        // Your existing MySQL storage logic here—make sure it's asynchronous!
        // Use coroutines, AsyncTask, or a background thread to avoid blocking the service
    }
}

2. Update Your Manifest & Permissions #

Declare the service and request the necessary permissions in AndroidManifest.xml:

<!-- Core location permission -->
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<!-- Required for background location on Android 10+ (API 29) -->
<uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
<!-- Foreground service base permission -->
<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
<!-- Required for location-focused foreground services on Android 12+ (API 31) -->
<uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION" />

<application ...>
    <service
        android:name=".GPSCollectionService"
        android:foregroundServiceType="location" /> <!-- Android 12+ requirement -->
</application>

3. Start the Service from Your Main Activity #

In your main Activity, verify permissions first, then start the service:

// Check if all required permissions are granted
if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED &&
    ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_BACKGROUND_LOCATION) == PackageManager.PERMISSION_GRANTED) {
    
    val serviceIntent = Intent(this, GPSCollectionService::class.java)
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        // Use startForegroundService for API 26+
        startForegroundService(serviceIntent)
    } else {
        startService(serviceIntent)
    }
}

4. Handle App Being Killed #

Even with START_STICKY, the system might not always restart your service (especially if the user force-stops it). For extra reliability, add WorkManager as a fallback:

• Use PeriodicWorkRequest to run a location check at regular intervals
• If your service isn’t running, the Worker can restart it (or directly save the latest location to your DB)

Example WorkManager Setup: #

// In your Activity or Service
val constraints = Constraints.Builder()
    .setRequiredNetworkType(NetworkType.CONNECTED) // Only run if network is available (for MySQL upload)
    .setRequiresBatteryNotLow(true)
    .build()

val periodicWork = PeriodicWorkRequestBuilder<GPSWorker>(15, TimeUnit.MINUTES)
    .setConstraints(constraints)
    .build()

WorkManager.getInstance(this).enqueue(periodicWork)

// The Worker class
class GPSWorker(context: Context, params: WorkerParameters) : CoroutineWorker(context, params) {
    override suspend fun doWork(): Result {
        val fusedLocationClient = LocationServices.getFusedLocationProviderClient(applicationContext)
        return try {
            val location = fusedLocationClient.lastLocation.await()
            location?.let {
                saveLocationToDB(it.latitude, it.longitude)
            }
            Result.success()
        } catch (e: Exception) {
            // Retry if something goes wrong
            Result.retry()
        }
    }

    private suspend fun saveLocationToDB(lat: Double, lon: Double) {
        // Async storage logic using coroutines
    }
}

5. Key Tips to Avoid Issues #

• Battery Optimization: Ask users to exclude your app from battery optimization (Settings > Battery > Battery Optimization > Your App > Don’t Optimize). This prevents the system from throttling your service.
• Test on Real Devices: Emulators don’t always replicate real-world background behavior—test on a physical device to ensure your service stays running.
• Balance Update Frequency: Don’t set location intervals too short (e.g., <5 seconds) unless absolutely necessary—this drains battery fast. Adjust based on your use case.

That should cover it! With a Foreground Service and WorkManager fallback, your app will keep collecting GPS data even when it’s in the background or gets killed.

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