Picasso图片加载框架 —— 源码解析（一）

图片加载是Android开发中的常见情景，在日常项目中，也一直在用Picasso来处理各种加载需求。用的多了，也就自然想了解下其实现过程。这里，将深入源码，学习Picasso框架的实现过程和设计思想。计划用三篇文章来对Picasso做一个全面的分析，而这第一篇的目标则是梳理一下Picasso加载图片的整体思路和核心流程。这样有了主干，学习起来才能全而不乱。

一、Picasso简介

Picasso是Square公司推出的开源图片加载库。体量轻、功能完善、使用简单，配合OkHttp使用效果极佳。
官方链接：http://square.github.io/picasso/

若想在项目中使用Picasso，只需在gradle中添加依赖即可：

//2.5.0为版本号
dependencies {
    compile 'com.squareup.picasso:picasso:2.5.0'
}

本文所涉及到的源码均为Picasso 2.5.0版本

二、源码分析

在分析源码之前，我们先看下Picasso是如何使用的：

Picasso.with(context).load(url).into(imageView);

给定一个url和ImageView，就可以将图片加载到ImageView中，十分简单。

接下来，我们就一步步的看下，Picasso是如何通过一行代码实现图片加载的。

1. 初始化Picasso实例

static Picasso singleton = null;

Picasso是一个单例类，可通过Picasso.with()静态方法对Picasso进行初始化。

/**
 * Lru memory cache: 默认缓存大小为程序运行内存的15%
 * Disk cache: 默认缓存大小为5MB ~ 50MB 
*/
public static Picasso with(Context context) {
  if (singleton == null) {
    synchronized (Picasso.class) {
      if (singleton == null) {
        singleton = new Builder(context).build();
      }
    }
  }
  return singleton;
}

从源码可以看到，Picasso.with()方法做的事情非常简单，就是使用双重校验锁的方式，调用Picasso.Builder.build()构造Picasso的单例对象。

既然如此，那么Builder就一定保存了初始化Picasso所需的参数：

public static class Builder {
  //上下文
  private final Context context;
  //从外部资源(网络、磁盘等)下载图片的下载器
  private Downloader downloader;
  //异步加载图片的线程池  
  private ExecutorService service;
  //内存缓存    
  private Cache cache;
  //监听图片加载失败的回调 
  private Listener listener;
  //request的修改器 
  private RequestTransformer transformer;
  //自定义的图片获取方式  
  private List<RequestHandler> requestHandlers;
  //图片配置    
  private Bitmap.Config defaultBitmapConfig;
  //是否显示debug indicators    
  private boolean indicatorsEnabled;
  //是否允许debug logging   
  private boolean loggingEnabled;
}

所有变量均提供了set方法供用户从外部进行设置。若不设置，则Builder.build()方法也为其提供了默认实现。

public Picasso build() {
  Context context = this.context;

  if (downloader == null) {
    //若能反射找到com.squareup.okhttp.OkHttpClient,则downloader为OkHttpDownloader
    //否则downloader为UrlConnectionDownloader
    downloader = Utils.createDefaultDownloader(context);
  }
  if (cache == null) {
    cache = new LruCache(context);
  }
  if (service == null) {
    //核心线程数和最大线程数均为3的线程池
    service = new PicassoExecutorService();
  }
  if (transformer == null) {
    transformer = RequestTransformer.IDENTITY;
  }

  Stats stats = new Stats(cache);

  Dispatcher dispatcher = new Dispatcher(context, service, HANDLER, downloader, cache, stats);

  return new Picasso(context, dispatcher, cache, listener, transformer, requestHandlers, stats,
      defaultBitmapConfig, indicatorsEnabled, loggingEnabled);
}

可以看到，Builder.build()方法做的事情就是为各成员变量赋值，并调用new Picasso()来构建Picasso的实例。

