Android IntentService 源码解析

前言

顾名思义，是一个 Service，先说和普通的 Service 的区别吧，普通的 Service 通常运行在主线程，而 IntentService 的处理逻辑在子线程里，另外 Service 需要自己去 destroy，而 IntentService 在处理完自己的逻辑时会自动结束，那他是怎么实现线程切换，主要还是 Handler 机制，内部有一个 HandleThread，关于这个，可以查看 [HandlerThread 源码解析] (https://www.jianshu.com/p/5ff83236c8e2)

前世今生

public abstract class IntentService extends Service {}

继承自 Service，拥有 Service 的特性，不熟悉 Service 的同学可以自行百度，面试必问的，然而感觉我还是不想深入了解，以后再说吧
记住

onCreate -> onStartCommand -> onDestroy
onCreate -> onBind -> onUnbind

自己写一个 IntentService

public class MyIntentService extends IntentService {}

源码解析

很熟悉的 Looper 和 ServiceHandler

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) {
        onHandleIntent((Intent)msg.obj);
        stopSelf(msg.arg1);
    }
}

看一下 onCreate，初始化了一个 HandlerThread，然后再把他的 Looper 拿出来，然后抛弃了它，这个 Looper 是子线程的 Looper，因此事件处理也发生在子线程。利用这个 Looper 新建了一个 Handler

@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);
  }

启动以后调用 onStart，发送一个消息，onHandleIntent((Intent)msg.obj) 里面进行处理，我们要重写这个方法，通常这个在子线程中运行

 @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 onStart(@Nullable Intent intent, int startId) {
     Message msg = mServiceHandler.obtainMessage();
     msg.arg1 = startId;
     msg.obj = intent;
     mServiceHandler.sendMessage(msg);
 }

处理完即关闭，不需要手动关闭

public final void stopSelf() {
    stopSelf(-1);
}

/**
 * Old version of {@link #stopSelfResult} that doesn't return a result.
 *  
 * @see #stopSelfResult
 */
public final void stopSelf(int startId) {
    if (mActivityManager == null) {
        return;
    }
    try {
        mActivityManager.stopServiceToken(
                new ComponentName(this, mClassName), mToken, startId);
    } catch (RemoteException ex) {
    }
}

在我们自己的 IntentService 里面，写处理的逻辑，由于是在子线程中，所以可以处理耗时的逻辑，不必担心 ANR，普通 Service 由于在主线程运行，所以不能直接处理耗时逻辑

@Override
protected void onHandleIntent(Intent intent) {
    if (intent != null) {
        final String action = intent.getAction();
        if (ACTION_FOO.equals(action)) {
            final String param1 = intent.getStringExtra(EXTRA_PARAM1);
            final String param2 = intenonHt.getStringExtra(EXTRA_PARAM2);
            handleActionFoo(param1, param2);
        } else if (ACTION_BAZ.equals(action)) {
            final String param1 = intent.getStringExtra(EXTRA_PARAM1);
            final String param2 = intent.getStringExtra(EXTRA_PARAM2);
            handleActionBaz(param1, param2);
        }
    }
}

小结

非常简单的 IntentService，使用的时候注意与普通 Service 的区别即可，里面使用了 HandlerThread 获取 Looper 对象，处理完会自动关闭，即调用 onDestroy，再次启动又重新走 Service 的生命周期，一个问题，如果多次 startService，那么 onHandleIntent 是怎么样的呢？答案是一次执行，因为 Looper 事件处理是阻塞的