Picasso 載入圖片的流程分析

Picasso 是一款老牌的圖片載入器，特別小巧，功能上雖然比不上 Glide 和 Fresco。但是一般的圖片載入需求都能滿足。關鍵是 square 出品，JakeWharton 大神主導的專案，必屬精品，和自家的 OkHtttp 無縫銜接。

分析版本： 2.5.2

  Picasso.with(this)
        .load("https://www.kaochong.com/static/imgs/ic_course_logo_92e76ec.png")
        .into(imageView);
複製程式碼

with()

看了幾個開源庫，都是一個套路，先用門面模式提供一個單例給外部訪問，這裡是 Picasso，其他開源框架如 EventBus，Retrofit 都是一樣的。因為開源需要滿足很多 feature 避免不了使用一堆引數，建造者模式也是很常見的，幾乎每個開源庫必備。

  public static Picasso with(Context context) {
    if (singleton == null) {
      synchronized (Picasso.class) {
        if (singleton == null) {
          singleton = new Builder(context).build();
        }
      }
    }
    return singleton;
  }
複製程式碼

load()

接著看 load 方法:

load 有 4 個過載方法：

1. load(Uri)
2. load(String)
3. load(File)
4. load(int)

分別對應載入不同的來源。 這個方法會構造一個 RequestCreator 物件並返回。這個 RequestCreator 看名字就知道，是負責建立圖片請求的。RequestCreator 和 Request 的區別在於，Request 是最終建立完成的請求，所有關於圖片的資訊都在這個請求裡，包括圖片大小，圖片怎麼轉換，圖片是否有漸變動畫等等。而 RequestCreator 是一個 Request 的生產者，負責把請求引數組合然後建立成一個 Request。

    Picasso.with(this).load("url").placeholder()
        .resize()
        .transform()
        .error()
        .noFade()
        .networkPolicy()
        .centerCrop()
        .into(imageview);
複製程式碼

上面這段程式碼中，load() 返回的是 RequestCreator 物件，後面從 placeholder() 到 into() 都是 RequestCreator 的中的方法。直到在 into() 中才會把最終圖片請求 Request 物件構造出來處理。所以之前都是一堆引數的設定。

以 load(String) 為例看看內部的操作：

 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));
  }
複製程式碼

load(String) 其實呼叫的是 load(Uri):

public RequestCreator load(Uri uri) {
    return new RequestCreator(this, uri, 0);
}
複製程式碼

RequestCreator 的構造中，傳入了 picasso 例項，用傳入的 Uri、resourceId、預設 Bitmap 引數在內部構造一個 Request.Builder 例項，用於拼接後續引數最終 build 出一個 Request 例項。

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;
    this.data = new Request.Builder(uri, resourceId, picasso.defaultBitmapConfig);
}
複製程式碼

後面的 error()、placeholder() 等等就很簡單了，就是把引數進行賦值修改。

into()

關鍵的地方來了。 into 有 4 個過載方法：

1. into(Target)
2. into(RemoteViews,int,int,Notification)
3. into(RemoteViews,int,int[])
4. into(ImageView)
5. into(ImageView,Callback)

