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 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 extraRequestHandlers, Stats stats,
      Bitmap.Config defaultBitmapConfig, boolean indicatorsEnabled, boolean loggingEnabled) {
    //省略其他代码

    //分发器
    this.dispatcher = dispatcher;
    //请求处理器
    List allRequestHandlers =
        new ArrayList(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()默认提供了四种重载:
Picasso图片加载框架 —— 源码解析(一)_第1张图片
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 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 copy = new ArrayList(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 batch = (List) 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 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 {
  @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图片加载框架 —— 源码解析(一)_第2张图片
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框架的实现细节感兴趣,欢迎关注该系列的后续文章。如对本文有疑问,欢迎留言交流。如需要转载,则请注明出处。

你可能感兴趣的:(Picasso图片加载框架 —— 源码解析(一))