阅读 633

Android图片加载框架Picasso源码分析(基于Picasso 2.71828)

Picasso 是 Android 开发中最受欢迎的图片请求加载框架之一 ,它诞生于 2013 年,距今已有五年的生命。在这五年间 Picasso 发布过 21 个版本更新,而最近的一次更新为今年的 3 月 8 日,更新的版本号为 2.71828(文中统称为新版),该版本离上一次发布更新相隔了三年。本文主要分析新版 Picasso 的源码实现和它的一些 API 变化。

1. 新版 Picasso 的使用

新版 Picasso 最直观的变化就是在 App 中的调用方式为:

Picasso.get().load(url).into(imageView);
复制代码

该调用跟原来版本的调用区别是,没有了需要传 Context 的 with 方法,取而代之是一个不需要传参的 get 方法来获取全局唯一 Picasso 实例。

本文也主要通过分析 Picasso.get().load(url).into(imageView) 该句调用的来龙去脉来理清新版 Picasso 框架的实现原理。

2. Picasso 实例的获取

Picasso 实例是通过调用 Picasso 类中的静态方法 get 获取的,该方法也是新版 Picasso 的入口,我们从该方法开始看起:

static volatile Picasso singleton = null;

public static Picasso get() {
  if (singleton == null) {
    synchronized (Picasso.class) {
      if (singleton == null) {
        if (PicassoProvider.context == null) {
          throw new IllegalStateException("context == null");
        }
        singleton = new Builder(PicassoProvider.context).build();
      }
    }
  }
  return singleton;
}
复制代码

上面这段代码是一个非常经典的双重检查锁模式 (Double Checked Locking Pattern)。

首先进入 get 方法即检查一次 Picasso 实例 singleton 是否为 null,不为 null 就可以直接返回该实例。

接着进入到同步块,因为可能会一个线程进入同步块后创建完对象后退出,另一个线程又紧接着进入同步块,因此进入同步块后需要再检查一次 singleton 是否为 null,如果还为 null,这时候可以开始初始化该实例。

最后静态变量 singleton 需要用 volatile 关键字来修饰,目的是为了防止重排序。

2.1 使用 ContentProvider 获取 Context

新版 Picasso 提供给我们的入口方法 get 不需要传 Context,因为它使用的是 PicassoProvider 类中的 context,我们看一下 PicassoProvider 类:

public final class PicassoProvider extends ContentProvider {

  @SuppressLint("StaticFieldLeak") static Context context;

  @Override public boolean onCreate() {
    context = getContext();
    return true;
  }
    
}
复制代码

PicassoProvider 类继承自 ContentProvider,除了 onCreate 方法,其他方法都是默认实现 (为了节省篇幅,省略了该部分代码),而 onCreate 方法也只是调用 getContext 方法并赋值给静态变量 context,然后返回 true 表示成功加载了该 ContentProvider。

Picasso 这么做的理由是,只要将 PicassoProvider 在 AndroidManifest 文件中注册,那么 App 在启动的时候,系统就会自动回调 PicassoProvider 的 onCreate 方法,因此也就自动获取到了 Context。

2.2 Picasso 实例的创建

接着回到 Picasso.get 方法中,Picasso 实例通过该句代码创建:

singleton = new Builder(PicassoProvider.context).build();
复制代码

这里使用到了常用的 Builder 设计模式。当一个类的属性过多,通过构造函数构造一个对象过于复杂时,可以选择使用 Builder 设计模式来简化对象的构造过程。

看下 Picasso 类中静态内部类 Builder 的构造函数:

public Builder(@NonNull Context context) {
  if (context == null) {
    throw new IllegalArgumentException("Context must not be null.");
  }
  this.context = context.getApplicationContext();
}
复制代码

该构造函数确保传进来的 Context 实例不为 null,然后获取全局的 Application Context。

接着是 Picasso.Builder 类中的 build 方法:

private final Context context;
private Downloader downloader;
private ExecutorService service;
private Cache cache;
private Listener listener;
private RequestTransformer transformer;
private List<RequestHandler> requestHandlers;
private Bitmap.Config defaultBitmapConfig;

public Picasso build() {
  Context context = this.context;
  // 配置下载器 Downloader,用于从网络下载图片资源,默认为 OkHttp3Downloader
  if (downloader == null) {
    downloader = new OkHttp3Downloader(context);
  }
  // 配置缓存 Cache,用来保存最近查看使用的图片,默认为 LruCache
  if (cache == null) {
    cache = new LruCache(context);
  }
  // 配置 ExecutorService,默认为 PicassoExecutorService
  // 后面 Bitmap 的获取任务就在该线程池中完成
  if (service == null) {
    service = new PicassoExecutorService();
  }
  // 配置 RequestTransformer 实例
  if (transformer == null) {
    transformer = RequestTransformer.IDENTITY;
  }
  // 创建 Stats 实例,Stats 类用来进行一些统计,如缓存命中数,图片下载数等
  Stats stats = new Stats(cache);
  // 创建 Dispatcher 实例,Dispatcher 类顾名思义,它的作用就是用来分发处理
  // 各种图片操作事件的如提交图片请求事件,图片获取完成事件等;
  // 传入前面配置好的对象和 HANDLER 实例给 Dispatcher 类构造函数
  // 该 HANDLER 在主线程接收处理事件,后面获取到 Bitmap 后需要回调到
  // 该 HANDLER 的 handleMessage 方法中以便将 Bitmap 切换回主线程显示
  Dispatcher dispatcher = new Dispatcher(context, service, HANDLER, downloader, cache, stats);
  // 传入前面配置好的一系列参数,创建 Picasso 实例
  return new Picasso(context, dispatcher, cache, listener, transformer, requestHandlers, stats,
      defaultBitmapConfig, indicatorsEnabled, loggingEnabled);
}
复制代码