第 1 個用於實現了 Target 介面的物件，第 2、3 用於 RemoteView 的載入，分別用於通知和桌面小部件。4 和 5 就是我們常用的方法，把圖片載入到 ImageView, 區別是 5 有回撥。這 5 個流程基本是一樣，我們就看 5 來看看載入的具體過程。

  public void into(ImageView target, Callback callback) {
    // 獲取載入的開始時間，納秒級別的，因為載入很快的
    long started = System.nanoTime();
    // 檢查是否在主執行緒
    checkMain();

    // target 不能為空，不然沒法載入
    if (target == null) {
      throw new IllegalArgumentException("Target must not be null.");
    }

    // 沒圖片就設定佔點陣圖
    if (!data.hasImage()) {
      picasso.cancelRequest(target);
      if (setPlaceholder) {
        setPlaceholder(target, getPlaceholderDrawable());
      }
      return;
    }

    // 如果是 fit 模式，圖片自適應控制元件的大小，需要等 View layout 完確定寬和高再載入。這裡採用的是監聽 OnPreDraw 介面的方法。
    if (deferred) {
    // fit 模式不能指定圖片大小，和 resize 衝突
      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 request = createRequest(started);
    // 建立 Request key 用於快取 Request
    String requestKey = createKey(request);

    // 首先從記憶體中查詢，記憶體中有就把這個請求取消，直接從記憶體載入
    if (shouldReadFromMemoryCache(memoryPolicy)) {
      Bitmap bitmap = picasso.quickMemoryCacheCheck(requestKey);
      if (bitmap != null) {
        picasso.cancelRequest(target);
        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());
    }
    
    // 構造出 Action 
    Action action =
        new ImageViewAction(picasso, target, request, memoryPolicy, networkPolicy, errorResId,
            errorDrawable, requestKey, tag, callback, noFade);
    // 將 Action 入隊執行
    picasso.enqueueAndSubmit(action);
  }

複製程式碼

into 中會檢查呼叫程式碼是否在主執行緒，因為要更新 View，還有回撥，肯定要在主執行緒。然後判斷是否有圖片的源地址，如果給的是個 null，那麼直接就終止請求了。如果設定了 fit 模式(自適應 ImageView 的寬和高)，fit 模式和 resize 衝突，既然自適應寬高了，肯定就不能指定寬高。自適應 ImageView 的寬和高需要等待測量完成後得到寬高再繼續請求，否則得到的寬高是 0，Picasso 使用 ViewTreeObserver 監聽 ImageView 的 OnPreDrawListener 介面來獲取寬和高，詳細的程式碼可以看 DeferredRequestCreator 這個類。

然後建立出最終的 Request，此時的 Request 就代表了最終的圖片請求資訊。然後沒有直接去請求，而是去快取中查詢，有的話就直接取消請求從記憶體中載入。沒有的話就建立一個 ImageViewAction , 它是 Action 的子類。載入到不同的 Target 會使用不同的 Action。載入到 Target 使用 TargetAction。載入到通知就使用 NotificationAction。可以去其他的 into 方法中檢視原始碼。

Action是一個抽象類， 內部封裝了圖片的請求資訊，以及當前圖片請求的其他引數（快取策略，網路策略，是否取消了請求，Tag, 是否有動畫等等）。需要子類實現 2 個方法：

// 解析圖片完成後拿到 Bitmap，子類定義如何顯示
 abstract void complete(Bitmap result, VanGogh.LoadedFrom from);
// 解析傳送錯誤
 abstract void error(Exception e);
複製程式碼

這下可以理解它為啥叫 Action 了，它需要子類自己處理 Bitmap。定義自己的 Action (行為), 成功拿到 Bitmap 怎麼辦，發生錯誤了怎麼辦？

ImageViewAction 的實現很簡單，內部通過自定義 BitmapDrawable 來繪製自己的影象，實現漸變。載入錯誤的時候就放置佔點陣圖。

接著看這最後一行 picasso.enqueueAndSubmit(action); 看看把 action 扔到哪去處理了。

 void enqueueAndSubmit(Action action) {
    Object target = action.getTarget();
    if (target != null && targetToAction.get(target) != action) {
    // 取消原來 target 的 action，將新的 action 存入    
      cancelExistingRequest(target);
      targetToAction.put(target, action);
    }
    submit(action);
  }

  void submit(Action action) {
    dispatcher.dispatchSubmit(action);
  }
  
  void dispatchSubmit(Action action) {
    handler.sendMessage(handler.obtainMessage(REQUEST_SUBMIT, action));
  }
  
 void performSubmit(Action action, boolean dismissFailed) {
    // 處理暫停的請求
    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;
    }
    
    // 將 action 合併，action 的 key 是根據 Request 中圖片引數生成的，
    // 這裡的意思就是如果圖片請求完全一樣，只是 Action 不一樣，只需要請求一次拿到 Bitmap 就行，
    // 因為圖片資訊完全相同，一個 Request 對應了對個 Action
    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.future = service.submit(hunter);
    // 快取 hunter
    hunterMap.put(action.getKey(), hunter);
    // 是否移除請求失敗的 Action
    if (dismissFailed) {
      failedActions.remove(action.getTarget());
    }
  }
複製程式碼

跟蹤可以發現交給 Dispatcher 中的 handler 處理了。

在 performSubmit() 中重點看 forRequest() 方法構造出 BitmapHunter 例項。

static BitmapHunter forRequest(Picasso picasso, Dispatcher dispatcher, Cache cache, Stats stats,
      Action action) {
    Request request = action.getRequest();
    List<RequestHandler> requestHandlers = 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);
}
複製程式碼

forRequest() 中遍歷所有的 RequestHandler。誰能處理 Action 就處理這個 Action。這是典型的責任鏈模式- 《JAVA與模式》之責任鏈模式。

在 Picasso 例項初始化的時候就把這些 RequestHandler 都加入了列表中。

Picasso(Context context, Dispatcher dispatcher, Cache cache, Listener listener,
      RequestTransformer requestTransformer, List<RequestHandler> extraRequestHandlers...) {
  
    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);

    
  }
複製程式碼

每個 RequestHandler 重寫 canHandleRequest 來表明自己能處理哪種請求。

