Fresco图片库研读分析

http://blog.csdn.net/lpw14/article/details/51260153

Fresco是Facebook推出的一款用于Android应用的强大图片库，相对于其他主流的图片库而言，Fresco的主要优秀特性的在于缓存和内存控制上，当然有利就有弊，Fresco的代码量大，方法数较多，阅读难度比较大，下面我们就从三个方面入手来分析Fresco

一、初始化配置

二、图片的加载与缓存

三、图片的绘制显示

关于Fresco中的一些概念和使用方法，见Fresco的官方文档http://fresco-cn.org/docs/index.html

一、初始化配置

使用Fresco的第一步，就是进行初始化，Fresco提供了两种初始化方式，一种是使用默认配置初始化，一种是使用用户自定义配置初始化。就使用而言，默认配置能完全满足我们的需要，但如果想要做更多的控制，那么可以使用自定义的配置。当然，使用自定义配置的前提，是我们要了解Fresco都提供了哪些配置，哪些配置需要我们自定义，哪些可以使用默认的配置。

默认配置初始化：

[java]  view plain  copy

 

1. /** Initializes Fresco with the default config. */  
2. public static void initialize(Context context) {  
3.   ImagePipelineFactory.initialize(context);  
4.   initializeDrawee(context);  
5. }  

自定义配置初始化：

[java]  view plain  copy

 

1. /** Initializes Fresco with the specified config. */  
2. public static void initialize(Context context, ImagePipelineConfig imagePipelineConfig) {  
3.   ImagePipelineFactory.initialize(imagePipelineConfig);  
4.   initializeDrawee(context);  
5. }  

这两种的区别就在于ImagePipelineConfig参数，此类是主配置类，主要提供了内存缓存配置，未解码的内存缓存配置，磁盘缓存配置，网络请求配置，线程池配置，缓存Key工厂配置，Pool工厂配置，渐进式Jpeg配置等等。也就是说我们在自定义配置的时候，这些都是可以自定义的，只要实现相应的接口及其接口方法即可，具体可参考默认的实现类，这里不对这些配置一一分析。

我们看默认初始化实现：

[java]  view plain  copy

 

1. /** Initializes {@link ImagePipelineFactory} with default config. */  
2. public static void initialize(Context context) {  
3.   initialize(ImagePipelineConfig.newBuilder(context).build());  
4. }  

使用builder模式构建出ImagePipelineConfig，然后进行初始化。在ImagePipelineConfig的构造方法中，那些必要的配置，如果是空实现，那么都赋值为默认的实现。因此我们在自定义配置时，不用每个配置都去自定义设置。在自定义配置时，通过ImagePipelineConfig.newBuilder(context)构建出ImagePipelineConfig.Builder类，根据其提供的方法设置自己对应的实现即可。

ImagePipelineConfig初始化完成后，接着调用了initializeDrawee(context); 我们看下这一步是做什么的。

[java]  view plain  copy

 

1. private static void initializeDrawee(Context context) {  
2.   sDraweeControllerBuilderSupplier = new PipelineDraweeControllerBuilderSupplier(context);  
3.   SimpleDraweeView.initialize(sDraweeControllerBuilderSupplier);  
4. }  

调用了SimpleDraweeView的静态初始化方法，其接受一个Supplier<? extends SimpleDraweeControllerBuilder>的参数，这个Supplier是一个接口，仅有一个get()方法，用来提供一个实例对象。在SimpleDraweeView构造方法被调用时，会调用Supplier的get()方法，将其返回的实例对象（这里是PipelineDraweeControllerBuilder）保存到SimpleDraweeView的成员变量中供后续使用。

其实initializeDrawee(context)方法提供了一种默认的实现，即PipelineDraweeControllerBuilder，Fresco同时给我们提供了另一个实现VolleyDraweeControllerBuilder，我们也可以更换为这个，当然更换后的实现细节，也都不太一样了。甚至如果我们愿意，可以自己写一个实现，只要继承AbstractDraweeControllerBuilder抽象类即可，前提是要对后续逻辑流程有足够的了解。

回头来看，初始化过程并不复杂，主要是ImagePipelineConfig的初始化构造和提供SimpleDraweeControllerBuilder的实现类。Fresco类其实就是一个入口封装，方便外部统一调用，我们完全可以不用这个类或者自己写一个封装类去实现自定义的初始化操作。

从初始化的流程，我们可以看到Fresco严格遵循面向对象的设计思想，模块分离，面向接口编程，各种设计模式的使用等都非常值得我们学习借鉴。当我们在做一个库供别人使用时，也应该像这样，定义好接口，提供一些默认的实现，方便使用者自定义自己的实现。

二、图片的加载与缓存

初始化工作做好之后，接下来就是加载显示图片了，这块是重头戏。Fresco与其他图片库最大的不同之处就是它是控件级的，自定义了一个用于显示静态图片或动画图片的视图DraweeView，我们只需要在布局中使用SimpleDraweeView替换ImageView即可，其中SimpleDraweeView在创建的时，其父类GenericDraweeView的构造方法中会构建GenericHierarchy并设置给DraweeHolder，GenericHierarchy是做什么的，我们后面会说明。

加载显示图片非常简单，调用SimpleDraweeView的以下两个方法即可

[java]  view plain  copy

 

1. setImageURI(Uri uri);  
2. setImageURI(Uri uri, @Nullable Object callerContext);  