Picasso(Context context, Dispatcher dispatcher, Cache cache, Listener listener,
      RequestTransformer requestTransformer, List<RequestHandler> extraRequestHandlers, Stats stats,
      Bitmap.Config defaultBitmapConfig, boolean indicatorsEnabled, boolean loggingEnabled) {
    //省略其他代码

    //分发器
    this.dispatcher = dispatcher;
    //请求处理器
    List<RequestHandler> allRequestHandlers =
        new ArrayList<RequestHandler>(builtInHandlers + extraCount);
    // ResourceRequestHandler needs to be the first in the list to avoid
    // forcing other RequestHandlers to perform null checks on request.uri
    // to cover the (request.resourceId != 0) case.
    allRequestHandlers.add(new ResourceRequestHandler(context));
    if (extraRequestHandlers != null) {
      allRequestHandlers.addAll(extraRequestHandlers);
    }
    allRequestHandlers.add(new ContactsPhotoRequestHandler(context));
    allRequestHandlers.add(new MediaStoreRequestHandler(context));
    allRequestHandlers.add(new ContentStreamRequestHandler(context));
    allRequestHandlers.add(new AssetRequestHandler(context));
    allRequestHandlers.add(new FileRequestHandler(context));
    allRequestHandlers.add(new NetworkRequestHandler(dispatcher.downloader, stats));
    requestHandlers = Collections.unmodifiableList(allRequestHandlers);
    //省略其他代码
}

在这之中，有两个很重要角色：Dispatcher和RequestHandler。大家先对此有个印象，后面用到时会详细讲。

2. 创建Request

初始化好了Picasso的实例，接下来就要调用Picasso.load()方法了。

Picasso.load()默认提供了四种重载： load()

// load(String)和load(File)最终都会调用load(Uri)。
public RequestCreator load(File file) {
    if (file == null) {
      return new RequestCreator(this, null, 0);
    }
    return load(Uri.fromFile(file));
  }

public RequestCreator load(String path) {
    if (path == null) {
      return new RequestCreator(this, null, 0);
    }
    if (path.trim().length() == 0) {
      throw new IllegalArgumentException("Path must not be empty.");
    }
    return load(Uri.parse(path));
  }

public RequestCreator load(Uri uri) {
    return new RequestCreator(this, uri, 0);
  }

//直接创建RequestCreator
public RequestCreator load(int resourceId) {
    if (resourceId == 0) {
      throw new IllegalArgumentException("Resource ID must not be zero.");
    }
    return new RequestCreator(this, null, resourceId);
  }

可以看到，这四个方法内部实现大同小异，最终都会创建一个RequestCreator对象。

RequestCreator(Picasso picasso, Uri uri, int resourceId) {
    if (picasso.shutdown) {
      throw new IllegalStateException(
          "Picasso instance already shut down. Cannot submit new requests.");
    }
    this.picasso = picasso;
    //data即Request.Builder对象，其封装了真实的请求内容
    this.data = new Request.Builder(uri, resourceId, picasso.defaultBitmapConfig);
  }

3. 分发Action

Picasso.load()方法创建好了RequestCreator，也准备好了url，接下来就要创建Action了。

//采用异步方式，将request的结果填充到ImageView中
public void into(ImageView target) {
    into(target, null);
  }

// Callback为监听图片添加结果（成功/失败）的回调
public void into(ImageView target, Callback callback) {
    long started = System.nanoTime();
    //检查是否为主线程调用
    checkMain();

    if (target == null) {
      throw new IllegalArgumentException("Target must not be null.");
    }
    
    //检查请求中是否设置了uri或resourceId。若均没有设置，则视其为无效请求，取消这次request
    if (!data.hasImage()) {
      picasso.cancelRequest(target);
      if (setPlaceholder) {
        setPlaceholder(target, getPlaceholderDrawable());
      }
      return;
    }

    //是否调整图片尺寸
    if (deferred) {
      if (data.hasSize()) {
        throw new IllegalStateException("Fit cannot be used with resize.");
      }
      int width = target.getWidth();
      int height = target.getHeight();
      if (width == 0 || height == 0) {
        if (setPlaceholder) {
          setPlaceholder(target, getPlaceholderDrawable());
        }
        picasso.defer(target, new DeferredRequestCreator(this, target, callback));
        return;
      }
      data.resize(width, height);
    }

    //创建真实请求
    Request request = createRequest(started);
    String requestKey = createKey(request);

    //是否允许从cache中读取图片
    if (shouldReadFromMemoryCache(memoryPolicy)) {
      Bitmap bitmap = picasso.quickMemoryCacheCheck(requestKey);
      //若cache中存在要请求的图片，则取消请求，直接加载cache中的图片
      if (bitmap != null) {
        picasso.cancelRequest(target);
        //将cache中的图片加载到ImageView上
        setBitmap(target, picasso.context, bitmap, MEMORY, noFade, picasso.indicatorsEnabled);
        if (picasso.loggingEnabled) {
          log(OWNER_MAIN, VERB_COMPLETED, request.plainId(), "from " + MEMORY);
        }
        if (callback != null) {
          callback.onSuccess();
        }
        return;
      }
    }

    //是否需要占位图片
    if (setPlaceholder) {
      setPlaceholder(target, getPlaceholderDrawable());
    }

    //执行到此，则表示需要从外部资源下载图片
    //创建ImageViewAction，ImageViewAction内部持有ImageView和Request
    Action action =
        new ImageViewAction(picasso, target, request, memoryPolicy, networkPolicy, errorResId,
            errorDrawable, requestKey, tag, callback, noFade);
    
    //将Action放入队列并提交
    picasso.enqueueAndSubmit(action);
  }

