盒子
盒子
文章目录
  1. Producer
  2. Result处理
  3. Producer的兄弟姐妹
    1. Bitmap缓存系列Producer
    2. 未解码图片的内存缓存与磁盘缓存系列Producer
    3. 网络请求Producer
  4. 总结

Fresco源码分析之Producer

2017.12.28 Rouse android  热度 ℃

Fresco有三级缓存，分别为Bitmap缓存、未解码图片的内存缓存与磁盘缓存。如果这三级缓存没有找到对应请求的图片时，才会走网络请求这条路。那么Fresco又是怎么管理这些缓存，或者说如何从这些步骤中获取到最终的Result并且返回给UI层的呢？这个时候就该Producer出场了。

Producer

首先Producer是一个接口，它内部就一个待实现的方法produceResults

1
2
3
4
5
6
7
8
9
10
public interface Producer<T> {
 
  /**
   * Start producing results for given context. Provided consumer is notified whenever progress is
   * made (new value is ready or error occurs).
   * @param consumer
   * @param context
   */
  void produceResults(Consumer<T> consumer, ProducerContext context);
}

Producer主要用来执行对图片资源获取的多样方式处理。例如：网络方式、磁盘缓存方式、内存缓存方式、解码方式与一些旋转变换等操作。这里的Consumer主要作为回调，由于Producer多样方式的处理逻辑是通过内部递归的方式进行的，所以递归回调处理是必不可少的；同时对于内部递归时一些数据的传递，则是通过ProducerContext来进行。ProducerContext只是一个接口，提供获取需要传递的数据的抽象方法。

Result处理

我们先来看下最终的Producer返回的Result的处理方式。看下它是如果将数据传递给UI层，使得UI更新加载的图片视图。

在上一篇关于Controller的文章中，提到对于DataSource是通过ImagePipeline中的fetchDecodeImage方法获取的。我们来重温它的方法实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public DataSource<CloseableReference<CloseableImage>> fetchDecodedImage(
    ImageRequest imageRequest,
    Object callerContext,
    ImageRequest.RequestLevel lowestPermittedRequestLevelOnSubmit) {
  try {
    Producer<CloseableReference<CloseableImage>> producerSequence =
        mProducerSequenceFactory.getDecodedImageProducerSequence(imageRequest);
    return submitFetchRequest(
        producerSequence,
        imageRequest,
        lowestPermittedRequestLevelOnSubmit,
        callerContext);
  } catch (Exception exception) {
    return DataSources.immediateFailedDataSource(exception);
  }
}

在这里我们如愿看到了Producer，它的内部递归先不看，我们先看下一步submitFetchRequest。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
private <T> DataSource<CloseableReference<T>> submitFetchRequest(
    Producer<CloseableReference<T>> producerSequence,
    ImageRequest imageRequest,
    ImageRequest.RequestLevel lowestPermittedRequestLevelOnSubmit,
    Object callerContext) {
  final RequestListener requestListener = getRequestListenerForRequest(imageRequest);
 
  try {
    ImageRequest.RequestLevel lowestPermittedRequestLevel =
        ImageRequest.RequestLevel.getMax(
            imageRequest.getLowestPermittedRequestLevel(),
            lowestPermittedRequestLevelOnSubmit);
    SettableProducerContext settableProducerContext = new SettableProducerContext(
        imageRequest,
        generateUniqueFutureId(),
        requestListener,
        callerContext,
        lowestPermittedRequestLevel,
      /* isPrefetch */ false,
        imageRequest.getProgressiveRenderingEnabled() ||
            imageRequest.getMediaVariations() != null ||
            !UriUtil.isNetworkUri(imageRequest.getSourceUri()),
        imageRequest.getPriority());
    return CloseableProducerToDataSourceAdapter.create(
        producerSequence,
        settableProducerContext,
        requestListener);
  } catch (Exception exception) {
    return DataSources.immediateFailedDataSource(exception);
  }
}

在这里让我们定位到SettableProducerContext，它实现了ProducerContext接口，用来对producerSequence的内部递归的数据传递。例如：ImageRequest、Id、ProducerListener与RequestLevel等。

