Android[学习] IntentService详解

IntentService是Service的子类，用来处理异步请求。

一、使用介绍

通过Context.startService(Intent)启动可以处理异步请求的Service,使用时，你只需要继承IntentService和重写onHandleIntent(Intent)方法接收一个Intent对象。不会阻塞主线程，一次执行一个操作。

特点：

1. IntentService自带一个工作线程
2. 将需要实际的工作放到onHandleIntent方法中，当调用startService后，系统framework层会回调onHandleIntent中，并且传入intent
3. 排队执行，当多次调用startService时，但是只能处理一个请求，那么就需要排队处理。

二、源码解析

package android.app;
import android.content.Intent;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;
 
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) {
   //在工作线程中调用onHandleIntent，确保onHandleIntent不会阻塞主线程
   onHandleIntent((Intent)msg.obj);
   //在执行完了onHandleIntent之后，我们需要调用stopSelf(startId)声明某个job完成了
   //当所有job完成的时候，Android就会回调onDestroy方法，销毁IntentService
   stopSelf(msg.arg1);
  }
 }
 
 public IntentService(String name) {
  //此处的name将用作线程名称
  super();
  mName = name;
 }
 
 public void setIntentRedelivery(boolean enabled) {
  mRedelivery = enabled;
 }
 
 @Override
 public void onCreate() {
  super.onCreate();
  //创建HandlerThread，利用mName作为线程名称，HandlerThread是IntentService的工作线程
  HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
  thread.start();
 
  mServiceLooper = thread.getLooper();
  //将创建的HandlerThread所绑定的looper对象传递给ServiceHandler，
  //这样我们创建的Handler就和HandlerThread通过消息队列绑定在了一起
  mServiceHandler = new ServiceHandler(mServiceLooper);
 }
 
 @Override
 public void onStart(Intent intent, int startId) {
  //在此方法中创建Message对象，并将intent作为Message的obj参数,
  //这样Message与Intent就关联起来了
  Message msg = mServiceHandler.obtainMessage();
  msg.arg1 = startId;
  msg.obj = intent;
  //将关联了Intent信息的Message发送给Handler
  mServiceHandler.sendMessage(msg);
 }
 
 @Override
 public int onStartCommand(Intent intent, int flags, int startId) {
  //IntentService重写了onStartCommand回调方法:在内部调用onStart回调方法
  //所以我们在继承IntentService时，不应该再覆写该方法，即便覆盖该方法，我们也应该调用super.onStartCommand()
  onStart(intent, startId);
  return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
 }
 
 @Override
 public void onDestroy() {
  //在onDestroy方法中调用了Handler的quit方法，该方法会终止消息循环
  mServiceLooper.quit();
 }
 
 @Override
 public IBinder onBind(Intent intent) {
  return null;
 }
 
 protected abstract void onHandleIntent(Intent intent);
}

分析：

（1）可以看到在oncreate方法中，先是创建线程，从线程中获取到looper，然后通过looper创建handler，handler是自己定义的ServiceHandler，在回调handlerMessage方法中调用onHandleIntent方法，这个onHandleIntent方法，是抽象方法，需要实现自己的一些业务。

（2）oncreate方法执行后是onStartCommand,调用方法时看到，只是调用了onStart()方法，传入参数，返回值，至于，为啥先调用onStartCommand方法，在以后的章节中会讲到，在onStart方法里面，看到，创建消息message,并且向hander发生消息。

（3）在onDestroy方法中销毁looper.

接下来让我们来看看如何使用，写一个Demo来模拟两个耗时操作，Operation1与Operation2，先执行1，2必须等1执行完才能执行2：

新建工程，新建一个继承IntentService的类，我这里是IntentServiceDemo.java

public class IntentServiceDemo extends IntentService {

    public IntentServiceDemo() {
        //必须实现父类的构造方法
        super("IntentServiceDemo");
    }
    
    @Override
    public IBinder onBind(Intent intent) {
        System.out.println("onBind");
        return super.onBind(intent);
    }


    @Override
    public void onCreate() {
        System.out.println("onCreate");
        super.onCreate();
    }

