Android：如何正确启动后台Service？生命周期与绑定需求咨询

Hey Harry, let's tackle this head-on—your location tracking use case is really common, and the confusion usually comes from mixing started services and bound services (since you need both: long-running background work + UI interaction when the Activity is active). Let's start with clarifying the lifecycle bits you're missing, then walk through a concrete implementation.

First, let's break down the two service modes you'll need to combine:

• Started Service: When you call startService() from your Activity, the service launches and keeps running even after the Activity is destroyed—unless you explicitly call stopService()/stopSelf() or the system kills it due to low memory. Its lifecycle: onCreate() → onStartCommand() (called every time you start it) → onDestroy() (only when stopped).
• Bound Service: When you call bindService(), the service connects to your Activity so you can interact with it (like fetching location data). Its lifecycle adds: onBind() (called when first client binds) → onUnbind() (when last client unbinds) → but if the service was also started via startService(), onDestroy() won't trigger here—it only dies when stopped.

Your goal is to use both: start the service to keep it alive in the background, and bind/unbind as needed when the Activity is visible.

Let's build this out with code examples tailored to your needs.

1. Custom Location Tracking Service #

We'll create a service that handles both start commands and binding, plus manages location updates.

class LocationTrackingService : Service() {
    // Binder to let Activity connect to this service
    private val binder = LocalBinder()
    // Store latest location (for Activity to retrieve)
    private var latestLocation: Location? = null
    // Location provider client (using FusedLocationProvider for reliability)
    private lateinit var fusedLocationClient: FusedLocationProviderClient
    private lateinit var locationRequest: LocationRequest
    private lateinit var locationCallback: LocationCallback

    inner class LocalBinder : Binder() {
        // Return this service instance to the Activity
        fun getService(): LocationTrackingService = this@LocationTrackingService
    }

    override fun onCreate() {
        super.onCreate()
        // Initialize location tracking setup
        fusedLocationClient = LocationServices.getFusedLocationProviderClient(this)
        locationRequest = LocationRequest.create().apply {
            interval = 5000 // Update every 5 seconds
            fastestInterval = 2000
            priority = LocationRequest.PRIORITY_HIGH_ACCURACY
        }
        locationCallback = object : LocationCallback() {
            override fun onLocationResult(locationResult: LocationResult) {
                super.onLocationResult(locationResult)
                locationResult.lastLocation?.let {
                    latestLocation = it
                    // Do something with the location (save to DB, send to server, etc.)
                }
            }
        }
        // For Android 8.0+, we need to run as a foreground service to avoid being killed
        startForeground(1, createNotification())
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        // Start location updates when the service is started
        requestLocationUpdates()
        // Return START_STICKY to let the system restart the service if it's killed (optional but useful)
        return START_STICKY
    }

    override fun onBind(intent: Intent): IBinder {
        // Return the binder when Activity binds
        return binder
    }

    override fun onUnbind(intent: Intent?): Boolean {
        // Don't stop location updates here—we want the service to keep running
        return super.onUnbind(intent)
    }

    override fun onDestroy() {
        super.onDestroy()
        // Clean up location updates when service is stopped
        fusedLocationClient.removeLocationUpdates(locationCallback)
    }

    // Helper method for Activity to get latest location
    fun getLatestLocation(): Location? = latestLocation

    private fun requestLocationUpdates() {
        // Make sure we have permissions first!
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED &&
            ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_BACKGROUND_LOCATION) == PackageManager.PERMISSION_GRANTED) {
            fusedLocationClient.requestLocationUpdates(locationRequest, locationCallback, Looper.getMainLooper())
        }
    }

    private fun createNotification(): Notification {
        // Build a simple foreground service notification (required for Android 8.0+)
        val channelId = "location_tracking_channel"
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            val channel = NotificationChannel(channelId, "Location Tracking", NotificationManager.IMPORTANCE_LOW)
            getSystemService(NotificationManager::class.java).createNotificationChannel(channel)
        }
        return NotificationCompat.Builder(this, channelId)
            .setContentTitle("Tracking Location")
            .setContentText("Running in background")
            .setSmallIcon(R.drawable.ic_location)
            .build()
    }
}

2. Activity Implementation #

Your Activity will start the service on launch, bind to it when visible, and unbind when hidden.

class MainActivity : AppCompatActivity() {
    private var locationService: LocationTrackingService? = null
    private var isServiceBound = false
    // Connection to the service
    private val serviceConnection = object : ServiceConnection {
        override fun onServiceConnected(className: ComponentName, service: IBinder) {
            // Cast the binder to our local binder and get the service instance
            val binder = service as LocationTrackingService.LocalBinder
            locationService = binder.getService()
            isServiceBound = true
            // Now we can interact with the service—e.g., display latest location
            updateLocationDisplay()
        }

        override fun onServiceDisconnected(arg0: ComponentName) {
            isServiceBound = false
            locationService = null
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        // Start the service first—this ensures it runs even after Activity is destroyed
        Intent(this, LocationTrackingService::class.java).also { intent ->
            startService(intent)
        }
    }

    override fun onResume() {
        super.onResume()
        // Bind to the service when Activity is visible to interact with it
        Intent(this, LocationTrackingService::class.java).also { intent ->
            bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE)
        }
    }

    override fun onPause() {
        super.onPause()
        // Unbind when Activity is hidden—this doesn't stop the service
        if (isServiceBound) {
            unbindService(serviceConnection)
            isServiceBound = false
        }
    }

    private fun updateLocationDisplay() {
        locationService?.getLatestLocation()?.let { location ->
            // Update UI with location data (e.g., latitude/longitude)
            locationTextView.text = "Lat: ${location.latitude}, Lng: ${location.longitude}"
        }
    }
}

3. Critical Notes to Avoid Pitfalls #

• Permissions: Don't forget to declare these in your AndroidManifest.xml:

  <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
  <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" /> <!-- Required for Android 10+ -->
  <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
  

  Also, request runtime permissions from the user before starting the service.
• Foreground Service: Android 8.0+ (API 26+) restricts background services, so we use startForeground() to keep the service alive—this requires showing a persistent notification (you can customize it to be less intrusive if needed).
• Service Destruction: The service will only stop if you call stopService() (e.g., from a "Stop Tracking" button in your Activity) or if the system kills it. To handle system kills, START_STICKY in onStartCommand() helps the system restart the service when memory is available.

That should cover exactly what you need: the service runs continuously after the Activity exits, and you can bind to it again later to pull location data for display.

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