那么下一步就是真正的DataSource的创建CloseableProducerToDataSourceAdapter.creat()。它继承于AbstractProducerToDataSourceAdapter，它的父类AbstractDataSource实现了DataSource接口。在AbstractProducerToDataSourceAdapter的构造方法中能够找到我们想要的东西。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
protected AbstractProducerToDataSourceAdapter(
    Producer<T> producer,
    SettableProducerContext settableProducerContext,
    RequestListener requestListener) {
  mSettableProducerContext = settableProducerContext;
  mRequestListener = requestListener;
  mRequestListener.onRequestStart(
      settableProducerContext.getImageRequest(),
      mSettableProducerContext.getCallerContext(),
      mSettableProducerContext.getId(),
      mSettableProducerContext.isPrefetch());
  //PostprocessedBitmapMemoryCacheProducer
  producer.produceResults(createConsumer(), settableProducerContext);
}

settableProducerContext数据传递使用的出神入化。调用了Producer的produceResults方法，开启递归调用各个Producer，因为每一个Producer的produceResults方法中如果没有获取到最终的图片资源，都会调用下一个Producer的produceResults方法，最终通过Consumer回调到最初的Producer中，即createConsumer()方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
private Consumer<T> createConsumer() {
  return new BaseConsumer<T>() {
    @Override
    protected void onNewResultImpl(@Nullable T newResult, @Status int status) {
      AbstractProducerToDataSourceAdapter.this.onNewResultImpl(newResult, status);
    }
 
    @Override
    protected void onFailureImpl(Throwable throwable) {
      AbstractProducerToDataSourceAdapter.this.onFailureImpl(throwable);
    }
 
    @Override
    protected void onCancellationImpl() {
      AbstractProducerToDataSourceAdapter.this.onCancellationImpl();
    }
 
    @Override
    protected void onProgressUpdateImpl(float progress) {
      AbstractProducerToDataSourceAdapter.this.setProgress(progress);
    }
  };
}

在createConsumer()中分别调用了onNewResultImpl、onFailureImpl、setProgress与onCancellationImpl方法。分别代表成功的回调、失败的回调、请求进度回调与请求取消回调。对于前三回调都会触发AbstractDataSource中的notifyDataSubscribers()方法。例如onNewResultImpl方法

1
2
3
4
5
6
7
8
9
10
11
12
protected void onNewResultImpl(@Nullable T result, int status) {
  boolean isLast = BaseConsumer.isLast(status);
  //setResult将结果传入AbstractDataSource中
  if (super.setResult(result, isLast)) {
    if (isLast) {
      mRequestListener.onRequestSuccess(
          mSettableProducerContext.getImageRequest(),
          mSettableProducerContext.getId(),
          mSettableProducerContext.isPrefetch());
    }
  }
}

调用了父类的super.setResult()方法。

1
2
3
4
5
6
7
8
protected boolean setResult(@Nullable T value, boolean isLast) {
  //将从Producer中获取都的数据源保存到mResult中,外部可以通过getResult获取。
  boolean result = setResultInternal(value, isLast);
  if (result) {
    notifyDataSubscribers();
  }
  return result;
}

Result保存到DataSource中的mResult中，在之前的Controller中，就可以通过调用DataSource的getResult方法获取请求的Result。Controller对DataSource的订阅也将通过notifyDataSubscribers()方法进行通知。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
private void notifyDataSubscribers() {
  final boolean isFailure = hasFailed();
  final boolean isCancellation = wasCancelled();
  //通知所有的订阅者
  for (Pair<DataSubscriber<T>, Executor> pair : mSubscribers) {
    notifyDataSubscriber(pair.first, pair.second, isFailure, isCancellation);
  }
}
 
private void notifyDataSubscriber(
    final DataSubscriber<T> dataSubscriber,
    final Executor executor,
    final boolean isFailure,
    final boolean isCancellation) {
  executor.execute(
      new Runnable() {
        @Override
        public void run() {
          if (isFailure) {
            dataSubscriber.onFailure(AbstractDataSource.this);
          } else if (isCancellation) {
            dataSubscriber.onCancellation(AbstractDataSource.this);
          } else {
            dataSubscriber.onNewResult(AbstractDataSource.this);
          }
        }
      });
}