该方法的逻辑与相关类作用已在注释中进行了说明。

接下来看 Picasso 类的构造函数:

private final Listener listener;
private final RequestTransformer requestTransformer;
private final CleanupThread cleanupThread;
private final List<RequestHandler> requestHandlers;

final Context context;
final Dispatcher dispatcher;
final Cache cache;
final Stats stats;
final Map<Object, Action> targetToAction;
final Map<ImageView, DeferredRequestCreator> targetToDeferredRequestCreator;
final ReferenceQueue<Object> referenceQueue;
final Bitmap.Config defaultBitmapConfig;

boolean indicatorsEnabled;
volatile boolean loggingEnabled;

boolean shutdown;

Picasso(Context context, Dispatcher dispatcher, Cache cache, Listener listener, RequestTransformer requestTransformer, List<RequestHandler> extraRequestHandlers, Stats stats,Bitmap.Config defaultBitmapConfig, boolean indicatorsEnabled, boolean loggingEnabled) {
  // 一些赋值操作
  this.context = context;
  this.dispatcher = dispatcher;
  this.cache = cache;
  this.listener = listener;
  this.requestTransformer = requestTransformer;
  this.defaultBitmapConfig = defaultBitmapConfig;
  // Picasso 默认包含七个内置 RequestHandler 分别用来处理七种不同类型的请求
  // 你也可以自己继承 RequestHandler 类来处理你的自定义请求
  // 自定义请求放在 extraRequestHandlers 中
  int builtInHandlers = 7;
  int extraCount = (extraRequestHandlers != null ? extraRequestHandlers.size() : 0);
  List<RequestHandler> allRequestHandlers = new ArrayList<>(builtInHandlers + extraCount);
  // 添加 ResourceRequestHandler,用于处理加载图片资源 id 的情况
  // ResourceRequestHandler 需要第一个进行添加
  // 避免其他的 RequestHandler 检查 (request.resourceId != 0) 的情况
  allRequestHandlers.add(new ResourceRequestHandler(context));
  // 然后添加自定义的 RequestHandler (如果有的话)
  if (extraRequestHandlers != null) {
    allRequestHandlers.addAll(extraRequestHandlers);
  }
  // 添加 ContactsPhotoRequestHandler,用于处理手机联系人图片
  allRequestHandlers.add(new ContactsPhotoRequestHandler(context));
  // 添加 MediaStoreRequestHandler,用于处理 content://media/ 开头的 URI
  allRequestHandlers.add(new MediaStoreRequestHandler(context));
  // 添加 ContentStreamRequestHandler,用于处理 scheme 为 content 的 URI
  allRequestHandlers.add(new ContentStreamRequestHandler(context));
  // 添加 AssetRequestHandler,用于处理 file:///android_asset/ 开头的 URI
  allRequestHandlers.add(new AssetRequestHandler(context));
  // 添加 FileRequestHandler,用于处理 scheme 为 file 的 URI
  allRequestHandlers.add(new FileRequestHandler(context));
  // 添加 NetworkRequestHandler,用于处理 http 或 https 图片 url
  allRequestHandlers.add(new NetworkRequestHandler(dispatcher.downloader, stats));
  // 调用 Collections 的静态方法 unmodifiableList 
  // 返回一个不能进行修改操作的 List 实例,防止 requestHandlers 被修改
  requestHandlers = Collections.unmodifiableList(allRequestHandlers);
  this.stats = stats;
  this.targetToAction = new WeakHashMap<>();
  this.targetToDeferredRequestCreator = new WeakHashMap<>();
  this.indicatorsEnabled = indicatorsEnabled;
  this.loggingEnabled = loggingEnabled;
  this.referenceQueue = new ReferenceQueue<>();
  this.cleanupThread = new CleanupThread(referenceQueue, HANDLER);
  this.cleanupThread.start();
}
复制代码

到这里 Picasso 实例就创建完毕了。

2.3 Dispatcher 实例的创建

Picasso.Builder 类的 build 方法在创建 Picasso 实例前先创建了 Dispatcher 类的实例,Dispatcher 类对后面分发处理图片事件至关重要,这里先看一下它的构造函数:

final DispatcherThread dispatcherThread;
final Context context;
final ExecutorService service;
final Downloader downloader;
final Map<String, BitmapHunter> hunterMap;
final Map<Object, Action> failedActions;
final Map<Object, Action> pausedActions;
final Set<Object> pausedTags;
final Handler handler;
final Handler mainThreadHandler;
final Cache cache;
final Stats stats;
final List<BitmapHunter> batch;
final NetworkBroadcastReceiver receiver;
final boolean scansNetworkChanges;

boolean airplaneMode;

Dispatcher(Context context, ExecutorService service, Handler mainThreadHandler,
    Downloader downloader, Cache cache, Stats stats) {
  // 创建静态内部类 DispatcherThread 的实例并启动
  this.dispatcherThread = new DispatcherThread();
  this.dispatcherThread.start();
  this.context = context;
  this.service = service;
  this.hunterMap = new LinkedHashMap<>();
  this.failedActions = new WeakHashMap<>();
  this.pausedActions = new WeakHashMap<>();
  this.pausedTags = new LinkedHashSet<>();
  // 创建静态内部类 DispatcherHandler 的实例
  this.handler = new DispatcherHandler(dispatcherThread.getLooper(), this);
  this.downloader = downloader;
  // 保存前面 Picasso 类传进来的主线程 HANDLER
  this.mainThreadHandler = mainThreadHandler;
  this.cache = cache;
  this.stats = stats;
  this.batch = new ArrayList<>(4);
}
复制代码

该构造函数首先创建了 DispatcherThread 实例,而后面 DispatcherHandler 实例的创建用到了 DispatcherThread 中的 Looper。

DispatcherThread 和 DispatcherHandler 都是 Dispatcher 中的静态内部类:

static class DispatcherThread extends HandlerThread {
  DispatcherThread() {
    super(Utils.THREAD_PREFIX + DISPATCHER_THREAD_NAME, THREAD_PRIORITY_BACKGROUND);
  }
}
复制代码
private static class DispatcherHandler extends Handler {
  private final Dispatcher dispatcher;

  DispatcherHandler(Looper looper, Dispatcher dispatcher) {
    super(looper);
    this.dispatcher = dispatcher;
  }

  @Override public void handleMessage(final Message msg) {
    switch (msg.what) {
      case REQUEST_SUBMIT: {
        Action action = (Action) msg.obj;
        dispatcher.performSubmit(action);
        break;
      }
      case HUNTER_COMPLETE: {
        BitmapHunter hunter = (BitmapHunter) msg.obj;
        dispatcher.performComplete(hunter);
        break;
      }
      default:
        Picasso.HANDLER.post(new Runnable() {
          @Override public void run() {
            throw new AssertionError("Unknown handler message received: " + msg.what);
          }
        });
    }
  }
}
复制代码

可以看到,DispatcherThread 继承自 HandlerThread,而 DispatcherHandler 实例是通过 DispatcherThread 的 Looper 创建的,因此 DispatcherHandler 发送的消息将切换到工作线程 (即 DispatcherThread) 中处理,即 DispatcherHandler 的 handleMessage 方法会在工作线程中执行。

3. Picasso 类中的 load 方法

获取到 Picasso 实例后,紧接着调用 Picasso 类的 load 方法,该方法主要作用就是创建并返回一个 RequestCreator 实例。

RequestCreator 类的主要作用就是创建 Request 对象,并提供了一系列的 into 方法来开始图片请求。

先来看一下 Picasso 类中的 load 方法:

public RequestCreator load(@Nullable String path) {
  // 如果传进来的 path 为 null,创建并返回一个
  // Uri 为 null 的 RequestCreator 对象。
  if (path == null) {
    return new RequestCreator(this, null, 0);
  }
  // 如果 path 为空字符串,抛出异常。
  if (path.trim().length() == 0) {
    throw new IllegalArgumentException("Path must not be empty.");
  }
  return load(Uri.parse(path));
}
复制代码

最后 path 不为 null 也不为空字符串,则调用 Uri.parse(path) 方法对 path 进行解析并返回 一个 Uri 对象传给 load(@Nullable Uri uri) 方法。

public RequestCreator load(@Nullable Uri uri) {
  return new RequestCreator(this, uri, 0);
}
复制代码

该方法创建并返回一个 RequestCreator 实例,看一下 RequestCreator 类的构造函数:

private final Picasso picasso;
private final Request.Builder data;

RequestCreator(Picasso picasso, Uri uri, int resourceId) {
  this.picasso = picasso;
  this.data = new Request.Builder(uri, resourceId, picasso.defaultBitmapConfig);
}
复制代码

可以看到 RequestCreator 对象持有了 Picasso 的一份引用,然后创建了 Request.Builder 类的实例 data,这里又用到了 Builder 设计模式。

Request.Builder 的构造函数为:

Builder(Uri uri, int resourceId, Bitmap.Config bitmapConfig) {
  this.uri = uri;
  this.resourceId = resourceId;
  this.config = bitmapConfig;
}
复制代码

到这里 RequestCreator 就创建完成了,接下来就可以调用 RequestCreator 类中的许多方法,如 placeholder 方法,centerCrop 方法等,我们这里直接前往 into 方法。

4. RequestCreator 类的 into 方法

