Picasso源码完全解析（六）--请求的取消、暂停、和恢复

Picasso源码完全解析（一）--概述

Picasso源码完全解析（二）--Picasso实例的创建

Picasso源码完全解析（三）--Request和Action的创建

Picasso源码完全解析（四）--Action分发和执行

Picasso源码完全解析（五）--图片的获取（BitmapHunter）

Picasso源码完全解析（六）--请求的取消、暂停、和恢复

Picasso源码完全解析（七）--
CleanupThread 取消请求

Picasso源码完全解析（六）--请求的取消、暂停、和恢复

Picasso为管理请求，提供了取消、暂停和恢复请求的方法。

请求的取消

请求的取消通常是通过picasso.cancel方法执行的，最终会调用这个方法：

private void cancelExistingRequest(Object target) {
checkMain();
Action action = targetToAction.remove(target);
if (action != null) {
action.cancel();
dispatcher.dispatchCancel(action);
}
if (target instanceof ImageView) {
ImageView targetImageView = (ImageView) target;
DeferredRequestCreator deferredRequestCreator = targetToDeferredRequestCreator.remove(targetImageView);
if (deferredRequestCreator != null) {
deferredRequestCreator.cancel();
}
}
}

可以看到 是通过dispatcher.dispatchCancel(action)来执行的。在之前的基础上我们很容易明白，这是通过Dispatcher进行分发处理的。

void performCancel(Action action) {
String key = action.getKey();
BitmapHunter hunter = hunterMap.get(key);
if (hunter != null) {
hunter.detach(action);
if (hunter.cancel()) {
hunterMap.remove(key);
if (action.getPicasso().loggingEnabled) {
log(OWNER_DISPATCHER, VERB_CANCELED, action.getRequest().logId());
}
}
}

if (pausedTags.contains(action.getTag())) {
pausedActions.remove(action.getTarget());
if (action.getPicasso().loggingEnabled) {
log(OWNER_DISPATCHER, VERB_CANCELED, action.getRequest().logId(),
"because paused request got canceled");
}
}

Action remove = failedActions.remove(action.getTarget());
if (remove != null && remove.getPicasso().loggingEnabled) {
log(OWNER_DISPATCHER, VERB_CANCELED, remove.getRequest().logId(), "from replaying");
}
}

没错，最终是通过

hunter.cancel()

来暂停请求的。

boolean cancel() {
return action == null
&& (actions == null || actions.isEmpty())
&& future != null
&& future.cancel(false);
}

最终的取消是通过 future.cancel()完成的。

请求的暂停

请求的暂停是通过 picasso.pause()来完成的，具体调用流程和cancel类似，这里不再赘述，通过分析，发现最终还是通过

 hunter.cancel()

来暂停请求的，也就是暂停请求只不过是临时取消了这个请求。

请求的恢复

有请求的暂停也就有请求的恢复，请求的恢复是通过picass.resume()调用完成的，也是通过Dispatcher进行分的，

void performResumeTag(Object tag) {
// Trying to resume a tag that is not paused.
if (!pausedTags.remove(tag)) {
return;
}

List<Action> batch = null;
for (Iterator<Action> i = pausedActions.values().iterator(); i.hasNext(); ) {
Action action = i.next();
if (action.getTag().equals(tag)) {
if (batch == null) {
batch = new ArrayList<>();
}
batch.add(action);
i.remove();
}
}

if (batch != null) {
mainThreadHandler.sendMessage(mainThreadHandler.obtainMessage(REQUEST_BATCH_RESUME, batch));
}
}

可以看到这里是通过mainThreadHandler发送消息，我们知道mainThreadHandler是Picasso实例所在线程也就是Main线程的Handler，看看消息是如何处理的：

case REQUEST_BATCH_RESUME:
@SuppressWarnings("unchecked") List<Action> batch = (List<Action>) msg.obj;
//noinspection ForLoopReplaceableByForEach
for (int i = 0, n = batch.size(); i < n; i++) {
Action action = batch.get(i);
action.picasso.resumeAction(action);
}
break;

再看看 action.picasso.resumeAction(action);

void resumeAction(Action action) {
Bitmap bitmap = null;
if (shouldReadFromMemoryCache(action.memoryPolicy)) {
bitmap = quickMemoryCacheCheck(action.getKey());
}

if (bitmap != null) {
// Resumed action is cached, complete immediately.
deliverAction(bitmap, MEMORY, action, null);
if (loggingEnabled) {
log(OWNER_MAIN, VERB_COMPLETED, action.request.logId(), "from " + MEMORY);
}
} else {
// Re-submit the action to the executor.
enqueueAndSubmit(action);
if (loggingEnabled) {
log(OWNER_MAIN, VERB_RESUMED, action.request.logId());
}
}
}

很明显，如果能从内存缓存中取得结果就从内存中去，否在重新提交该action。

通过上面的分析可以看到，picasso暂停和恢复请求，实际上是取消请求然后再重新提交请求，并不是真正意义上的暂停和恢复请求。

我们在实际使用过程中，往往将picasso的tag设置为统一对象，可以是所在activity的context，并在activity的生命周期中做相应的控制，或者在列表中使用的时候，为了滑动的流畅，可以根据list的滑动状态来暂停和恢复请求。