executor.execute()方法解释了一切。调用了Controller中传递过来的dataSubscriber的各个回调。那么Result的处理过程就走通了。

如需了解Controller，推荐阅读Fresco源码分析之Controller

Producer的兄弟姐妹

接下来我们来认识下Producer的家庭成员。回到最初的fetchDecodedImage()方法，我们找到如下代码。

1
2
Producer<CloseableReference<CloseableImage>> producerSequence =
    mProducerSequenceFactory.getDecodedImageProducerSequence(imageRequest);

Producer的家庭成员的出生地都是ProducerSequenceFactory工厂。最先出生的是解码了的ImageProducer成员。通过getDecodeImageProducerSquence()方法获取。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public Producer<CloseableReference<CloseableImage>> getDecodedImageProducerSequence(
    ImageRequest imageRequest) {
  //通过Uri类型来获取不同的请求队列
  Producer<CloseableReference<CloseableImage>> pipelineSequence =
      getBasicDecodedImageSequence(imageRequest);
 
  // 通过ImageRequestBuilder.setPostprocessor()设置, 一般为null。
  // 作用是用来对获取到的Bitmap进行加工处理。例如：添加水印等。
  if (imageRequest.getPostprocessor() != null) {
    pipelineSequence = getPostprocessorSequence(pipelineSequence);
  }
 
  //一般用来实验，ImagePipelineConfig.Builder->ImagePipelineExperiments->setBitmapPrepareToDraw
  //所以正常情况都为false
  if (mUseBitmapPrepareToDraw) {
    pipelineSequence = getBitmapPrepareSequence(pipelineSequence);
  }
  return pipelineSequence;
}

上面代码的注释已经很清楚了，正常的流程只需关注getBasicDecodedImageSequence()方法。其它的都是对获取到的Result进行加工处理，并不是真正的Result获取步骤。那么继续看getBasicDecodedImageSequence。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
private Producer<CloseableReference<CloseableImage>> getBasicDecodedImageSequence(
    ImageRequest imageRequest) {
  Preconditions.checkNotNull(imageRequest);
 
  Uri uri = imageRequest.getSourceUri();
  Preconditions.checkNotNull(uri, "Uri is null.");
 
  switch (imageRequest.getSourceUriType()) {
    case SOURCE_TYPE_NETWORK:
      return getNetworkFetchSequence();
    case SOURCE_TYPE_LOCAL_VIDEO_FILE:
      return getLocalVideoFileFetchSequence();
    case SOURCE_TYPE_LOCAL_IMAGE_FILE:
      return getLocalImageFileFetchSequence();
    case SOURCE_TYPE_LOCAL_CONTENT:
      if (MediaUtils.isVideo(mContentResolver.getType(uri))) {
        return getLocalVideoFileFetchSequence();
      }
      return getLocalContentUriFetchSequence();
    case SOURCE_TYPE_LOCAL_ASSET:
      return getLocalAssetFetchSequence();
    case SOURCE_TYPE_LOCAL_RESOURCE:
      return getLocalResourceFetchSequence();
    case SOURCE_TYPE_QUALIFIED_RESOURCE:
      return getQualifiedResourceFetchSequence();
    case SOURCE_TYPE_DATA:
      return getDataFetchSequence();
    default:
      throw new IllegalArgumentException(
          "Unsupported uri scheme! Uri is: " + getShortenedUriString(uri));
  }
}

到这里就是一个分水岭，根据ImageRequest的SourceUriType，来决定不同类型资源的获取方式。这里以SOURCE_TYPE_NETWORK进行详细分析，getNetworkFetchSequence是网络请求的获取方法。

1
2
3
4
5
6
7
private synchronized Producer<CloseableReference<CloseableImage>> getNetworkFetchSequence() {
  if (mNetworkFetchSequence == null) {
    mNetworkFetchSequence =
        newBitmapCacheGetToDecodeSequence(getCommonNetworkFetchToEncodedMemorySequence());
  }
  return mNetworkFetchSequence;
}