BitmapHunter 是一個 Runnable, 構造之後交給執行緒池處理。來看看 BitmapHunter 的 run()。

  @Override public void run() {
    try {
      updateThreadName(data);
      // 解析圖片得到 Bitmap
      result = hunt();
    
        // 由 dispatcher 分發解析圖片的結果。
      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);
    }
  }
複製程式碼

首先由 hunt() 方法解析出 Bitmap，再把解析後的結果交給 Dispatcher 來分發，成功了咋樣，失敗了咋樣，失敗了是否重試。Dispatcher 在 Picasso 中扮演了重要的角色，負責整個流程的排程。

看看 hunt() 是怎麼解析出 Bitmap 的。首先還是從記憶體中取，每個 RequestHandler 物件都持有了下載器，用於下載網路圖片。網路圖片下載完是一個流需要解析成 Bitmap，非網路的就直接得到一個 Bitmap。最後在處理變換操作得到最終的 bitmap。

  Bitmap hunt() throws IOException {
    Bitmap bitmap = null;
    
    // 從記憶體快取中取
    if (shouldReadFromMemoryCache(memoryPolicy)) {
      bitmap = cache.get(key);
      if (bitmap != null) {
      // 統計 快取命中
        stats.dispatchCacheHit();
        loadedFrom = MEMORY;
        return bitmap;
      }
    }
    
    data.networkPolicy = retryCount == 0 ? NetworkPolicy.OFFLINE.index : networkPolicy;
    // 用下載器請求url得到結果
    RequestHandler.Result result = requestHandler.load(data, networkPolicy);
    if (result != null) {
      loadedFrom = result.getLoadedFrom();
      exifRotation = result.getExifOrientation();

      bitmap = result.getBitmap();

        // 從流中解析出 Bitmap
      if (bitmap == null) {
        InputStream is = result.getStream();
        try {
          bitmap = decodeStream(is, data);
        } finally {
          Utils.closeQuietly(is);
        }
      }
    }
    
    if (bitmap != null) {
        // 解碼
      stats.dispatchBitmapDecoded(bitmap);
      if (data.needsTransformation() || exifRotation != 0) {
        // 同一時間只處理一個 bitmap
        synchronized (DECODE_LOCK) {
          if (data.needsMatrixTransform() || exifRotation != 0) {
            bitmap = transformResult(data, bitmap, exifRotation);
           
          }
          if (data.hasCustomTransformations()) {
            bitmap = applyCustomTransformations(data.transformations, bitmap);
            
          }
        }
    
      }
    }

    return bitmap;
  }
複製程式碼

Dispatcher 內部例項化了一個 HandlerThread，所有的排程都是通過這個子執行緒上執行，通過這個子執行緒的 Handler 和 主執行緒的 Handler 以及執行緒池互相通訊。

解析圖片的得到 Bitmap 後，Dispatcher 會排程到 dispatchComplete，跟蹤程式碼走到 performComplete。

void performComplete(BitmapHunter hunter) {
    // 是否寫入記憶體快取
    if (shouldWriteToMemoryCache(hunter.getMemoryPolicy())) {
      cache.set(hunter.getKey(), hunter.getResult());
    }
    hunterMap.remove(hunter.getKey());
    // 批處理 hunter
    batch(hunter);
    
}

// 執行批處理  
void performBatchComplete() {
    List<BitmapHunter> copy = new ArrayList<BitmapHunter>(batch);
    batch.clear();
    mainThreadHandler.sendMessage(mainThreadHandler.obtainMessage(HUNTER_BATCH_COMPLETE, copy));
    logBatch(copy);
}
複製程式碼

最終將一批 BitmapHunter 打包一起扔給主執行緒處理。跟蹤程式碼到 Picasso 類中的主執行緒的 Handler, 遍歷執行 complete(hunter)

@SuppressWarnings("unchecked") List<BitmapHunter> batch = (List<BitmapHunter>) msg.obj;
          //noinspection ForLoopReplaceableByForEach
          for (int i = 0, n = batch.size(); i < n; i++) {
            BitmapHunter hunter = batch.get(i);
            hunter.picasso.complete(hunter);
}
複製程式碼

complete(hunter) 中將呼叫 Action 的 complete/error 方法進行最後一步把 Bitmap 顯示到 target 上，並進行相應的成功或者失敗回撥。

總結

引用一下blog.happyhls.me的圖（自己懶得畫了%>_<%），上面的流程可以總結成：

看原始碼的過程中發現 Dispatcher 裡面一堆 handler send message，和 ActivityThread 中 H 和 AMS 通訊很像，都用 Handler 來進行通訊。Handler 真是 Android 的精髓。