服务概览

Service 是一种可在后台执行长时间运行的操作的应用组件。它不提供界面。服务启动后,可能会持续运行一段时间,即使用户切换到其他应用也是如此。此外,组件可以绑定到服务,以与之进行交互,甚至执行进程间通信 (IPC)。例如,服务可以处理网络事务、播放音乐、执行文件 I/O 或与 content provider 交互,而所有这些工作都可以在后台进行。

注意:服务在其托管进程的主线程中运行,它不会创建自己的线程,也不会在单独的进程中运行(除非您另行指定)。您应在服务内的单独线程中运行任何阻塞操作,以避免发生“应用无响应”(ANR) 错误。

Service 类型

以下是三种不同类型的服务:

前景

前台服务执行一些用户能注意到的操作。例如,音频应用会使用前台服务播放音轨。前台服务必须显示通知。 即使在用户未与应用互动时,前台服务也会继续运行。

使用前台服务时,您必须显示通知,让用户主动知道该服务正在运行。除非服务停止或从前台移除,否则无法关闭此通知。

详细了解如何在应用中配置前台服务。

注意:WorkManager API 提供了一种灵活的任务调度方式,并且能够根据需要将这些作业作为前台服务运行。在许多情况下,使用 WorkManager 比直接使用前台服务更可取。

背景
后台服务用于执行用户不会直接注意到的操作。例如,如果应用使用某项服务来压缩其存储空间,则该服务通常是后台服务。

注意:如果您的应用以 API 级别 26 或更高级别为目标平台,当应用本身不在前台时,系统会限制运行后台服务。例如,在大多数情况下,您不应从后台访问位置信息。而是使用 WorkManager 调度任务。

已绑定
当应用组件通过调用 bindService() 绑定到服务时,服务即处于绑定状态。绑定服务提供客户端-服务器接口,以便组件与服务进行交互、发送请求、接收结果,甚至可以利用进程间通信 (IPC) 跨进程执行这些操作。绑定服务仅在有其他应用组件与其绑定时才会运行。多个组件可同时绑定到该服务,但当所有这些组件都解绑时,系统会销毁该服务。

虽然本文档通常会分开讨论启动服务和绑定服务,但您的服务可以同时以这两种方式工作,也就是说,它既可以是启动服务(无限期运行),也允许绑定。这只是您是否实现几个回调方法的问题:onStartCommand() 允许组件启动它,onBind() 允许绑定。

无论服务是启动状态、绑定状态还是两者兼而有之,任何应用组件都可以使用该服务(甚至可以从其他应用中使用),就像任何组件都可以通过 Intent 启动 activity 一样。不过,您可以在清单文件中将服务声明为私有,并阻止其他应用访问。在清单中声明服务部分对此进行了详细讨论。

在服务和线程之间进行选择

服务只是一个可在后台运行的组件,即使用户不与您的应用互动,它也能运行。因此,您应仅在需要时才创建服务。

如果您必须在主线程之外执行工作,但仅在用户与您的应用互动时执行,则应在另一个应用组件的上下文中创建新线程。例如,如果您想播放一些音乐,但仅在 activity 运行时播放,则可以在 onCreate() 中创建线程,在 onStart() 中开始运行该线程,然后在 onStop() 中停止该线程。此外,请考虑使用 java.util.concurrent 软件包或 Kotlin 协程中的线程池和执行器,而不是传统的 Thread 类。如需详细了解如何将执行移至后台线程,请参阅 Android 上的线程处理文档。

请记住,如果您确实要使用服务,默认情况下,它仍会在应用的主线程中运行,因此,如果服务执行的是密集型或阻塞性操作,您仍应在服务内创建新线程。

基础知识

如需创建服务,您必须创建 Service 的子类或使用其某个现有子类。在实现中,您必须替换一些回调方法,这些方法用于处理服务生命周期的关键方面,并提供一种机制来允许组件绑定到服务(如果适用)。以下是您应替换的最重要的回调方法:

onStartCommand()
当另一个组件(例如 activity)请求启动服务时,系统会通过调用 startService() 来调用此方法。 此方法执行时,服务会启动,并可在后台无限期运行。如果您实现此服务,则有责任在服务完成工作后通过调用 stopSelf() 或 stopService() 来停止服务。如果您只想提供绑定,则无需实现此方法。
onBind()
当另一个组件想要与服务绑定(例如执行 RPC)时,系统会通过调用 bindService() 来调用此方法。 在实现此方法时,您必须通过返回 IBinder 来提供一个接口,供客户端用来与服务进行通信。您必须始终实现此方法;不过,如果您不想允许绑定,则应返回 null。
onCreate()
系统会在首次创建服务时(在调用 onStartCommand() 或 onBind() 之前)调用此方法来执行一次性设置程序。如果服务已在运行,则不会调用此方法。
onDestroy()
当服务不再使用且将被销毁时,系统会调用此方法。您的服务应实现此方法,以清理任何资源,例如线程、已注册的监听器或接收器。这是服务收到的最后一个调用。

如果组件通过调用 startService() 启动服务(这会导致对 onStartCommand() 的调用),服务会一直运行,直到其使用 stopSelf() 自行停止运行,或由其他组件通过调用 stopService() 将其停止。

如果某个组件调用 bindService() 来创建服务,但未调用 onStartCommand(),则该服务仅在组件绑定到它时运行。当服务与所有客户端解除绑定后,系统会销毁该服务。

只有在内存不足且必须回收系统资源以供用户关注的 activity 使用时,Android 系统才会停止服务。如果服务绑定到用户聚焦的 activity,则不太可能被终止;如果服务声明为在前台运行,则很少会被终止。如果服务已启动且长时间运行,系统会随着时间的推移降低其在后台任务列表中的位置,而服务也会变得极易被终止。如果您的服务已启动,您必须将其设计为能够妥善处理系统重启。如果系统终止了您的服务,它会在资源可用时立即重启该服务,但这还取决于您从 onStartCommand() 返回的值。如需详细了解系统何时可能会销毁服务,请参阅进程和线程文档。

在以下部分中,您将了解如何创建 startService() 和 bindService() 服务方法,以及如何从其他应用组件中使用这些方法。

在清单中声明服务

您必须在应用的清单文件中声明所有服务,就像声明 activity 和其他组件一样。

如需声明服务,请添加 <service> 元素作为 <application> 元素的子元素。示例如下:

<manifest ... >
  ...
  <application ... >
      <service android:name=".ExampleService" />
      ...
  </application>
</manifest>

如需详细了解如何在清单中声明服务,请参阅 <service> 元素参考文档。

您可以在 <service> 元素中添加其他属性,以定义一些属性,例如启动服务所需的权限以及服务应在其中运行的进程。android:name 属性是唯一必需的属性,用于指定服务的类名称。发布应用后,请勿更改此名称,以免因依赖显式 intent 来启动或绑定服务而导致代码损坏(请参阅博文无法更改的内容)。

注意:为确保应用的安全性,请始终使用显式 intent 启动 Service,且不要为服务声明 intent 过滤器。使用隐式 intent 启动服务存在安全隐患,因为您无法确定哪些服务将响应 intent,且用户无法看到哪些服务已启动。从 Android 5.0(API 级别 21)开始,如果使用隐式 intent 调用 bindService(),系统会抛出异常。

您可以通过添加 android:exported 属性并将其设置为 false,确保您的服务仅供您的应用使用。这可以有效阻止其他应用启动您的服务,即使使用显式 intent 也不例外。

注意:用户可以查看其设备上正在运行的服务。如果用户看到不认识或不信任的服务,可以停止该服务。为避免用户意外停止您的服务,您需要将 android:description 属性添加到应用清单中的 <service> 元素。在说明中,提供一个简短的句子,说明服务的功能及其提供的好处。

创建启动的服务

启动的服务是指其他组件通过调用 startService() 启动的服务,这会导致调用服务的 onStartCommand() 方法。

服务启动后,其生命周期独立于启动它的组件。服务可以在后台无限期运行,即使启动服务的组件已被销毁也不受影响。因此,服务应在作业完成时通过调用 stopSelf() 自行停止,或者由另一个组件通过调用 stopService() 将其停止。

应用组件(如 activity)可通过调用 startService() 并传递 Intent(指定服务并包含服务要使用的任何数据)来启动服务。该服务会在 onStartCommand() 方法中收到此 Intent。

例如,假设某个 activity 需要将一些数据保存到在线数据库。该 activity 可以启动配套服务,并通过向 startService() 传递 intent 来向其提供要保存的数据。该服务在 onStartCommand() 中接收 intent,连接到互联网,并执行数据库事务。事务完成后,服务会自行停止并销毁。