文章开头已经提及到Fresco有三级缓存：Bitmap缓存、未解码图片的内存缓存与磁盘缓存。根据上面的代码首先的从Bitmap缓存到图片解码，Bitmap缓存在newBitmapCacheGetToDecodeSequence中。至于图片解码直接调用了DecodeProducer进行实现。

Bitmap缓存系列Producer

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
private Producer<CloseableReference<CloseableImage>> newBitmapCacheGetToDecodeSequence(
    Producer<EncodedImage> inputProducer) {
  //解码Producer,对于图片的解码操作都在DecodeProducer中进行
  DecodeProducer decodeProducer = mProducerFactory.newDecodeProducer(inputProducer);
  //获取Bitmap缓存资源
  return newBitmapCacheGetToBitmapCacheSequence(decodeProducer);
}

  private Producer<CloseableReference<CloseableImage>> newBitmapCacheGetToBitmapCacheSequence(
    Producer<CloseableReference<CloseableImage>> inputProducer) {
  BitmapMemoryCacheProducer bitmapMemoryCacheProducer =
      mProducerFactory.newBitmapMemoryCacheProducer(inputProducer);
  BitmapMemoryCacheKeyMultiplexProducer bitmapKeyMultiplexProducer =
      mProducerFactory.newBitmapMemoryCacheKeyMultiplexProducer(bitmapMemoryCacheProducer);
  ThreadHandoffProducer<CloseableReference<CloseableImage>> threadHandoffProducer =
      mProducerFactory.newBackgroundThreadHandoffProducer(
          bitmapKeyMultiplexProducer,
          mThreadHandoffProducerQueue);
  return mProducerFactory.newBitmapMemoryCacheGetProducer(threadHandoffProducer);
}

在获取Bitmap缓存的过程中依次使用了BitmapMemoryCacheGetProducer、ThreadHandoffProducer、BitmapMemoryCacheKeyMultiplexProducer与BitmapMemoryCacheProducer。

如果想了解如果获取Bitmap缓存可以直接查看BitmapMemoryCacheProducer。由于篇幅受限，这里不对各个Producer内部实现细节进行解析，后续会单独开篇幅进行分析内部实现。

未解码图片的内存缓存与磁盘缓存系列Producer

回到之前的getNetworkFetchSequence方法，如果Bitmap缓存没有获取到最终的结果，那么会进入getCommonNetworkFetchToEncodedMemorySequence，进一步通过未解码的图片内存缓存与网络请求获取。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
private synchronized Producer<EncodedImage> getCommonNetworkFetchToEncodedMemorySequence() {
  if (mCommonNetworkFetchToEncodedMemorySequence == null) {
    //未解码的图片缓存与磁盘缓存->网络请求
    Producer<EncodedImage> inputProducer =
        newEncodedCacheMultiplexToTranscodeSequence(
            mProducerFactory.newNetworkFetchProducer(mNetworkFetcher));
    //对图片的Meta Data进行转换
    mCommonNetworkFetchToEncodedMemorySequence =
        ProducerFactory.newAddImageTransformMetaDataProducer(inputProducer);
    //对JPEG格式的图片进行缩放与旋转操作
    mCommonNetworkFetchToEncodedMemorySequence =
        mProducerFactory.newResizeAndRotateProducer(
            mCommonNetworkFetchToEncodedMemorySequence,
            mResizeAndRotateEnabledForNetwork,
            mUseDownsamplingRatio);
  }
  return mCommonNetworkFetchToEncodedMemorySequence;
}

