一 IntentService概述

• 本质是一个Service，继承自Service且是个抽象类
• 它用来在后台执行耗时的异步任务，当任务执行完毕后自动停止
• 它内部通过HandlerThread和Handler来实现异步操作
• 用户通过实现onHandleIntent方法，并在此方法中处理耗时任务

二 IntentService使用

• 直接上代码

public class MyIntentService extends IntentService {
    private static final String ACTION_FOO = "com.jrmf360.service.action.FOO";
    private static final String ACTION_BAZ = "com.jrmf360.service.action.BAZ";

    private static final String EXTRA_PARAM = "com.jrmf360.service.extra.PARAM";

    public MyIntentService() {
        super("MyIntentService");
    }

    /**
     * Starts this service to perform action Foo with the given parameters. If
     * the service is already performing a task this action will be queued.
     *
     * @see IntentService
     */
    public static void startActionFoo(Context context, String param) {
        Intent intent = new Intent(context, MyIntentService.class);
        intent.setAction(ACTION_FOO);
        intent.putExtra(EXTRA_PARAM, param);
        context.startService(intent);
    }

    /**
     * Starts this service to perform action Baz with the given parameters. If
     * the service is already performing a task this action will be queued.
     *
     * @see IntentService
     */
    public static void startActionBaz(Context context, String param) {
        Intent intent = new Intent(context, MyIntentService.class);
        intent.setAction(ACTION_BAZ);
        intent.putExtra(EXTRA_PARAM, param);
        context.startService(intent);
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        if (intent != null) {
            Log.e(getClass().getSimpleName(),"当前线程:"+Thread.currentThread().getName());
            String action = intent.getAction();
            String param = intent.getStringExtra(EXTRA_PARAM);
            if (ACTION_FOO.equals(action)) {
                handleActionFoo(param);
            } else if (ACTION_BAZ.equals(action)) {
                handleActionBaz(param);
            }
            Log.e(getClass().getSimpleName(),param+"处理结束");
        }
    }

    /**
     * Handle action Foo in the provided background thread with the provided
     * parameters.
     */
    private void handleActionFoo(String param1) {
        Log.e(getClass().getSimpleName(),"当前处理任务:"+param1);
    }

    /**
     * Handle action Baz in the provided background thread with the provided
     * parameters.
     */
    private void handleActionBaz(String param1) {
        Log.e(getClass().getSimpleName(),"当前处理任务:"+param1);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.e(getClass().getSimpleName(),"IntentServer 销毁");
    }
}

我们创建一个MyIntentService继承自IntentService，然后实现onHandleIntent方法，在该方法中获得intent传递过来的参数并处理耗时任务。

• MyIntentService使用
  在Activity中直接调用

MyIntentService.startActionBaz(this,"吃饭");
MyIntentService.startActionFoo(MainActivity.this,"打游戏");

• 打印日志

07-10 16:24:43.652 27125-27178/com.jrmf360.service E/MyIntentService: 当前线程:IntentService[MyIntentService]
07-10 16:24:43.652 27125-27178/com.jrmf360.service E/MyIntentService: 当前处理任务:吃饭
07-10 16:24:43.652 27125-27178/com.jrmf360.service E/MyIntentService: 吃饭处理结束
07-10 16:24:43.660 27125-27178/com.jrmf360.service E/MyIntentService: 当前线程:IntentService[MyIntentService]
07-10 16:24:43.660 27125-27178/com.jrmf360.service E/MyIntentService: 当前处理任务:打游戏
07-10 16:24:43.660 27125-27178/com.jrmf360.service E/MyIntentService: 打游戏处理结束
07-10 16:24:43.660 27125-27125/com.jrmf360.service E/MyIntentService: IntentServer 销毁

从日志中我们可以发现，IntentService开启之后会在线程中处理异步任务，线程名字为IntentService[MyIntentService]是我们在构造函数中设置的。并且多个任务是串行执行，当所有的任务处理完毕，销毁该IntentService。

三 IntentService原理分析

• 首先我们看下IntentService的源码

public abstract class IntentService extends Service {
    private volatile Looper mServiceLooper;
    private volatile ServiceHandler mServiceHandler;
    private String mName;
    private boolean mRedelivery;

    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            //处理消息并且在处理完毕后，销毁该IntentService
            onHandleIntent((Intent)msg.obj);
            stopSelf(msg.arg1);
        }
    }

    /**
     *构造方法，并且设置线程的名字
     *
     */
    public IntentService(String name) {
        super();
        mName = name;
    }

    public void setIntentRedelivery(boolean enabled) {
        mRedelivery = enabled;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        //创建HandlerThread 并且开始该线程
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();

        //使用HanderThread的Looper对象去创建handler
        //所以该Handler也在此线程中处理任务
        mServiceLooper = thread.getLooper();
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }

    //在此方法中利用Handler发送消息，从而可以在Handler中的handleMessage方法中处理该消息
    @Override
    public void onStart(@Nullable Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        mServiceHandler.sendMessage(msg);
    }

    /**
     * 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(@Nullable Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
    }

    @Override
    public void onDestroy() {
        mServiceLooper.quit();
    }

    /**
     * Unless you provide binding for your service, you don't need to implement this
     * method, because the default implementation returns null.
     * @see android.app.Service#onBind
     */
    @Override
    @Nullable
    public IBinder onBind(Intent intent) {
        return null;
    }

    @WorkerThread
    protected abstract void onHandleIntent(@Nullable Intent intent);
}

分析源码可知，开启IntentService的时候在onCreate方法中创建了一个HandlerThread，HandlerThread本身是一个线程并且拥有Looper对象，使用这个Looper对象创建Handler就可以在该线程中处理Handler发送的消息。
接着往下看，IntentService在onStartCommand方法中调用了onStart，而在onStart方法中获得了一个Message并使用mServiceHandler发送这个消息。因此我们一旦调用startService方法开启服务，就会走到onHandleIntent方法中并且该方法是在HandlerThread线程中被调用。
再看ServiceHandler中的handleMessage方法，处理完消息后，会调用stopSelf方法停止该服务。这就是任务处理完之后会调用IntentService的onDestroy方法的原因。