第三部分：Android 应用程序接口指南---第一节：应用程序组件---第二章1.Services

第2章 Services

Service是一个长期运行在后台，并不提供用户界面的应用程序组件。其他应用程序的组件可以启动一个service，并且即使用户切换到另一个应用程序，service也可以在后台继续运行。此外，一个组件可以绑定到service与它进行交互，甚至执行进程间通信（IPC）。例如，一个service可能会处理来自后台的所有事情，包括网络事务、播放音乐、执行文件I/O或者与content provider交互。

一个service基本上有两种形态：

1. 启动态（Started）:当应用程序组件调用startService()方法来启动一个service时，service就处于“started”状态。一旦启动了service，即使启动service的组件被销毁，它也可以在后台运行下去。通常，一个已启动的service只执行单一的操作，且不会给它的调用者返回结果。例如，它可能通过网络下载或上传文件。当操作完成时，service应该要自行停止。

2. 绑定态（bound）:当应用程序组件通过bindService()方法与service绑定时，service就处于“bound”状态。一个绑定了的service会提供一个客户端-服务器（CS）接口，组件可以通过这个接口与service交互、发送请求、获取结果，甚至是跨进程的通信。只有当另一个应用程序与service绑定时，这个service才会运行。service可以与多个组件同时绑定，但是当它们全部解除时，service会被销毁。

   尽管上面分别介绍了service的两种类型，但你的service是可以在这两种情况下同时工作的，它可以在被启动的同时也能允许绑定。你只需要简单地执行这两种回调方法：允许应用程序组件启动service的onStartCommand()方法和允许绑定的onBinding()方法。无论你的应用程序是启动态、绑定态还是同时是这两种状态，任何应用程序组件都可以使用service（甚至从单独的一个应用程序中），同样的，任何组件也可以通过一个Intent来启动activity进而使用这个activity。另外，你可以在manifest文件中，将service声明为私有，并阻止来自其他应用程序的访问。

注意：service是在宿主进程中的主线程上运行，因为service不会创建自己的线程，也不会在独立的进程上运行（除非你另行指定）。这就意味着，如果你的service要执行任何密集使用CPU的工作或者阻塞操作（如MP3播放音乐或网络工作），你就应该在service中创建一个新的线程来处理这些事情。通过使用一个独立的线程，你将减少应用程序无响应（ANR）错误的风险，并且能让应用程序主线程继续处理用户界面与activity的交互工作。

 

2.1 基础知识

要创建一个service，你就必须创建一个service的子类（或者一个现有的子类）。在实现过程中，你需要重新写入能处理service生命周期关键方面的回调方法，并且在适当条件下，提供一个将组件绑定到service的机制。下面是一些最重要的回调方法，你应该重写它们：

1. onStartCommand():当另一个组件，如activity，调用startService()方法来请求启动service时，系统会调用这个方法。一旦这个方法执行，service就处于已启动状态，并且会在后台继续运行下去。如果你实现这个方法，当工作完成后，你应该使用stopSelf()方法和stopService()方法来停止service（如果你只是想提供绑定，那你就不需要实现这个方法）。

2. onBind()：当另一个组件想要通过调用bindService()方法与service绑定时，系统会调用这个方法。在这个方法的实现中，你必须提供一个接口让客户端与service通信，并返回一个Ibinder对象。你必须总是实现这个方法，但是如果你不想允许绑定，那么你应该返回null。

3. onCreate():当service第一次被创建，用来执行一次性设置的程序时（在调用onStartCommand()或onBind()方法之前），系统会调用这个方法。如果service已经运行了，那么这个方法不会被调用。

4. onDestroy():当service不再使用并且即将要被销毁时，系统会调用这个方法。你的service应该实现这个方法来清除如线程、注册监听器、接收器等的所有资源。这是service接收到的最后一个调用。

讨论：我们到底应该使用一个service还是一个线程？

    一个service是即使用户不再与你的应用程序交互，它仍然可以在后台运行的一个简单组件。因此，你应该只要创建一个你真正需要的service。如果你需要执行在主线程以外的工作，但用户正在与你的应用程序进行交互，那么你应该创建一个新线程，而不是一个新的service。例如，如果你想播放一些音乐，但你的activty正在运行，那么你可以用onCreate()来创建一个线程，onStart()方法开始运行它，然后用onStop()方法来停止它。你也可以考虑使用AsyncTask或HandleThread，而不是传统的Thread类。要记住，如果你确实是要使用一个service，而它在默认情况下，仍然是在你的主线程上运行，那么如果你要执行密集型或阻塞操作，你应该还是要在你的service上创建一个新线程。

 