注意:默认情况下,服务在声明它的应用所在的进程中运行,并且在应用的主线程中运行。如果您的服务在用户与来自同一应用的 activity 互动时执行密集或阻塞操作,则服务会降低 activity 性能。为避免影响应用性能,请在服务内启动新线程。

Service 类是所有服务的基类。扩展此类时,请务必创建一个新线程,以便服务在其中完成所有工作;默认情况下,服务会使用应用的主线程,这可能会降低应用正在运行的任何 activity 的性能。

Android 框架还提供了 Service 的 IntentService 子类,该子类使用工作器线程逐一处理所有启动请求。不建议在新应用中使用此类,因为从 Android 8 Oreo 开始,由于引入了后台执行限制,此类将无法正常运行。 此外,从 Android 11 开始,该方法已被弃用。 您可以使用 JobIntentService 替代 IntentService,它与较新版本的 Android 兼容。

以下部分介绍了如何实现您自己的自定义服务,但对于大多数用例,您应强烈考虑改用 WorkManager。请参阅 Android 后台处理指南,了解是否有符合您需求的解决方案。

扩展 Service 类

您可以扩展 Service 类来处理每个传入 intent。基本实现可能如下所示:

class HelloService : Service() {

    private var serviceLooper: Looper? = null
    private var serviceHandler: ServiceHandler? = null

    // Handler that receives messages from the thread.
    private inner class ServiceHandler(looper: Looper) : Handler(looper) {

        override fun handleMessage(msg: Message) {
            // Normally we would do some work here, like download a file.
            // For our sample, we just sleep for 5 seconds.
            try {
                Thread.sleep(5000)
            } catch (e: InterruptedException) {
                // Restore interrupt status.
                Thread.currentThread().interrupt()
            }

            // Stop the service using the startId, so that we don't stop
            // the service in the middle of handling another job.
            stopSelf(msg.arg1)
        }
    }

    override fun onCreate() {
        // Start up the thread running the service.  Note that we create a
        // separate thread because the service normally runs in the process's
        // main thread, which we don't want to block.  We also make it
        // background priority so CPU-intensive work will not disrupt our UI.
        HandlerThread("ServiceStartArguments", Process.THREAD_PRIORITY_BACKGROUND).apply {
            start()

            // Get the HandlerThread's Looper and use it for our Handler.
            serviceLooper = looper
            serviceHandler = ServiceHandler(looper)
        }
    }

    override fun onStartCommand(intent: Intent, flags: Int, startId: Int): Int {
        Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show()

        // For each start request, send a message to start a job and deliver the
        // start ID so we know which request we're stopping when we finish the job.
        serviceHandler?.obtainMessage()?.also { msg ->
            msg.arg1 = startId
            serviceHandler?.sendMessage(msg)
        }

        // If we get killed, after returning from here, restart.
        return START_STICKY
    }

    override fun onBind(intent: Intent): IBinder? {
        // We don't provide binding, so return null.
        return null
    }

    override fun onDestroy() {
        Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show()
    }
}

示例代码会处理 onStartCommand() 中的所有来电,并将工作发布到在后台线程上运行的 Handler。它的工作方式与 IntentService 类似,会按顺序逐个处理所有请求。 您可以更改代码,以便在线程池上运行工作,例如,如果您想同时运行多个请求。

请注意,onStartCommand() 方法必须返回一个整数。该整数值用于描述系统在终止服务后应如何继续运行服务。onStartCommand() 的返回值必须是以下常量之一:

START_NOT_STICKY
如果系统在 onStartCommand() 返回后终止服务,则不要重新创建服务,除非有待传递的 intent。这是最安全的选项,可避免在不必要时运行服务,并且您的应用可以简单地重启任何未完成的作业。
START_STICKY
如果系统在 onStartCommand() 返回后终止服务,请重新创建服务并调用 onStartCommand(),但不要重新传递最后一个 intent。 相反,系统会使用 null intent 调用 onStartCommand(),除非有待处理 intent 要启动服务。在这种情况下,系统会传递这些 intent。这适用于不执行命令但无限期运行并等待作业的媒体播放器(或类似服务)。
START_REDELIVER_INTENT
如果系统在 onStartCommand() 返回后终止服务,则会重新创建服务,并使用上次传递给服务的 intent 调用 onStartCommand()。所有待处理 intent 都会依次传递。这适用于正在执行应立即恢复的作业(例如下载文件)的服务。