后续就不用我们关心了， Fresco 会加载图片并缓存和显示。

我们看这两个方法具体是怎么实现的

[java]  view plain  copy

 

1. /** 
2.  * Displays an image given by the uri. 
3.  * 
4.  * @param uri uri of the image 
5.  * @undeprecate 
6.  */  
7. @Override  
8. public void setImageURI(Uri uri) {  
9.   setImageURI(uri, null);  
10. }  
11.   
12. /** 
13.  * Displays an image given by the uri. 
14.  * 
15.  * @param uri uri of the image 
16.  * @param callerContext caller context 
17.  */  
18. public void setImageURI(Uri uri, @Nullable Object callerContext) {  
19.   DraweeController controller = mSimpleDraweeControllerBuilder  
20.       .setCallerContext(callerContext)  
21.       .setUri(uri)  
22.       .setOldController(getController())  
23.       .build();  
24.   setController(controller);  
25. }  

setImageURI(Uri uri) 是 ImageView 的方法， DraweeView 继承自 ImageView ，据 Fresco 开发者称后续会直接继承 View ，所以谨慎使用继承自 ImageView 的相关方法。 setImageURI(Uri uri) 调用了两个参数的 setImageURI(Uri uri, @Nullable Object callerContext) 方法，第二个参数没太大作用，对于统计和日志记录可能会有用。方法中的 mSimpleDraweeControllerBuilder ，就是第一步初始化时传入的 Supplier 接口提供的实例。
一图胜千言，看图

此图描述了DraweeView、DraweeHierarchy、DraweeController等类之间的关系，一个简单的MVC框架设计。DraweeHolder主要用于分离DraweeHierarchy、DraweeController与DraweeView之间的强耦合。

回到setImageURI(Uri uri, @Nullable Object callerContext)方法，短短几行代码，背后做了很多的事情，我们一点点分析，首先看DraweeController是如何被build出来的。

1. setCallerContext()我们暂不关心，先看setUri(uri)方法，其内部构建了一个不可变的ImageRequest实例对象，并将其赋值给AbstractDraweeControllerBuilder的成员变量，用于后续的数据请求使用；

2. 再查看build()方法，此方法在AbstractDraweeControllerBuilder类中，其最终结果是返回一个DraweeController实例，看代码中的过程：

[java]  view plain  copy

 

1. /** Builds the specified controller. */  
2. @Override  
3. public AbstractDraweeController build() {  
4.   validate();  
5.   
6.   // if only a low-res request is specified, treat it as a final request.  
7.   if (mImageRequest == null && mMultiImageRequests == null && mLowResImageRequest != null) {  
8.     mImageRequest = mLowResImageRequest;  
9.     mLowResImageRequest = null;  
10.   }  
11.   
12.   return buildController();  
13. }  
14.   
15. /** Builds a regular controller. */  
16. protected AbstractDraweeController buildController() {  
17.   AbstractDraweeController controller = obtainController();  
18.   controller.setRetainImageOnFailure(getRetainImageOnFailure());  
19.   maybeBuildAndSetRetryManager(controller);  
20.   maybeAttachListeners(controller);  
21.   return controller;  
22. }  

obtainController()方法是个抽象方法，其实现类是第一步初始化配置时确定的，即PipelineDraweeControllerBuilder类，我们看这个方法的实现：

[java]  view plain  copy

 

1. @Override  
2. protected PipelineDraweeController obtainController() {  
3.   DraweeController oldController = getOldController();  
4.   PipelineDraweeController controller;  
5.   if (oldController instanceof PipelineDraweeController) {  
6.     controller = (PipelineDraweeController) oldController;  
7.     controller.initialize(  
8.         obtainDataSourceSupplier(),  
9.         generateUniqueControllerId(),  
10.         getCallerContext());  
11.   } else {  
12.     controller = mPipelineDraweeControllerFactory.newController(  
13.         obtainDataSourceSupplier(),  
14.         generateUniqueControllerId(),  
15.         getCallerContext());  
16.   }  
17.   return controller;  
18. }  

第一次执行时由于oldController不存在，因此会走else分支，由工场方法newController去创建，会构建出PipelineDraweeController类实例。我们看newController方法接收的三个参数，第一个参数为提供DataSource的Supplier，第二个参数Controller的唯一Id，第三个参数为前文提到的CallerContext，这三个参数将作为的PipelineDraweeController实例对象的成员变量，重点是第一个参数，跟踪 obtainDataSourceSupplier()方法， 其最终创建如下：

[java]  view plain  copy

 

1. new Supplier<DataSource<IMAGE>>() {  
2.   @Override  
3.   public DataSource<IMAGE> get() {  
4.     return getDataSourceForRequest(imageRequest, callerContext, bitmapCacheOnly);  
5.   }  
6.   @Override  
7.   public String toString() {  
8.     return Objects.toStringHelper(this)  
9.         .add("request", imageRequest.toString())  
10.         .toString();  
11.   }  
12. }  

此匿名Supplier类的get()方法会返回一个DataSource类的对象实例，我们先记录，看后面在什么时机调用其get()方法。

至此，build()方法已走完，构建出了具体的PipelineDraweeController实例对象。

再次回到SimpleDraweeView的setImageURI(Uri uri, @Nullable Object callerContext)方法，往下该执行setController(controller)方法了，我们看这个方法

[java]  view plain  copy

 

