服务概述

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

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

服务类型

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

前台服务

前台服务执行对用户可见的一些操作。例如，音频应用将使用前台服务来播放音频轨道。前台服务必须显示 通知。即使用户没有与应用交互，前台服务也会继续运行。

当您使用前台服务时，必须显示通知，以便用户主动意识到服务正在运行。除非服务已停止或从前台移除，否则此通知无法被解除。

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

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

后台服务
后台服务执行用户不会直接注意到的操作。例如，如果应用使用服务来压缩其存储，这通常是后台服务。

注意：如果您的应用的目标 API 级别为 26 或更高，则系统会在应用本身不在前台时 对运行后台服务进行限制。在大多数情况下，例如，您不应该 从后台访问位置信息。相反，使用 WorkManager 调度任务。

绑定服务
当应用组件通过调用 bindService() 绑定到服务时，该服务就被绑定了。绑定服务提供客户端-服务器接口，允许组件与服务交互，发送请求，接收结果，甚至通过进程间通信 (IPC) 在进程之间执行此操作。绑定服务仅在另一个应用组件绑定到它时才运行。多个组件可以同时绑定到服务，但当所有组件都解除绑定时，服务就会被销毁。

尽管此文档通常分别讨论启动服务和绑定服务，但您的服务可以同时以这两种方式工作——它可以启动（无限期运行）并允许绑定。这仅仅是您是否实现了一些回调方法的问题：onStartCommand() 以允许组件启动它，以及 onBind() 以允许绑定。

无论您的服务是启动、绑定还是同时启动和绑定，任何应用程序组件都可以像使用活动一样使用该服务（即使来自单独的应用程序）——通过使用Intent启动它。但是，您可以在清单文件中将服务声明为私有，并阻止其他应用程序访问它。这将在关于在清单中声明服务的部分中详细讨论。

选择服务还是线程

服务只是一个可以在后台运行的组件，即使用户没有与您的应用程序交互，因此您应该只在需要时才创建服务。

如果您必须在主线程之外执行工作，但仅在用户与您的应用程序交互时执行，则应在另一个应用程序组件的上下文中创建一个新线程。例如，如果您想播放一些音乐，但仅在您的活动正在运行时播放，您可以在onCreate()中创建一个线程，在onStart()中开始运行它，并在onStop()中停止它。还可以考虑使用java.util.concurrent包中的线程池和执行器或Kotlin协程，而不是传统的Thread类。有关将执行移至后台线程的更多信息，请参阅Android上的线程文档。

请记住，如果您确实使用了服务，它默认情况下仍然在您的应用程序的主线程中运行，因此如果它执行密集型或阻塞操作，您仍然应该在服务中创建一个新线程。

基础知识

要创建服务，您必须创建Service的子类或使用其现有的子类之一。在您的实现中，您必须覆盖一些处理服务生命周期关键方面的回调方法，并提供允许组件绑定到服务的机制（如果适用）。以下是要覆盖的最重要的回调方法

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

如果组件通过调用startService()（导致调用onStartCommand()）启动服务，则服务将继续运行，直到它使用stopSelf()自行停止或另一个组件通过调用stopService()停止它。

如果组件调用bindService()来创建服务，并且未调用onStartCommand()，则服务仅在组件绑定到它的时间内运行。在服务从所有客户端取消绑定后，系统会销毁它。

只有当内存不足并且必须为具有用户焦点的活动恢复系统资源时，Android系统才会停止服务。如果服务绑定到具有用户焦点的活动，则不太可能被杀死；如果服务被声明为在前台运行，则很少被杀死。如果服务已启动并且是长时间运行的服务，则系统会随着时间的推移降低其在后台任务列表中的位置，并且服务变得非常容易被杀死——如果您的服务已启动，则必须将其设计为能够优雅地处理系统的重新启动。如果系统杀死了您的服务，它会在资源可用后立即重新启动它，但这还取决于您从onStartCommand()返回的值。有关系统何时可能销毁服务的更多信息，请参阅进程和线程文档。

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

在清单中声明服务

您必须在应用程序的清单文件中声明所有服务，就像对活动和其他组件一样。

