IntentService源码分析
IntentService源码分析
一、什么是IntentService
IntentService继承自Service并且本身就是一个抽象类
它可以用于在后台执行耗时的异步任务，当任务完成后会自动停止。
二、IntentService源码分析
先来看下IntentService的类结构
内部类ServiceHandler是一个Handler的子类，简单的实现了handleMessage
并在接收到消息时调用onHandleIntent，然后调用stopSelf退出service。
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);
}
}
private volatile Looper mServiceLooper;
private volatile ServiceHandler mServiceHandler;
private String mName; //
private boolean mRedelivery;
构造函数参数name是用来给工作线程命名用的。
public IntentService(String name) {
super();
mName = name;
}
IntentService继承自service那么根据service的生命周期，首先会调用onCreate函数
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 + "]");//构造HandlerThread 实例
thread.start();
mServiceLooper = thread.getLooper();
mServiceHandler = new ServiceHandler(mServiceLooper);//构造ServiceHandler实例
}
在onCreate函数内部先构造了一个HandlerThread，然后调用了其start函数。之后还获取了HandlerThread的looper，并用该looper构造了ServiceHandler实例。
这里的HandlerThread实际是一个Thread类,其作用就是作为工作线程异步处理IntentService的任务。主要关注其run函数，在run函数内部其调用了Looper.prepare()和Looper.loop()，这样就开启了looper循环。
public class HandlerThread extends Thread {
int mPriority;
int mTid = -1;
Looper mLooper;
private @Nullable Handler mHandler;
public HandlerThread(String name) {
super(name);
mPriority = Process.THREAD_PRIORITY_DEFAULT;
}
/**
* Constructs a HandlerThread.
* @param name
* @param priority The priority to run the thread at. The value supplied must be from
* {@link android.os.Process} and not from java.lang.Thread.
*/
public HandlerThread(String name, int priority) {
super(name);
mPriority = priority;
}
/**
* Call back method that can be explicitly overridden if needed to execute some
* setup before Looper loops.
*/
protected void onLooperPrepared() {
}
@Override
public void run() {
mTid = Process.myTid();
Looper.prepare();//构造looper
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop();//开启looper循环
mTid = -1;
}
/**
* This method returns the Looper associated with this thread. If this thread not been started
* or for any reason isAlive() returns false, this method will return null. If this thread
* has been started, this method will block until the looper has been initialized.
* @return The looper.
*/
public Looper getLooper() {
if (!isAlive()) {
return null;
}
// If the thread has been started, wait until the looper has been created.
synchronized (this) {
while (isAlive() && mLooper == null) {
try {
wait();
} catch (InterruptedException e) {
}
}
}
return mLooper;
}
}
接着看IntentService，oncreate之后便是onStartCommand，它内部只是简单调用了onStart。我们来看onStart，它内部就是构造一个携带intent的Message并将其通过mServiceHandler发送出去。
public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
onStart(intent, startId);
return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
}
public void onStart(@Nullable Intent intent, int startId) {
Message msg = mServiceHandler.obtainMessage();
msg.arg1 = startId;
msg.obj = intent;
mServiceHandler.sendMessage(msg);
}
这样消息就会在ServiceHandler的handlemessage中被处理，我们之前已经看过了handlemessage会调用onHandleIntent然后调用stopself停止。
onHandleIntent是一个抽象方法，我们继承IntentService实现该方法并在内部完成我们想要的操作。onHandleIntent运行在工作线程即HandlerThread中。
protected abstract void onHandleIntent(@Nullable Intent intent);
以上就是IntentService的源码解析，通过分析我们知道IntentService的异步处理请求是通过handler来完成的，它在内部构造了一个Theard作为工作线程，在该Theard的run方法中开启了looper循环，然后每当启动IntentService后会通过handler来异步处理。所以IntentService本质是service+handler。