1. /** Sets the controller. */  
2. public void setController(@Nullable DraweeController draweeController) {  
3.   mDraweeHolder.setController(draweeController);  
4.   super.setImageDrawable(mDraweeHolder.getTopLevelDrawable());  
5. }  

内部两行代码，第一行将controller设置给DraweeHolder，第二行设置显示的drawable，这块我们在第三部分图片的绘制显示中进行分析，先分析第一行

[java]  view plain  copy

 

1. /** 
2.  * Sets a new controller. 
3.  */  
4. public void setController(@Nullable DraweeController draweeController) {  
5.   boolean wasAttached = mIsControllerAttached;  
6.   if (wasAttached) {  
7.     detachController();  
8.   }  
9.   
10.   // Clear the old controller  
11.   if (mController != null) {  
12.     mEventTracker.recordEvent(Event.ON_CLEAR_OLD_CONTROLLER);  
13.     mController.setHierarchy(null);  
14.   }  
15.   mController = draweeController;  
16.   if (mController != null) {  
17.     mEventTracker.recordEvent(Event.ON_SET_CONTROLLER);  
18.     mController.setHierarchy(mHierarchy);  
19.   } else {  
20.     mEventTracker.recordEvent(Event.ON_CLEAR_CONTROLLER);  
21.   }  
22.   
23.   if (wasAttached) {  
24.     attachController();  
25.   }  
26. }  

将draweeController赋值给DraweeHolder的成员变量mController，然后根据是否被Attached，来执行相应的操作。

这里补充一点，DraweeView会根据其当前是否位于屏幕的可视区域来决定图片的加载与否，比如view在滑出屏幕可视区域会停止加载，如果图片正在下载，则会取消。

[java]  view plain  copy

 

1. @Override  
2. protected void onAttachedToWindow() {  
3.   super.onAttachedToWindow();  
4.   mDraweeHolder.onAttach();  
5. }  
6.   
7. @Override  
8. protected void onDetachedFromWindow() {  
9.   super.onDetachedFromWindow();  
10.   mDraweeHolder.onDetach();  
11. }  
12.   
13. @Override  
14. public void onStartTemporaryDetach() {  
15.   super.onStartTemporaryDetach();  
16.   mDraweeHolder.onDetach();  
17. }  
18.   
19. @Override  
20. public void onFinishTemporaryDetach() {  
21.   super.onFinishTemporaryDetach();  
22.   mDraweeHolder.onAttach();  
23. }  

当DraweeView位于屏幕可视区域内时，会执行DraweeHolder的onAttach()方法，此方法内部最终调用了DraweeController的onAttach()方法，图片的加载由此正式开始，我们看AbstractDraweeController中的onAttach方法

[java]  view plain  copy

 

1. @Override  
2. public void onAttach() {  
3.   if (FLog.isLoggable(FLog.VERBOSE)) {  
4.     FLog.v(  
5.         TAG,  
6.         "controller %x %s: onAttach: %s",  
7.         System.identityHashCode(this),  
8.         mId,  
9.         mIsRequestSubmitted ? "request already submitted" : "request needs submit");  
10.   }  
11.   mEventTracker.recordEvent(Event.ON_ATTACH_CONTROLLER);  
12.   Preconditions.checkNotNull(mSettableDraweeHierarchy);  
13.   mDeferredReleaser.cancelDeferredRelease(this);  
14.   mIsAttached = true;  
15.   if (!mIsRequestSubmitted) {  
16.     submitRequest();  
17.   }  
18. }  
19.   
20. protected void submitRequest() {  
21.   mEventTracker.recordEvent(Event.ON_DATASOURCE_SUBMIT);  
22.   getControllerListener().onSubmit(mId, mCallerContext);  
23.   mSettableDraweeHierarchy.setProgress(0, true);  
24.   mIsRequestSubmitted = true;  
25.   mHasFetchFailed = false;  
26.   mDataSource = getDataSource();  
27.   if (FLog.isLoggable(FLog.VERBOSE)) {  
28.     FLog.v(  
29.         TAG,  
30.         "controller %x %s: submitRequest: dataSource: %x",  
31.         System.identityHashCode(this),  
32.         mId,  
33.         System.identityHashCode(mDataSource));  
34.   }  
35.   final String id = mId;  
36.   final boolean wasImmediate = mDataSource.hasResult();  
37.   final DataSubscriber<T> dataSubscriber =  
38.       new BaseDataSubscriber<T>() {  
39.         @Override  
40.         public void onNewResultImpl(DataSource<T> dataSource) {  
41.           // isFinished must be obtained before image, otherwise we might set intermediate result  
42.           // as final image.  
43.           boolean isFinished = dataSource.isFinished();  
44.           float progress = dataSource.getProgress();  
45.           T image = dataSource.getResult();  
46.           if (image != null) {  
47.             onNewResultInternal(id, dataSource, image, progress, isFinished, wasImmediate);  
48.           } else if (isFinished) {  
49.             onFailureInternal(id, dataSource, new NullPointerException(), /* isFinished */ true);  
50.           }  
51.         }  
52.         @Override  
53.         public void onFailureImpl(DataSource<T> dataSource) {  
54.           onFailureInternal(id, dataSource, dataSource.getFailureCause(), /* isFinished */ true);  
55.         }  
56.         @Override  
57.         public void onProgressUpdate(DataSource<T> dataSource) {  
58.           boolean isFinished = dataSource.isFinished();  
59.           float progress = dataSource.getProgress();  
60.           onProgressUpdateInternal(id, dataSource, progress, isFinished);  
61.         }  
62.       };  
63.   mDataSource.subscribe(dataSubscriber, mUiThreadImmediateExecutor);  
64. }  