在这里首先会进行一些转换操作，例如：ResizeAndRotateProducer作用是对JPEG格式的图片根据EXIF的orientation与指定的rotation进行缩放与旋转操作。之后就是AddImageTransformMetaDataProducer对图片的Meta Data进行转换。最后调用newEncodedCacheMultiplexToTranscodeSequence进行未解码的图片缓存与磁盘缓存操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
private Producer<EncodedImage> newEncodedCacheMultiplexToTranscodeSequence(
    Producer<EncodedImage> inputProducer) {
  //对webp图片进行转码
  if (WebpSupportStatus.sIsWebpSupportRequired &&
      (!mWebpSupportEnabled || WebpSupportStatus.sWebpBitmapFactory == null)) {
    inputProducer = mProducerFactory.newWebpTranscodeProducer(inputProducer);
  }
  //磁盘缓存
  inputProducer = newDiskCacheSequence(inputProducer);
  //未解码的图片缓存
  EncodedMemoryCacheProducer encodedMemoryCacheProducer =
      mProducerFactory.newEncodedMemoryCacheProducer(inputProducer);
  //进行多路复用操作，通过未解码的缓存作为key,来获取对应的request
  return mProducerFactory.newEncodedCacheKeyMultiplexProducer(encodedMemoryCacheProducer);
}

所以它的调用链是：EncodedCacheKeyMultiplexProducer -> EncodedMemoryCacheProducer -> newDiskCacheSequence -> WebpTranscodeProducer。

如果以上步骤都没有获取到最终的结果，那么将正式进入网络获取。入口在mProducerFactory.newNetworkFetchProducer(mNetworkFetcher))方法中，对应的Producer为NetworkFetchProducer。

网络请求Producer

网络请求是最终的获取方式，下面对NetworkFetchProducer进行简要分析，直接看它的最终方法produceResults。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@Override
public void produceResults(Consumer<EncodedImage> consumer, ProducerContext context) {
  context.getListener()
      .onProducerStart(context.getId(), PRODUCER_NAME);
  //保存fetch的请求状态信息(Consumer,ProducerContext)
  final FetchState fetchState = mNetworkFetcher.createFetchState(consumer, context);
  mNetworkFetcher.fetch(
      fetchState, new NetworkFetcher.Callback() {
        @Override
        public void onResponse(InputStream response, int responseLength) throws IOException {
          //该response即为最终请求图片的uri响应资源
          NetworkFetchProducer.this.onResponse(fetchState, response, responseLength);
        }
 
        @Override
        public void onFailure(Throwable throwable) {
          NetworkFetchProducer.this.onFailure(fetchState, throwable);
        }
 
        @Override
        public void onCancellation() {
          NetworkFetchProducer.this.onCancellation(fetchState);
        }
      });
}

首先通过mNetworkFetcher创建了FetchState，mNetworkFetcher是网络层请求方式，如果没有特别指定，默认使用HttpUrlConnection，对应为HttpUrlConnectionNetworkFetcher。接下来调了fetch方法，正式发起网络请求，细节实现在mNetworkFetcher中。对应的回调响应为onResponse、onFailure与onCancellation，这里拿onResponse步骤进行分析。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
private void onResponse(
    FetchState fetchState,
    InputStream responseData,
    int responseContentLength)
    throws IOException {
  final PooledByteBufferOutputStream pooledOutputStream;
  //获取pooledOutputStream
  if (responseContentLength > 0) {
    pooledOutputStream = mPooledByteBufferFactory.newOutputStream(responseContentLength);
  } else {
    pooledOutputStream = mPooledByteBufferFactory.newOutputStream();
  }
  final byte[] ioArray = mByteArrayPool.get(READ_SIZE);
  try {
    int length;
    while ((length = responseData.read(ioArray)) >= 0) {
      if (length > 0) {
        //将数据写入pooledOutputStream中
        pooledOutputStream.write(ioArray, 0, length);
        //定时触发consumer回调
        maybeHandleIntermediateResult(pooledOutputStream, fetchState);
        float progress = calculateProgress(pooledOutputStream.size(), responseContentLength);
        //进度更新
        fetchState.getConsumer().onProgressUpdate(progress);
      }
    }
    mNetworkFetcher.onFetchCompletion(fetchState, pooledOutputStream.size());
    //全部数据获取完毕，回调Consumer
    handleFinalResult(pooledOutputStream, fetchState);
  } finally {
    mByteArrayPool.release(ioArray);
    pooledOutputStream.close();
  }
}