RequestCreator.into()方法主要做了一些检查和准备工作，包括：
1）确保在主线程进行调用；
2）检查request的有效性，即uri或resourceId是否为空；
3）是否从cache中获取图片；
4）若request有效且cache中没有目标图片，则创建ImageViewAction，提交并放入队列。

到此为止，还是没有看到处理url和添加图片的过程，只能跟着Picasso.enqueueAndSubmit(action)继续往下看。

void enqueueAndSubmit(Action action) {
    //对于ImageViewAction来说，target即ImageView
    Object target = action.getTarget();

    //检查ImageView是否有其他正在执行的action，若有，则取消之前的action
    if (target != null && targetToAction.get(target) != action) {
      cancelExistingRequest(target);
      targetToAction.put(target, action);
    }

    //提交action
    submit(action);
  }

Picasso.enqueueAndSubmit()方法将action存入WeakHashMap中，并确保ImageView当前只有一个正在执行的action。

void submit(Action action) {
    dispatcher.dispatchSubmit(action);
  }

Picasso.submit()方法也没有对action进行处理，而是直接调用Dispatcher.dispatchSubmit()继续下发。

Dispatcher(Context context, ExecutorService service, Handler mainThreadHandler,
      Downloader downloader, Cache cache, Stats stats) {
    //省略其他代码

    // DispatcherHandler继承自HandlerThread，因此handler为子线程的handler
    this.handler = new DispatcherHandler(dispatcherThread.getLooper(), this);
    // mainThreadHandler为主线程handler
    this.mainThreadHandler = mainThreadHandler;

    //省略其他代码
}

void dispatchSubmit(Action action) {
    //将action装入message，并由子线程handler进行发送，完成线程切换
    handler.sendMessage(handler.obtainMessage(REQUEST_SUBMIT, action));
  }

Dispatcher是分发器，该类持有两个Handler：一个是mainThreadHandler，另一个是子线程handler。dispatchSubmit()方法即调用子线程handler的sendMessage()方法，将action发送到子线程进行处理。

值得注意的是，之前的代码是在主线程中运行的，而在handler.sendMessage()之后，便完成了主线程到子线程的切换。这也意味着接下来要做耗时操作了。

4. 提交BitmapHunter

在子线程接收到message后，会调用Dispatcher.performSubmit()方法。

@Override 
public void handleMessage(final Message msg) {
      switch (msg.what) {
        case REQUEST_SUBMIT: {
          Action action = (Action) msg.obj;
          dispatcher.performSubmit(action);
          break;
        }
      //省略其他代码
      }
}

void performSubmit(Action action) {
    performSubmit(action, true);
}

void performSubmit(Action action, boolean dismissFailed) {
    //如果当前action在pausedTags中，则暂停执行并将其放入pausedActions
    if (pausedTags.contains(action.getTag())) {
      pausedActions.put(action.getTarget(), action);
      if (action.getPicasso().loggingEnabled) {
        log(OWNER_DISPATCHER, VERB_PAUSED, action.request.logId(),
            "because tag '" + action.getTag() + "' is paused");
      }
      return;
    }

    //从active hunters中寻找有无action对应的BitmapHunter
    BitmapHunter hunter = hunterMap.get(action.getKey());
    if (hunter != null) {
      hunter.attach(action);
      return;
    }

    //若线程池已关闭，则退出执行
    if (service.isShutdown()) {
      if (action.getPicasso().loggingEnabled) {
        log(OWNER_DISPATCHER, VERB_IGNORED, action.request.logId(), "because shut down");
      }
      return;
    }

    //创建hunter对象
    hunter = forRequest(action.getPicasso(), this, cache, stats, action);
    //执行hunter任务
    hunter.future = service.submit(hunter);
    //将hunter放入active hunters
    hunterMap.put(action.getKey(), hunter);
    if (dismissFailed) {
      failedActions.remove(action.getTarget());
    }

    if (action.getPicasso().loggingEnabled) {
      log(OWNER_DISPATCHER, VERB_ENQUEUED, action.request.logId());
    }
}

