Android圖片加載框架Picasso源碼分析（基於Picasso 2.71828）

時間  2019-11-29
標籤 android 圖片 加載 框架 picasso 源碼 分析 基於 2.71828 欄目 Android 简体版
原文   原文鏈接

Picasso 是 Android 開發中最受歡迎的圖片請求加載框架之一 ，它誕生於 2013 年，距今已有五年的生命。在這五年間 Picasso 發佈過 21 個版本更新，而最近的一次更新爲今年的 3 月 8 日，更新的版本號爲 2.71828（文中統稱爲新版），該版本離上一次發佈更新相隔了三年。本文主要分析新版 Picasso 的源碼實現和它的一些 API 變化。html

1. 新版 Picasso 的使用

新版 Picasso 最直觀的變化就是在 App 中的調用方式爲：java

Picasso.get().load(url).into(imageView);
複製代碼

該調用跟原來版本的調用區別是，沒有了須要傳 Context 的 with 方法，取而代之是一個不須要傳參的 get 方法來獲取全局惟一 Picasso 實例。android

本文也主要經過分析 Picasso.get().load(url).into(imageView) 該句調用的前因後果來理清新版 Picasso 框架的實現原理。git

2. Picasso 實例的獲取

Picasso 實例是經過調用 Picasso 類中的靜態方法 get 獲取的，該方法也是新版 Picasso 的入口，咱們從該方法開始看起：github

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 關鍵字來修飾，目的是爲了防止重排序。app

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. 參考

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程