如果一个组件通过调用startService()（它会导致onStartCommand()方法的调用）方法来启动service，那么service会一直运行，直到它使用stopSelf()方法自行停止了或者另一个组件通过stopService()方法停止了它。如果一个组件调用bindService()方法来创建service（onStartCommand()方法没有调用），那么只有组件与service绑定，它才会运行。一旦services从所有的客户端中解除，系统才会销毁它。只有在内存很低和系统必须恢复系统资源时，Android系统才会强制停止service。如果service被绑定到一个获取到用户焦点的activity，那么service是不太容易被kill掉，并且如果声明了service是在前台运行，那么它几乎是不会被kill掉。否则，如果service已经启动并长时间在运行，那么系统会久而久之降低它在后台任务列表中的位置，并且让它变得很容易被kill掉-如果你的service被启动了，那么你必须设计它怎样优雅的通过系统来处理重新启动的事件。如果系统kill掉了你的service，当他再次被重新启动后，那么资源很快就变得可用了（尽管这取决于从onStartCommand()方法中返回的值）。下面将介绍如何创建各种类型的service，以及如何从其他的应用程序组件中使用它。

 

2.1.1  在manifest中声明service

 

   跟activity（和其他的组件）一样，你必须在manifest文件中声明所有的services。把一个<service>节点作为子节点添加到<application>节点中就可以声明你的service，如代码清单2-1所示：

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

代码清单2-1

   <service>节点还有几个其他的属性，包括定义属性，如请求启动service的权限和service应该运行的进程。指定service类名的啊android:name属性是唯一必需的属性。一旦发布了应用程序，你就不应该更改这个名称，因为如果你改动了，你就可能破坏某些要用到隐式intents来引用service的功能。与activity一样，service也可以定义intent filters，它允许其他组件通过隐式的intents来调用service。如果你声明的intent filter与其他应用程序传递到startService()上的intent相匹配，那么安装到用户设备上的任何应用程序组件都可以启动service。如果你计划使用的是本地service（其他的应用程序不能使用它），那么你不需要（不应该）任何的intent filters。没有intent filter的情况下，你就必须使用一个有明确类名的intent来启动service。此外，只有把android:exported属性包括进去并且把它设置成“false”，你才能确保你的service是对你的应用程序私有。即便你的service有intent filters，你的service仍然是为你的应用程序私有。

2.2 创建一个启动态的service

   一个启动态的service是另一个组件通过调用startService()方法启动的，它会导致services的onStartCommand()方法的调用。当service启动了，它就拥有了一个与启动它的组件相独立的生命周期，并且即使启动它的组件被销毁，service也会继续在后台运行。因此，当工作完成时，service可以调用stopSelf()方法来自行停止或者其他的组件通过stopService()方法来停止service。应用程序组件如activity，可以通过调用startService()方法来启动一个service，并给它传递一个Intent。这个intent指定了你要启动的service，并包含了service要用到的数据。service将会在onStartCommand()方法中接收到这个intent。例如，假设activity想把一些数据保存到一个在线数据库中。那么Activity可以启动一个service并通过一个intent来传递数据并使用startService()方法来保存的数据。这个service在onStartCommand()中接收到这个intent，与网络连接并执行数据库事务处理。当事务完成后，service会自行停止并会被摧毁。

注意：针对Android 1.6或更低版，如果你要创建一个适合Android 1.6或更低版的应用程序，你需要实现onStart()方法，而不是onStartCommand()方法（在Android 2.0中，onStart()被弃用，它支持onStartCommand()方法）。还有默认情况下，service运行在与activity相同的进程中，并且是在这个应用程序的主线程上运行。所以，当用户与应用程序中的activity交互操作并且你的service要执行的密集或阻塞操作是在同一个应用程序时，service将会减弱activity的性能。为了避免影响到应用程序的性能，你应该在service中启动一个新的线程。

 

传统来说，你可以继承下面两个类来创建一个启动态的service。

1. Service:这是所有service的基类。当你继承这个类时，你可以在service中创建一个新的线程来处理service的所有工作，因为默认情况下，service会使用你的应用程序上的主线程，它会减弱应用程序中所有正在运行的activity的性能。