Dispatcher.performSubmit()方法是Dispatcher中非常重要的方法，所有的请求都会经此方法进行提交。该方法主要干了几件事：
1）从action中取出对应的tag，并检查其是否在pausedTags中。如果存在，则暂停执行该action并将其放入pausedActions；
2）从active hunters中寻找有无action对应的BitmapHunter。如果有，则直接取出对应的BitmapHunter，并将action attach上去；
3）若以上条件均不满足，则为当前action创建新的BitmapHunter，并提交给线程池执行。

5. hunt目标图片

至此，我们可以大胆猜测，这个BitmapHunter应该就是一个Runnable，图片下载过程应该就在其run()方法中。

class BitmapHunter implements Runnable {

  static BitmapHunter forRequest(Picasso picasso, Dispatcher dispatcher, Cache cache, Stats stats, Action action) {
    Request request = action.getRequest();
    List<RequestHandler> requestHandlers = picasso.getRequestHandlers();

    //遍历Picasso.getRequestHandlers()，寻找合适的请求处理器
    for (int i = 0, count = requestHandlers.size(); i < count; i++) {
      RequestHandler requestHandler = requestHandlers.get(i);
      if (requestHandler.canHandleRequest(request)) {
        return new BitmapHunter(picasso, dispatcher, cache, stats, action, requestHandler);
      }
    }

    return new BitmapHunter(picasso, dispatcher, cache, stats, action, ERRORING_HANDLER);
    }

  @Override
  public void run() {
    try {
      updateThreadName(data);

      if (picasso.loggingEnabled) {
        log(OWNER_HUNTER, VERB_EXECUTING, getLogIdsForHunter(this));
      }

      //调用hunt()方法获取结果
      // result是一个Bitmap变量
      result = hunt();

      //如果bitmap为null，则图片获取失败，调用dispatchFailed()方法分发失败消息
      //否则，调用dispatchComplete()方法分发成功消息
      if (result == null) {
        dispatcher.dispatchFailed(this);
      } else {
        dispatcher.dispatchComplete(this);
      }
    } catch (Downloader.ResponseException e) {
      if (!e.localCacheOnly || e.responseCode != 504) {
        exception = e;
      }
      dispatcher.dispatchFailed(this);
    } catch (NetworkRequestHandler.ContentLengthException e) {
      exception = e;
      dispatcher.dispatchRetry(this);
    } catch (IOException e) {
      exception = e;
      dispatcher.dispatchRetry(this);
    } catch (OutOfMemoryError e) {
      StringWriter writer = new StringWriter();
      stats.createSnapshot().dump(new PrintWriter(writer));
      exception = new RuntimeException(writer.toString(), e);
      dispatcher.dispatchFailed(this);
    } catch (Exception e) {
      exception = e;
      dispatcher.dispatchFailed(this);
    } finally {
      Thread.currentThread().setName(Utils.THREAD_IDLE_NAME);
    }
  }
}

BitmapHunter有一个名为forRequest()的静态方法，用于BitmapHunter的实例化。在该方法内部，会遍历Picasso.getRequestHandlers()列表，寻找合适的RequestHandler。而这个RequestHandlers列表便是在Picasso.new()方法中创建的，参考2.1节。

得到BitmapHunter后，便可将其交给线程池来执行了。run()方法主要做了两件事：
1）调用hunt()方法得到Bitmap结果；
2）若成功获取图片，则调用dispatchComplete()方法分发成功消息，否则，调用dispatchFailed()方法分发失败消息。

接着看BitmapHunter.hunt()方法：