通过上面的注释解析，主要的方法就两个：maybeHandleIntermediateResult与handleFinalResult，他们都是对网络请求的结果进行发送传递，他们的内部实现都是调用notifyConsumer方法进行回调通知。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
private void maybeHandleIntermediateResult(
    PooledByteBufferOutputStream pooledOutputStream,
    FetchState fetchState) {
  final long nowMs = SystemClock.uptimeMillis();
  //时间间隔大于等于100毫秒进行通知
  if (shouldPropagateIntermediateResults(fetchState) &&
      nowMs - fetchState.getLastIntermediateResultTimeMs() >= TIME_BETWEEN_PARTIAL_RESULTS_MS) {
    fetchState.setLastIntermediateResultTimeMs(nowMs);
    fetchState.getListener()
        .onProducerEvent(fetchState.getId(), PRODUCER_NAME, INTERMEDIATE_RESULT_PRODUCER_EVENT);
    notifyConsumer(
        pooledOutputStream,
        fetchState.getOnNewResultStatusFlags(),
        fetchState.getResponseBytesRange(),
        fetchState.getConsumer());
  }
}
 
private void handleFinalResult(
    PooledByteBufferOutputStream pooledOutputStream,
    FetchState fetchState) {
  Map<String, String> extraMap = getExtraMap(fetchState, pooledOutputStream.size());
  ProducerListener listener = fetchState.getListener();
  listener.onProducerFinishWithSuccess(fetchState.getId(), PRODUCER_NAME, extraMap);
  listener.onUltimateProducerReached(fetchState.getId(), PRODUCER_NAME, true);
  notifyConsumer(
      pooledOutputStream,
      Consumer.IS_LAST | fetchState.getOnNewResultStatusFlags(),
      fetchState.getResponseBytesRange(),
      fetchState.getConsumer());
}

它们最主要的区别是maybeHandleIntermediateResult是间隔性的调用notifyConsumer通知回调者。那么我们来看最终的回调通知方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
private void notifyConsumer(
    PooledByteBufferOutputStream pooledOutputStream,
    @Consumer.Status int status,
    @Nullable BytesRange responseBytesRange,
    Consumer<EncodedImage> consumer) {
  //对于PooledByteBuffer构建可关闭引用CloseableReference
  CloseableReference<PooledByteBuffer> result =
      CloseableReference.of(pooledOutputStream.toByteBuffer());
  EncodedImage encodedImage = null;
  try {
    //保存到EncodedImage中
    encodedImage = new EncodedImage(result);
    encodedImage.setBytesRange(responseBytesRange);
    //解析MetaData
    encodedImage.parseMetaData();
    //回调通知
    consumer.onNewResult(encodedImage, status);
  } finally {
    EncodedImage.closeSafely(encodedImage);
    CloseableReference.closeSafely(result);
  }
}

首先对结果进行封装，保存到EncodedImage中，然后通过Consumer回调onNewResult方法将encodedImage传递到上一层的Producer系列，即之前所进过的流程，对其进行未解码的图片缓存与磁盘缓存操作。简单的说就是通过Consumer对结果进行一系列的解码、转换、缓存等操作，最终获取到Bitmap，传递给UI层进行图片更新设置。

HttpUrlConnectionNetworkFetcher的具体实现，有兴趣的可以自行查看源码，内部就是使用HttpUrlConnection进行网络资源请求与解析。

到这里整个的Producer调用流程就结束了，最终结果都会回到开篇分析的Result处理，AbstractProducerToDataSourceAdapter中的onNewResultImpl方法，通过super.setResult(result, isLast)传递结果与通知UI层更新UI。

总结

最后对Producer的整个调用流程做个总结，这里就直接使用源码中的注释调用链，主要可划分为三大部分，分别为：
swallow result if prefetch -> bitmap cache get ->
background thread hand-off -> multiplex -> bitmap cache -> decode -> multiplex ->
encoded cache -> disk cache -> (webp transcode) -> network fetch
分别对应Bitmap缓存获取、图片解码、未解码图片缓存获取、磁盘缓存获取与网络请求获取。

支持一下
赞赏是一门艺术