IntentService源码分析
要分析Servcie和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) {
onHandleIntent((Intent)msg.
obj
);
stopSelf(msg.
arg1
);
}
}
/**
* Creates an IntentService. Invoked by your subclass's constructor.
*
*
@param
name
Used to name the worker thread, important only for debugging.
*/
public
IntentService(String name) {
super
();
mName
= name;
}
/**
* Sets intent redelivery preferences. Usually called from the constructor
* with your preferred semantics.
*
*
If enabled is true,
* {
@link
#onStartCommand(Intent, int, int)} will return
* {
@link
Service#START_REDELIVER_INTENT}, so if this process dies before
* {
@link
#onHandleIntent(Intent)} returns, the process will be restarted
* and the intent redelivered. If multiple Intents have been sent, only
* the most recent one is guaranteed to be redelivered.
*
*
If enabled is false (the default),
* {
@link
#onStartCommand(Intent, int, int)} will return
* {
@link
Service#START_NOT_STICKY}, and if the process dies, the Intent
* dies along with it.
*/
public void
setIntentRedelivery(
boolean
enabled) {
mRedelivery
= enabled;
}
@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
);
}
@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
;
}
/**
* This method is invoked on the worker thread with a request to process.
* Only one Intent is processed at a time, but the processing happens on a
* worker thread that runs independently from other application logic.
* So, if this code takes a long time, it will hold up other requests to
* the same IntentService, but it will not hold up anything else.
* When all requests have been handled, the IntentService stops itself,
* so you should not call {
@link
#stopSelf}.
*
*
@param
intent
The value passed to {
@link
* android.content.Context#startService(Intent)}.
* This may be null if the service is being restarted after
* its process has gone away; see
* {
@link
android.app.Service#onStartCommand}
* for details.
*/
@WorkerThread
protected abstract void
onHandleIntent(@Nullable Intent intent);
}
IntentServie是一个抽象类
先从onCreate看起
@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
);
}
在onCreate里会开启一个线程，这个线程HandlerThread，看下这个HandlerThread是个啥
看注释
/**
* Handy class for starting a new thread that has a looper. The looper can then be
* used to create handler classes. Note that start() must still be called.
*/
HandlerThread就是拥有一个Looper的Thread
看它的Run方法
@Override
public void
run() {
mTid
= Process.
myTid
();
Looper.
prepare
();
synchronized
(
this
) {
mLooper
= Looper.
myLooper
();
notifyAll();
}
Process.
setThreadPriority
(
mPriority
);
onLooperPrepared();
Looper.
loop
();
mTid
= -
1
;
}
在run方法里会执行Looper的prepare和loop方法
mServiceLooper
= thread.getLooper();
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
;
}
在Thread启动后，才会返回Looper对象
再看下一句
mServiceHandler
=
new
ServiceHandler(
mServiceLooper
);
看下ServiceHanlder的定义
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);
}
}
它是IntentService中的一个内部类，在handleMessage方法里执行了stopSelf方法，即停止Service
Service在执行任务时会调用onStartCommand方法，看下onStartCommand
@Override
public int
onStartCommand(@Nullable Intent intent,
int
flags,
int
startId) {
onStart(intent, startId);
return
mRedelivery
?
START_REDELIVER_INTENT
:
START_NOT_STICKY
;
}
发现会调用onStart方法
再看onStart方法
@Override
public void
onStart(@Nullable Intent intent,
int
startId) {
Message msg =
mServiceHandler
.obtainMessage();
msg.
arg1
= startId;
msg.
obj
= intent;
mServiceHandler
.sendMessage(msg);
}
再onStart方法里会调用handler的sendMeasage方法
sendMessage后就会调用ServieHanlder里的handMessage方法
handleMessage方法调用了onHandleIntent方法
这个方法是抽象方法，需要在子类中重写，任务的处理就写在这个方法里
处理完任务就是stopSelf，即关闭Service。
总结：IntentService会自己开启一个线程执行任务，在任务完成后会自己stopSelf停止Service.
它的好处就是省去了自己开线程和关闭Service的麻烦。