IntentService

首先来看下源码，分析在代码中

public abstract class IntentService extends Service {
    //Looper
    private volatile Looper mServiceLooper;
    //内部定义的handler
    private volatile ServiceHandler mServiceHandler;
    //线程名称
    private String mName;
    private boolean mRedelivery;

    //定义一个Handler用来接收消息
    private final class ServiceHandler extends Handler {
        //构造函数绑定Looper，用来确定当前所属的线程
        public ServiceHandler(Looper looper) {
            super(looper);
        }

        //处理消息的回调，如果绑定的Looper所属的是子线程，那么该回调是在子线程中
        @Override
        public void handleMessage(Message msg) {
            //该回调是在子线程，可以执行处理耗时任务
            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();
        //获取子线程的Looper
        mServiceLooper = thread.getLooper();
        //将Looper绑定到内部的Handler
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }

    @Override
    public void onStart(@Nullable Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        mServiceHandler.sendMessage(msg);
    }

    @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() {
        //service销毁时会将Looper退出
        mServiceLooper.quit();
    }

    @Override
    @Nullable
    public IBinder onBind(Intent intent) {
        return null;
    }

    //暴露给外部实现的API
    @WorkerThread
    protected abstract void onHandleIntent(@Nullable Intent intent);
}

通过源码可以看到IntentService是一个抽象类继承自Service，内部重新实现了Handler，在onCraete生命周期回调中实例化HandlerThread绑定Handler，在start的生命周期回调中发送消息回调handleMessage方法。

也就是说IntentService内部创建并绑定了一个子线程，那么IntentService具有执行耗时任务的功能，在执行完耗时任务后会自动退出生命周期。

使用

自定义一个IntentService

public class MyIntentService extends IntentService {

    private static final String TAG = "MyIntentService====>";

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

    public static void startActionFoo(Context context, String param1, String param2) {
        Intent intent = new Intent(context, MyIntentService.class);

        context.startService(intent);
    }

    public static void startActionBaz(Context context, String param1, String param2) {
        Intent intent = new Intent(context, MyIntentService.class);
        context.startService(intent);
    }

    @Override
    protected void onHandleIntent(Intent intent) {

        String threadName = Thread.currentThread().getName();
        boolean isMainThread = Thread.currentThread() == Looper.getMainLooper().getThread();
        Log.d(TAG, "当前线程是否是主线程： " + isMainThread );


        if (intent != null) {
            final String action = intent.getAction();

        }
    }

}

总结

相当于系统封装了一个Service+Thread+Handler的组合，很方便的可以执行耗时任务。