2. IntentService:这是service的子类，它使用一个工作线程来处理所有启动的请求，每次只有一个线程存在。如果你不想service同时处理多个请求，那么这个类是最好的选择。你所需要做的只是实现onHandleIntent()方法，它会为每个启动service的请求来负责接收intent，这样你就可以在后台做这些工作。下面将介绍如何用这些类中的一个来实现你的service。

2.2.1  继承IntentService类

    因为大多数启动的service不需要同时处理多个请求（实际上同时处理多个请求的情况是多线程），所以，实现service的最好办法也许是使用IntentService类。

IntentService类会执行下面这些工作：

1.创建一个默认的工作线程，在onStartCommand()方法中执行所有传递过来的intents，这个线程独立于应用程序的主线程。

2.创建一个工作队列，在你实现的onHandleIntent()方法中，每次只会只会传递一个intent，这样你就不必担心多线程操作了。

3.所有的启动请求都已经处理完了，就会停止service，这样你永远都不需要调用stopSelf()方法。

4.提供一个onBind()方法的默认实现，他返回null。

5.提供onStartCommand()方法的默认实现，这个方法会把intent发送给工作队列，然后在onHandleIntent()方法中处理它们。

所有这些都说明了，你需要做的事只是实现onHandleIntent()方法来处理由客户端提供的工作（尽管你还需要为service提供一个小的构造函数），下面让我们看下代码清单2-2所示的例子：

public class HelloIntentService extends IntentService {
  /** 
   * 需求一个构造函数，因为需要调用父类的构造函数方法，传入一个字符串 用来表示工作线程的名字
   */
  public HelloIntentService() {
      super("HelloIntentService");
  }
 
  /**
   * IntentService从默认的工作线程中调用这个方法并且传入了一个启动service的intent供我们使用。
   * 当这个方法返回时IntentService停止了service。
   */
  @Override
  protected void onHandleIntent(Intent intent) {
      // 通常我们在这做一些工作，例如下载一个文件。本例中我们只让它休眠5秒 
      long endTime = System.currentTimeMillis() + 5*1000;
      while (System.currentTimeMillis() < endTime) {
          synchronized (this) {
              try {
                  wait(endTime - System.currentTimeMillis());
              } catch (Exception e) {
              }
          }
      }
  }
}

 

代码清单2-2

上面就是你所需要做的：一个构造函数和onHandleIntent()方法的实现。如果你决定覆盖其他的回调方法，如onCreate、onStartCommand()或者onDestroy(),那么就一定要确保调用父类方法的实现，这样IntentService()方法才能处理好工作线程的生命周期。

例如，onStartCommand()方法必须返回默认父类的实现（这是intent传递到onHandleIntent()方法的途径），如代码清单2-3所示：

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show();
    return super.onStartCommand(intent,flags,startId);
}

 

代码清单2-3

   除了onHandleIntent()方法之外，仅有一个onBind()方法你不需要调用父类的实现（但是，如果你的service允许绑定，你就只需要实现它）。下面将介绍，当继承service基类时是如何的实现相同的service，这个类的代码稍微多一点，但是如果你想处理同时发起的多个请求的话，这个类也许是适合的。

2.2.2  继承service类

正如前面所说的，用IntentService类来实现启动的service是非常简单的。然而，如果你想你的service能执行多线程操作（而不是通过工作队列来处理启动请求），那么你可以继承Service类来处理这些intents。经过比较，下面这个service类的实现代码，与上面那个使用IntentService类的示例所做的工作相同。也就是说，对于每一个发起的请求，它都能用一个工作线程来执行工作，并且每次只处理一个请求，如代码清单2-4所示：

public class HelloService extends Service {
  private Looper mServiceLooper;
  private ServiceHandler mServiceHandler;
 
  // 从线程中处理接收到的消息
  private final class ServiceHandler extends Handler {
      public ServiceHandler(Looper looper) {
          super(looper);
      }
      @Override
      public void handleMessage(Message msg) {
          //和上面一样休眠5秒
          long endTime = System.currentTimeMillis() + 5*1000;
          while (System.currentTimeMillis() < endTime) {
              synchronized (this) {
                  try {
                      wait(endTime - System.currentTimeMillis());
                  } catch (Exception e) {
                  }
              }
          }
          // 工作结束后使用startID停止service
          stopSelf(msg.arg1);
      }
  }
 
