Glide-源碼分析(三)

時間 2019-11-17

標籤 glide 源碼分析简体版

原文原文鏈接

正文

第一篇文章介紹了下第一次加載網絡圖片的流程。第二篇文章介紹了下加載過圖片，而後重啓app，從磁盤加載圖片的流程。這一篇介紹下，已經加載過圖片，沒有重啓app，直接從內存加載圖片。咱們這裏說的加載圖片是指同一個url的圖片，不一樣的url就至關於第一次加載，這裏就再也不贅述了。java

雖說是加載一樣的url的圖片。可是也是分不少種狀況的。這邊舉3個例子，來分析。web

相同的target，也能夠簡單理解爲相同的ImageView
不一樣的ImageView

相同的target

Glide.with(this).load("https://cdn2.jianshu.io/assets/web/nav-logo-4c7bbafe27adc892f3046e6978459bac.png").into(iv)
複製代碼

這裏咱們直接從into方法看起。緩存

private <Y extends Target<TranscodeType>> Y into( @NonNull Y target, @Nullable RequestListener<TranscodeType> targetListener, @NonNull RequestOptions options) {
  ...
    Request request = buildRequest(target, targetListener, options);

    Request previous = target.getRequest();
    //因爲以前第一次請求，因此當前的request!=以前的request。
    //可是通過一次請求後，再次請求同樣的url
    if (request.isEquivalentTo(previous)
        && !isSkipMemoryCacheWithCompletePreviousRequest(options, previous)) {
      request.recycle();   
      if (!Preconditions.checkNotNull(previous).isRunning()) {
        previous.begin();
      }
      return target;
    }

    requestManager.clear(target);
    target.setRequest(request);
    requestManager.track(target, request);

    return target;
  }
複製代碼

以前第一次請求的時候，判斷條件不成立，直接走requestManager.track(target, request);，而如今相同的target請求同樣的url，這裏會再次構建一個新的Request對象。而target也保存着以前請求過的Request對象。網絡

//SingleRequest.java
 @Override
  public boolean isEquivalentTo(Request o) {
    if (o instanceof SingleRequest) {
      SingleRequest<?> that = (SingleRequest<?>) o;
      return overrideWidth == that.overrideWidth
          && overrideHeight == that.overrideHeight
          && Util.bothModelsNullEquivalentOrEquals(model, that.model)
          && transcodeClass.equals(that.transcodeClass)
          && requestOptions.equals(that.requestOptions)
          && priority == that.priority
          && listenerCountEquals(this, that);
    }
    return false;
  }
複製代碼

這裏的Request對象實際上是SingleRequest這裏就很少介紹了。第二次請求，參數確定仍是跟第一次請求一致，因此返回true。固然這裏還有個判斷。app

private boolean isSkipMemoryCacheWithCompletePreviousRequest( RequestOptions options, Request previous) {
    return !options.isMemoryCacheable() && previous.isComplete();
  }
複製代碼

看options中是否設置不支持內存緩存以及以前的請求是否以及完成。ide

因此第二次相同的target加載圖片的話，會進入if裏面ui

request.recycle();   
      if (!Preconditions.checkNotNull(previous).isRunning()) {
        previous.begin();
      }
      return target;
    }

複製代碼

把這一次生成的request對象回收後，開始請求以前的requestthis

//SingleRequest.java
public void begin() {
  ...
    if (status == Status.COMPLETE) {
      onResourceReady(resource, DataSource.MEMORY_CACHE);
      return;
    }
....
  }
複製代碼

由於以前這個Request已經請求過了，因此參數status==Status.COMPLETE。因此直接調用onResourceReady，沒有發起真正的請求。使用了以前緩存的。url

不一樣的target

咱們仍是從前面的into方法開始，顯然不一樣的target確定不會進if語句裏面了。仍是走requestManager.track(target, request)。spa

這裏讓你們更清楚點，就再完整的過一遍.

//RequestManager.java
 void track(@NonNull Target<?> target, @NonNull Request request) {
    ...
    requestTracker.runRequest(request);
  }

//RequestTracker.java
 public void runRequest(@NonNull Request request) {
   ...
      request.begin();
    ...
  }

//SingleRequest.java
public void begin() {
   ....
      target.getSize(this);
   ...
  }
//ViewTarget.java
public void getSize(@NonNull SizeReadyCallback cb) {
    sizeDeterminer.getSize(cb);
  }

//ViewTarget.java
void getSize(@NonNull SizeReadyCallback cb) {
      ...
        ViewTreeObserver observer = view.getViewTreeObserver();
        layoutListener = new SizeDeterminerLayoutListener(this);
        observer.addOnPreDrawListener(layoutListener);
      ...
    }

//SingleRequest.java
public void onSizeReady(int width, int height) {
    ...
    loadStatus = engine.load(...);
...
  }

//Engine.java
public <R> LoadStatus load( ... EngineKey key = keyFactory.buildKey(model, signature, width, height, transformations, resourceClass, transcodeClass, options);

    EngineResource<?> active = loadFromActiveResources(key, isMemoryCacheable);
    if (active != null) {
      cb.onResourceReady(active, DataSource.MEMORY_CACHE);
     ...
      return null;
    }

    EngineResource<?> cached = loadFromCache(key, isMemoryCacheable);
    if (cached != null) {
      cb.onResourceReady(cached, DataSource.MEMORY_CACHE);
      if (VERBOSE_IS_LOGGABLE) {
        logWithTimeAndKey("Loaded resource from cache", startTime, key);
      }
      return null;
    }
...
  }
複製代碼

這裏就直接把源碼貼出，給你們過一遍，就不一步步解析了，不太熟悉的同窗能夠看下第一篇文章。那麼這邊就直接說出結果

EngineResource<?> active = loadFromActiveResources(key, isMemoryCacheable);
    if (active != null) {
      cb.onResourceReady(active, DataSource.MEMORY_CACHE);
     ...
      return null;
    }


private EngineResource<?> loadFromActiveResources(Key key, boolean isMemoryCacheable) {
    ...
    EngineResource<?> active = activeResources.get(key);
  ...
    return active;
  }
複製代碼

其實就是直接從activeResources獲取到緩存的資源直接調用onResourceReady方法。

那麼咱們這裏能夠回溯下，activeResources是何時放入資源的呢。ctrl+鼠標左鍵看下引用。

找到了2個地方，第一個地方很快就排除了。只剩下這一個，來看

//Engine.java
 public void onEngineJobComplete(EngineJob<?> engineJob, Key key, EngineResource<?> resource) {
   ...
      if (resource.isCacheable()) {
        activeResources.activate(key, resource);
      }
    }
...
  }
複製代碼

繼續找哪裏調用onEngineJobComplete，也只有2個地方，有個地方沒有傳入resource引用直接排除。

//EngineJob.java
void handleResultOnMainThread() {
    ...
    listener.onEngineJobComplete(this, key, engineResource);
...
  }

public boolean handleMessage(Message message) {
      EngineJob<?> job = (EngineJob<?>) message.obj;
      switch (message.what) {
        case MSG_COMPLETE:
          job.handleResultOnMainThread();
        ...
複製代碼