看submitRequest()方法中的第六行mDataSource = getDatasource()，即获取DataSource，还记得上面我们在创建PipelineDraweeController时传入的第一个参数吗，由obtainDataSourceSupplier()方法创建的匿名类Supplier的实例，之前说我们看它的get()方法什么时候调用，OK，就是此刻，调用getDataSource()时调用。

[java]  view plain  copy

 

1. @Override  
2. protected DataSource<CloseableReference<CloseableImage>> getDataSource() {  
3.   return mDataSourceSupplier.get();  
4. }  

我们回过头看其get()方法的调用，AbstractDraweeControllerBuilder类中

[java]  view plain  copy

 

1. /** Creates a data source supplier for the given image request. */  
2. protected Supplier<DataSource<IMAGE>> getDataSourceSupplierForRequest(  
3.     final REQUEST imageRequest,  
4.     final boolean bitmapCacheOnly) {  
5.   final Object callerContext = getCallerContext();  
6.   return new Supplier<DataSource<IMAGE>>() {  
7.     @Override  
8.     public DataSource<IMAGE> get() {  
9.       return getDataSourceForRequest(imageRequest, callerContext, bitmapCacheOnly);  
10.     }  
11.     @Override  
12.     public String toString() {  
13.       return Objects.toStringHelper(this)  
14.           .add("request", imageRequest.toString())  
15.           .toString();  
16.     }  
17.   };  
18. }  

看子类PipelineDraweeControllerBuilder中的实现

[java]  view plain  copy

 

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

终于看到ImagePipeline了，ImagePipeline是发起请求以及缓存的清理与查询的入口，在ImagePipeline中创建了DataSource，我们看else分支，不限定只从cache中读取，ImagePipeline的fetchDecodedImage方法

[java]  view plain  copy

 

1. /** 
2. * Submits a request for execution and returns a DataSource representing the pending decoded 
3. * image(s). 
4. * <p>The returned DataSource must be closed once the client has finished with it. 
5. * @param imageRequest the request to submit 
6. * @return a DataSource representing the pending decoded image(s) 
7. */  
8. public DataSource<CloseableReference<CloseableImage>> fetchDecodedImage(  
9.     ImageRequest imageRequest,  
10.     Object callerContext) {  
11.   try {  
12.     Producer<CloseableReference<CloseableImage>> producerSequence =  
13.         mProducerSequenceFactory.getDecodedImageProducerSequence(imageRequest);  
14.     return submitFetchRequest(  
15.         producerSequence,  
16.         imageRequest,  
17.         ImageRequest.RequestLevel.FULL_FETCH,  
18.         callerContext);  
19.   } catch (Exception exception) {  
20.     return DataSources.immediateFailedDataSource(exception);  
21.   }  
22. }  
23.   
24. private <T> DataSource<CloseableReference<T>> submitFetchRequest(  
25.     Producer<CloseableReference<T>> producerSequence,  
26.     ImageRequest imageRequest,  
27.     ImageRequest.RequestLevel lowestPermittedRequestLevelOnSubmit,  
28.     Object callerContext) {  
29.   try {  
30.     ImageRequest.RequestLevel lowestPermittedRequestLevel =  
31.         ImageRequest.RequestLevel.getMax(  
32.             imageRequest.getLowestPermittedRequestLevel(),  
33.             lowestPermittedRequestLevelOnSubmit);  
34.     SettableProducerContext settableProducerContext = new SettableProducerContext(  
35.         imageRequest,  
36.         generateUniqueFutureId(),  
37.         mRequestListener,  
38.         callerContext,  
39.         lowestPermittedRequestLevel,  
40.       /* isPrefetch */ false,  
41.         imageRequest.getProgressiveRenderingEnabled() ||  
42.             !UriUtil.isNetworkUri(imageRequest.getSourceUri()),  
43.         imageRequest.getPriority());  
44.     return CloseableProducerToDataSourceAdapter.create(  
45.         producerSequence,  
46.         settableProducerContext,  
47.         mRequestListener);  
48.   } catch (Exception exception) {  
49.     return DataSources.immediateFailedDataSource(exception);  
50.   }  
51. }  

最后的return通过 CloseableProducerToDataSourceAdapter类的 静态方法创建DataSource的具体实例类，其中一个重要的参数，producerSequence，在前一个方法中创建并传递过来。为什么说这个参数重要，我们稍后再说。

代码回到AbstractDraweeController类的submitRequest()方法中，getDataSource()已完成，再往下看，创建了一个DataSubscriber的类实例对象，然后DataSource通过subscribe方法将DataSubscriber实例对象传入，即数据的订阅，当数据发生改变时会通知给订阅者，好了，以上的所有流程我们可以用图来表示下

总结下这个流程：

1. 当调用SimpleDraweeView的setImageUri(uri)方法时，PipelineDraweeControllerBuilder通过setUri(uri)生成不可变的ImageReqeust成员对象，通过build()方法构建PipelineDraweeController实例对象（创建的Supplier<DataSource<IMAGE>>作为其成员变量），然后将controller设置给DraweeHolder；

