Fresco源码赏析之后台获取流程

1
2
3
4
5
6
7
8
9
10
11
@Override
  protected DataSource<CloseableReference<CloseableImage>> getDataSourceForRequest(
      ImageRequest imageRequest,
      Object callerContext,
      boolean bitmapCacheOnly) {
    if (bitmapCacheOnly) {
      return mImagePipeline.fetchImageFromBitmapCache(imageRequest, callerContext);
    } else {
      return mImagePipeline.fetchDecodedImage(imageRequest, callerContext);
    }
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
   * swallow result if prefetch -> bitmap cache get -> wait if scrolling ->
   * background thread hand-off -> multiplex -> bitmap cache -> decode -> multiplex ->
   * encoded cache -> disk cache -> (webp transcode) -> network fetch.
   */
  private synchronized Producer<CloseableReference<CloseableImage>> getNetworkFetchSequence() {
    if (mNetworkFetchSequence == null) {
      mNetworkFetchSequence =
          newBitmapCacheGetToDecodeSequence(getCommonNetworkFetchToEncodedMemorySequence());
    }
    return mNetworkFetchSequence;
  }

1
2
3
4
5
6
7
8
9
10
/**
   * Same as {@code newBitmapCacheGetToBitmapCacheSequence} but with an extra DecodeProducer.
   * @param nextProducer next producer in the sequence after decode
   * @return bitmap cache get to decode sequence
   */
  private Producer<CloseableReference<CloseableImage>> newBitmapCacheGetToDecodeSequence(
      Producer<CloseableReference<PooledByteBuffer>> nextProducer) {
    DecodeProducer decodeProducer = mProducerFactory.newDecodeProducer(nextProducer);//这个是对图片数据进行编码，并用一些比较复杂的算法进行扫描处理
    return newBitmapCacheGetToBitmapCacheSequence(decodeProducer);
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
   * Bitmap cache get -> wait if scrolling -> thread hand off -> multiplex -> bitmap cache
   * @param nextProducer next producer in the sequence after bitmap cache
   * @return bitmap cache get to bitmap cache sequence
   */
  private Producer<CloseableReference<CloseableImage>> newBitmapCacheGetToBitmapCacheSequence(
      Producer<CloseableReference<CloseableImage>> nextProducer) {
    BitmapMemoryCacheProducer bitmapMemoryCacheProducer =
        mProducerFactory.newBitmapMemoryCacheProducer(nextProducer);//这个是去bitmap缓存找有没有缓存，并且如果需要缓存的话将数据缓存并复制一份数据，将复制的数据返回
    BitmapMemoryCacheKeyMultiplexProducer bitmapKeyMultiplexProducer =
        mProducerFactory.newBitmapMemoryCacheKeyMultiplexProducer(bitmapMemoryCacheProducer);//这个是合并请求，如何多个请求获取的是同一张图片的画将请求合并成一个，为了只保存一份数据
    ThreadHandoffProducer<CloseableReference<CloseableImage>> threadHandoffProducer =
        mProducerFactory.newBackgroundThreadHandoffProducer(bitmapKeyMultiplexProducer);//这个是启动线程，让接下来的pruducer全都在线程中执行
    return mProducerFactory.newBitmapMemoryCacheGetProducer(threadHandoffProducer);//这个是单纯去bitmap缓存找有没有数据
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
* multiplex -> encoded cache -> disk cache -> (webp transcode) -> network fetch.
*/
private synchronized Producer<CloseableReference<PooledByteBuffer>>
getCommonNetworkFetchToEncodedMemorySequence() {
if (mCommonNetworkFetchToEncodedMemorySequence == null) {
mCommonNetworkFetchToEncodedMemorySequence =
newEncodedCacheMultiplexToTranscodeSequence(mNetworkFetchProducer, /* isLocal */false);
if (mResizeAndRotateEnabledForNetwork) {
mCommonNetworkFetchToEncodedMemorySequence =
newResizeAndRotateImagesSequence(mCommonNetworkFetchToEncodedMemorySequence);
}
}
return mCommonNetworkFetchToEncodedMemorySequence;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/**
   * encoded cache multiplex -> encoded cache -> (disk cache) -> (webp transcode)
   * @param nextProducer next producer in the sequence
   * @param isLocal whether the image source is local or not
   * @return encoded cache multiplex to webp transcode sequence
   */
  private Producer<CloseableReference<PooledByteBuffer>>
      newEncodedCacheMultiplexToTranscodeSequence(
          Producer<CloseableReference<PooledByteBuffer>> nextProducer,
          boolean isLocal) {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR2) {
      nextProducer = mProducerFactory.newWebpTranscodeProducer(nextProducer);//将获取到的图片转码
    }
    if (!isLocal) {
      nextProducer = mProducerFactory.newDiskCacheProducer(nextProducer);//将获取到的数据缓存到硬盘
    }
    EncodedMemoryCacheProducer encodedMemoryCacheProducer =
        mProducerFactory.newEncodedMemoryCacheProducer(nextProducer);//根据编码后的缓存路径寻找有没有编码后的缓存，有就返回没有就进行下一步
    return mProducerFactory.newEncodedCacheKeyMultiplexProducer(encodedMemoryCacheProducer);//根据编码后的缓存的图片请求路径，对于同一个图片路径的不同缓存的不同请求合并成一个
  }

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
	@Override
	public void produceResults(final Consumer<CloseableReference<T>> consumer, final ProducerContext producerContext) {

		final ProducerListener listener = producerContext.getListener();
		final String requestId = producerContext.getId();
		listener.onProducerStart(requestId, getProducerName());

		final K cacheKey = getCacheKey(producerContext.getImageRequest());
		CloseableReference<T> cachedReference = mMemoryCache.get(cacheKey, null);
		if (cachedReference != null) {// 不为空说明拿到的内存的缓存数据
			boolean shouldStartNextProducer = shouldStartNextProducer(cachedReference);
			if (!shouldStartNextProducer) {// 是否进行下一个produder操作，不需要就将结果返回当前的producer
				listener.onProducerFinishWithSuccess(requestId, getProducerName(),
						listener.requiresExtraMap(requestId) ? ImmutableMap.of(CACHED_VALUE_FOUND, "true") : null);
			}
			consumer.onNewResult(cachedReference, !shouldStartNextProducer);
			cachedReference.close();
			if (!shouldStartNextProducer) {
				return;
			}
		}
		// 当内存缓存没有数据说明内存数据清掉了，进行下个操作
		Consumer<CloseableReference<T>> consumerOfNextProducer;// 下一个生存者的消费者，生存者主要是用来进行获取数据的操作，消费者主要是用于处理数据的操作
		if (!shouldCacheReturnedValues()) {//如果当前生存者的消费者不需要进行数据处理，就将当前消费者指定为下个生存者的消费者，否则进行数据处理
			consumerOfNextProducer = consumer;
		} else {
			//必要的时候创建了一个新的consumer传递下去，这样对就可以对数据进行拦截
			consumerOfNextProducer = new BaseConsumer<CloseableReference<T>>() {
				@Override
				public void onNewResultImpl(CloseableReference<T> newResult, boolean isLast) {
					CloseableReference<T> cachedResult = null;//newResult这个结果是下面的生存者传递回来的数据，然后将数据返回给前一个消费者
					if (newResult != null && shouldCacheResult(newResult, cacheKey, isLast)) {
						cachedResult = mMemoryCache.cache(cacheKey, newResult);
					}

					if (cachedResult != null) {//缓存操作后通过旧的consumer将数据返回回去
						consumer.onNewResult(cachedResult, isLast);
						cachedResult.close();
					} else {
						consumer.onNewResult(newResult, isLast);
					}
				}

				@Override
				public void onFailureImpl(Throwable t) {
					consumer.onFailure(t);
				}

				@Override
				protected void onCancellationImpl() {
					consumer.onCancellation();
				}
			};
		}

		listener.onProducerFinishWithSuccess(requestId, getProducerName(),
				listener.requiresExtraMap(requestId) ? ImmutableMap.of(CACHED_VALUE_FOUND, "false") : null);
		mNextProducer.produceResults(consumerOfNextProducer, producerContext);//这里进行跳转到下个生存者
	}