Bitmap hunt() throws IOException {
    Bitmap bitmap = null;

    //从cache中获取目标图片
    if (shouldReadFromMemoryCache(memoryPolicy)) {
      bitmap = cache.get(key);
      if (bitmap != null) {
        //若找到目标图标，则更新stats状态并返回bitmap
        stats.dispatchCacheHit();
        loadedFrom = MEMORY;
        if (picasso.loggingEnabled) {
          log(OWNER_HUNTER, VERB_DECODED, data.logId(), "from cache");
        }
        return bitmap;
      }
    }

    data.networkPolicy = retryCount == 0 ? NetworkPolicy.OFFLINE.index : networkPolicy;

    //调用requestHandler.load()方法获取目标图片
    //目标图片会以Bitmap或Stream的形式存在result中
    RequestHandler.Result result = requestHandler.load(data, networkPolicy);
    if (result != null) {
      loadedFrom = result.getLoadedFrom();
      exifRotation = result.getExifOrientation();

      bitmap = result.getBitmap();

      //如果目标图片是Stream形式，则需decodeStream()
      if (bitmap == null) {
        InputStream is = result.getStream();
        try {
          bitmap = decodeStream(is, data);
        } finally {
          Utils.closeQuietly(is);
        }
      }
    }

    if (bitmap != null) {
      if (picasso.loggingEnabled) {
        log(OWNER_HUNTER, VERB_DECODED, data.logId());
      }
      stats.dispatchBitmapDecoded(bitmap);
      //是否需要对图片进行变换
      if (data.needsTransformation() || exifRotation != 0) {
        synchronized (DECODE_LOCK) {
          if (data.needsMatrixTransform() || exifRotation != 0) {
            bitmap = transformResult(data, bitmap, exifRotation);
            if (picasso.loggingEnabled) {
              log(OWNER_HUNTER, VERB_TRANSFORMED, data.logId());
            }
          }
          if (data.hasCustomTransformations()) {
            bitmap = applyCustomTransformations(data.transformations, bitmap);
            if (picasso.loggingEnabled) {
              log(OWNER_HUNTER, VERB_TRANSFORMED, data.logId(), "from custom transformations");
            }
          }
        }
        if (bitmap != null) {
          stats.dispatchBitmapTransformed(bitmap);
        }
      }
    }

    return bitmap;
}

可以看到，图片获取过程是由requestHandler.load()完成的。而这个RequestHandler就是我们在forRequest()方法中找的请求处理器。

6. 下载目标图片

假设我们要从网络上获取图片，那么forRequest()中找的的目标RequestHandler应该就是NetworkRequestHandler。load()方法自然就是发送网络请求，返回Result的过程。

@Override 
public Result load(Request request, int networkPolicy) throws IOException {
    //downloader才是request的真正执行者
    Response response = downloader.load(request.uri, request.networkPolicy);
    if (response == null) {
      return null;
    }

    Picasso.LoadedFrom loadedFrom = response.cached ? DISK : NETWORK;

    //目标图片以Bitmap的形式返回
    Bitmap bitmap = response.getBitmap();
    if (bitmap != null) {
      return new Result(bitmap, loadedFrom);
    }

    //目标图片以Stream的形式返回
    InputStream is = response.getInputStream();
    if (is == null) {
      return null;
    }
    // Sometimes response content length is zero when requests are being replayed. Haven't found
    // root cause to this but retrying the request seems safe to do so.
    if (loadedFrom == DISK && response.getContentLength() == 0) {
      Utils.closeQuietly(is);
      throw new ContentLengthException("Received response with 0 content-length header.");
    }
    if (loadedFrom == NETWORK && response.getContentLength() > 0) {
      stats.dispatchDownloadFinished(response.getContentLength());
    }
    return new Result(is, loadedFrom);
}

通过源码发现，NetworkRequestHandler并非request的真正处理者，其内部的downloader才是request的负责人。

Downloader是一个接口，Picasso内置两种实现：OkHttpDownloader和UrlConnectionDownloader。如果用户不主动设置的话，Picasso.Builder.build()方法会根据规则两者选一：若能反射找到com.squareup.okhttp.OkHttpClient，则使用OkHttpDownloader，否则downloader为UrlConnectionDownloader。

这里，我们以UrlConnectionDownloader为例，看一下UrlConnectionDownloader.load()方法：