经过 load 方法后,紧接着就来到了 into 方法,该方法是整个 API 调用流程的最后一步,可以说是整个调用流程的重头戏,因此篇幅也比较大。

我们往 into 方法传的是 ImageView 实例,看一下该方法源码:

public void into(ImageView target) {
  into(target, null);
}
复制代码
public void into(ImageView target, Callback callback) {
  // 记录开始处理的时间戳
  long started = System.nanoTime();
  // 检查当前方法是否在主线程进行调用,如果不是抛出异常
  checkMain();
  // ImageView 实例 target 不能为 null,否则抛异常
  if (target == null) {
    throw new IllegalArgumentException("Target must not be null.");
  }
  // data 即前面的 Request.Builder 实例
  // 如果 data 中没有图片(例如传入的 path 为 null)
  // 直接对该 target 取消请求,并设置占位图如果有设置 placeholder
  if (!data.hasImage()) {
    picasso.cancelRequest(target);
    if (setPlaceholder) {
      setPlaceholder(target, getPlaceholderDrawable());
    }
    return;
  }
  // 创建 Request 实例
  Request request = createRequest(started);
  // 为当前 Request 生成一个 requestKey,用来标记 Request
  String requestKey = createKey(request);
  // 如果当前的 memoryPolicy 允许从缓存中读取图片
  // 从 Cache 中获取 requestKey 对应的 Bitmap,如果该 Bitmap 存在
  // 则取消当前请求,直接为 target 设置该 Bitmap
  if (shouldReadFromMemoryCache(memoryPolicy)) {
    Bitmap bitmap = picasso.quickMemoryCacheCheck(requestKey);
    if (bitmap != null) {
      picasso.cancelRequest(target);
      setBitmap(target, picasso.context, bitmap, MEMORY, noFade, picasso.indicatorsEnabled);
      if (callback != null) {
        callback.onSuccess();
      }
      return;
    }
  }

  // 前面缓存中没有查找到图片,从这里开始请求
  // 先设置 placeholder 如果有配置的话 
  if (setPlaceholder) {
    setPlaceholder(target, getPlaceholderDrawable());
  }

  // 创建一个 ImageViewAction 的实例
  Action action = new ImageViewAction(picasso, target, request, memoryPolicy, networkPolicy, errorResId,
          errorDrawable, requestKey, tag, callback, noFade);
  // 向 picasso 提交该 Action 实例
  picasso.enqueueAndSubmit(action);
}
复制代码

这里省略了部分与 Picasso.get().load(uri).into(imageView) 调用不相关的代码,代码中的注释只是大致逻辑流程,接下来按 into 方法的代码逻辑对一些细节进行分析。

4.1 设置占位图 (placeholder) 的实现

从 into 方法中可以看到,有两处需要设置占位图,设置占位图的逻辑是:

if (setPlaceholder) {
  setPlaceholder(target, getPlaceholderDrawable());
}
复制代码

看一下 getPlaceholderDrawable 方法:

private Drawable getPlaceholderDrawable() {
  if (placeholderResId != 0) {
    if (Build.VERSION.SDK_INT >= 21) {
      return picasso.context.getDrawable(placeholderResId);
    } else if (Build.VERSION.SDK_INT >= 16) {
      return picasso.context.getResources().getDrawable(placeholderResId);
    } else {
      TypedValue value = new TypedValue();
      picasso.context.getResources().getValue(placeholderResId, value, true);
      return picasso.context.getResources().getDrawable(value.resourceId);
    }
  } else {
    return placeholderDrawable;
  }
}
复制代码

该方法根据当前运行的 Android SDK 版本进行不同的方法调用来通过 placeholderResId 获取到一个 Drawable 实例。

获取到占位图 Drawable 后接下来就可以进行设置了,setPlaceholder 方法为 PicassoDrawable 类中的静态方法,调用该方法后 ImageView 就可以显示占位图了。

static void setPlaceholder(ImageView target, Drawable placeholderDrawable) {
  target.setImageDrawable(placeholderDrawable);
  if (target.getDrawable() instanceof Animatable) {
    ((Animatable) target.getDrawable()).start();
  }
}
复制代码

4.2 Request 实例的创建

Request 对象是通过 createRequest 方法创建的:

private static final AtomicInteger nextId = new AtomicInteger();

private Request createRequest(long started) {
  // 为 Request 实例分配下一个 id
  int id = nextId.getAndIncrement();
  // 创建 Request 实例
  Request request = data.build();
  request.id = id;
  request.started = started;
  return request;
}
复制代码

Request 实例通过调用 Request.Builder 类的 build 方法创建:

public Request build() {
  // 先验证当前的配置参数是否合法
  // centerInside 和 centerCrop 方法不能同时用
  if (centerInside && centerCrop) {
    throw new IllegalStateException("Center crop and center inside can not be used together.");
  }
  // centerCrop 方法需要与 resize 方法同用
  if (centerCrop && (targetWidth == 0 && targetHeight == 0)) {
    throw new IllegalStateException(
        "Center crop requires calling resize with positive width and height.");
  }
  // centerInside 方法需要与 resize 方法同用
  if (centerInside && (targetWidth == 0 && targetHeight == 0)) {
    throw new IllegalStateException(
        "Center inside requires calling resize with positive width and height.");
  }
  // 设置 priority
  if (priority == null) {
    priority = Priority.NORMAL;
  }
  // 创建 Request 实例
  return new Request(uri, resourceId, stableKey, transformations, targetWidth, targetHeight,
      centerCrop, centerInside, centerCropGravity, onlyScaleDown, rotationDegrees,
      rotationPivotX, rotationPivotY, hasRotationPivot, purgeable, config, priority);
}
复制代码

该方法在最后一步创建了 Request 实例,看一下 Request 类的构造函数:

public final Uri uri;
public final int resourceId;
public final String stableKey;
public final List<Transformation> transformations;
public final int targetWidth;
public final int targetHeight;
public final boolean centerCrop;
public final int centerCropGravity;
public final boolean centerInside;
public final boolean onlyScaleDown;
public final float rotationDegrees;
public final float rotationPivotX;
public final float rotationPivotY;
public final boolean hasRotationPivot;
public final boolean purgeable;
public final Bitmap.Config config;
public final Priority priority;

private Request(Uri uri, int resourceId, String stableKey, List<Transformation> transformations,
    int targetWidth, int targetHeight, boolean centerCrop, boolean centerInside,
    int centerCropGravity, boolean onlyScaleDown, float rotationDegrees,
    float rotationPivotX, float rotationPivotY, boolean hasRotationPivot,
    boolean purgeable, Bitmap.Config config, Priority priority) {
  // 图片的 Uri,与 resourceId 不能共存
  this.uri = uri;
  // 图片的 resourceId,与 Uri 不能共存
  this.resourceId = resourceId;
  this.stableKey = stableKey;
  // 用来对 Bitmap 进行转换的一系列 Transformation
  if (transformations == null) {
    this.transformations = null;
  } else {
    this.transformations = unmodifiableList(transformations);
  }
  // resize 方法设置的图片宽度和高度
  this.targetWidth = targetWidth;
  this.targetHeight = targetHeight;
  // 图片 scaleType 是否为 centerCrop,与 centerInside 不共存
  this.centerCrop = centerCrop;
  // 图片 scaleType 是否为 centerInside,与 centerCrop 不共存
  this.centerInside = centerInside;
  // 如果设置了 centerCrop,centerCropGravity 用来设置中心的偏移量
  this.centerCropGravity = centerCropGravity;
  this.onlyScaleDown = onlyScaleDown;
  // 图片旋转的度数
  this.rotationDegrees = rotationDegrees;
  this.rotationPivotX = rotationPivotX;
  this.rotationPivotY = rotationPivotY;
  this.hasRotationPivot = hasRotationPivot;
  this.purgeable = purgeable;
  this.config = config;
  // 当前请求的优先级
  this.priority = priority;
}
复制代码

Request 实例创建完毕。

4.3 requestKey 的创建

requestKey 用来标识一个 Request,requestKey 通过调用 createKey 方法实现:

static final StringBuilder MAIN_THREAD_KEY_BUILDER = new StringBuilder();

static String createKey(Request data) {
  String result = createKey(data, MAIN_THREAD_KEY_BUILDER);
  MAIN_THREAD_KEY_BUILDER.setLength(0);
  return result;
}
复制代码
static String createKey(Request data, StringBuilder builder) {
  if (data.stableKey != null) {
    builder.ensureCapacity(data.stableKey.length() + KEY_PADDING);
    builder.append(data.stableKey);
  } else if (data.uri != null) {
    String path = data.uri.toString();
    builder.ensureCapacity(path.length() + KEY_PADDING);
    builder.append(path);
  } else {
    builder.ensureCapacity(KEY_PADDING);
    builder.append(data.resourceId);
  }
  builder.append(KEY_SEPARATOR);

  if (data.rotationDegrees != 0) {
    builder.append("rotation:").append(data.rotationDegrees);
    if (data.hasRotationPivot) {
      builder.append('@').append(data.rotationPivotX).append('x').append(data.rotationPivotY);
    }
    builder.append(KEY_SEPARATOR);
  }
  if (data.hasSize()) {
    builder.append("resize:").append(data.targetWidth).append('x').append(data.targetHeight);
    builder.append(KEY_SEPARATOR);
  }
  if (data.centerCrop) {
    builder.append("centerCrop:").append(data.centerCropGravity).append(KEY_SEPARATOR);
  } else if (data.centerInside) {
    builder.append("centerInside").append(KEY_SEPARATOR);
  }

  if (data.transformations != null) {
    for (int i = 0, count = data.transformations.size(); i < count; i++) {
      builder.append(data.transformations.get(i).key());
      builder.append(KEY_SEPARATOR);
    }
  }

  return builder.toString();
}
复制代码

该方法根据当前 Request 配置的参数来生成对应的 requestKey。

4.4 MemoryPolicy 的实现

into 方法通过调用 shouldReadFromMemoryCache 方法来判断是否应该从 Cache 中读取当前 requestKey 对应的 Bitmap。