要声明您的服务，请添加<service>元素作为<application>元素的子元素。这是一个示例

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

有关在清单中声明服务的更多信息，请参阅<service>元素参考。

您可以在<service>元素中包含其他属性来定义属性，例如启动服务所需的权限以及服务应运行的进程。android:name属性是唯一必需的属性——它指定服务的类名。发布应用程序后，请保持此名称不变，以避免由于依赖于显式意图来启动或绑定服务而导致代码中断的风险（阅读博文无法更改的事物）。

注意：为了确保您的应用程序安全，在启动Service时始终使用显式意图，并且不要为您的服务声明意图过滤器。使用隐式意图启动服务存在安全隐患，因为您无法确定响应意图的服务，并且用户也无法看到哪个服务启动。从 Android 5.0（API 级别 21）开始，如果您使用隐式意图调用bindService()，则系统会抛出异常。

您可以通过包含android:exported属性并将其设置为false来确保您的服务仅对您的应用可用。这有效地阻止了其他应用启动您的服务，即使使用显式意图也是如此。

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

创建已启动的服务

已启动的服务是指另一个组件通过调用startService()启动的服务，这会导致调用服务的onStartCommand()方法。

当服务启动时，它具有独立于启动它的组件的生命周期。即使启动它的组件被销毁，服务也可以无限期地在后台运行。因此，服务应在完成工作后自行停止，方法是调用stopSelf()，或者另一个组件可以通过调用stopService()停止它。

应用程序组件（例如活动）可以通过调用startService()并传递一个Intent来启动服务，该意图指定服务并包含服务要使用的任何数据。服务在onStartCommand()方法中接收此Intent。

例如，假设一个活动需要将一些数据保存到在线数据库。该活动可以启动一个配套服务并将其传递给要保存的数据，方法是将意图传递给startService()。服务在onStartCommand()中接收意图，连接到 Internet 并执行数据库事务。事务完成后，服务会自行停止并被销毁。

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

Service类是所有服务的基类。当您扩展此类时，重要的是创建一个新线程，以便服务可以在其中完成所有工作；服务默认使用您的应用程序的主线程，这可能会降低您的应用程序正在运行的任何活动的性能。

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

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

扩展 Service 类

您可以扩展 Service 类来处理每个传入的 Intent。以下是基本实现的示例：

Kotlin

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()
    }
}

Java

public class HelloService extends Service {
  private Looper serviceLooper;
  private ServiceHandler serviceHandler;

