Android 常用开源框架源码解析系列（四）Glide

一、定义

Glide 一个被google所推荐的图片加载库，作者是bumptech。对Android SDk 最低要求是 API 10

与之功能类似的是Square公司的picasso

二、基本概念

Model ：数据来源：Uri、本地文件、资源ID

Data ：加工数据

Resource ：对原始数据进行解码，解码之后的资源 resource

Resource decode ：资源解码器

TransformedResource：转换资源

TranscodedResource：转码，将静态、Gif动态图进行格式转换以便能加载

Target ：目标图片

三、整体流程

A：Model图片数据源 ———ModelLoader加载—>原始数据Data——Decoder解码——>

Resource——Transform裁剪——>TransformResource——Transcode转码——>TranscodeResource——封装——>Target

四、源码

引入：compile 'com.github.bumptech.glide:glide:3.7.0'

4.1、使用流程三步曲： Glide

.with(“上下文context”)

.load(“url”)

.into(“显示的控件资源");

4.2、常用加载图片的配置参数：

public void LoadImage(View view) {

//with 创建一个加载图片的Glide实例，流式接口

Glide.with(getApplicationContext()) //指定的Context，传入的参数会决定整个Glide的生命周期

ps：图片的加载会和传入的Acitivty或是Fragment保持一致，所以建议使用Activity 或是Fragment作为参数而不是单纯的使用this 或是 context

.load("url")//指定的图片的URL

加载占位图：-int or Drawable

.placeholder(R.mipmap.ic_launcher) //指定图片未成功加载前现实的图片占位符

// ，直到加载的网络图片显示就会被替换,仅支持本地图片资源

错误占位图：-int or Drawable

.error(R.mipmap.ic_launcher) //指定图片加载失败显示的图片占位图

加载本地缩略图：

.thumbnail( float ) //0.2f Glide会显示原始图片的20%大小，注意ImageView的ScaleType值的设置

加载网络缩略图：

DrawableRequestBuilder<String> thumbnailRequest = Glide.with(context).load(url);

Glide.with( context) .load(url)

.thumbnail (thumbnailRequest ).into (imageView);

加载图片动画效果：

.crossFade() or crossfade(int duration) //强制开启GLide默认的图片淡出淡入效果，默认持续时间300ms，设置dontAnimate()设置无任何淡出淡入效果

显示Gif 和Video 功能：

String gifUrl = “…xxxxoo.git”;

.load (gifUrl)

.asGif()

.error(xxxx)

// 如果图片类型不是Gif的话就会当作load 失败来处理

显示静态的Gif图片 //仅仅显示Gif的第一桢图像

String gifUrl = “…xxxxoo.git”;

.load (gifUrl)

.asBitmap()

.error(xxxx)

显示手机本地视频文件:

String filePath = “/storage/emulated/0/xxxx.mp4"

.load(Uri.fromFile ( new File (filePath) ))

.override(300, 300) //不自动适配图片尺寸的时候进行手动进行图片尺寸设置，glide可以自动限制图片的尺寸来优化图片的加载

//ps：Glide不会完整的加载原始图片资源到内存当中，会自动判断imageView大小再进行最优尺寸选择加载

.fitCenter() //指定图片缩放类型1，显示的图像宽和高都小于等于ImageView的边界范围

//ps：缺陷有可能不被填满所需要的ImageView， FIT_CENTER

.centerCrop() //指定图片缩放类型2。显示的图像填充整个ImageView，然后裁剪额外超出的部分

//ps：缺陷，有可能完整填充ImageView但是图片不能完整显示，CENTER_CROP

.skipMemoryCache(true) //不将该图片放在内存缓存中，但是仍然会利用该部分磁盘缓存，依然会在磁盘缓存中建立区域，Glide默认将图片放入内存缓存中

//ps: Glide默认会将图片缓存到内存缓存中所以无需传入false值,若同一Url地址在首次没有调用该方法则第二次直接从内存中缓存缓存图片，若想调整行为需要保证每次调用行为一致

//硬盘缓存策略-枚举值：默认开启

.diskCacheStrategy(DiskCacheStrategy.NONE) //禁用硬盘的缓存让其处于null状态，跳过磁盘缓存

.diskCacheStrategy(DiskCacheStrategy.SOURCE) //仅仅只缓存原来的全分辨率尺寸图像

.diskCacheStrategy(DiskCacheStrategy.RESULT) //仅仅只缓存资源最终的加载图像（降低压缩分辨率后的图片）

.diskCacheStrategy(DiskCacheStrategy.ALL) //缓存所有版本的图片

.priority(Priority.HIGH)//优先级先处理优先级高的图片信息，但不保证所有图片按照优先级顺序进行加载

.into(imageview); //显示到指定的ImageView

}

4.3、with()解析：基础目的：获取RequestManager对象（管理Request请求）

根据当前的上下文和组建选择不同的with构造方法，不同的参数对于图片加载的生命周期产生不同的影响，将图片加载的生命周期和组件相挂钩。

以context 为例：

public static RequestManager with(Context context) {

//用于产生requestManager 图片请求管理

RequestManagerRetriever 生产requestManager

RequestManagerRetrieverretriever = RequestManagerRetriever.get();

return retriever.get(context);

}

//通过RequestManagerRetriever 这个生产Request类来处理，同时Glide绑定了组件的生命周期

RequestManager的创建流程：

public RequestManager get(Context context) {

if (context == null) {

throw new IllegalArgumentException("You cannot start a load on a null Context");

}

//当前Context 是否是在主线程，context是否是application的实例

else if (Util.isOnMainThread() && !(context instanceof Application)) {

if (context instanceof FragmentActivity) {

return get((FragmentActivity) context);

} else if (context instanceof Activity) {

return get((Activity) context);

} else if (context instanceof ContextWrapper) {

return get(((ContextWrapper) context).getBaseContext());

}

//返回一个单例模式的ApplicationManager

return getApplicationManager(context);

}

//双重锁检查机制的单例模型

获取唯一个RequestManager，进行图片请求的处理

private RequestManager getApplicationManager(Context context) {

if (applicationManager == null) {

synchronized (this) {

if (applicationManager == null) {

applicationManager = new RequestManager(context.getApplicationContext(),

new ApplicationLifecycle(), new EmptyRequestManagerTreeNode());

}

return applicationManager;

}

RequestManagerRetriever的 get()解析：

a、传入application 类型的Context

当Glide传入的是整个程序的生命周期的时候，就不需要进行过多处理

b、传入非application 类型的Context （activity、fragment）

public RequestManager get(FragmentActivity activity) {

//是否是在后台线程，只有在非UI线程才进else

if (Util.isOnBackgroundThread()) {

return get(activity.getApplicationContext());

} else {

assertNotDestroyed(activity);

FragmentManager fm = activity.getSupportFragmentManager();

return supportFragmentGet(activity, fm);

}

supportFragmentGet（）：

RequestManager supportFragmentGet(Context context, FragmentManager fm) {

//Fragment 添加到Activity有两种方式，A有Ui的Fragment B没有Ui界面的Fragment

//这里使用第二种方式，通过RequestManagerFragment来监听Activity的生命周期来完成绑定生命周期，图片加载选择的过程

ps：Glide无法直接监听Activity的生命周期

SupportRequestManagerFragment current

= getSupportRequestManagerFragment(fm);

//创建RequestManager实例，完成Glide对象的构造，通过RequestManager就可以控制整个界面的生命周期的监听，通过监听进行图片的相应操作

RequestManager requestManager = current.getRequestManager();

if (requestManager == null) {

requestManager = new RequestManager(context,

current.getLifecycle(), current.getRequestManagerTreeNode());

current.setRequestManager(requestManager);

}

return requestManager;

}

setRequestManager（）：将RequestManagerFragment这个空界面的Fragment和RequestManager进行绑定；

目的：监听Activity生命周期，管理图片加载的整个流程绑定到Activity一起操作

public void setRequestManager(RequestManager requestManager) {

this.requestManager = requestManager;

}

ps：一个RequestManager 对应一个RequestManagerFragment，一一对应关系

思考：前文提到的 SupportRequestManagerFragment 空的Fragment 是如何和RequestManager建立生命周期关系的呢？

答：在RequestManagerFragment中含有ActivityFragmentLifecycle函数，用于管理组建生命周期的。RequestManager实际上在RequestManagerFragment中注册了一些回调接口，通过接口监听Activity 或是Fragment的生命周期

例如：

@Override

public void onStart() {

super.onStart();

lifecycle.onStart();

//说明RequestManagerFragment 这个无Ui的Fragment是通过LifeCycle进行生命周期的管理

}

根据不同的生命周期进行相应的处理

4.4、load()解析：初始化操作获取DrawableTypeRequest对象

思考：为什么Glide会有一大堆重载方法？

答：因为Glide支持多种格式的图片来源，依托于此Glide加载也就需要不同的类型

public DrawableTypeRequest<String> load(String string) {

return (DrawableTypeRequest<String>)

fromString().load(string);

}

DrawableTypeRequest（）：表示Glide中所有加载图片的Request请求

class DrawableTypeRequest<ModelType> extends DrawableRequestBuilder<ModelType> implements DownloadOptions

能想象到DrawableTypeRequest 应该就是通过Builder()内部类的构建者模式进行构建初始化的。

DrawableRequestBuilder：对Glide参数初始化的配置工作

而DrawableRequestBuilder又extends继承自 GenericRequestBuilder

GenericRequestBuilder：Glide所有配置参数基本的最终类：

public class DrawableRequestBuilder<ModelType>

extends GenericRequestBuilder<ModelType, ImageVideoWrapper, GifBitmapWrapper, GlideDrawable>

implements BitmapOptions, DrawableOptions

ps：DrawableRequestBuilder可以通过链式调用配置参数

在GenericRequestBuilder中有一个很重要的成员变量：

protected final RequestTracker requestTracker; //负责跟踪整个图片请求的周期

fromString（）：传入String的Class对象作为参数

public DrawableTypeRequest<String> fromString() {

return loadGeneric(String.class);

}

loadGeneric（）：

private <T> DrawableTypeRequest<T>

loadGeneric(Class<T> modelClass) {

//创建两个ModelLoader对象，通过数据来源，ML将来源加载成原始数据

ModelLoader<T, InputStream> streamModelLoader

= Glide.buildStreamModelLoader(modelClass, context);

ModelLoader<T, ParcelFileDescriptor>fileDescriptorModelLoader

= Glide.buildFileDescriptorModelLoader(modelClass, context);

if (modelClass != null && streamModelLoader == null && fileDescriptorModelLoader == null) {

throw new IllegalArgumentException(...);

}

//创建DrawableTypeRequest 对象

return optionsApplier.apply(

new DrawableTypeRequest<T>(modelClass, streamModelLoader, fileDescriptorModelLoader, context,

glide, requestTracker, lifecycle, optionsApplier));

}

DrawableTypeRequest（）：相对常用的方法，通过返回不同的TypeRequest来选择需要的方法

//强制指定加载静态图片

public BitmapTypeRequest<ModelType> asBitmap() {

return optionsApplier.apply(new BitmapTypeRequest<ModelType>

(this, streamModelLoader,

fileDescriptorModelLoader, optionsApplier));

}

//强制指定加载动态图片

public GifTypeRequest<ModelType> asGif() {

return optionsApplier.apply(new GifTypeRequest<ModelType> (this, streamModelLoader, optionsApplier));

}

4.5、into()解析：——在主线程中调用的更新UI操作

public Target<TranscodeType> into(ImageView view) {

//1、是否在主线程中操作，非主线程抛出异常

Util.assertMainThread();

if (view == null) {

throw new IllegalArgumentException("You must pass in a non null View");

}

//2、判断类型是否进行哪类图片处理

if (!isTransformationSet && view.getScaleType() != null) {

switch (view.getScaleType()) {

case CENTER_CROP:

applyCenterCrop();

break;

case FIT_CENTER:

case FIT_START:

case FIT_END:

applyFitCenter();

break;

//$CASES-OMITTED$

default:

// Do nothing.

}

//3、创建一个Target对象，图片所要显示的控件

return into(glide.buildImageViewTarget(view, transcodeClass));

}

applyCenterCrop（）：

————>centerCrop()————>centerCrop():

public DrawableRequestBuilder<ModelType> centerCrop() {

return transform(glide.getDrawableCenterCrop());

}

transform（）：//图片转换，对transformation进行赋值操作

public GenericRequestBuilder<ModelType, DataType,

ResourceType, TranscodeType> transform(

Transformation<ResourceType>... transformations) {

isTransformationSet = true;

if (transformations.length == 1) {

transformation = transformations[0];

} else {

transformation = new MultiTransformation<ResourceType>(transformations);

}

return this;

}

glide.buildImageViewTarget() 中Target接口：

//Glide能绑定生命周期的原因：

interface Target<R> extends LifecycleListener

接口内含有onStart（）、onStop()、onDestory()函数

在进行.with()操作的时候，会传入context or Activity or Fragment进行相应生命周期的绑定操作，这时候就是通过LifecycleListener进行组件的监听

<R> Target<R> buildImageViewTarget(ImageView imageView, Class<R> transcodedClass) {

//通过imageViewTargetFactory工厂构建Target

return imageViewTargetFactory.buildTarget(imageView, transcodedClass);

}

//通过传入class对象判断Glide需要加载哪类图片，buildTarget()就创建哪类Target

public <Z> Target<Z> buildTarget(ImageView view, Class<Z> clazz) {

if (GlideDrawable.class.isAssignableFrom(clazz)) {

//未调用asBitmap()方法就会默认采取GlideDrawableImageViewTarget()方法

return (Target<Z>) new GlideDrawableImageViewTarget(view);

} else if (Bitmap.class.equals(clazz)) {

//调用了asBitmap()

return (Target<Z>) new BitmapImageViewTarget(view);

} else if (Drawable.class.isAssignableFrom(clazz)) {

//使用较少

return (Target<Z>) new DrawableImageViewTarget(view);

} else {

throw new IllegalArgumentException("Unhandled class: " + clazz

+ ", try .as*(Class).transcode(ResourceTranscoder)");

}

into():

3、新建一个Request绑定到Target上

4、发送Request 交给RequestTracker进行相应的处理

public <Y extends Target<TranscodeType>> Y into(Y target) {

//是否在主线程（更新UI必须在主线程）

Util.assertMainThread();

…

1、对旧的绑定的Target对象进行清除

//获取当然Target对象所绑定的旧的Request对象

Request previous = target.getRequest();

if (previous != null) {

//清理操作

previous.clear();

//取消当前Request请求避免图片错位

requestTracker.removeRequest(previous);

//在该实现类中将成员变量赋值为null

ps:并调用REQUEST_POOL.offer(this);当前一个Request不用的时候会被放入请求池以备复用

previous.recycle();

}

2、创建一个加载图片的Request

ps：list图片错位的问题？

解决：给View绑定setTag()，将view和图片进行绑定

Request request = buildRequest(target);

//将图片Request请求和ImageView绑定

target.setRequest(request);

lifecycle.addListener(target);

//3、将Request发送给RequestTracker执行request请求

requestTracker.runRequest(request);

return target;

}

如何buildRequest？

buildRequest（）：————>buildRequestRecursive()

...

obtainRequest（）————>GenericRequest.obtain():实际创建Request（）

GenericRequest.obtain（）：

//从线程池中获取一个请求,如果有可以复用的就复用一个请求，如果没有就创建一个新的

...

GenericRequest<A, T, Z, R> request =

(GenericRequest<A, T, Z, R>) REQUEST_POOL.poll();

if (request == null) {

request = new GenericRequest<A, T, Z, R>();

}

request.init();//初始化操作

return request;

requestTracker.runRequest：

public void runRequest(Request request) {

//将当前request加入到set<Request> 集合当中

requests.add(request);

//对当前状态进行判断，当前是有Request请求进入else ，将当前Request加入pending悬挂中的集合中

if (!isPaused) {

request.begin();

} else {

pendingRequests.add(request);

}

request.begin（）：{

…

//判断前面是否调用了overrideWidth 限定宽高的方法，直接执行onSizeReady()

if (Util.isValidDimensions(overrideWidth, overrideHeight)) {

onSizeReady(overrideWidth, overrideHeight);

} else {

//没有限定款高通过getSize()计算宽高

target.getSize(this);

}

//当前状态是否已经完成，图片是否不是失败状态进行判断

if (!isComplete() && !isFailed() && canNotifyStatusChanged()) {

//设定图片（获取占位图）

target.onLoadStarted(getPlaceholderDrawable());

...

}

target.getSize——>

public void getSize(SizeReadyCallback cb) {

sizeDeterminer.getSize(cb);

}

getSize():内部根据ImageView宽高进行再次计算后再执行onSizeReady()

public void getSize(SizeReadyCallback cb) {

//1、获取宽高

int currentWidth = getViewWidthOrParam();

int currentHeight = getViewHeightOrParam()；

//3、当View绘制完时候就会进入onSizeReady()方法

if (isSizeValid(currentWidth) && isSizeValid(currentHeight)) {

cb.onSizeReady(currentWidth, currentHeight);

}

…

//2、当前View没有被测量完，会被添加到viewTreeObserver观察者中

final ViewTreeObserver observer = view.getViewTreeObserver();

layoutListener = new SizeDeterminerLayoutListener(this);

observer.addOnPreDrawListener(layoutListener);

1、通过LoadProvider()方法获取ModelLoader和Transcoder

2、根据ModelLoader获取DataFetcher

3、engine.load 进行实际图片加载

ModelLoader：从数据源中获取原始数据，一般是输入流inputStream，在Glide中被封装成Data

DataFetcher：将Data原始数据转换成能直接用的不同形式的图片数据类型

ResourceTranscoder：将原始数据解码，将io输入流解码成bitmap的解码工具对象

Resource：解码后的资源

onSizeReady(int width, int height) {:

…

ModelLoader<A, T> modelLoader

= loadProvider.getModelLoader();

//通过loadProvider接口获取到dataFetcher、loadProvider、transcoder

final DataFetcher<T> dataFetcher = modelLoader.getResourceFetcher(model, width, height);

…

loadStatus = engine.load(signature, width, height, dataFetcher, loadProvider, transformation, transcoder,

priority, isMemoryCacheable, diskCacheStrategy, this);

}

LoadProvider（）：GenericRequest的成员变量

public interface LoadProvider<A, T, Z, R> extends DataLoadProvider<T, Z> {

ModelLoader<A, T> getModelLoader();

ResourceTranscoder<Z, R> getTranscoder();

LoadProvider初始化：在GenericRequest的实现类

DrawableTypeRequest(...) {

super(context, modelClass,

buildProvider(glide, streamModelLoader, fileDescriptorModelLoader,)

...

}

buildProvider的返回值就是LoadProvider，FixedLoadProvider是LoadProvider的实现类：获取原始图片，进行编解码、转码等功能

private static <A, Z, R> FixedLoadProvider<A, ImageVideoWrapper, Z, R> buildProvider(Glide glide,

ModelLoader<A, InputStream> streamModelLoader,

ModelLoader<A, ParcelFileDescriptor> fileDescriptorModelLoader...) {

//判断来自不同数据的Loader

if (streamModelLoader == null && fileDescriptorModelLoader == null) {

return null;

}

//ResourceTranscoder是否为空，为null则通过Glide创建新的Transcoder

ps：对原始数据进行解码

if (transcoder == null) {

transcoder = glide.buildTranscoder(resourceClass, transcodedClass);

}

//DataLoadProvider对图片进行编解码的接口，实现类中LoadProvider

DataLoadProvider<ImageVideoWrapper, Z> dataLoadProvider

= glide.buildDataProvider(ImageVideoWrapper.class,resourceClass);

//封装了两个ModelLoader

ImageVideoModelLoader<A> modelLoader = new

ImageVideoModelLoader<A>(streamModelLoader,fileDescriptorModelLoader);

return new FixedLoadProvider<A, ImageVideoWrapper, Z, R>

(modelLoader, transcoder, dataLoadProvider);

}

DataLoadProvider：负责编解码

Data：从数据源获取的数据

Resource：解码后的资源

解码：Data————>Resource 资源

编码：将Data、Resource———>持久化到本地的过程用于实现Glide的磁盘缓存功能

engine.load（）：

engine:负责图片加载，管理正在使用和处于缓存的图片类

LoadStatus load（）{

…

//加载图片的唯一标识id，比如加载网络图片的话就是一个网络图片的url地址

final String id = fetcher.getId();

//传入唯一标识id ，其他很多参数依然可以决定EngineKey的值,构建Glide缓存中的一个key值

EngineKey key = keyFactory.buildKey(id,…);

...

//从缓存中获取图片

EngineResource<?> cached = loadFromCache(key, isMemoryCacheable);

if (cached != null) {

cb.onResourceReady(cached);

if (Log.isLoggable(TAG, Log.VERBOSE)) {

logWithTimeAndKey("Loaded resource from cache", startTime, key);

}

//若缓存图片是空的则调用loadFromActiveResources

EngineResource<?> active = loadFromActiveResources(key, isMemoryCacheable);

…

//若两者都没有获取到就自己开启一个runnable 从磁盘或是网络进行图片的获取

EngineRunnable runnable = new EngineRunnable(engineJob, decodeJob, priority);

jobs.put(key, engineJob);

engineJob.addCallback(cb);

engineJob.start(runnable);

}

GLide中的内存缓存策略

GLide 构建内存缓存的组成部分：cache、active

A、内存缓存读取操作原理

1、 LruCache算法：近期最少使用算法，将最近使用的对象的强引用存储在LinkHashMap上；并且把最近最少使用的对象，在缓存池达到预设值之前从内存中移除

2、弱引用缓存机制

Glide中的内存缓存对象：Engine类中的 Load()函数

MemoryCache——loadFromCache（EngineKey,boolean isMemoryCacheable）

cached ：最近使用过的而当前不在使用的EngineResource，LoadFromCache内部使用linkHashMap当内存达到阀值会通过LruCache算法进行清除操作

loadFromCache（）：1、从内存缓存MemoryCache中获取图片

private EngineResource<?> loadFromCache(Key key, boolean isMemoryCacheable) {

//配置Glide 的时候使用的isMemoryCacheable，跳过内存缓存操作skipMemoryCache(true)

默认情况下为true 的时候开启缓存模式

if (!isMemoryCacheable) {

return null;

}

//获取实际缓存对象

EngineResource<?> cached = getEngineResourceFromCache(key);

//ps：2、在该方法中会使用缓存的key值从cache中获取值并调用remove函数把这个图片从MemoryCahce缓存中移除掉

//Resource cached = this.cache.remove(key);

if (cached != null) {

cached.acquire();

//写入一个弱引用的缓存

activeResources.put(key, new ResourceWeakReference(key, cached, getReferenceQueue()));

}

return cached;

}

ps：使用弱引用的好处，使得该部分缓存不会被Lru算法给回收掉资源

loadFromActiveResources():3、调用该方法从正在使用的部分中继续获取图片

ActiveResource——loadFromActiveResources（EngineKey,boolean isMemoryCacheable）——HashMap<key,WeakReference<EngineResource>>

active：保存当前正在使用的EngineResource对象

ps：会以EngineKey为键，以EngineResource的弱引用为值

HashMap的Get()、 Put()函数对应着缓存的读和取的操作

//4、若前两步都没有获取到图片资源，就创建一个Engine runnbale对象加载，从磁盘或是网络获取图片

EngineJob engineJob = engineJobFactory.build(key, isMemoryCacheable);

DecodeJob<T, Z, R> decodeJob = new DecodeJob<T, Z, R>(key, width, height, fetcher, loadProvider, transformation,

transcoder, diskCacheProvider, diskCacheStrategy, priority);

EngineRunnablerunnable = new EngineRunnable(engineJob, decodeJob, priority);

jobs.put(key, engineJob);

B、内存缓存写入操作原理

if (cached != null) {

cb.onResourceReady(cached);

if (Log.isLoggable(TAG, Log.VERBOSE)) {

logWithTimeAndKey("Loaded resource from cache", startTime, key);

}

return null;

}

cb：callback回调

onResourceReady ：ResourceCallback的具体实现

在onResourceReady()中：定义一个handler发送message，将执行逻辑切回到主线程中操作

public void onResourceReady(final Resource<?> resource) {

this.resource = resource;

MAIN_THREAD_HANDLER.obtainMessage(

MSG_COMPLETE, this).sendToTarget();

}

其中MAIN_THREAD_HANDLER是MainThreadCallback回调定义：

private static final Handler MAIN_THREAD_HANDLER =

new Handler(Looper.getMainLooper(),

new MainThreadCallback());

MainThreadCallback（）：接受Message信息并处理的callback回调，通过名字可以知道该消息是在主线程进行结果回调

private static class MainThreadCallbackimplements Handler.Callback {

@Override

public boolean handleMessage(Message message) {

if (MSG_COMPLETE == message.what || MSG_EXCEPTION == message.what) {

EngineJob job = (EngineJob) message.obj;

if (MSG_COMPLETE == message.what) {

job.handleResultOnMainThread();

} else {

job.handleExceptionOnMainThread();

}

...

}

job.handleResultOnMainThread():

private void handleResultOnMainThread() {

//1、如果任务取消则回收资源 recycle

if (isCancelled) {

resource.recycle();

return;

//2、若callback集合为null 空则抛出异常

} else if (cbs.isEmpty()) {

throw new IllegalStateException("Received a resource without any callbacks to notify");

}

//3、通过工厂累创建包含图片资源的engineResource对象

engineResource = engineResourceFactory.build(resource, isCacheable);

...

//3、将对象回调到onEngineJobComplete()当中

engineResource.acquire();

//4、acquire():记录图片被引用的次数，同时在该函数结尾通过 ++this.acquire 来进行图片次数的+1 操作；当acquired >0 表示有图片正在使用中，也就是应该把图片放入到activeResource 这个弱引用缓存中

listener.onEngineJobComplete(key, engineResource);

for (ResourceCallback cb : cbs) {

if (!isInIgnoredCallbacks(cb)) {

engineResource.acquire();

cb.onResourceReady(engineResource);

}

//5、release() 当图片等于0的时候表示图片没有在使用了就调用onResourceReleased释放资源操作，该实现在Engine()函数中

engineResource.release();

}

onEngineJobComplete():

public void onEngineJobComplete(Key key, EngineResource<?> resource) {

Util.assertMainThread();

if (resource != null) {

resource.setResourceListener(key, this);

if (resource.isCacheable()) {

//最终调用activeResources.put()这个函数进行了缓存的写入操作

ps：这里写入的是弱引用的缓存

activeResources.put(key, new ResourceWeakReference(key, resource, getReferenceQueue()));

}

// TODO: should this check that the engine job is still current?

jobs.remove(key);

}

onResourceReleased（）：

public void onResourceReleased(Key cacheKey, EngineResource resource) {

Util.assertMainThread();

//1、把整个缓存图片从activeResources从缓存图片中删除

activeResources.remove(cacheKey);

if (resource.isCacheable()) {

//2、通过put()加入到LruCache算法中，

ps：实现正在使用的图片通过弱引用进行缓存，而不在使用的利用LruCache进行缓存

cache.put(cacheKey, resource);

} else {

resourceRecycler.recycle(resource);

}

磁盘缓存读写待补充

五、Glide常用

5.1 、Target函数的使用- Glide获取 Bitmap资源本身

Target其实就是整个图片的加载的生命周期，通过它在图片加载完成之后获取Bitmap

以 SimpleTarget 为例：

private SimpleTarget<Bitmap> mSimpleTarget= new SimleTarget<Bitmap> (可添加宽*高尺寸限定){

@Override

public void onResourceReady( Bitmap resource,

GlideAnimation< ? super Bitmap>animation) {

ImageView.setImageBitmap(resource);

}

};

private void loadImageSimpleTarget(){

Glide .with (1 ). load(url ) . asBitmap() . into ( mSimpleTarget )；

}

在这里如果SimpletTarget 使用匿名内部类的方式创建 SimpleTarget 的对象，这样会增大该对象在 Glide 完成图片请求之前就被回收的可能性。

（1）：这里如果传入的是Target ，可能独立于with的生命周期之外，所以最好给with里传入参数context .getApplicationContext()，让Glide持有整个app的生命周期。

5.2、ViewTarget函数的使用

在自定义View的时候，Glide有时候并不支持加载图片到自定义View中的时候，这时候就需要ViewTarget

public void loadImageTarget(Context context){

CustomView mCustomView = (CustomView) findViewById(R.id.custom_view); ViewTarget viewTarget =

new ViewTarget<CustomView,GlideDrawable>( mCustomView) {

@Override

public void onResourceReady(GlideDrawable resource,

GlideAnimation<? super GlideDrawable> glideAnimation) { this.view.setImage(resource);

}

};

Glide.with(context) .load(mUrl) .into(viewTarget);

}

onResourceReady回调方法中使用了自定义view自己的方法设置图片，可以看到在创建ViewTarget的时候传入了CustomView 对象

5.3、Transformations函数的使用

如果需要对图片进行图片切圆角、灰阶处理等功能就需要通过 Transformations来操作bitmap 。通过修改尺寸、范围、颜色、像素、位置等达到需求。

ps：若是对图片进行常规的bitmap转换的话，可以使用抽象类 BitmapTransformation 进行

对图片切圆角操作：getId()是图片的唯一标识符必须唯一

public class RoundTransformation extends BitmapTransformation {

private float radius = 0f;

public RoundTransformation(Context context) {

this(context, 4);

}

public RoundTransformation(Context context, int px) {

super(context);

this.radius = px;

}

@Override

protected Bitmap transform(BitmapPool pool, Bitmap toTransform,

int outWidth, int outHeight) {

return roundCrop(pool, toTransform);

}

private Bitmap roundCrop(BitmapPool pool, Bitmap source) {

if (source == null)

return null;

Bitmap result = pool.get(source.getWidth(),

source.getHeight(), Bitmap.Config.ARGB_8888);

if (result == null) {

result = Bitmap.createBitmap(source.getWidth(),

source.getHeight(), Bitmap.Config.ARGB_8888);

}

Canvas canvas = new Canvas(result);

Paint paint = new Paint();

paint.setShader(new BitmapShader(source, BitmapShader.TileMode.CLAMP,

BitmapShader.TileMode.CLAMP));

paint.setAntiAlias(true);

RectF rectF = new RectF(0f, 0f, source.getWidth(),

source.getHeight()); canvas.drawRoundRect(rectF, radius,radius, paint);

return result;

}

@Override

public String getId() {

return getClass().getName() + Math.round(radius);

}

下面是transform的调用：

Glide.with(context)

.load(mUrl)

.transform(new RoundTransformation(context , 20))

//.bitmapTransform( new RoundTransformation(context , 20) ) .into(mImageView);

ps:若需要同时执行多个transformation的话，不能再像这样通过链式调用的形式多次调用.transform() 或是.bitmapTransform() 方法。上面的transform会被最后一个覆盖掉。

这时候可以这样做：

Glide.with(context)

.load(mUrl)

.transform(new RoundTransformation(context , 20)

， new RotateTransformation(context , 90f))

.into(mImageView);

对图片旋转操作

public class RotateTransformationextends BitmapTransformation {

private float rotateRotationAngle = 0f;

public RotateTransformation(Context context, float rotateRotationAngle) {

super( context );

this.rotateRotationAngle = rotateRotationAngle;

}

@Override

protected Bitmap transform(BitmapPool pool,

Bitmap toTransform, int outWidth, int outHeight) {

Matrix matrix = new Matrix();

matrix.postRotate(rotateRotationAngle);

return Bitmap.createBitmap(toTransform, 0, 0,

toTransform.getWidth(), toTransform.getHeight(), matrix, true);

}

@Override

public String getId() {

return getClass().getName() + Math.round(rotateRotationAngle);

}

ps：这里需要注意一点 .centerCrop() 和 .fitCenter() 也都是 Transformation 所以也是遵循同时使用多个 Transformation 的规则的，即：当你使用了自定义转换后你就不能使用 .centerCrop() 或 .fitCenter() 了。

这里有一个 GLide Transformations 的库，它提供了很多 Transformation 的实现，非常值得去看，不必重复造轮子对吧！

glide-transformations

5.4、Animate动画函数的使用

图片间切换的平滑过渡是非常重要的！！所以Glide又一个标准动画去柔化Ui中的改变，但是如果是设置自己的动画的话：

一个小例子：

<set

xmlns:android="http://schemas.android.com/apk/res/android" android:fillAfter="true”>

<scale

android:duration="@android:integer/

config_longAnimTime”

android:fromXScale="0.1”

android:fromYScale="0.1”

android:pivotX="50%”

android:pivotY="50%”

android:toXScale="1”

android:toYScale="1"/>

</set>

XML 动画缩放动画，图片刚开始小的，然后逐渐增大到原尺寸。我们现在要应用到 Glide 加载图片中去，调用 .animate() 方法传入 XML 动画的 id 即可。

Glide.with(context)

.load(mUrl)

.transform(new RoundTransformation(this , 20))

.animate( R.anim.zoom_in )

.into(mImageView);

animate在Target中的使用：

ViewPropertyAnimation.Animatoranimator

= new ViewPropertyAnimation.Animator() {

@Override

public void animate(View view) {

view.setAlpha( 0f );

ObjectAnimator fadeAnim

= ObjectAnimator.ofFloat( view, "alpha", 0f, 1f );

fadeAnim.setDuration( 2500 );

fadeAnim.start();

}

};

Glide.with(context)

.load(mUrl)

.animate( animator )

.into(viewTarget);

5.5、Modules函数的使用

Glide 的Module 是一个可以全局改变Glide 的行为的东西。为了实现需求需要去实现 interface GlideModule 来实现功能

public class ExampleModule implements GlideModule{

@Override

public void applyOptions(Context context, GlideBuilder builder) {

// todo

}

@Override

public void registerComponents(Context context, Glide glide) {

// todo

} }

主要使用的是 applyOptions(Context context, GlideBuilder builder) ，我们自己的需要重新定义的代码写在该方法里就可以了。然后我们还需要去 AndroidManifest.xml 中使用 meta 声明我们上面实现的 Module：

="com.mrtrying.demoglide.module.ExampleModule" android:value="GlideModule" />

... </application>

到这里我们就完成了 ExampleModule 的声明，Glide 将会在工作是使用我们所定义的 Module

TIPS

我们需要将 android:name 属性改成包名+类名的形式，这样的引用才是正确的。如果你想删掉 Glide Module，只需要删除在 AndroidManifest.xml 中的声明就可以了。Java 类可以保存，说不定以后会用呢。如果它没有在 AndroidManifest.xml 中被引用，那它不会被加载或被使用。
定制 module 的话 Glide 会有这样一个优点：你可以同时声明多个 Glide module。Glide 将会（没有特定顺序）得到所有的声明 module。因为你当前不能定义顺序，请确保定制不会引起冲突！

applyOptions(Context context, GlideBuilder builder) 中有两个参数，我们通过使用 GlideBuilder 来实现我们的需求。先看看 GlideBuilder 中可用的方法

.setMemoryCache(MemoryCache memoryCache)
.setBitmapPool(BitmapPool bitmapPool)
.setDiskCache(DiskCache.Factory diskCacheFactory)
.setDiskCacheService(ExecutorService service)
.setResizeService(ExecutorService service)
.setDecodeFormat(DecodeFormat decodeFormat)

可以看到，这个 GlideBuilder 对象给你访问了 Glide 重要的核心组件。接下来我们就要试着去使用这些方法

增加 Glide 的图片质量

在 Android 中有两个主要的方法对图片进行解码：ARGB_8888 和 RGB_565 。前者为每个像素使用4个字节，后者每个像素仅使用2个字节。ARGB_8888 的有时就是图像质量更高以及能储存一个 alpha 通道。 Picasso 使用的就是 ARGB_8888 ， Glide 默认使用低质量的 RGB_565 ，但是现在你就可以使用 Glide module 来改变图片解码规则。就象这样

public class QualityModule implements GlideModule{

@Override

public void applyOptions(Context context , GlideBuilder builder){

builder.setDecodeFormat(DecodeFormat.PREFER_ARGB_8888);

}

@Override

public void registerComponents(Context context , Glide glide){

// nothing to do here

}

这样我们就简单的增加了 Glide 的图片质量。

往往我们还会遇到一些情况，希望 Glide 可以使用我们自己的网络框架，我们就需要做一些事情来实现这个需求了。Glide 的开发者不强制设置网络库给你，所以Glide可以说和 HTTPS 无关。理论上，它可以与任何的网络库实现，只要覆盖了基本的网络能力就行。同样是需要实现 Glide 的 ModuleLoader 的接口，为了让我们更加易用，Glide 为 OkHttp 和 Volley 两个网络库提供了实现。

假设我要集成 OkHttp 作为 Glide 的网络库，我可以手动实现一个 GlideModule 也可以在 build.gradle 中添加依赖：

dependencies{

//...

// Glide

compile 'com.github.bumptech.glide:glide:3.7.0'

// Glide's OkHttp Integration

compile 'com.github.bumptech.glide:okhttp-integration:1.4.0@aar'

compile 'com.squareup.okhttp:okhttp:3.2.0'

}

Gradle 会自动合并必要的 GlideModule 到你的 AndroidManifest.xml ， Glide 会认可在 manifest 中存在，然后使用 OkHttp 做到的所有网络连接！！

作者：MrTrying

链接：https://www.jianshu.com/p/7ce7b02988a4

來源：简书

以上一小节选取了该文章的内容多谢分享！

六、Gilde相关知识补充-bitmap &oom & 优化bitmap

4.6.1 bitmap 导致OOM

a、在使用list类View

一、加载大量View组件又没有合理的处理缓存的情况下，大量加载bitmap很容易造成OOM。

解决方法：

（1）三级缓存

（2）设置listView的监听事件，当滑动的时候不进行图片的加载，当停止滑动的时候再加载

二、图片分辨率越来越高，消耗的内存越来越大

注意：图片Bitmap所占用的内存 = 图片长度 * 图片宽度 * 一个像素点占用的字节数

三、VM值上限dalvik.vm.heapgrowthlimit

限定了每个app 可用的最大内存，如果超过这个值就会出现OOM现象

4.6.2 bitmap的4种优化策略

一、对图片质量进行压缩

private Bitmap compressImage(Bitmap image) {

//1、创建字节输出流

ByteArrayOutputStream baos = new ByteArrayOutputStream();

//2、Bitmap.CompressFormat进行压缩（类型，值越小代表压缩比例越大，100表示不压缩，压缩好的图片放在字节输出流）

image.compress(Bitmap.CompressFormat.JPEG

, 100, baos);

int options = 100;

//3、循环判断，压缩好的图片大小是否大于100kb，大于就进一步压缩

while (baos.toByteArray().length / 1024 > 100) {

//3.1、清空输出流

baos.reset();

//3.2、再次压缩

image.compress(Bitmap.CompressFormat.JPEG, options, baos);

//3.3、每次减少10options 数值

options -= 10;

}

//4、将压缩好的数据放入到字节输入流中

ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());

//5、通过BitmapFactory.decodeStream完成bitmap的重建

Bitmap bitmap = BitmapFactory.decodeStream(isBm, null, null);

return bitmap;

}

二、对图片按比例进行压缩

/**

* 图片比例压缩

private Bitmap comBitmapInSize(Bitmap image) {

//1、创建字节数组输入输出流

ByteArrayOutputStream baos = new ByteArrayOutputStream();

ByteArrayInputStream isBm;

//2、创建BitmapFactory的Options内部类对象，通过该对象可以对bimtap进行宽高、内存等的控制

BitmapFactory.Options newOpts = new BitmapFactory.Options();

//3、解码bitmap只返回它的宽高数值，而不必为他申请内存，通过设为true可以节省内存空间

newOpts.inJustDecodeBounds = true;

Bitmap bitmap;

int w = newOpts.outWidth;

int h = newOpts.outHeight;

float hh = 1290f; //设置高度为1280f

float ww = 720f; //设置宽度为720f

//4、创建be缩放比例

int be = 1;

if (w > h && w > ww) {

//4.1、如果宽大于高的话，就根据宽的大小进行缩放

be = (int) (newOpts.outWidth / ww);

} else if (w < h && h > hh) {

//4.2、如果宽小于高的话，就根据高的大小进行缩放

be = (int) (newOpts.outHeight / hh);

}

if (be <= 0)

be = 1;

//5、将计算好的比例数字be 赋值给Options中的缩放比例变量inSamplesize

newOpts.inSampleSize = be;

//6、将Options的inJustDecodeBounds设置为false表示需要将图片加载到内存中

newOpts.inJustDecodeBounds = false;

isBm = new ByteArrayInputStream(baos.toByteArray());

//7、重建bitmap

bitmap = BitmapFactory.decodeStream(isBm, null, newOpts);

return bitmap;

}

三、关于bitmap的recycle方法（含有争议话题）

/**

* Free the native object associated with this bitmap, and clear the

* reference to the pixel data. This will not free the pixel data synchronously;

* it simply allows it to be garbage collected if there are no other references.

* The bitmap is marked as "dead", meaning it will throw an exception if

* getPixels() or setPixels() is called, and will draw nothing. This operation

* cannot be reversed, so it should only be called if you are sure there are no

* further uses for the bitmap. This is an advanced call, and normally need

* not be called, since the normal GC process will free up this memory when

* there are no more references to this bitmap.

/**

* 当释放这个bitmap相关联的native对象的时候，它会清除像素数据。ps：不会同步的释放像素数据，只是根据在没有其他引用的情况下收集该GC垃圾，同时将状态标记为dead状态。这时候意味着调用 setPixels() 或是getPixels()时候都会抛出异常。而不回去绘制任务东西。通常情况下不需要手动的调用，当其没有引用这个bitmap的时候，正常的垃圾回收进程会释放掉该部分内存。

public void recycle() {

...

}

注解：手动的调用recycle()本身可能并没有被释放资源。所以硬要调用recycle的时候要将bitmap设置为null，好让GC和垃圾回收器回收这部分的对象。

四、捕获异常

针对OOM 的区域进行异常捕获

public void handleBitmapCrash() {

Bitmap bitmap = null;

String path = "xx/xx/xx";

try {

//实例化bitmap

bitmap = BitmapFactory.decodeFile(path);

} catch (OutOfMemoryError e) {

e.printStackTrace();

}

七、Gilde相关知识补充-三级缓存 /LruChache算法

Android的缓存策略-三级缓存

内存 - 本地 - 网络

意义：

第一次从网络获取，之后将获取的图片保存到本地和内存各一份，当程序再次用到该图片的时候首先会从内存中判断是否有缓存，有的话直接从内存中获取，没有的话再从本地SD卡中进行获取。如果内存和本地均没有的话，再次从网络上获取。

思考：内存缓存是如何实现的呢？

缓存主要是通过添加、获取、删除进行操作的。

不论内存缓存还是硬盘缓存，缓存的大小都是固定的，有个max限制。当该部分缓存用满之后其他缓存就无法再添加，所以需要进行删除无用缓存的操作。这时候就需要一个删除旧缓存的算法，也就说常说的LRU(Least Recently Used)近期最少使用缓存算法

LruChache算法

LRU核心

当缓存已满的时候会优先淘汰掉最近使用最少的缓存对象

整个Lru算法的核心是LinkedHashMap,其继承自HashMap，其构造函数中会有一个boolean类型的值，尤其控制插入的顺序，a是Lru顺序，b是正常顺序

public class LruCache<T, Y> {

private final LinkedHashMap<T, Y> cache= new LinkedHashMap<T, Y>(100, 0.75f(负载因子), true(当为true时候说明整个顺序是通过Lru算法顺序删除元素的));

int size : 当前缓存的大小

int maxSize : 当前缓存的最大值

int putCount : put方法调用的次数

int createCount : create方法调用的次数

int evictionCount : 当需要淘汰一些缓存变量时候的计数器

int hitCount : 缓存对象使用到hitCount +1 计数

int missCount : 缓存未命中计数 +1

Get():

传入key值获取相应的item，若是无缓存会创建并返回相应的item，相应的item会被移动到队列的尾部。

public final V get(K key){

if(key == null ) {

throw new NullPointerException(“key==null"):

}

V mapValue;

//利用LinkedHashMap的get方法获取相应的value

synchronized(this){

mapValue = map.get(key);

if(mapValue !=null){

//获取到缓存 hitCount+1 并返回Value值

hitCount++;

return mapValue;

}

missCount++ ;

}

//未命中，调用create()创建一个对象

V createdValue = create(key);

if(createdValue == null) {

return null;

}

synchronized (this ){

createCount++;

//覆盖原有Value值并添加到mapValue中

mapValue = map.put(key , createdValue);

if(mapValue !=null){

//如果该值不为空，将重新创建好的cratedValue又覆盖成原来的mapValue，逆推上一步操作

map.put(key,mapValue); //插入的新的对象会存储到列表的尾端

}else{

//加入新创建的对象需要重新创建缓存size大小

size += safeSizeOf(key ,createValue);

}

if(mapValue != null){

entryRemoved(false, key,createdValue,mapValue);

return mapValue;

}else {

//新加入对象都会调用trimToSize()，来查看对象是否需要被回收。根据传入的缓存的最大容量调整缓存的大小。传入 -1 表示清空所有缓存对象

trimToSize(maxSize);

return createdValue;

}

Put():

public final V put (K key , V value){

if(key == null || value == null) {

throw new NullPointerException (“key ==null ||value ==null ")

}

V previos ;

synchronized (this ){

//调用put方法每次计数+1

putCount ++;

// 每次put都会造成整个缓存大小增大，所以需要自增当前缓存

size += safeSizeOf (key ,value );

previous= map .put(key , value );

//如果之前存在key为键值的对象，这时候当前的缓存size 需要减掉这个对象的大小

if( previous !=null){

size -= safeSizeOf (key ,previous);

}

if(previous !=null ){

entryRemoved (false ,key ,previous ,value);

}

//调整内存缓存大小，插入的新对象会存储在列表的尾端

trimToSize (maxSize);

return previous;

}

LruCache中将LinkedHashMap的顺序设置为LRU顺序来实现LRU缓存
每次调用get则将该对象移到链表的尾端
调用put插入新的对象也是存储在链表尾端
当内存缓存达到设定的最大值时候，将链表头部的对象(近期最少使用到的)移除

转载于:https://www.cnblogs.com/cold-ice/p/9303485.html