    @Override
    public void onStart(Intent intent, int startId) {
        System.out.println("onStart");
        super.onStart(intent, startId);
    }


    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        System.out.println("onStartCommand");
        return super.onStartCommand(intent, flags, startId);
    }


    @Override
    public void setIntentRedelivery(boolean enabled) {
        super.setIntentRedelivery(enabled);
        System.out.println("setIntentRedelivery");
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        //Intent是从Activity发过来的，携带识别参数，根据参数不同执行不同的任务
        System.out.println("currentThread()=" + Thread.currentThread().getName());
        String action = intent.getExtras().getString("param");
        if (action.equals("oper1")) {
            System.out.println("Operation1");
        }else if (action.equals("oper2")) {
            System.out.println("Operation2");
        }
        
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void onDestroy() {
        System.out.println("onDestroy");
        super.onDestroy();
    }

}

我把生命周期方法全打印出来了，待会我们来看看它执行的过程是怎样的。接下来是Activity，在Activity中来启动IntentService：

public class TestActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        //可以启动多次，每启动一次，就会新建一个work thread，但IntentService的实例始终只有一个
        //Operation 1
        Intent startServiceIntent = new Intent("com.test.intentservice");
        Bundle bundle = new Bundle();
        bundle.putString("param", "oper1");
        startServiceIntent.putExtras(bundle);
        startService(startServiceIntent);
        
        //Operation 2
        Intent startServiceIntent2 = new Intent("com.test.intentservice");
        Bundle bundle2 = new Bundle();
        bundle2.putString("param", "oper2");
        startServiceIntent2.putExtras(bundle2);
        startService(startServiceIntent2);
    }
}

最后，别忘了配置Service，因为它继承于Service，所以，它还是一个Service，一定要配置，否则是不起作用的

<service android:name=".IntentServiceDemo">
      <intent-filter >
          <action android:name="com.test.intentservice"/>
      </intent-filter>
</service>

最后来看看执行结果:

从结果可以看到，onCreate方法只执行了一次，而onStartCommand和onStart方法执行了两次，开启了两个Work Thread，这就证实了之前所说的，启动多次，但IntentService的实例只有一个，这跟传统的Service是一样的。Operation1也是先于Operation2打印，并且我让两个操作间停顿了2s，最后是onDestroy销毁了IntentService。
IntentService 源码分析

@Override
public void onCreate() {
        super.onCreate();
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();
        mServiceLooper = thread.getLooper();
        mServiceHandler = new ServiceHandler(mServiceLooper);
}

源码可知：
1）实际上是使用了一个 HandlerThread 来维护线程的，
2） HandleThread 中，内部已经维护一个 Looper，这里直接使用 HandlerThread 的 Looper 对象，便于在 IntentService 中去维护消息队列，
3）创建的 mServiceHandler 是属于 HandleThread 这个 WorkerThread 的。

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

源码可知：
1）直接把消息交给 onHandleIntent() 方法去执行具体的业务逻辑
2）执行完成之后，立即调用 stopSelf() 方法停止自己
接下来分析start源码

 @Override
 public void onStart(Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        mServiceHandler.sendMessage(msg);
  }
  @Override
  public int onStartCommand(Intent intent, int flags, int startId) {
        onStart(intent, startId);
        return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
    }

源码可知
1）在 onStartCommand() 中直接调用了 onStart() 方法
2）而上面 stopSelf() 方法使用的 startId 来停止当前的此次任务服务。
3）而 Service 如果被启动多次，就会存在多个 startId ，当所有的 startId 都被停止之后，才会调用 onDestory() 自我销毁。
我们在看看HandlerThread启动之后的源码

@Override
public void run() {
    mTid = Process.myTid();
     Looper.prepare();
     synchronized (this) {
         mLooper = Looper.myLooper();
         notifyAll();
     }
     Process.setThreadPriority(mPriority);
     onLooperPrepared();
     Looper.loop();
     mTid = -1;
}

源码可知
1）run方法里面添加了锁，这也解释了为什么多次 start 同一个 IntentService 它会顺序执行，全部执行完成之后，再自我销毁。