  // Handler that receives messages from the thread
  private final class ServiceHandler extends Handler {
      public ServiceHandler(Looper looper) {
          super(looper);
      }
      @Override
      public void handleMessage(Message msg) {
          // 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 (InterruptedException e) {
              // 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
  public void 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 doesn't disrupt our UI.
    HandlerThread thread = new HandlerThread("ServiceStartArguments",
            Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();

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

  @Override
  public int onStartCommand(Intent intent, int flags, int startId) {
      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
      Message msg = serviceHandler.obtainMessage();
      msg.arg1 = startId;
      serviceHandler.sendMessage(msg);

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

  @Override
  public IBinder onBind(Intent intent) {
      // We don't provide binding, so return null
      return null;
  }

  @Override
  public void onDestroy() {
    Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show();
  }
}

示例代码在 onStartCommand() 中处理所有传入的调用，并将工作发布到后台线程上运行的 Handler。它的工作方式与 IntentService 类似，并按顺序处理所有请求，一次一个。例如，如果您希望同时运行多个请求，可以更改代码以在线程池上运行工作。

请注意，onStartCommand() 方法必须返回一个整数。该整数是一个值，描述了系统在系统终止服务的情况下应如何继续服务。 onStartCommand() 的返回值必须是以下常量之一：

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

有关这些返回值的更多详细信息，请参阅每个常量的链接参考文档。

启动服务

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

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

例如，活动可以使用显式 Intent 和 startService() 启动上一节中的示例服务（HelloService），如下所示：

Kotlin

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

Java

startService(new Intent(this, HelloService.class));

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

如果服务不提供绑定，则使用 startService() 传递的 Intent 是应用程序组件和服务之间唯一通信模式。但是，如果希望服务发送结果，则启动服务的客户端可以为广播创建 PendingIntent（使用 getBroadcast()）并将其传递给启动服务的 Intent 中的服务。然后，服务可以使用广播传递结果。

多个启动服务的请求会导致对服务的 onStartCommand() 进行多个相应的调用。但是，只需要一个停止服务的请求（使用 stopSelf() 或 stopService()）即可停止它。

停止服务

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

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

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

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

有关服务生命周期的更多信息，请参阅下面关于 管理服务生命周期 的部分。

创建绑定服务

绑定服务是一种允许应用程序组件通过调用 bindService() 来绑定到它的服务，以创建长期连接。它通常不允许组件通过调用 startService() 来启动它。

当您希望从活动和应用程序中的其他组件与服务交互或通过进程间通信 (IPC) 向其他应用程序公开应用程序的一些功能时，请创建绑定服务。

要创建绑定服务，请实现 onBind() 回调方法以返回 IBinder，该回调方法定义了与服务通信的接口。然后，其他应用程序组件可以调用 bindService() 来检索接口并开始在服务上调用方法。服务仅用于为绑定到它的应用程序组件提供服务，因此，当没有组件绑定到服务时，系统会销毁它。您不需要以与通过 onStartCommand() 启动服务时相同的方式停止绑定服务。

要创建绑定服务，必须定义一个接口，指定客户端如何与服务通信。服务和客户端之间的此接口必须是IBinder的实现，并且是服务必须从onBind()回调方法中返回的内容。客户端收到IBinder后，就可以通过该接口开始与服务交互。

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

实现绑定服务有多种方法，并且实现比启动服务更复杂。由于这些原因，绑定服务的讨论出现在有关绑定服务的单独文档中。

向用户发送通知

当服务正在运行时，它可以使用Snackbar 通知或状态栏通知通知用户事件。

Snackbar 通知是在当前窗口表面上显示的消息，在消失前只会停留片刻。状态栏通知在状态栏中提供一个带有消息的图标，用户可以选择该图标以执行操作（例如启动活动）。

通常，当后台工作（例如文件下载）完成并且用户现在可以对其进行操作时，状态栏通知是最佳使用技巧。当用户从展开视图中选择通知时，通知可以启动活动（例如显示下载的文件）。

管理服务的生命周期

服务的生命周期比活动的简单得多。但是，更重要的是要注意服务的创建和销毁方式，因为服务可以在后台运行，而用户却不知道。

服务生命周期（从创建到销毁）可以遵循以下两种路径之一

  • 启动的服务

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

  • 绑定服务

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

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

实现生命周期回调

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

Kotlin

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
    }
}

Java

public class ExampleService extends Service {
    int startMode;       // indicates how to behave if the service is killed
    IBinder binder;      // interface for clients that bind
    boolean allowRebind; // indicates whether onRebind should be used

    @Override
    public void onCreate() {
        // The service is being created
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // The service is starting, due to a call to startService()
        return startMode;
    }
    @Override
    public IBinder onBind(Intent intent) {
        // A client is binding to the service with bindService()
        return binder;
    }
    @Override
    public boolean onUnbind(Intent intent) {
        // All clients have unbound with unbindService()
        return allowRebind;
    }
    @Override
    public void onRebind(Intent intent) {
        // A client is binding to the service with bindService(),
        // after onUnbind() has already been called
    }
    @Override
    public void onDestroy() {
        // The service is no longer used and is being destroyed
    }
}

注意：与活动生命周期回调方法不同，**不需要**调用这些回调方法的超类实现。

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

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

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

注意：尽管启动的服务可以通过调用stopSelf()或stopService()来停止，但服务没有相应的回调（没有onStop()回调）。除非服务绑定到客户端，否则系统在服务停止时会将其销毁——onDestroy()是收到的唯一回调。

有关创建提供绑定的服务的更多信息，请参阅绑定服务文档，其中包含有关管理绑定服务生命周期部分中的onRebind()回调方法的更多信息。