为什么要使用IntentService？
谈谈Service
Service不是独立的进程，也不是独立的线程，它是依赖于应用程序的主线程的，在更多时候不建议在Service中执行耗时的逻辑和操作，否则会引起ANR。
谈谈IntentService
IntentService继承自Serivce，在IntentService内有一个工作线程可以处理耗时任务。通过StartService可以启动IntentService，且当任务执行完后，IntentService会自动停止，无需手动控制。
多次启动IntentService，每个耗时的操作会以工作队列方式在onHandleIntent回调方法中执行，且每次只会执行一个工作线程，依次执行。
那么，在开发过程中，遇到耗时的任务，我们考虑用Service去处理，Service可置于后台运行，但是在Service里不能直接进行耗时的操作，一般我们通过开启子线程去做一些事情，但是需要自己管理Service的生命周期和子线程。Android提供了一个类IntentService刚好可以解决这个问题。
如何使用IntentService？
模拟两个启动IntentService的任务，来查看IntentService的生命周期和使用过程。
1 . 创建TestIntentService类，并继承自IntentService类，重写onHandleIntent()方法，该方法负责处理异步任务，在子线程中执行。
/**
* Created by Kathy on 17-2-22.
*/
public class TestIntentService extends IntentService{
public TestIntentService() {
// Used to name the worker thread, important only for debugging
super("TestIntentService");
}
@Override
public void onCreate() {
Log.d("Kathy", "onCreate");
super.onCreate();
}
@Override
public void onStart(Intent intent, int startId) {
Log.d("Kathy", "onStart");
super.onStart(intent, startId);
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Log.d("Kathy", "onStartCommand");
return super.onStartCommand(intent, flags, startId);
}
@Override
protected void onHandleIntent(Intent intent) {
String action = intent.getAction();
if (null != action) {
if (action.equals("TaskOne")) {
Log.d("Kathy", "TaskOne is Executed!");
}else if (action.equals("TaskTwo")) {
Log.d("Kathy", "TaskTwo is Executed!");
}
}
}
@Override
public void onDestroy() {
Log.d("Kathy", "onDestroy");
super.onDestroy();
}
}
2 . 在AndroidManifest中注册TestIntentService，并建立一个Activity来启动service，核心代码如下：
Intent intentOne = new Intent(this, TestIntentService.class);
intentOne.setAction("TaskOne");
startService(intentOne);
Intent intentTwo = new Intent(this, TestIntentService.class);
intentTwo.setAction("TaskTwo");
startService(intentTwo);
3 . 启动Activity并执行，得到以下Log：
02-22 14:27:24.263 32515-32515/com.demo.kathy.demo D/Kathy: onCreate
02-22 14:27:24.265 32515-32515/com.demo.kathy.demo D/Kathy: onStartCommand
02-22 14:27:24.265 32515-32515/com.demo.kathy.demo D/Kathy: onStart
02-22 14:27:24.265 32515-6855/com.demo.kathy.demo D/Kathy: TaskOne is Executed!
02-22 14:27:24.265 32515-32515/com.demo.kathy.demo D/Kathy: onStartCommand
02-22 14:27:24.265 32515-32515/com.demo.kathy.demo D/Kathy: onStart
02-22 14:27:24.266 32515-6855/com.demo.kathy.demo D/Kathy: TaskTwo is Executed!
02-22 14:27:24.296 32515-32515/com.demo.kathy.demo D/Kathy: onDestroy
从以上结果可以看出：
- onCreate()方法只执行了一次；
- onStartCommand()和onStart()方法被执行了两次；
- 先开启的TaskOne先执行，后开启的TaskTwo后执行；
- 线程执行完后，onDestory()自动调用了。
我们需要从源码角度解析一下IntentService的生命周期及执行方式！IntentService的源码并不多，建议大家自己阅读SDK！
源码角度解析IntentService
首先来看IntentService的构造函数，在初始化构造函数时，需要传递一个String类型的数据，用于命名工作线程。并将线程名保存在mName变量中。
/**
* Creates an IntentService. Invoked by your subclass's constructor.
*
* @param name Used to name the worker thread, important only for debugging.
*/
public IntentService(String name) {
super();
mName = name;
}
接下来看看onCreate()方法都做了什么？
@Override
public void onCreate() {
// TODO: It would be nice to have an option to hold a partial wakelock
// during processing, and to have a static startService(Context, Intent)
// method that would launch the service & hand off a wakelock.
super.onCreate();
HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
thread.start();
mServiceLooper = thread.getLooper();
mServiceHandler = new ServiceHandler(mServiceLooper);
}
onCreate()方法都做了几件事呢？
- 创建了一个 HandlerThread，并将构造方法中传入的参数mName赋值给线程名，并启动了这个Thread。
- 给mServiceLooper赋值，该对象是由上边创建的HandlerThread的Looper对象赋值的，有了Looper对象并开启循环后，Looper取的消息会在HandlerThread这个工作线程中执行。
- 实例化mServiceHandler，传入了mServiceLooper的looper对象，也就是说，由mServiceLooper负责取出mServiceHandler发送的消息，并在HandlerThread中执行。
接下来，onStartCommand()方法和onStart()方法都执行了什么？
/**
* You should not override this method for your IntentService. Instead,
* override {@link #onHandleIntent}, which the system calls when the IntentService
* receives a start request.
* @see android.app.Service#onStartCommand
*/
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
onStart(intent, startId);
return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
}
@Override
public void onStart(Intent intent, int startId) {
Message msg = mServiceHandler.obtainMessage();
msg.arg1 = startId;
msg.obj = intent;
mServiceHandler.sendMessage(msg);
}
- onStartCommand()会调用onStart()方法，并传入两个参数intent和startId。
- onStart()方法中，通过mServiceHandler发送了一条异步消息，并携带startId和intent，那么必须注意的是，这个消息被发送到哪儿？并在哪儿接收执行呢？
下面我们来看ServiceHandler的回调方法：
private final class ServiceHandler extends Handler {
public ServiceHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
onHandleIntent((Intent)msg.obj);
stopSelf(msg.arg1);
}
}
- ServiceHandler执行在子线程还是UI线程，取决于Looper，ServiceHandler的Looper对象是mServiceLooper，mServiceLooper获得的是HandlerThread的Looper对象，所以ServiceHandler的回调方法执行在子线程中。
- handleMessage()回调中，直接调用了onHandleIntent()方法，并传入了intent对象，并且，在onHandleIntent()执行完之后，调用了stopSelf()，也就是停止了Service，无需手动停止。
下面来看必须实现的onHandleIntent()方法：
/**
* This method is invoked on the worker thread with a request to process.
* Only one Intent is processed at a time, but the processing happens on a
* worker thread that runs independently from other application logic.
* So, if this code takes a long time, it will hold up other requests to
* the same IntentService, but it will not hold up anything else.
* When all requests have been handled, the IntentService stops itself,
* so you should not call {@link #stopSelf}.
*
* @param intent The value passed to {@link
* android.content.Context#startService(Intent)}.
*/
@WorkerThread
protected abstract void onHandleIntent(Intent intent);
这个方法就是我们要在创建intentserivice类的时候必须实现的抽象方法了，它负责处理一切需要执行的任务！
OK，IntentService解析就到这里了。