2. 当View处于屏幕的可视区域时，会执行controller的onAttach()方法，获取DataSource并绑定订阅者DataSubscriber。

整理下思路回来，我们接着分析，到目前为止还没看到时怎么去加载图片的呀，现在我们去看如何去加载图片，记得我们前面提到的在创建DataSource时传入的一个重要参数producerSequence吗，加载图片的关键流程要登场了。Fresco使用了producer(生产者) — consumer(消费者)模式加载和缓存图片的，producerSequence看名字就知道它应该持有了一系列生产者的序列，其内部代码我们在这不做分析，它内部采用了包装模式，一个producer包装另一个producer，类似于Java中的InputStream，调用关系也是一级一级的调用，consumer是在外面创建，并传递给producer的produceResults方法，在某个producer中如果consumer需要包装，那么包装一层再传递给下一个producer的produceResults方法。

Producer的包装过程，主要涉及两个类，ProducerSequenceFactory，ProducerFactory，前者用来获取经过包装的producer，后者获取具体的单个producer。

producer--生产者，负责生产获取结果，从内存，未解码内存，磁盘，网络等获取数据

consumer–消费者，负责消费使用结果，解码，变换，返回。存到各个缓存中。

前面在创建DataSource时使用了CloseableProducerToDataSourceAdapter.create()的静态方法，创建了一个CloseableProducerToDataSourceAdapter的实例对象（实现了DataSource接口），我们看其父类AbstractProducerToDataSourceAdapter的构造方法

[java]  view plain  copy

 

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

在构造方法内部，producer已经开始工作了，一层一层的执行；consumer为内部创建的一个匿名类，作为根的consumer，在得到最终结果后，通知数据订阅者，将数据交给订阅者处理（UI线程执行），一个完整图片获取过程所经历的producer顺序如下：

1. BitmapMemoryCacheGetProducer    只读内存缓存的producer

2. ThreadHandoffProducer    启动线程的producer，后续的producer都在线程中执行

3. BitmapMemoryCacheKeyMultiplexProducer    使用memory cache key合并请求的producer

4. BitmapMemoryCacheProducer    读取内存缓存的producer

5. DecodeProducer    解码图片的producer，渐进式JPEG图片，gif和webp等动画图片的解码

6. ResizeAndRotateProducer    JPEG图片resizes和rotates处理

7. AddImageTransformMetaDataProducer    主要包装解码的consumer，并传递到下一个producer

8. EncodedCacheKeyMultiplexProducer    使用encoded cache key合并请求的producer

9. EncodedMemoryCacheProducer    读取未解码的内存缓存的producer

10. DiskCacheProducer    读取磁盘缓存的producer

11. WebpTranscodeProducer    包装转码WebP到JPEG/PNG的consumer，并传递到下一个producer

12. NetworkFetchProducer    网络请求的producer

整个图片的加载流程如下：

1. 检查内存缓存，如有，返回
2. 后台线程开始后续工作
3. 检查是否在未解码内存缓存中。如有，解码，变换，返回，然后缓存到内存缓存中。
4. 检查是否在文件缓存中，如果有，变换，返回。缓存到未解码缓存和内存缓存中。
5. 从网络或者本地加载。加载完成后，解码，变换，返回。存到各个缓存中。

每个过程的具体细节不在这里分析了，有兴趣的话仔细研读。

回到AbstractDraweeController类的submitRequest()方法，数据订阅者DataSubscriber在收到正常的数据结果提醒时，如下处理：

[java]  view plain  copy

 

1. private void onNewResultInternal(  
2.     String id,  
3.     DataSource<T> dataSource,  
4.     @Nullable T image,  
5.     float progress,  
6.     boolean isFinished,  
7.     boolean wasImmediate) {  
8.   // ignore late callbacks (data source that returned the new result is not the one we expected)  
9.   if (!isExpectedDataSource(id, dataSource)) {  
10.     logMessageAndImage("ignore_old_datasource @ onNewResult", image);  
11.     releaseImage(image);  
12.     dataSource.close();  
13.     return;  
14.   }  
15.   mEventTracker.recordEvent(  
16.       isFinished ? Event.ON_DATASOURCE_RESULT : Event.ON_DATASOURCE_RESULT_INT);  
17.   // create drawable  
18.   Drawable drawable;  
19.   try {  
20.     drawable = createDrawable(image);  
21.   } catch (Exception exception) {  
22.     logMessageAndImage("drawable_failed @ onNewResult", image);  
23.     releaseImage(image);  
24.     onFailureInternal(id, dataSource, exception, isFinished);  
25.     return;  
26.   }  
27.   T previousImage = mFetchedImage;  
28.   Drawable previousDrawable = mDrawable;  
29.   mFetchedImage = image;  
30.   mDrawable = drawable;  
31.   try {  
32.     // set the new image  
33.     if (isFinished) {  
34.       logMessageAndImage("set_final_result @ onNewResult", image);  
35.       mDataSource = null;  
36.       mSettableDraweeHierarchy.setImage(drawable, 1f, wasImmediate);  
37.       getControllerListener().onFinalImageSet(id, getImageInfo(image), getAnimatable());  
38.       // IMPORTANT: do not execute any instance-specific code after this point  
39.     } else {  
40.       logMessageAndImage("set_intermediate_result @ onNewResult", image);  
41.       mSettableDraweeHierarchy.setImage(drawable, progress, wasImmediate);  
42.       getControllerListener().onIntermediateImageSet(id, getImageInfo(image));  
43.       // IMPORTANT: do not execute any instance-specific code after this point  
44.     }  
45.   } finally {  
46.     if (previousDrawable != null && previousDrawable != drawable) {  
47.       releaseDrawable(previousDrawable);  
48.     }  
49.     if (previousImage != null && previousImage != image) {  
50.       logMessageAndImage("release_previous_result @ onNewResult", previousImage);  
51.       releaseImage(previousImage);  
52.     }  
53.   }  
54. }  