如需详细了解这些返回值,请参阅每个常量的关联参考文档。

启动服务

您可以通过将 Intent 传递给 startService() 或 startForegroundService(),从 activity 或其他应用组件启动服务。Android 系统会调用服务的 onStartCommand() 方法,并向其传递 Intent,以指定要启动的服务。

注意:如果您的应用以目标 API 级别 26 或更高级别为目标平台,系统会对使用或创建后台服务施加限制,除非应用本身在前台运行。如果应用需要创建前台服务,则应调用 startForegroundService()。该方法会创建后台服务,但会向系统发出信号,表明该服务会将自身提升至前台。服务创建后,必须在 5 秒内调用其 startForeground() 方法。

例如,activity 可以通过使用 startService() 的显式 intent 来启动上一部分中的示例服务 (HelloService),如下所示:

startService(Intent(this, HelloService::class.java))

startService() 方法会立即返回,然后 Android 系统会调用服务的 onStartCommand() 方法。如果服务尚未运行,系统会先调用 onCreate(),然后再调用 onStartCommand()。

如果服务不提供绑定,则使用 startService() 传递的 intent 是应用组件与服务之间唯一的通信模式。不过,如果您希望服务将结果发送回来,则启动服务的客户端可以为广播(使用 getBroadcast())创建一个 PendingIntent,然后将其传递给启动服务的 Intent 中的服务。然后,该服务可以使用广播来传递结果。

多次发出启动服务的请求会导致多次对服务的 onStartCommand() 进行相应调用。不过,只需一个停止服务请求(使用 stopSelf() 或 stopService())即可停止服务。

停止服务

已启动的服务必须管理其自己的生命周期。也就是说,除非系统必须回收系统内存,否则不会停止或销毁服务,并且服务在 onStartCommand() 返回后会继续运行。服务必须通过调用 stopSelf() 自行停止,或者其他组件可通过调用 stopService() 停止服务。

一旦请求使用 stopSelf() 或 stopService() 停止服务,系统就会尽快销毁服务。

如果您的服务同时处理对 onStartCommand() 的多个请求,则不应在处理完启动请求后停止服务,因为您可能已收到新的启动请求(在第一个请求结束时停止会终止第二个请求)。为避免此问题,您可以使用 stopSelf(int) 确保停止服务的请求始终基于最新的启动请求。也就是说,当您调用 stopSelf(int) 时,您需要传递与停止请求对应的启动请求的 ID(即传递给 onStartCommand() 的 startId)。然后,如果服务在您能够调用 stopSelf(int) 之前收到新的启动请求,则 ID 不匹配,服务不会停止。

注意:为避免浪费系统资源和消耗电池电量,请确保应用在完成工作后停止其服务。如有必要,其他组件可以通过调用 stopService() 来停止服务。即使您为服务启用了绑定,也必须在服务收到对 onStartCommand() 的调用时自行停止服务。

如需详细了解服务的生命周期,请参阅下文有关管理服务的生命周期的部分。

创建绑定服务

绑定服务允许应用组件通过调用 bindService() 绑定到该服务,以创建长期连接。 它通常不允许组件通过调用 startService() 来启动它。

如果您想从应用中的 activity 和其他组件与服务进行交互,或者想通过进程间通信 (IPC) 向其他应用公开应用的某些功能,请创建绑定服务。

如需创建绑定服务,请实现 onBind() 回调方法,以返回一个 IBinder,用于定义与服务通信的接口。然后,其他应用组件可以调用 bindService() 来检索接口,并开始调用服务的方法。该服务仅用于为与其绑定的应用组件提供服务,因此当没有组件与该服务绑定时,系统会销毁该服务。您无需像通过 onStartCommand() 启动服务时那样停止绑定服务。

如需创建绑定服务,您必须定义接口,指定客户端如何与服务进行通信。服务与客户端之间的此接口必须是 IBinder 的实现,并且是您的服务必须从 onBind() 回调方法返回的接口。客户端收到 IBinder 后,便可以开始通过该接口与服务进行交互。

