Android 中的 IntentService 类详解

• 《Android Service基础》
• 《Android Service回调和配置》
• 《Android Service aidl使用及进阶》
• 《Android Service更多知识》
• 《Android 中的 IntentService 类详解》
• 《Android Service aidl分析》
• 《Android Service 流程分析》

Android Service 代码地址

Android 中的 IntentService 类详解

简介、与 Service 的区别

IntentService 继承至 Service ，所以 Service 的特点 IntentService 也全部拥有。首先，我们看一下 Service 的一些问题：

1. Service 默认运行在主线程，不能执行耗时操作；
2. 如果要在 Service 中执行耗时的操作，需要在 Service 中创建新的线程，但是这就会导致我们不知道在什么时候线程会执行完，也就会导致停止 Service 的时间的未知性。

针对上面的问题，IntentService 扩展了 Service 的功能，完美解决的这个问题，以下是 IntentService 的主要特征：

1. 会创建独立的工作线程来处理 onHandleIntent() 方法实现的代码，无需处理多线程问题；
2. 所有请求处理完成后，IntentService 会自动停止，无需调用 stopSelf() 方法停止 Service；
3. 为 Service 的 onBind() 提供默认实现，返回 null；
4. 为 Service 的 onStartCommand() 提供默认实现，将请求 Intent 添加到队列中。

好处

IntentService 的好处可以根据其特征来分析，主要体现在：

• 会创建独立的工作线程处理耗时操作，无需担心阻塞主线程
• 无需关在什么时候停止服务，当线程执行完成之后会自动停止服务

使用方式

1.创建 MyIntentService 继承 IntentService

public class MyIntentService extends IntentService {

	// 必须创建构造方法，调用父类的构造方法
    public MyIntentService() {
        super("intentservice");
    }

	// 在此方法中可以编写耗时操作的代码，执行在工作线程
    @Override
    protected void onHandleIntent(@Nullable Intent intent) {
        for (int i = 1; i <= 3; i++) {
            // 模拟耗时操作
            SystemClock.sleep(1000 * i);
            Log.i("MyIntentService", "Thread => " + Thread.currentThread().getName());
        }
    }
}

2.IntentService 既然是继承 Service，那么需要在 AndroidManifest.xml 文件中进行配置

<application>
	...
    <!-- 服务需要在 AndroidManifest.xml 文件中配置 -->
    <service android:name=".MyIntentService" />
</application>

3.启动服务

Intent intent = new Intent(this,MyIntentService.class);
startService(intent);

源码解析

1.构造方法

public IntentService(String name) {
    super();
    mName = name;
}

构造方法只有一个，子类必须重写构造方法并调用父类的构造方法传递 name 值，name 表示 onHandleIntent() 方法所运行的线程名。

2.继承至 Handler 的内部类 ServiceHandler

private final class ServiceHandler extends Handler {
	// 构造需要一个Looper对象，查看下面的 onCreate() 方法（第4点）
	// 在 onCreate() 方法中创建 ServiceHandler 对象时使用的是从 HandlerThread 中
	// 获取的 Looper ，所以 handleMessage() 方法处理时在工作线程中
    public ServiceHandler(Looper looper) {
        super(looper);
    }

	// 处理消息的方法
    @Override
    public void handleMessage(Message msg) {
		// 调用方法。抽象方法，子类具体实现
        onHandleIntent((Intent)msg.obj);
		// onHandleIntent() 方法执行完成，停止服务
        stopSelf(msg.arg1);
    }
}

如果对 HandlerThread 类不了解的可以查看 《Android 中的 HandlerThread 类详解》

3.在 ServiceHandler 的 handleMessage() 方法内部调用的抽象方法

// 抽象方法，方法的执行代码运行在工作线程
@WorkerThread
protected abstract void onHandleIntent(@Nullable Intent intent);

在 onHandleIntent() 是抽象方法，子类必须重写，方法转给你的内容执行在工作线程。

4.onCreate()方法

@Override
public void onCreate() {
    super.onCreate();
	// 创建 HandlerThread 对象，并启动线程
    HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
    thread.start();

	// 获取 HandlerThread 中的 Looper 对象，并作为参数用来创建 ServiceHandler 对象
    mServiceLooper = thread.getLooper();
    mServiceHandler = new ServiceHandler(mServiceLooper);
}

如果对 HandlerThread 类不了解的可以查看 《Android 中的 HandlerThread 类详解》

5.重写 onStartCommand() / onStart() 方法

@Override
public void onStart(@Nullable Intent intent, int startId) {
	// 将 Intent 发送给 ServiceHandler 进行处理
    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;
}

// 确定 onStartCommand() 方法的返回值，是否需要重启服务
public void setIntentRedelivery(boolean enabled) {
    mRedelivery = enabled;
}

将请求添加到工作线程的 MessageQueue 队列中。

6.重写 onBind() 方法

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

提供 onBind() 的默认实现，返回 null

7.销毁 onDestory() 方法

@Override
public void onDestroy() {
    mServiceLooper.quit();
}

调用 Looper 的 quit() 方法，清除所有的消息。

总结

• 会创建独立的工作线程来处理 onHandleIntent() 方法实现的代码，无需处理多线程问题；
• 所有请求处理完成后，IntentService 会自动停止，无需调用 stopSelf() 方法停止 Service；
• 为 Service 的 onBind() 提供默认实现，返回 null；
• 为 Service 的 onStartCommand() 提供默认实现，将请求 Intent 添加到队列中；
• IntentService 内部使用的是 HandlerThread ，所以有 HandlerThread 的局限性（HandlerThread 本质是一个线程，在线程内部，代码是串行处理的；
  由于每一个任务都将以队列的方式逐个被执行到，一旦队列中有某个任务执行时间过长，那么就会导致后续的任务都会被延迟处理）。

相关文章

《Android 中的 HandlerThread 类详解》
《AsyncTask 完全解析》
《Android中的Handler机制分析(一) Handler和Message分析》
《Android中的Handler机制分析(二) MessageQueue分析》
《Android中的Handler机制分析(三) Looper分析和Handler其他知识》