创建Drawable，并将其设置给DraweeHierarchy，我们看Drawable时如何创建的，类PipelineDraweeController中

[java]  view plain  copy

 

1. @Override  
2. protected Drawable createDrawable(CloseableReference<CloseableImage> image) {  
3.   Preconditions.checkState(CloseableReference.isValid(image));  
4.   CloseableImage closeableImage = image.get();  
5.   if (closeableImage instanceof CloseableStaticBitmap) {  
6.     CloseableStaticBitmap closeableStaticBitmap = (CloseableStaticBitmap) closeableImage;  
7.     BitmapDrawable bitmapDrawable = new BitmapDrawable(  
8.         mResources,  
9.         closeableStaticBitmap.getUnderlyingBitmap());  
10.     if (closeableStaticBitmap.getRotationAngle() == 0 ||  
11.         closeableStaticBitmap.getRotationAngle() == EncodedImage.UNKNOWN_ROTATION_ANGLE) {  
12.       return bitmapDrawable;  
13.     } else {  
14.       return new OrientedDrawable(bitmapDrawable, closeableStaticBitmap.getRotationAngle());  
15.     }  
16.   } else if (closeableImage instanceof CloseableAnimatedImage) {  
17.     return mAnimatedDrawableFactory.create(  
18.         ((CloseableAnimatedImage) closeableImage).getImageResult());  
19.   } else {  
20.     throw new UnsupportedOperationException("Unrecognized image class: " + closeableImage);  
21.   }  
22. }  

如果是静态图片则创建BitmapDrawable，否则如果是动画图片，则创建包含多帧AnimatedDrawable。

最后将Drawable设置给DraweeHierarchy，由DraweeHierarchy负责Drawable的绘制工作。

三、图片的绘制显示

终于到图片的绘制了，接着上一节，AbstractDraweeController将Drawable设置给SettableDraweeHierarchy，其唯一实现类为GenericDraweeHierarchy，我们看它的setImage方法

[java]  view plain  copy

 

1. @Override  
2. public void setImage(Drawable drawable, float progress, boolean immediate) {  
3.   drawable = WrappingUtils.maybeApplyLeafRounding(drawable, mRoundingParams, mResources);  
4.   drawable.mutate();  
5.   mActualImageWrapper.setDrawable(drawable);  
6.   mFadeDrawable.beginBatchMode();  
7.   fadeOutBranches();  
8.   fadeInLayer(mActualImageIndex);  
9.   setProgress(progress);  
10.   if (immediate) {  
11.     mFadeDrawable.finishTransitionImmediately();  
12.   }  
13.   mFadeDrawable.endBatchMode();  
14. }  

直接看这个方法会比较迷茫，根本不知道drawable究竟是怎么被绘制的，我们先分析下GenericDraweeHierarchy的构造方法

[java]  view plain  copy

 

1. GenericDraweeHierarchy(GenericDraweeHierarchyBuilder builder) {  
2.   mResources = builder.getResources();  
3.   mRoundingParams = builder.getRoundingParams();  
4.   
5.   mActualImageWrapper = new ForwardingDrawable(mEmptyActualImageDrawable);  
6.   
7.   int numBackgrounds = (builder.getBackgrounds() != null) ? builder.getBackgrounds().size() : 0;  
8.   int numOverlays = (builder.getOverlays() != null) ? builder.getOverlays().size() : 0;  
9.   numOverlays += (builder.getPressedStateOverlay() != null) ? 1 : 0;  
10.   
11.   // layer indices and count  
12.   int numLayers = 0;  
13.   int backgroundsIndex = numLayers;  
14.   numLayers += numBackgrounds;  
15.   mPlaceholderImageIndex = numLayers++;  
16.   mActualImageIndex = numLayers++;  
17.   mProgressBarImageIndex = numLayers++;  
18.   mRetryImageIndex = numLayers++;  
19.   mFailureImageIndex = numLayers++;  
20.   int overlaysIndex = numLayers;  
21.   numLayers += numOverlays;  
22.   
23.   // array of layers  
24.   Drawable[] layers = new Drawable[numLayers];  
25.   if (numBackgrounds > 0) {  
26.     int index = 0;  
27.     for (Drawable background : builder.getBackgrounds()) {  
28.       layers[backgroundsIndex + index++] = buildBranch(background, null);  
29.     }  
30.   }  
31.   layers[mPlaceholderImageIndex] = buildBranch(  
32.       builder.getPlaceholderImage(),  
33.       builder.getPlaceholderImageScaleType());  
34.   layers[mActualImageIndex] = buildActualImageBranch(  
35.       mActualImageWrapper,  
36.       builder.getActualImageScaleType(),  
37.       builder.getActualImageFocusPoint(),  
38.       builder.getActualImageMatrix(),  
39.       builder.getActualImageColorFilter());  
40.   layers[mProgressBarImageIndex] = buildBranch(  
41.       builder.getProgressBarImage(),  
42.       builder.getProgressBarImageScaleType());  
43.   layers[mRetryImageIndex] = buildBranch(  
44.       builder.getRetryImage(),  
45.       builder.getRetryImageScaleType());  
46.   layers[mFailureImageIndex] = buildBranch(  
47.       builder.getFailureImage(),  
48.       builder.getFailureImageScaleType());  
49.   if (numOverlays > 0) {  
50.     int index = 0;  
51.     if (builder.getOverlays() != null) {  
52.       for (Drawable overlay : builder.getOverlays()) {  
53.         layers[overlaysIndex + index++] = buildBranch(overlay, null);  
54.       }  
55.     }  
56.     if (builder.getPressedStateOverlay() != null) {  
57.       layers[overlaysIndex + index] = buildBranch(builder.getPressedStateOverlay(), null);  
58.     }  
59.   }  
60.   
61.   // fade drawable composed of layers  
62.   mFadeDrawable = new FadeDrawable(layers);  
63.   mFadeDrawable.setTransitionDuration(builder.getFadeDuration());  
64.   
65.   // rounded corners drawable (optional)  
66.   Drawable maybeRoundedDrawable =  
67.       WrappingUtils.maybeWrapWithRoundedOverlayColor(mFadeDrawable, mRoundingParams);  
68.   
69.   // top-level drawable  
70.   mTopLevelDrawable = new RootDrawable(maybeRoundedDrawable);  
71.   mTopLevelDrawable.mutate();  
72.   
73.   resetFade();  
74. }  

