android面试（10）-IntentService

1.概念：

IntentService是继承并处理异步请求的一个类，在IntentService内有一个工作线程来处理耗时操作，启动IntentService的方式和启动传统的Service一样，同时，当任务执行完后，IntentService会自动停止，而不需要我们手动去控制或者stopSelf（）。另外，可以启动IntentService多次，而每一个耗时操作会以工作队列的方式在IntentService的onHandlerIntent回调方法中执行，并且，每次只会执行一个工作线程，执行完第一个再执行第二个；

本质上就是一个Service，内部通过HandlerThread和Handler实现异步操作；

2.使用方法：

创建一个类，继承自IntentService，实现其构造方法及onHandlerIntent（）方法，在onHandlerIntent（）方法中执行耗时操作；

代码实例：

public class IntentServiceFace extends IntentService {

    public final static String DOWNLOAD_URL="download_url";
    public UpdateUI updateUI;

    public IntentServiceFace(String name) {
        super("IntentServiceFace");
    }
    /**
     * 模拟下载图片的操作，在下载完成后由Activity的回调来通知主线程更新UI
     * @param intent
     */
    @Override
    protected void onHandleIntent(@Nullable Intent intent) {
        Bitmap bitmap=downloadBitmapUrl(intent.getExtras().getString(DOWNLOAD_URL));
        Message message=Message.obtain();
        message.obj=bitmap;
        message.what=0;
        if (updateUI!=null){
            updateUI.updateUI(message);
        }
    }

    /**
     * 模拟下载图片的方法
     * @param string
     * @return
     */
    private Bitmap downloadBitmapUrl(String string) {
        return null;
    }

    public interface UpdateUI{
        void updateUI(Message msg);
    }
}

然后在Activity中

public class IntentServiceActivity extends Activity implements IntentServiceFace.UpdateUI{

    private final static Handler handler=new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            //更新UI
        }
    };

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        Intent intent=new Intent(this,IntentServiceFace.class);
        intent.putExtra("download_url","图片的Url地址");
        startService(intent);
        IntentServiceFace.setUpdateUI(this);
    }

    @Override
    public void updateUI(Message msg) {
        handler.sendMessageDelayed(msg,1000);
    }
}

3.源码解析：

@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()方法可以看出，IntentService内部其实是HandlerThread，其次new了一个ServiceHandler，

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

可以看出ServiceHandler其实就是一个继承了Handler的handler，只不过就是在handler的基础上做了一些封装，这就证明了之前说的IntentService其实就是一个封装了HandlerThread和Handler的Service；

IntentService的主要作用就是为了进行异步操作，那么它是怎么发起异步操作的呢？

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

可以看到在服务正在启动，也就是调用onStartCommand方法时，调用了onStart方法，而onStart方法中则是调用servicehandler的sendMessage方法去实现异步操作的，这个消息应该是发给HandlerThread中的，因为HandlerThread才有Looper轮循器。

我们再来回头看看ServiceHandler的源码：

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

这里面其实是在handleMessage方法中调用了onHandlerIntent（）方法，而onHandlerIntent是一个抽象方法，同时也是一个异步方法，然后它自己调用了stopSelf（msg.arg1）方法，这就证明了上面所说的，不需要我们去手动关闭这个服务，它在完成任务之后会自动停止，但是这里带了一个msg.arg1的参数，这就代表了它并不会立即停止，而是等待服务中所以线程任务都完成后才会停止；