shouldReadFromMemoryCache 方法是枚举类型 MemoryPolicy 中的一个静态方法,MemoryPolicy 源码如下:

public enum MemoryPolicy {

  NO_CACHE(1 << 0),
  NO_STORE(1 << 1);

  static boolean shouldReadFromMemoryCache(int memoryPolicy) {
    return (memoryPolicy & MemoryPolicy.NO_CACHE.index) == 0;
  }

  static boolean shouldWriteToMemoryCache(int memoryPolicy) {
    return (memoryPolicy & MemoryPolicy.NO_STORE.index) == 0;
  }

  final int index;

  MemoryPolicy(int index) {
    this.index = index;
  }
    
}
复制代码

可以看到 MemoryPolicy 用到了一些位操作。

MemoryPolicy 共两种枚举类型,NO_CACHE 和 NO_STORE,NO_CACHE 的 index 为 1 (二进制为 1),NO_STORE 的 index 为 2 (二进制为 10)。

shouldReadFromMemoryCache 方法返回 true 如果 (memoryPolicy & MemoryPolicy.NO_CACHE.index) == 0 ,即 memoryPolicy 为 0 。返回 true 表示当前 memoryPolicy 允许从 Cache 中读取图片。

shouldWriteToMemoryCache 方法在满足 (memoryPolicy & MemoryPolicy.NO_STORE.index) == 0 的条件下返回 true,即 memoryPolicy 为 0。返回 true 表示当前 memoryPolicy 允许向 Cache 中写入图片。

而在没有配置 memoryPolicy 的情况下,memoryPolicy 默认为 0,因此这两个方法这里都会返回 true。

4.5 Action 实例的创建

Picasso 将一次图片获取活动封装成一个 Action 实例。

Action 为抽象类,包含两个必须实现的抽象方法,complete 方法和 error 方法,分别表示该次图片获取活动完成或出错。

abstract void complete(Bitmap result, Picasso.LoadedFrom from);
abstract void error(Exception e);
复制代码

Picasso 提供了不同的 Action 子类来对应不同的图片获取活动。

我们这里用到的是 ImageViewAction,ImageViewAction 用于将获取到的 Bitmap 加载到 ImageView 中:

class ImageViewAction extends Action<ImageView> {

  Callback callback;

  ImageViewAction(Picasso picasso, ImageView imageView, Request data, int memoryPolicy,
      int networkPolicy, int errorResId, Drawable errorDrawable, String key, Object tag,
      Callback callback, boolean noFade) {
    super(picasso, imageView, data, memoryPolicy, networkPolicy, errorResId, errorDrawable, key,
        tag, noFade);
    this.callback = callback;
  }

  @Override public void complete(Bitmap result, Picasso.LoadedFrom from) {
    // 获取要加载图片进去的 ImageView
    ImageView target = this.target.get();
    if (target == null) return;
    Context context = picasso.context;
    boolean indicatorsEnabled = picasso.indicatorsEnabled;
    // 为 target 设置 Bitmap
    PicassoDrawable.setBitmap(target, context, result, from, noFade, indicatorsEnabled);
    // 回调 callback
    if (callback != null) callback.onSuccess();
  }

  @Override public void error(Exception e) {
    ImageView target = this.target.get();
    if (target == null) return;
    // 获取占位图 Drawable 实例,如果该 Drawable 实现了 Animatable 接口
    // 这时候就应该停止该 Animatable
    Drawable placeholder = target.getDrawable();
    if (placeholder instanceof Animatable) ((Animatable) placeholder).stop();
    // 设置错误情况下的图片
    if (errorResId != 0) {
      target.setImageResource(errorResId);
    } else if (errorDrawable != null) {
      target.setImageDrawable(errorDrawable);
    }
    if (callback != null) callback.onError(e);
  }

  @Override void cancel() {
    super.cancel();
    if (callback != null) callback = null;
  }
}
复制代码

可以看到 ImageViewAction 类继承自 Action,泛型参数为 ImageView 作为该 Action 的 target。

ImageViewAction 实现了 complete 方法和 error 方法并重写了 cancel 方法。

4.6 Action 实例的提交

Action 实例创建完毕后,就可以调用 Picasso 类中的 enqueueAndSubmit 方法提交该 Action 实例了,然后从这里开始一次图片获取活动,由于这部分代码过于庞大,从 enqueueAndSubmit 方法开始放在下一节分析。

5. Picasso 处理 Action 的实现

Picasso 处理 Action 从 Picasso 类的 enqueueAndSubmit 方法开始:

void enqueueAndSubmit(Action action) {
  // 省略部分代码...
  // 调用 submit 方法提交该 Action
  submit(action);
}
复制代码
void submit(Action action) {
  dispatcher.dispatchSubmit(action);
}
复制代码

submit 方法又调用了 Dispatcher 类的 dispatchSubmit 方法,Picasso 类这时候就将此 Action 交接给 Dispatcher 类进行处理。

5.1 Dispatcher 类提交 Action 的实现