  @Override
  public void onCreate() {
    // 启动线程执行service.注意我们创建一个单独的线程是因为正常情况下service在主线程执行操作，可能会导致阻塞。   
    HandlerThread thread = new HandlerThread("ServiceStartArguments",
            Process.THREAD_PRIORITY_BACKGROUND);
    thread.start();
    
    //获得HandlerThread的 Looper并用在我们的Handler中 
    mServiceLooper = thread.getLooper();
    mServiceHandler = new ServiceHandler(mServiceLooper);
  }
 
  @Override
  public int onStartCommand(Intent intent, int flags, int startId) {
      Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show();
 
      // 为每一个启动请求发送一个消息来执行一个工作并传递startID，因为我们需要知道当完成工作时应该停止请求
      Message msg = mServiceHandler.obtainMessage();
      msg.arg1 = startId;
      mServiceHandler.sendMessage(msg);
      
      return START_STICKY;
  }
 
  @Override
  public IBinder onBind(Intent intent) {
      // 不需要绑定 返回null即可
      return null;
  }
  
  @Override
  public void onDestroy() {
    Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show(); 
  }

 

代码清单2-4

   正如你看到的，这个类比使用IntentService类多了很多工作。然而，因为你能自行处理onStartCommand()方法的每次调用，所以你可以同时执行多个请求。这个例子没有这样做，但是如果你想这样做，那么你可以为每个请求创建一个新线程并立刻运行它（而不是等到上一个请求完成后才执行）。要注意的是，onStartCommand()方法必须返回一个整数。这个整数是一个值，它描述了当系统kill掉service时，系统应该如何继续这个service（onStartCommand()的默认实现会为你处理好，但你也可以修改它）。从onStartCommand()中返回的值必须是下面常量中的一个：

1. START_NOT_STICKY:如果系统在onStartCommand()方法返回后kill掉service，那么不要重新创建service，除非有一个特定的intents要传递。这是一种最安全的选择，它避免执行不必要的service，并且你的应用程序能简单的重新开始未完成的工作。

2. START_STICKY:如果系统在onStartCommand()返回后，kill掉service，那么就要重新启动service并调用onStartCommand()方法，但不用传递最后的intent。相反，系统调用onStartCommand()方法，传递一个值为null的intent，除非有一个用来启动service的特定intents，在这种情况下，这些intents就会被传递。这很适用于多媒体播放器（或类似的service），它们不需要执行命令，但是它还是会继续运行并且等待执行工作。

3. START_REDELIVER_INTENT:如果系统在onStartCommand()方法返回后,kill掉services，那么就要重新启动service并且调用onStartCommand()方法，并将最后的一个intent传递给onStartCommand()方法。反过来，任何特定的intents都会被传递。这适用于service去执行那些要立即恢复的工作，如下载文件。

2.2.3  启动一个service

你可以通过给startService()传递一个Intent（指定要启动的service）来启动一个service，在activity和其他的应用程序组件中都能这样启动。Android系统调用service的onStartCommand()方法，并且把这个Intent传递给它（你应该永远都不要直接调用onStartCommand()方法）。例如，activity可以传递一个显式的intent给startService()方法来启动service，如代码清单2-5所示：

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

 

代码清单2-5

   startService()会立即返回，然后Android系统会调用service的onStartCommand()方法。如果service没有正在运行，那么系统会首先调用onCreate()方法，然后才调用onStartCommand()方法。如果service也没有提供绑定，那么使用startService()方法是应用程序组件与service通信的唯一模式。如果你希望service返回一个结果，那么启动service的客户端可以为广播（用getBroadcast()方法）创建一个PendingIntent，并且在启动service的Intent中，把这个intent传递给service。然后service就可以用这个广播来传递一个结果。多个启动service的请求，会相应的导致多个service的onStartCommand()方法的调用。

2.2.4停止一个service

