Glide-源码分析(三)

正文

第一篇文章介绍了下第一次加载网络图片的流程。第二篇文章介绍了下加载过图片，然后重启app，从磁盘加载图片的流程。这一篇介绍下，已经加载过图片，没有重启app，直接从内存加载图片。我们这里说的加载图片是指同一个url的图片，不同的url就相当于第一次加载，这里就不再赘述了。

虽然说是加载同样的url的图片。但是也是分很多种情况的。这边举3个例子，来分析。

相同的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。当然这里还有个判断。

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

看options中是否设置不支持内存缓存以及之前的请求是否以及完成。

所以第二次相同的target加载图片的话，会进入if里面

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

把这一次生成的request对象回收后，开始请求之前的request

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

因为之前这个Request已经请求过了，所以参数status==Status.COMPLETE。所以直接调用onResourceReady，没有发起真正的请求。使用了之前缓存的。

不同的target

我们还是从前面的into方法开始，显然不同的target肯定不会进if语句里面了。还是走requestManager.track(target, request)。

这里让大家更清楚点，就再完整的过一遍.

//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();
        ...

看到这个MSG_COMPLETE 大家应该很熟悉，可以去看下第一篇文章，最终加载好图片之后，发送下这个消息。然后图片就缓存再内存里了。