Picasso 通过调用 Dispatcher 类的 dispatchSubmit 方法开始提交该 Action 实例:

void dispatchSubmit(Action action) {
  handler.sendMessage(handler.obtainMessage(REQUEST_SUBMIT, action));
}
复制代码

该方法使用 handler 发送了一条 REQUEST_SUBMIT 信息,我们在 2.3 小节中可以看到,该 handler 即 DispatcherHandler 实例,发送该消息后会在工作线程回调到 DispatcherHandler 中的 handleMessage 方法,然后从该方法接着会调用 Dispatcher 类的 performSubmit 方法:

void performSubmit(Action action) {
  performSubmit(action, true);
}
复制代码
void performSubmit(Action action, boolean dismissFailed) {
  // 创建 BitmapHunter 实例
  BitmapHunter hunter = forRequest(action.getPicasso(), this, cache, stats, action);
  // 使用配置好的 PicassoExecutorService 提交该 BitmapHunter 实例
  hunter.future = service.submit(hunter);
}
复制代码

上面的代码做了一些简化,删除了与当前逻辑无关的代码。

该方法通过调用 forRequest 方法来创建 BitmapHunter 实例,而 forRequest 方法是 BitmapHunter 类中的静态方法。

从上面的代码可以看到,接下来的工作就交给 BitmapHunter 来完成了。

5.2 BitmapHunter 类的实现

BitmapHunter 类的主要职责是结合 Action 和 RequestHandler 来获取 Bitmap 实例。

BitmapHunter 提供了静态方法 forRequest 来创建实例:

static BitmapHunter forRequest(Picasso picasso, Dispatcher dispatcher, Cache cache, Stats stats,
    Action action) {
  // 获取 Action 中的 Request 对象
  Request request = action.getRequest();
  // 获取 Picasso 配置的全部 RequestHandler
  List<RequestHandler> requestHandlers = picasso.getRequestHandlers();
  // 从下标 0 开始迭代全部 RequestHandler,如果该 RequestHandler 能
  // 处理该 Request,则用该 RequestHandler 创建 BitmapHunter 实例并返回。
  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);
    }
  }
  // 没有 RequestHandler 能处理该 Request,传入 ERRORING_HANDLER
  return new BitmapHunter(picasso, dispatcher, cache, stats, action, ERRORING_HANDLER);
}
复制代码

这里的 requestHandlers 部分用到了责任链模式 (Chains of Responsibility)。

接着看下 BitmapHunter 的构造函数:

final int sequence;
final Picasso picasso;
final Dispatcher dispatcher;
final Cache cache;
final Stats stats;
final String key;
final Request data;
final int memoryPolicy;
int networkPolicy;
final RequestHandler requestHandler;

Action action;
List<Action> actions;
Bitmap result;
Future<?> future;
Picasso.LoadedFrom loadedFrom;
Exception exception;
int exifOrientation;
int retryCount;
Priority priority;

BitmapHunter(Picasso picasso, Dispatcher dispatcher, Cache cache, Stats stats, Action action,
    RequestHandler requestHandler) {
  this.sequence = SEQUENCE_GENERATOR.incrementAndGet();
  this.picasso = picasso;
  this.dispatcher = dispatcher;
  this.cache = cache;
  this.stats = stats;
  this.action = action;
  this.key = action.getKey();
  this.data = action.getRequest();
  this.priority = action.getPriority();
  this.memoryPolicy = action.getMemoryPolicy();
  this.networkPolicy = action.getNetworkPolicy();
  this.requestHandler = requestHandler;
  this.retryCount = requestHandler.getRetryCount();
}
复制代码

BitmapHunter 类实现了 Runnable 接口,因此当前面调用 service.submit(hunter) ,BitmapHunter 类中的 run 方法会在线程池中运行:

@Override public void run() {
  try {
    result = hunt();
    if (result == null) {
      dispatcher.dispatchFailed(this);
    } else {
      dispatcher.dispatchComplete(this);
    }
  } catch (Exception e) {
    // 处理一堆异常...
  }
}
复制代码

run 方法主要通过调用 hunt 方法获取返回的 Bitmap 并赋值给 result,如果 result 不为 null,则调用 Dispatcher 类的 dispatchComplete 方法,否则调用 dispatchFailed 方法。

因此获取 Bitmap 的具体逻辑就在 hunt 方法中完成:

Bitmap hunt() throws IOException {
  Bitmap bitmap = null;
  // 先从缓存中查找 key 对应的 Bitmap,该 key 即之前创建的 requestKey
  if (shouldReadFromMemoryCache(memoryPolicy)) {
    bitmap = cache.get(key);
    if (bitmap != null) {
      stats.dispatchCacheHit();
      loadedFrom = MEMORY;
      return bitmap;
    }
  }
  // 调用 RequestHandler 的 load 方法获取 RequestHandler.Result 实例
  // Picasso 将 RequestHandler 加载的结果封装成一个 Result 对象
  // 我们这里调用的是 NetworkRequestHandler 类中的 load 方法
  RequestHandler.Result result = requestHandler.load(data, networkPolicy);
  if (result != null) {
    loadedFrom = result.getLoadedFrom();
    exifOrientation = result.getExifOrientation();
    bitmap = result.getBitmap();
	// result 中的 bitmap 为 null,将 source 中的字节流编码成 Bitmap
    if (bitmap == null) {
      Source source = result.getSource();
      try {
        bitmap = decodeStream(source, data);
      } finally {
        try {
          source.close();
        } catch (IOException ignored) {
        }
      }
    }
  }
  return bitmap;
}
复制代码