   一个启动的service必须管理好自己的生命周期。也就是说，除非系统必须恢复它的内存，否则系统是不会停止或销毁service的，并且在onStartCommand()方法返回后service仍可以继续运行。所以，service必须通过调用stopSelf()方法才能自行停止，或者另一个组件调用stopService()方法来停止service。一旦用stopSelf()或stopService()方法来请求停止service，那么系统会尽快的销毁service。然而，如果你的service正在同时处理多个onServiceCommand()的请求，那么你就不应该在处理完一个启动请求后就停止你的service，因为你有可能已经接收到了一个新的启动请求（第一个请求结束时停止service，这将会终结第二个请求）。为了避免这个问题，你可以用stopSelf(int)方法来确保停止service的请求总是基于最后的启动请求。这也就是说，当你调用stopSelf(int)方法时，你会传递一个启动请求的ID（会传递到onStartCommand()方法中）来停止相应的请求。然后，如果service在调用stopSelf(int)方法之前接收到一个新的启动请求，那么这个ID就不会匹配，service也就不会停止了。

注意：当service工作完成后，应用程序停止service是很重要的，因为要避免浪费系统的资源和消耗的电池。如果有必要的话，其他的组件也可以通过调用stopService()方法来停止service。如果你激活绑定了service，你也必须在onServiceCommand()方法的回调中不断的停止service。

2.3 创建一个绑定的service

绑定service是指：允许应用程序通过调用bindService()方法来绑定到它的一个service，这是为了建立一个长期的连接（一般不允许组件通过startService()来启动它）。当你想services与activity和其他组件交互时，或者想通过进程间通信(IPC)向其他的应用程序展示你的应用程序功能时，你就可以创建一个绑定的service。要创建一个绑定的service，你就选必须实现onBind()回调方法，使它返回一个IBinder，这个IBinder能定义与service进行通信的接口。然后其他应用程序组件就调用bindService()来检索这个接口，并开始调用service中的方法。只有当服务于它绑定的应用程序组件时，service才会存在，所以当没有组件绑定service时，系统就会销毁它（你不需要停止一个绑定的service，但是当service是通过调用onStartCommand()方法来启动时，你才必须停止它）。要创建一个绑定的service，首先要做的第一件事是定义一个客户端如何与service通信的接口。service和客户端之间的接口必须是一个IBinder的实现，并且必须是从onBind()回调方法中返回的。一旦客户端接收到IBinder，它就能通过接口与service进行交互了。多个客户端可以同时绑定到一个service。当某个客户端完成了与service的交互工作时，它就会调用unbindService()方法来解除绑定。一旦没有客户端与service绑定了，系统就会销毁service。

2.4 向用户发送通知

   当运行service时，它可以用Toast Notifications或Status Bar Notifications向用户发送事件通知。一个toast通知是出现在当前窗口上面的一个信息，它显示一会就会消失，然而一个状态栏通知是提供一个带有信息的图标，它显示在状态栏里，这样用户要执行动作的话就可以选择它（如启动一个activty）。通常来说，当一些后台工作已经完成（例如，一个文件已经完成下载），一个状态栏通知是最好的技术，因为用户可以立刻执行那些后台操作。当用户从view中选择通知时，这个通知就可以启动一个activty（如查看下载好的文件）

2.5 在前台运行service

一个前台service是考虑做一些让用户特别关心的事情，并且它不是系统在低内存时要kill掉的候选。一个前台service必须为状态栏提供通知，并且放在持续性的标题栏的下方。这也就意味着通知是不会消失的，除非service它被停止了或把它从前台移除。例如，一个从service播放音乐的播放器应该设置成在前台运行，因为用户很关心它的操作。在状态栏中的通知可能会指示出当前播放的歌曲，并且允许用户启动一个activity来与音乐播放器进行交互。要使你的service能在前台运行，就调用startForeground()方法。这个方法有两个参数：一个int ID和一个用于状态栏Notification，如代码清单2-6所示：

Notification notification = new Notification(R.drawable.icon, getText(R.string.ticker_text),
        System.currentTimeMillis());
Intent notificationIntent = new Intent(this, ExampleActivity.class);
PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent, 0);
notification.setLatestEventInfo(this, getText(R.string.notification_title),
        getText(R.string.notification_message), pendingIntent);
startForeground(ONGOING_NOTIFICATION, notification);

 

代码清单2-6

要把前台的service移除的话，就调用stopForeground()方法。这个方法带有一个boolean值，它表示是否能同时移除状态栏通知。这个方法不能停止service。但是，如果你停止service，而它仍然在前台运行，那么这个通知也会被移除。

注意：Android 2.0引用了startForeground()和stopForeground()方法（API级别5）。为了让你的service能在旧版本的平台运行，你必须使用先前的setForeground()方法。

2.6 管理Service的生命周期

Service的生命周期比activity的生命周期要简单的多。但是，由于service可以在后台运行，并且用户察觉不到，所以更进一步的了解service是如何被创建和销毁的就显得更加重要。

从它被创建到被销毁，service的生命周期可以遵从下面两条路径：

1.一个启动态的service：当另一个组件调用startService()方法时，service就会被创建。然后service会无限期的运行，要调用stopSelf()方法才能停止它。另一个组件也可以调用stopService()来停止service。当service停止，系统就会销毁它。