多个客户端可以同时绑定到该服务。当客户端与服务交互完毕后,会调用 unbindService() 来解除绑定。 当没有客户端绑定到服务时,系统会销毁该服务。

实现绑定服务的方式有多种,并且其实现比启动服务更复杂。因此,有关绑定服务的讨论会显示在绑定服务的单独文档中。

向用户发送通知

服务运行时,可以使用信息提示控件通知或状态栏通知向用户发送事件通知。

信息条通知是指在当前窗口表面上仅显示片刻便消失的消息。状态栏通知会在状态栏中提供一个图标,并附带一条消息,用户可以选择该图标来执行操作(例如启动 activity)。

通常,当后台工作(例如文件下载)已完成且用户现在可以对其执行操作时,状态栏通知是最佳的使用方法。当用户从展开后的视图中选择该通知时,该通知可以启动一个 activity(例如显示下载的文件)。

管理服务的生命周期

服务的生命周期比 activity 的生命周期简单得多。不过,更重要的是,您要密切关注服务的创建和销毁方式,因为服务可以在用户不知情的情况下在后台运行。

服务的生命周期(从创建到销毁)可以遵循以下两条路径之一:

  • 启动的服务

    当其他组件调用 startService() 时,系统会创建服务。然后,服务会无限期运行,并且必须通过调用 stopSelf() 自行停止。其他组件也可以通过调用 stopService() 来停止服务。当服务停止时,系统会将其销毁。

  • 绑定服务

    当另一个组件(客户端)调用 bindService() 时,系统会创建服务。然后,客户端通过 IBinder 接口与服务通信。客户端可以通过调用 unbindService() 来关闭连接。多个客户端可以绑定到同一服务,当所有客户端都解除绑定时,系统会销毁该服务。该服务不需要自行停止。

这两条路径并非完全独立。您可以绑定到已使用 startService() 启动的服务。例如,您可以通过使用标识要播放的音乐的 Intent 调用 startService() 来启动后台音乐服务。之后,当用户想要对播放器进行一些控制或获取有关当前歌曲的信息时,activity 可以通过调用 bindService() 绑定到服务。在这种情况下,stopService() 或 stopSelf() 实际上不会停止服务,直到所有客户端都解除绑定。

实现生命周期回调

与 activity 类似,服务也具有生命周期回调方法,您可以实现这些方法来监控服务状态的变化,并在适当的时间执行工作。以下框架服务演示了每个生命周期方法:

class ExampleService : Service() {
    private var startMode: Int = 0             // indicates how to behave if the service is killed
    private var binder: IBinder? = null        // interface for clients that bind
    private var allowRebind: Boolean = false   // indicates whether onRebind should be used

    override fun onCreate() {
        // The service is being created
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        // The service is starting, due to a call to startService()
        return startMode
    }

    override fun onBind(intent: Intent): IBinder? {
        // A client is binding to the service with bindService()
        return binder
    }

    override fun onUnbind(intent: Intent): Boolean {
        // All clients have unbound with unbindService()
        return allowRebind
    }

    override fun onRebind(intent: Intent) {
        // A client is binding to the service with bindService(),
        // after onUnbind() has already been called
    }

    override fun onDestroy() {
        // The service is no longer used and is being destroyed
    }
}

注意:与 activity 生命周期回调方法不同,您无需调用这些回调方法的父类实现。

图 2. 服务生命周期。左图显示了使用 startService() 创建服务时的生命周期,右图显示了使用 bindService() 创建服务时的生命周期。

图 2 说明了服务的典型回调方法。虽然该图将由 startService() 创建的服务与由 bindService() 创建的服务分开,但请注意,任何服务(无论其启动方式如何)都可能允许客户端绑定到它。 最初使用 onStartCommand() 启动的服务(由客户端调用 startService())仍可以接收对 onBind() 的调用(当客户端调用 bindService() 时)。

通过实现这些方法,您可以监控服务生命周期的以下两个嵌套循环:

注意:虽然已启动的服务会通过调用 stopSelf() 或 stopService() 来停止,但服务没有相应的回调(没有 onStop() 回调)。除非服务绑定到客户端,否则系统会在服务停止时将其销毁,onDestroy() 是收到的唯一回调。

如需详细了解如何创建提供绑定的服务,请参阅绑定服务文档,其中管理绑定服务的生命周期部分详细介绍了 onRebind() 回调方法。