hunt 方法结束,返回获取到的 Bitmap 实例,回到 BitmapHunter 的 run 方法,这时候如果返回的 Bitmap 实例不为null,就调用 Dispatcher 类中的 dispatchComplete 方法,这样剩下的工作又交接给了 Dispatcher。

5.3 Dispatcher 类请求完成的实现

BitmapHunter 获取到不为 null 的 Bitmap 实例后,调用 Dispatcher 类中的 dispatchComplete 方法分发其完成事件:

void dispatchComplete(BitmapHunter hunter) {
  handler.sendMessage(handler.obtainMessage(HUNTER_COMPLETE, hunter));
}
复制代码

handler 发送该消息后,接着又在工作线程中回调到了 Dispatcher 类的 performComplete 方法:

void performComplete(BitmapHunter hunter) {
  if (shouldWriteToMemoryCache(hunter.getMemoryPolicy())) {
    cache.set(hunter.getKey(), hunter.getResult());
  }
  batch(hunter);
}
复制代码

这时候 Picasso 将 Bitmap 存入到了缓存中,然后调用 batch 方法:

private void batch(BitmapHunter hunter) {
  if (hunter.isCancelled()) {
    return;
  }
  if (hunter.result != null) {
    hunter.result.prepareToDraw();
  }
  batch.add(hunter);
  if (!handler.hasMessages(HUNTER_DELAY_NEXT_BATCH)) {
    handler.sendEmptyMessageDelayed(HUNTER_DELAY_NEXT_BATCH, BATCH_DELAY);
  }
}
复制代码

handler 最后发送了 HUNTER_DELAY_NEXT_BATCH 消息,发送该消息后又回调到了 Dispatcher 类的 performBatchComplete 方法:

void performBatchComplete() {
  batch.clear();  mainThreadHandler.sendMessage(mainThreadHandler.obtainMessage(HUNTER_BATCH_COMPLETE, copy));
}
复制代码

这时候发送消息的是 mainThreadHandler,切换到主线程来了,发送的消息为 HUNTER_BATCH_COMPLETE,该消息回调到了 Picasso 类中的 HANDLER 实例中:

static final Handler HANDLER = new Handler(Looper.getMainLooper()) {
  @Override public void handleMessage(Message msg) {
    switch (msg.what) {
      case HUNTER_BATCH_COMPLETE: {
        List<BitmapHunter> batch = (List<BitmapHunter>) msg.obj;
        for (int i = 0, n = batch.size(); i < n; i++) {
          BitmapHunter hunter = batch.get(i);
          hunter.picasso.complete(hunter);
        }
        break;
      }
      default:
        throw new AssertionError("Unknown handler message received: " + msg.what);
    }
  }
};
复制代码

对每个 BitmapHunter 实例调用 Picasso 类中的 complete 方法:

void complete(BitmapHunter hunter) {
  Action single = hunter.getAction();
  if (single == null) return;

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

  if (listener != null && exception != null) {
    listener.onImageLoadFailed(this, uri, exception);
  }
}
复制代码
private void deliverAction(Bitmap result, LoadedFrom from, Action action, Exception e) {
  if (action.isCancelled()) {
    return;
  }
  if (result != null) {
    if (from == null) {
      throw new AssertionError("LoadedFrom cannot be null.");
    }
    action.complete(result, from);
    }
  } else {
    action.error(e);
  }
}
复制代码

我们之前提交的是 ImageViewAction 实例,因此这时候会回调到 ImageViewAction 类的 complete 方法:

@Override public void complete(Bitmap result, Picasso.LoadedFrom from) {
  ImageView target = this.target.get();
  if (target == null) return;

  Context context = picasso.context;
  boolean indicatorsEnabled = picasso.indicatorsEnabled;
  PicassoDrawable.setBitmap(target, context, result, from, noFade, indicatorsEnabled);

  if (callback != null) {
    callback.onSuccess();
  }
}
复制代码

最后 setBitmap:

static void setBitmap(ImageView target, Context context, Bitmap bitmap,
    Picasso.LoadedFrom loadedFrom, boolean noFade, boolean debugging) {
  Drawable placeholder = target.getDrawable();
  if (placeholder instanceof Animatable) {
    ((Animatable) placeholder).stop();
  }
  PicassoDrawable drawable =
      new PicassoDrawable(context, bitmap, placeholder, loadedFrom, noFade, debugging);
  target.setImageDrawable(drawable);
}
复制代码

结束该方法后,这时候图片终于成功在界面显示了,整个调用流程到此也终于结束。

6. 参考

关注下面的标签,发现更多相似文章
评论