第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中讲解
转载于:https://www.cnblogs.com/Codenewbie/articles/2973126.html