看着挺多，不过并不复杂，mActualImageWrapper看名字应该是最终实际展示的drawable，事实确实如此，然后创建了一个Drawable数组，添加了包括 mActualImageWrapper在内的各种Drawable，有加载时占位用的drawable、加载失败显示的drawable、点击重试的drawable等，然后 mFadeDrawable创建时传入了一个Drawable数组， mTopLevelDrawable在创建时又间接（圆角Drawable的包装）或直接引用了mFadeDrawable。

还记得GenericDraweeHierarchy是在GenericDraweeView中被build出来并设置给DraweeHolder的吗，我们看下其setHierarchy(hierarchy)方法

[java]  view plain  copy

 

1. /** Sets the hierarchy. */  
2. public void setHierarchy(DH hierarchy) {  
3.   mDraweeHolder.setHierarchy(hierarchy);  
4.   super.setImageDrawable(mDraweeHolder.getTopLevelDrawable());  
5. }  

看到方法里有个getTopLevelDrawable()方法，没错，这个方法返回的就是 GenericDraweeHierarchy中的mTopLevelDrawable，将此drawable设置给了ImageView，此时，mTopLevelDrawable与ImageView建立了联系，mTopLevelDrawable的callback设置给了ImageView，我们看下Android的ImageView源码

[java]  view plain  copy

 

1. /** 
2.  * Sets a drawable as the content of this ImageView. 
3.  *  
4.  * @param drawable the Drawable to set, or {@code null} to clear the 
5.  *                 content 
6.  */  
7. public void setImageDrawable(@Nullable Drawable drawable) {  
8.     if (mDrawable != drawable) {  
9.         mResource = 0;  
10.         mUri = null;  
11.   
12.         final int oldWidth = mDrawableWidth;  
13.         final int oldHeight = mDrawableHeight;  
14.   
15.         updateDrawable(drawable);  
16.   
17.         if (oldWidth != mDrawableWidth || oldHeight != mDrawableHeight) {  
18.             requestLayout();  
19.         }  
20.         invalidate();  
21.     }  
22. }  
23.    
24. private void updateDrawable(Drawable d) {  
25.     if (d != mRecycleableBitmapDrawable && mRecycleableBitmapDrawable != null) {  
26.         mRecycleableBitmapDrawable.setBitmap(null);  
27.     }  
28.   
29.     if (mDrawable != null) {  
30.         mDrawable.setCallback(null);  
31.         unscheduleDrawable(mDrawable);  
32.     }  
33.   
34.     mDrawable = d;  
35.   
36.     if (d != null) {  
37.         d.setCallback(this);  
38.         d.setLayoutDirection(getLayoutDirection());  
39.         if (d.isStateful()) {  
40.             d.setState(getDrawableState());  
41.         }  
42.         d.setVisible(getVisibility() == VISIBLE, true);  
43.         d.setLevel(mLevel);  
44.         mDrawableWidth = d.getIntrinsicWidth();  
45.         mDrawableHeight = d.getIntrinsicHeight();  
46.         applyImageTint();  
47.         applyColorMod();  
48.   
49.         configureBounds();  
50.     } else {  
51.         mDrawableWidth = mDrawableHeight = -1;  
52.     }  
53. }  

在updateDrawable(d)方法中将drawable的callback设置为了this，而 mTopLevelDrawable在创建时，其父类ForwardingDrawable在构造方法中，将传递过来的参数Drawable（可能为mFadeDrawable也可能为maybeRoundedDrawable）赋值给其成员变量，并将其callback设置为了this

[java]  view plain  copy

 

1. public ForwardingDrawable(Drawable drawable) {  
2.   mCurrentDelegate = drawable;  
3.   DrawableUtils.setCallbacks(mCurrentDelegate, this, this);  
4. }  

mFadeDrawable创建时传入了drawable的数组，其父类ArrayDrawable的构造方法中，对数组中的每个drawable的callback设置为this