@Override 
public Response load(Uri uri, int networkPolicy) throws IOException {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
      installCacheIfNeeded(context);
    }
    
    //建立HttpURLConnection 
    HttpURLConnection connection = openConnection(uri);
    //使用cache
    connection.setUseCaches(true);

    if (networkPolicy != 0) {
      String headerValue;

      if (NetworkPolicy.isOfflineOnly(networkPolicy)) {
        headerValue = FORCE_CACHE;
      } else {
        StringBuilder builder = CACHE_HEADER_BUILDER.get();
        builder.setLength(0);

        if (!NetworkPolicy.shouldReadFromDiskCache(networkPolicy)) {
          builder.append("no-cache");
        }
        if (!NetworkPolicy.shouldWriteToDiskCache(networkPolicy)) {
          if (builder.length() > 0) {
            builder.append(',');
          }
          builder.append("no-store");
        }

        headerValue = builder.toString();
      }

      connection.setRequestProperty("Cache-Control", headerValue);
    }

    int responseCode = connection.getResponseCode();
    if (responseCode >= 300) {
      connection.disconnect();
      throw new ResponseException(responseCode + " " + connection.getResponseMessage(),
          networkPolicy, responseCode);
    }

    long contentLength = connection.getHeaderFieldInt("Content-Length", -1);
    boolean fromCache = parseResponseSourceHeader(connection.getHeaderField(RESPONSE_SOURCE));
    //返回Response
    return new Response(connection.getInputStream(), fromCache, contentLength);
}

基本就是HttpURLConnection发起网络请求的过程。

7. 分发Response

在UrlConnectionDownloader.load()得到Response后，会一层层地将结果返回：UrlConnectionDownloader.load() ---> NetworkRequestHandler.load() ---> BitmapHunter.hunt() ---> BitmapHunter.run()。

在BitmapHunter.run()中，根据目标图片是否为null来决定是发送成功消息，还是失败消息。

@Override 
public void run() {
      //省略其他代码
      result = hunt();
      if (result == null) {
        dispatcher.dispatchFailed(this);
      } else {
        dispatcher.dispatchComplete(this);
      }
      //省略其他代码
}

这里，我们假设分发成功消息，即调用dispatcher.dispatchComplete(this)。

void dispatchComplete(BitmapHunter hunter) {
    handler.sendMessage(handler.obtainMessage(HUNTER_COMPLETE, hunter));
  }

@Override 
public void handleMessage(final Message msg) {
  switch (msg.what) {
    case HUNTER_COMPLETE: {
      BitmapHunter hunter = (BitmapHunter) msg.obj;
      dispatcher.performComplete(hunter);
      break;
    }
    //省略其他代码
  }
}

void performComplete(BitmapHunter hunter) {
    //是否将目标图片缓存起来
    if (shouldWriteToMemoryCache(hunter.getMemoryPolicy())) {
      cache.set(hunter.getKey(), hunter.getResult());
    }
    //将当前的BitmapHunter从active hunters中移除
    hunterMap.remove(hunter.getKey());
    //批处理
    batch(hunter);
    if (hunter.getPicasso().loggingEnabled) {
      log(OWNER_DISPATCHER, VERB_BATCHED, getLogIdsForHunter(hunter), "for completion");
    }
}

在Dispatcher.performComplete()中，根据内存策略决定是否缓存目标图片并调用Dispatcher.batch()继续批处理。

private void batch(BitmapHunter hunter) {
   if (hunter.isCancelled()) {
     return;
   }

   //将hunter添加到List中
   batch.add(hunter);
   if (!handler.hasMessages(HUNTER_DELAY_NEXT_BATCH)) {
     //延迟200ms发送消息
     handler.sendEmptyMessageDelayed(HUNTER_DELAY_NEXT_BATCH, BATCH_DELAY);
   }
}

@Override 
public void handleMessage(final Message msg) {
 switch (msg.what) {
   case HUNTER_DELAY_NEXT_BATCH: {
         dispatcher.performBatchComplete();
         break;
   }
   //省略其他代码
 }
}

Dispatcher.batch()方法会将分发过来的hunter放到batch列表中，并延迟发送。

void performBatchComplete() {
    List<BitmapHunter> copy = new ArrayList<BitmapHunter>(batch);
    batch.clear();
    //调用mainThreadHandler发送消息
    mainThreadHandler.sendMessage(mainThreadHandler.obtainMessage(HUNTER_BATCH_COMPLETE, copy));
    logBatch(copy);
  }

@Override 
public void handleMessage(final Message msg) {
  switch (msg.what) {
    case HUNTER_BATCH_COMPLETE: {
      List<BitmapHunter> batch = (List<BitmapHunter>) msg.obj;
      //遍历batch列表，依次处理各个hunter
      for (int i = 0, n = batch.size(); i < n; i++) {
        BitmapHunter hunter = batch.get(i);
        hunter.picasso.complete(hunter);
      }
      break;
    }
    //省略其他代码
  }
}