2.一个绑定态的service:当另一个组件（一个客户端）调用bindService()方法，service就会被创建。这个客户端通过一个IBinder接口就可以与service通信。它也可以调用unbindService()方法来关闭这种连接。多个客户端可以与同一个service绑定，并且当所有的绑定都解除时，系统会销毁service（service并不需要自行停止）。这两条路径并不是完全分开的。也就是说，你可以绑定一个已经用startService()方法启动的service。例如，通过调用一个带有Intent的startService()方法，可以启动一个后台播放音乐的service，这个Intent会指定要播放的音乐。之后，用户可能想要对播放器进行控制或者获取当前歌曲的信息，那么activity就可以通过调用bindService()方法来绑定到这个service。在这种情况下，stopService()或stopSelf()方法会直到所有的客户端都解除，才能真正的停止service。

2.6.1实现生命周期回调方法

    和activity一样，service有自己的生命周期回调方法，你可以实现这些方法来监测service的状态变化，并且还可以在适当的时候处理一些工作。以下是一个service的框架，展示了它的每个基本生命周期方法，如代码清单2-7所示：

public class ExampleService extends Service {
    int mStartMode;       // service被killed掉后的启动模式
    IBinder mBinder;      // 用于客户端的绑定接口
    boolean mAllowRebind; // 是否需要重新绑定
 
    @Override
    public void onCreate() {
        // service 被创建
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // service运行中，处理startService()方法的回调
        return mStartMode;
    }
    @Override
    public IBinder onBind(Intent intent) {
        // 一个客户端使用bindService()方法绑定service后的回调
        return mBinder;
    }
    @Override
    public boolean onUnbind(Intent intent) {
        // 所有客户端使用unbindService() 解除绑定时的回调
        return mAllowRebind;
    }
    @Override
    public void onRebind(Intent intent) {
        // 一个客户端在onUnbind()调用后，在调用bindService()的回调 
    }
    @Override
    public void onDestroy() {
        // service不在被使用时
    }
}

 

代码清单2-7

注意：与activity生命周期回调方法不同的是，你不需要调用service方法的父类实现。

下面我们看下启动态和绑定态两种情况下的生命周期流程图，图2-1：

 

 

图2-1 service的生命周期（左边演示的是用startService()方法来创建一个service时的生命周期，右边则是用bindService()方法创建一个service时的生命周期。）

 

通过实现这些方法，你可以监测service生命周期中的两个嵌套循环：

1. 整体生命期：一个service的整循环是在调用onCreate()方法和onDestroy()方法之间出现的。和activity一样，service在onCreate()方法中进行它的初始化设置，并用onDestroy()方法来释放所有剩余资源。例如，一个音乐回放service可以用onCreate()方法创建一个播放音乐的线程，然后用onDestroy()方法来停止这个线程。无论这两个方法是不是由startService()和bindService()方法创建，所有的services都会调用onCreate()和onDestroy()方法。

2. 激活生命期：一个service的激活生命期开始于onStartCommand()和onBind()方法的调用。每个方法都会分别处理传给startService()方法或bindService()方法的Intent。如果service已经启动，那么service的激活生命期会在整体生命期结束时也跟着结束（即使onStartCommand()方法返回了，service仍然是激活的）。如果service是绑定的，那么激活生命期会在onUnbind()方法返回时结束。

注意：尽管一个启动态的service可以通过stopSelf()方法或stopService()方法来停止，但service没有与此相应的回调方法（没有onStop()回调方法）。所以，除非service与一个客户端绑定，否则系统会在service停止时销毁它，而onDestroy()方法是service能接收到的使它停止的唯一回调方法。

 

图2-1展示了service的一个典型回调方法。尽管该图把由startService()方法创建的service和由bindService()方法创建的service分开了，但要记住，不管service是如何启动的，它都能允许客户端绑定到它。所以，最初用onStartCommand()方法（客户端调用startService()方法）启动的service也仍然可以接收到onBind()方法的调用（当一个客户端调用bindService()方法时）。具体更详细的例子以后我们会在SDK下samples中讲解

 本文来自jy02432443，QQ78117253。是本人辛辛苦苦一个个字码出来的，转载请保留出处，并保留追究法律责任的权利

posted @ 2013-11-19 21:09  jy02432443  阅读(902)  评论(0)  编辑  收藏  举报