[java]  view plain  copy

 

1. public ArrayDrawable(Drawable[] layers) {  
2.   Preconditions.checkNotNull(layers);  
3.   mLayers = layers;  
4.   for (int i = 0; i < mLayers.length; i++) {  
5.     DrawableUtils.setCallbacks(mLayers[i], this, this);  
6.   }  
7.   mDrawableParents = new DrawableParent[mLayers.length];  
8. }  

看下图来了解类之间关系和callback链

也就是说ArrayDrawable中mLayers的Drawable数组中的每个drawable都间接与ImageView建立了联系，其callback的调用关系为的责任链模式，一级一级往上层调用。

看到这里我们在回到本节的开始出，GenericDraweeHierarchy的setImage方法，mActualImageWrapper为实际要绘制的图片，其位于mFadeDrawable的mLayers数组中，fadeInLayer(mActualImageIndex)设置要绘制的Drawable的索引，fendBatchMode()方法中调用了invalidateSelf()，此方法触发调用callback，然后callback链一级一级网上调用直到ImageView，ImageView最终调用onDraw方法，交由Drawable进行绘制，最终会调用到FadeDrawable的draw(canvas)方法，在其方法内部绘制mLayers数组中被标记的Drawable，至此drawable将被绘制到canvas上在屏幕上呈现。如果最终要绘制的Drawable为AnimatedDrawable(gif，webP等动画图片)，那么调用其draw(canvas)方法将不断地绘制每一帧。

一些补充：

1、Pool模型

Fresco中有个Pool和Bucket的概念，可理解为缓存池，类似与线程池，即当需要分配一块内存的时候，先从Pool中取，如果有相应大小Bucket，则返回，没有的话看是否满足条件可分配，如果满足则分配对应大小的内存并返回，否则抛出异常。当得到对应的Bucket后获取其FreeList中块大小的值，如果没有，则新分配内存并使用，使用完之后返回到Bucket的FreeList中。

Pool是在初始化阶段完成配置，包括有几个Pool，每个Pool大小的软限制，硬限制，和包含多少个Bucket，每个Bucket的itemSize大小以及item的个数等，看下图来理解

2、Image Decoder

Fresco中图片的解码操作根据不同的系统版本而有所不同，在4.4以下的版本中（sdk<19）解码时先将数据copy到Ashmem区域，然后进行解码；4.4版本由于使用MemoryFile不能work，而使用java内存来存储未解码image，使用BitmapFactory.decodeByteArray方法解码数据，不能从stream解码，因为不支持purgeable；5.0及以上版本使用BitmapFactory.decodeStream方法解码。

3、引用计数CloseableReference

Fresco中使用了一种引用计数的方式来管理内存，主要为了解决Ashmem区域的Bitmap内存的分配管理

以下内容摘自网上：

Ashmem:

在Android系统里面，Ashmem这个区域的内存并不属于Java Heap，也不属于Native Heap。而Ashmem的使用，又有一点像Java的垃圾回收。

当Ashmem中的某个内存空间像要被释放时候，会通过系统调用unpin来告知，但实际上这块内存空间的数据并没有被真正的擦除。

如果Android系统发现内存吃紧时，就会把unpin的内存空间利用起来去存储所需的数据。

而被unpin的内存空间，是可以被重新pin的，如果此时的该内存空间还没有被其他人使用的话，就节省了重新往Ashmem重新写入数据的过程了。

所以Ashmem这个工作原理是一种延迟释放。

 

Bitmap在Ashmem中的使用

Ashmem内存区域是不能被Java应用直接使用的，但这其中有一些例外，而Bitmap是其中一个。

BitmapFactory.Options = new BitmapFactory.Options();

options.inPurgeable = true;

Bitmap bitmap = BitmapFactory.decodeByteArray(jpeg, 0, jpeg.length, options);

Purgeable被设置成true以后，这个Bigmap就是保存在Ashmem内存区域中的，Java的垃圾回收是不能回收这片区域的内存的。

当Android系统需要渲染这个Bitmap的时候，会调用pin，渲染完成后会调用unpin。而unpin后的内存空间表示能被其他人所使用。

如果被unpin的Bitmap需要重新渲染，系统会再次Decode这个Bitmap，而这个Decode的过程是在UI线程上完成的，Bitmap decode是非常消耗CPU资源的，当消耗过大时会引起UI阻塞，所以Google后来废弃了这个purgeable的参数。

后来Google提供了另外一个Flag，叫inBitmap。很遗憾的是，直到Android4.4后，这个新的Flag才得到完善。而Fresco致力于实现一个包括Android2.3以及以上的Android系统都能完美工作的图片加载管理开源库，因此Fresco放弃了使用inBitmap的解决方案。

 

Fresco是如何利用Ashmem去给Bitmap分配和管理内存?

上面说到的pin和unpin两个操作，对应的NDK调用是AndroidBitmap_lockPixels和unlockPixels。按照我们一惯认知，为了避免内存泄漏，这两者必须成对出现。而Fresco为了避免Bitmap再次渲染而导致的在UI线程Decode的过程，偏偏不在渲染完成后调用unlockPixels。

这就需要Fresco自己去管理这块内存区域，保证当这个Bitmap不再使用时，Ashmem的内存空间能被unpin。

而Fresco选择在Bitmap离开屏幕可视范围时候(onDetachWindow等时候)，去做unpin。