在接收到HUNTER_DELAY_NEXT_BATCH消息后，Dispatcher.performBatchComplete()调用主线程handler继续分发消息，实现线程切换。

8. 加载图片

在Picasso.handleMessage()收到批处理消息后，会依次取出各个hunter，并调用Picasso.complete()。

void complete(BitmapHunter hunter) {
    Action single = hunter.getAction();
    List<Action> joined = hunter.getActions();

    boolean hasMultiple = joined != null && !joined.isEmpty();
    boolean shouldDeliver = single != null || hasMultiple;

    if (!shouldDeliver) {
      return;
    }

    Uri uri = hunter.getData().uri;
    Exception exception = hunter.getException();
    Bitmap result = hunter.getResult();
    LoadedFrom from = hunter.getLoadedFrom();

    //处理action
    if (single != null) {
      deliverAction(result, from, single);
    }

    //处理action
    if (hasMultiple) {
      for (int i = 0, n = joined.size(); i < n; i++) {
        Action join = joined.get(i);
        deliverAction(result, from, join);
      }
    }

    if (listener != null && exception != null) {
      listener.onImageLoadFailed(this, uri, exception);
    }
}

private void deliverAction(Bitmap result, LoadedFrom from, Action action) {
    if (action.isCancelled()) {
      return;
    }
    if (!action.willReplay()) {
      targetToAction.remove(action.getTarget());
    }
    if (result != null) {
      if (from == null) {
        throw new AssertionError("LoadedFrom cannot be null.");
      }

      //回调action.complete()
      action.complete(result, from);
      if (loggingEnabled) {
        log(OWNER_MAIN, VERB_COMPLETED, action.request.logId(), "from " + from);
      }
    } else {
      action.error();
      if (loggingEnabled) {
        log(OWNER_MAIN, VERB_ERRORED, action.request.logId());
      }
    }
}

经过Picasso.complete() ---> Picasso.deliverAction()，最终回调到ImageViewAction.complete()方法。在该方法中，完成了ImageView加载图片的过程。

class ImageViewAction extends Action<ImageView> {
  @Override 
  public void complete(Bitmap result, Picasso.LoadedFrom from) {
    if (result == null) {
      throw new AssertionError(
          String.format("Attempted to complete action with no result!\n%s", this));
    }

    ImageView target = this.target.get();
    if (target == null) {
      return;
    }

    Context context = picasso.context;
    boolean indicatorsEnabled = picasso.indicatorsEnabled;
    //将图片加载到ImageView上
    PicassoDrawable.setBitmap(target, context, result, from, noFade, indicatorsEnabled);

    if (callback != null) {
      callback.onSuccess();
    }
  }
}

final class PicassoDrawable extends BitmapDrawable {
  static void setBitmap(ImageView target, Context context, Bitmap bitmap,
      Picasso.LoadedFrom loadedFrom, boolean noFade, boolean debugging) {
    Drawable placeholder = target.getDrawable();
    if (placeholder instanceof AnimationDrawable) {
      ((AnimationDrawable) placeholder).stop();
    }
    PicassoDrawable drawable =
        new PicassoDrawable(context, bitmap, placeholder, loadedFrom, noFade, debugging);
    //为ImageView添加图片
    target.setImageDrawable(drawable);
  }
}

三、总结

经过上述源码分析，想必大家都已了解Picasso是如何从网络下载图片并加载到ImageView的。这里，直接用流程图作简要总结： Picasso工作流程

其中，橙线为发送过程调用链，绿线为返回过程调用链。主要步骤如下：
1）在Picasso中创建RequestCreator；
2）创建并提交Action至Dispatcher；
3）Dispatcher创建BitmapHunter并交给线程池执行；
4）BitmapHunter调用ResourceHandler及Downloader下载图片；
5）图片下载成功后，返回BitmapHunter并由Dispatcher负责分发；
6）Picasso收到下载成功的消息后，回调Action的complete()方法，将图片加载到ImageView上。

最后

本文作为Picasso源码解析系列的第一篇，目标是从源码入手，梳理Picasso加载图片的工作流程，掌握其主要思路。如大家对Picasso框架的实现细节感兴趣，欢迎关注该系列的后续文章。如对本文有疑问，欢迎留言交流。如需要转载，则请注明出处。