with
public static RequestManager with(Activity activity) {
//单例返回RequestManagerRetriever对象,构造中对应主线程
RequestManagerRetriever retriever = RequestManagerRetriever.get();
//多个重载方法
return retriever.get(activity);//[1.1]
}
1.1 RequestManagerRetriever.get()
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
public RequestManager get(Activity activity) {
//低版本或者子线程中无法管理生命周期
if (Util.isOnBackgroundThread() || Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB) {
return get(activity.getApplicationContext());
} else {
assertNotDestroyed(activity);
//得到FragmentManager
android.app.FragmentManager fm = activity.getFragmentManager();
return fragmentGet(activity, fm);//[1.2]
}
}
1.2 RequestManagerRetriever.fragmentGet()
由于生命周期在RequestManagerFragment中掌控,所以必须有核心类RequestManager做支持处理
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
RequestManager fragmentGet(Context context, android.app.FragmentManager fm) {
//得到的RequestManagerFragment是一个继承自Fragment的对象,并且绑定到了Activity中,所以生命周期同步
//内部可以通过ActivityFragmentLifecycle这个对象进行生命周期方法的处理
RequestManagerFragment current = getRequestManagerFragment(fm);
//首次肯定为null
RequestManager requestManager = current.getRequestManager();
if (requestManager == null) {
requestManager = new RequestManager(context, current.getLifecycle(), current.getRequestManagerTreeNode());
//将生成的RequestManager设置到RequestManagerFragment内部
current.setRequestManager(requestManager);
}
return requestManager;
}
具体生命周期做了什么可以看RequestManagerFragment内部实现
现在看RequestManager类
RequestManager.java
public RequestManager(Context context, Lifecycle lifecycle, RequestManagerTreeNode treeNode) {
this(context, lifecycle, treeNode, new RequestTracker(), new ConnectivityMonitorFactory());
}
RequestManager(Context context, final Lifecycle lifecycle, RequestManagerTreeNode treeNode,
RequestTracker requestTracker, ConnectivityMonitorFactory factory) {
this.context = context.getApplicationContext();
this.lifecycle = lifecycle;//ActivityFragmentLifecycle
this.treeNode = treeNode;//RequestManagerTreeNode
this.requestTracker = requestTracker;//RequestTracker
this.glide = Glide.get(context);
this.optionsApplier = new OptionsApplier();
//通过工厂构造一个连接监听器,工厂内部通过权限做判断,有网络情况使用DefaultConnectivityMonitor
//内部有个广播接收器,如果收到广播则调用requestTracker中的restartRequests重启请求方法
ConnectivityMonitor connectivityMonitor = factory.build(context,
new RequestManagerConnectivityListener(requestTracker));
//增加生命周期监听,这样就把生命周期回调的方法移植到RequestManager中
if (Util.isOnBackgroundThread()) {
new Handler(Looper.getMainLooper()).post(new Runnable() {
@Override
public void run() {
lifecycle.addListener(RequestManager.this);
}
});
} else {
lifecycle.addListener(this);
}
//同样的,在生命周期的过程中有对链接的处理DefaultConnectivityMonitor
lifecycle.addListener(connectivityMonitor);
}
由此可以看出RequestManager作为一个大类负责掌控这生命周期回调的大全,所以这里是核心中的核心也是一个掌控者。
当然,但是掌控者具体不做处理,只是作为管理,那么谁才是处理呢?那就是glide对象,下面分析此构造方法。
Glide
自定义model使用
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<meta-data
android:name="com.example.lizejun.repoglidelearn.CustomGlideModule"
android:value="GlideModule"/>
</application>
public class CustomGlideModule implements GlideModule {
@Override
public void applyOptions(Context context, GlideBuilder builder) {
//通过builder.setXXX进行配置.
}
@Override
public void registerComponents(Context context, Glide glide) {
//通过glide.register进行配置.
}
}
public static Glide get(Context context) {
if (glide == null) {
synchronized (Glide.class) {
if (glide == null) {
Context applicationContext = context.getApplicationContext();
//根据GlideModule标记进行解析,将反射的GlideModule放入列表中
List<GlideModule> modules = new ManifestParser(applicationContext).parse();
GlideBuilder builder = new GlideBuilder(applicationContext);
for (GlideModule module : modules) {
//调用自定义model的实现方法applyOptions
module.applyOptions(applicationContext, builder);
}
//创造Glide对象
glide = builder.createGlide();
for (GlideModule module : modules) {
//进行注册
module.registerComponents(applicationContext, glide);
}
}
}
}
return glide;
}
Glide createGlide() {
//创建自己的线程池
if (sourceService == null) {
final int cores = Math.max(1, Runtime.getRuntime().availableProcessors());
sourceService = new FifoPriorityThreadPoolExecutor(cores);
}
//再来一个线程池
if (diskCacheService == null) {
diskCacheService = new FifoPriorityThreadPoolExecutor(1);
}
//内存计算类
MemorySizeCalculator calculator = new MemorySizeCalculator(context);
//搞一个bitmap池
if (bitmapPool == null) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
int size = calculator.getBitmapPoolSize();
bitmapPool = new LruBitmapPool(size);
} else {
bitmapPool = new BitmapPoolAdapter();
}
}
//资源缓存
if (memoryCache == null) {
memoryCache = new LruResourceCache(calculator.getMemoryCacheSize());
}
//磁盘缓存
if (diskCacheFactory == null) {
diskCacheFactory = new InternalCacheDiskCacheFactory(context);
}
//处理引擎
if (engine == null) {
engine = new Engine(memoryCache, diskCacheFactory, diskCacheService, sourceService);
}
//默认编码
if (decodeFormat == null) {
decodeFormat = DecodeFormat.DEFAULT;
}
//创建这些组合对象完成之后构造Glide
return new Glide(engine, memoryCache, bitmapPool, context, decodeFormat);
}
- 资源缓存
- 磁盘缓存
- bitmap缓存
- 默认编码格式
- 处理引擎
- 磁盘线程池
- 来源线程池
继续来到Glide构造
Glide(Engine engine, MemoryCache memoryCache, BitmapPool bitmapPool, Context context, DecodeFormat decodeFormat) {
this.engine = engine;
this.bitmapPool = bitmapPool;
this.memoryCache = memoryCache;
this.decodeFormat = decodeFormat;
//各种加载方案的生成器
loaderFactory = new GenericLoaderFactory(context);
mainHandler = new Handler(Looper.getMainLooper());
//bitmap的过滤器
bitmapPreFiller = new BitmapPreFiller(memoryCache, bitmapPool, decodeFormat);
//数据源注册器
dataLoadProviderRegistry = new DataLoadProviderRegistry();
//下面就是各种数据源注册
StreamBitmapDataLoadProvider streamBitmapLoadProvider =
new StreamBitmapDataLoadProvider(bitmapPool, decodeFormat);
dataLoadProviderRegistry.register(InputStream.class, Bitmap.class, streamBitmapLoadProvider);
FileDescriptorBitmapDataLoadProvider fileDescriptorLoadProvider =
new FileDescriptorBitmapDataLoadProvider(bitmapPool, decodeFormat);
dataLoadProviderRegistry.register(ParcelFileDescriptor.class, Bitmap.class, fileDescriptorLoadProvider);
ImageVideoDataLoadProvider imageVideoDataLoadProvider =
new ImageVideoDataLoadProvider(streamBitmapLoadProvider, fileDescriptorLoadProvider);
dataLoadProviderRegistry.register(ImageVideoWrapper.class, Bitmap.class, imageVideoDataLoadProvider);
GifDrawableLoadProvider gifDrawableLoadProvider =
new GifDrawableLoadProvider(context, bitmapPool);
dataLoadProviderRegistry.register(InputStream.class, GifDrawable.class, gifDrawableLoadProvider);
dataLoadProviderRegistry.register(ImageVideoWrapper.class, GifBitmapWrapper.class,
new ImageVideoGifDrawableLoadProvider(imageVideoDataLoadProvider, gifDrawableLoadProvider, bitmapPool));
dataLoadProviderRegistry.register(InputStream.class, File.class, new StreamFileDataLoadProvider());
//注册不同模型
register(File.class, ParcelFileDescriptor.class, new FileDescriptorFileLoader.Factory());
register(File.class, InputStream.class, new StreamFileLoader.Factory());
register(int.class, ParcelFileDescriptor.class, new FileDescriptorResourceLoader.Factory());
register(int.class, InputStream.class, new StreamResourceLoader.Factory());
register(Integer.class, ParcelFileDescriptor.class, new FileDescriptorResourceLoader.Factory());
register(Integer.class, InputStream.class, new StreamResourceLoader.Factory());
register(String.class, ParcelFileDescriptor.class, new FileDescriptorStringLoader.Factory());
register(String.class, InputStream.class, new StreamStringLoader.Factory());
register(Uri.class, ParcelFileDescriptor.class, new FileDescriptorUriLoader.Factory());
register(Uri.class, InputStream.class, new StreamUriLoader.Factory());
register(URL.class, InputStream.class, new StreamUrlLoader.Factory());
register(GlideUrl.class, InputStream.class, new HttpUrlGlideUrlLoader.Factory());
register(byte[].class, InputStream.class, new StreamByteArrayLoader.Factory());
//转换器的注册
transcoderRegistry.register(Bitmap.class, GlideBitmapDrawable.class,
new GlideBitmapDrawableTranscoder(context.getResources(), bitmapPool));
transcoderRegistry.register(GifBitmapWrapper.class, GlideDrawable.class,
new GifBitmapWrapperDrawableTranscoder(
new GlideBitmapDrawableTranscoder(context.getResources(), bitmapPool)));
//裁剪注册
bitmapCenterCrop = new CenterCrop(bitmapPool);
drawableCenterCrop = new GifBitmapWrapperTransformation(bitmapPool, bitmapCenterCrop);
//位图大小适配器注册
bitmapFitCenter = new FitCenter(bitmapPool);
drawableFitCenter = new GifBitmapWrapperTransformation(bitmapPool, bitmapFitCenter);
}
我们这个时候需要分析一下DataLoadProviderRegistry.register和GenericLoaderFactory.register到底是干什么的有什么作用
//DataLoadProviderRegistry
//在StreamBitmapDataLoadProvider中定义了
StreamBitmapDataLoadProvider streamBitmapLoadProvider = new StreamBitmapDataLoadProvider(bitmapPool, decodeFormat);
dataLoadProviderRegistry.register(InputStream.class, Bitmap.class, streamBitmapLoadProvider);
public StreamBitmapDataLoadProvider(BitmapPool bitmapPool, DecodeFormat decodeFormat) {
sourceEncoder = new StreamEncoder();//流编码器,用于将原始数据写入磁盘
decoder = new StreamBitmapDecoder(bitmapPool, decodeFormat);//解码器,用于从原始数据解码资源
encoder = new BitmapEncoder();//位图编码器,用于将已经解码的资源写入磁盘
cacheDecoder = new FileToStreamDecoder<Bitmap>(decoder);//用于解码磁盘中缓存中的资源
}
然后在分析DataLoadProviderRegistry.register方法
public <T, Z> void register(Class<T> dataClass, Class<Z> resourceClass, DataLoadProvider<T, Z> provider) {
//MultiClassKey是将两种类型绑定起来当成一种类型进行处理
providers.put(new MultiClassKey(dataClass, resourceClass), provider);
}
也就是说,dataProvider的处理是将这些数据的写入和读取做封装,用组合作为key,具体的key有:
- InputStream.class, Bitmap.class
- ParcelFileDescriptor.class, Bitmap.class
- ImageVideoWrapper.class, Bitmap.class
- InputStream.class, GifDrawable.class
- ImageVideoWrapper.class, GifBitmapWrapper.class
- InputStream.class, File.class
然后在分析Glide.register
先看内部结构
public <T, Y> void register(Class<T> modelClass, Class<Y> resourceClass, ModelLoaderFactory<T, Y> factory) {
ModelLoaderFactory<T, Y> removed = loaderFactory.register(modelClass, resourceClass, factory);
if (removed != null) {
removed.teardown();
}
}
其中用到了loaderFactory,这个是在Glide构造时候产生的,对应类型是GenericLoaderFactory
public <T, Y> void register(Class<T> modelClass, Class<Y> resourceClass, ModelLoaderFactory<T, Y> factory) {
ModelLoaderFactory<T, Y> removed = loaderFactory.register(modelClass, resourceClass, factory);
if (removed != null) {
removed.teardown();
}
}
public synchronized <T, Y> ModelLoaderFactory<T, Y> register(Class<T> modelClass, Class<Y> resourceClass,
ModelLoaderFactory<T, Y> factory) {
cachedModelLoaders.clear();
Map<Class/*Y*/, ModelLoaderFactory/*T, Y*/> resourceToFactories = modelClassToResourceFactories.get(modelClass);
if (resourceToFactories == null) {
resourceToFactories = new HashMap<Class/*Y*/, ModelLoaderFactory/*T, Y*/>();
modelClassToResourceFactories.put(modelClass, resourceToFactories);
}
ModelLoaderFactory/*T, Y*/ previous = resourceToFactories.put(resourceClass, factory);
//下面操作是去掉重复的老值
if (previous != null) {
// This factory may be being used by another model. We don't want to say it has been removed unless we
// know it has been removed for all models.
for (Map<Class/*Y*/, ModelLoaderFactory/*T, Y*/> factories : modelClassToResourceFactories.values()) {
if (factories.containsValue(previous)) {
previous = null;
break;
}
}
}
return previous;
}
这里注意hashmap的put方法,如果put成功了则返回null,如果key重复了,就返回原来的值
看下这块数据结构:
private final Map<Class , Map<Class, ModelLoaderFactory>> modelClassToResourceFactories = new HashMap<Class, Map<Class, ModelLoaderFactory>>();
第一个class是modelClass,第二个class是resourceClass,ModelLoaderFactory是factory
那也就是说,主要是用模型来映射资源类和工厂类
然后总结效果图:
- File对应的如下:
- ParcelFileDescriptor:FileDescriptorFileLoader
- InputStream:StreamFileLoader
- int:
- ParcelFileDescriptor:FileDescriptorResourceLoader
- InputStream:StreamResourceLoader
- Integer:
- ParcelFileDescriptor:FileDescriptorResourceLoader
- InputStream:StreamResourceLoader
- String:
- ParcelFileDescriptor:FileDescriptorStringLoader
- InputStream:StreamStringLoader
- Uri:
- ParcelFileDescriptor:FileDescriptorUriLoader
- InputStream:StreamUriLoader
- URL:
- InputStream:StreamUrlLoader
- GlideUrl:
- InputStream:HttpUrlGlideUrlLoader
- byte:
- InputStream:StreamByteArrayLoader
我们大概看一眼工厂都干啥
public interface ModelLoaderFactory<T, Y> {
ModelLoader<T, Y> build(Context context, GenericLoaderFactory factories);
void teardown();
}
public static class Factory implements ModelLoaderFactory<String, InputStream> {
public Factory() {
}
//主要方法是build,进行构造对应类
public ModelLoader<String, InputStream> build(Context context, GenericLoaderFactory factories) {
return new StreamStringLoader(factories.buildModelLoader(Uri.class, InputStream.class));
}
public void teardown() {
}
}
所以工厂类就是专门提供创建获取资源的数据的类。
小结:
DataLoadProviderRegistry注册器注册了什么:
//注册进了
Map<MultiClassKey, DataLoadProvider<?, ?>> providers;
providers.put(new MultiClassKey(dataClass, resourceClass), provider);
- InputStream
- Bitmap
:
StreamBitmapDataLoadProvider - GifDrawable
:
GifDrawableLoadProvider - File
:
StreamFileDataLoadProvider
- Bitmap
- ParcelFileDescriptor
- Bitmap
:
FileDescriptorBitmapDataLoadProvider
- Bitmap
- ImageVideoWrapper
- Bitmap
:
ImageVideoDataLoadProvider - GifBitmapWrapper
:
ImageVideoGifDrawableLoadProvider
- Bitmap
GenericLoaderFactory.loaderFactory注册器注册了什么:
//注册进了
Map<Class/*T*/, Map<Class/*Y*/, ModelLoaderFactory/*T, Y*/>> modelClassToResourceFactories;
- File
- ParcelFileDescriptor
:
FileDescriptorFileLoader - InputStream
:
StreamFileLoader
- ParcelFileDescriptor
- int
- ParcelFileDescriptor
:
FileDescriptorResourceLoader - InputStream
:
StreamResourceLoader
- ParcelFileDescriptor
- Integer
- ParcelFileDescriptor
:
FileDescriptorResourceLoader - InputStream
:
StreamResourceLoader
- ParcelFileDescriptor
- String
- ParcelFileDescriptor
:
FileDescriptorStringLoader - InputStream
:
StreamStringLoader
- ParcelFileDescriptor
- Uri
- ParcelFileDescriptor
:
FileDescriptorUriLoader - InputStream
:
StreamUriLoader
- ParcelFileDescriptor
- URL
- InputStream
:
StreamUrlLoader
- InputStream
- GlideUrl
- InputStream
:
HttpUrlGlideUrlLoader
- InputStream
- byte
- InputStream
:
StreamByteArrayLoader
- InputStream
TranscoderRegistry.transcoderRegistry注册器注册了什么:
//同理这个注册进了
Map<MultiClassKey, ResourceTranscoder<?, ?>> factories;
factories.put(new MultiClassKey(decodedClass, transcodedClass), transcoder);
- Bitmap
- GlideBitmapDrawable
:
GlideBitmapDrawableTranscoder
- GlideBitmapDrawable
- GifBitmapWrapper
- GlideDrawable
:
GifBitmapWrapperDrawableTranscoder
- GlideDrawable
load
public DrawableTypeRequest<String> load(String string) {
return (DrawableTypeRequest<String>) fromString().load(string);
}
public DrawableTypeRequest<Uri> load(Uri uri) {
return (DrawableTypeRequest<Uri>) fromUri().load(uri);
}
public DrawableTypeRequest<File> load(File file) {
return (DrawableTypeRequest<File>) fromFile().load(file);
}
从fromString()开始分析
public DrawableTypeRequest<String> fromString() {
return loadGeneric(String.class);
}
private <T> DrawableTypeRequest<T> loadGeneric(Class<T> modelClass) {
//通过loaderFactory去找
//拿到了FileDescriptorStringLoader
ModelLoader<T, InputStream> streamModelLoader = Glide.buildStreamModelLoader(modelClass, context);
//拿到了StreamStringLoader
ModelLoader<T, ParcelFileDescriptor> fileDescriptorModelLoader =
Glide.buildFileDescriptorModelLoader(modelClass, context);
if (modelClass != null && streamModelLoader == null && fileDescriptorModelLoader == null) {
throw new IllegalArgumentException("xxx");
}
//根据String.class和FileDescriptorStringLoader,了StreamStringLoader等构造DrawableTypeRequest
return optionsApplier.apply(
new DrawableTypeRequest<T>(modelClass, streamModelLoader, fileDescriptorModelLoader, context,
glide, requestTracker, lifecycle, optionsApplier));
}
针对下面这句代码,做如下分析
ModelLoader<T, InputStream> streamModelLoader = Glide.buildStreamModelLoader(modelClass, context);
首先modelClass是String.class
public static <T> ModelLoader<T, InputStream> buildStreamModelLoader(Class<T> modelClass, Context context) {
return buildModelLoader(modelClass, InputStream.class, context);
}
所以传入和是String.class和InputStream.class
然后通过这两种类型去loader工厂中找。这个时候我们就要看我们当初注册的了。
public ModelLoader<String, InputStream> build(Context context, GenericLoaderFactory factories) {
return new StreamStringLoader(factories.buildModelLoader(Uri.class, InputStream.class));
}
所以返回的是这样一个ModelLoader。
然后我们分析下一句:
传入的是String.class和
ModelLoader<T, ParcelFileDescriptor> fileDescriptorModelLoader =
Glide.buildFileDescriptorModelLoader(modelClass, context);
所以还是老套路,通过String.class和ParcelFileDescriptor.class在列表中找。
看上面这一句。
先看DrawableTypeRequest的构造
参数列表:
- String.class
- StreamStringLoader
- FileDescriptorStringLoader
- context
- glide
- RequestTracker
- Lifecycle
- RequestManager.OptionsApplier
DrawableTypeRequest(Class<ModelType> modelClass, ModelLoader<ModelType, InputStream> streamModelLoader,
ModelLoader<ModelType, ParcelFileDescriptor> fileDescriptorModelLoader, Context context, Glide glide,
RequestTracker requestTracker, Lifecycle lifecycle, RequestManager.OptionsApplier optionsApplier) {
super(context, modelClass,
buildProvider(glide, streamModelLoader, fileDescriptorModelLoader, GifBitmapWrapper.class,
GlideDrawable.class, null),
glide, requestTracker, lifecycle);
this.streamModelLoader = streamModelLoader;
this.fileDescriptorModelLoader = fileDescriptorModelLoader;
this.optionsApplier = optionsApplier;
}
将这些大杂烩集中起来
DrawableTypeRequest 参数列表:
- String.class
- StreamStringLoader
- FileDescriptorStringLoader
- context
- glide
- RequestTracker
- Lifecycle
- RequestManager.OptionsApplier
DrawableRequestBuilder extends DrawableRequestBuilder
DrawableTypeRequest传入的参数
变量 | 类型 |
---|---|
T | String.class |
modelClass | String.class |
streamModelLoader | StreamStringLoader |
fileDescriptorModelLoader | FileDescriptorStringLoader |
context | Context |
glide | Glide |
requestTracker | RequestTracker |
lifecycle | Lifecycle |
optionsApplier | OptionsApplier |
buildProvider(xxx)
所需参数
变量 | 类型 |
---|---|
glide | Glide |
streamModelLoader | StreamStringLoader |
fileDescriptorModelLoader | FileDescriptorStringLoader |
resourceClass | GifBitmapWrapper.class |
transcodedClass | GlideDrawable.class |
null | ResourceTranscoder.class |
然后看实现部分:
- transcoder==null,然后根据GifBitmapWrapper.class和GlideDrawable.class进行build出ResourceTranscoder
在gilde的构造中:
所以第一步可以看出,得到的是
new GifBitmapWrapperDrawableTranscoder(new GlideBitmapDrawableTranscoder(context.getResources(), bitmapPool))
- 根据ImageVideoWrapper.class和GifBitmapWrapper.class进行build
同样在glide的构造中得到对应的注册表
所以这里得到的是:
new ImageVideoGifDrawableLoadProvider(imageVideoDataLoadProvider, gifDrawableLoadProvider, bitmapPool)
- 根据StreamStringLoader的对象和FileDescriptorStringLoader对象创建了一个ImageVideoModelLoader
ImageVideoModelLoader<A> modelLoader = new ImageVideoModelLoader<A>(streamModelLoader,fileDescriptorModelLoader);
- 生成一个FixedLoadProvider进行返回
其中FixedLoadProvider持有:
- ImageVideoModelLoader modelLoader
- GifBitmapWrapperDrawableTranscoder transcoder
- ImageVideoGifDrawableLoadProvider dataLoadProvider
然后这个时候回到DrawableTypeRequest中继续super方法进入DrawableRequestBuilder extends GenericRequestBuilder构造
参数传入的是
变量 | 类型 |
---|---|
modelClass | String.class |
context | Context |
loadProvider | LoadProvider<ModelType, ImageVideoWrapper, GifBitmapWrapper, GlideDrawable> loadProvider |
glide | Glide |
requestTracker | RequestTracker |
lifecycle | Lifecycle |
继续GenericRequestBuilder构造
继承关系图如下:
into
由于执行load返回的是DrawableTypeRequest对象,所以在其中搜into方法
public Target<GlideDrawable> into(ImageView view) {
return super.into(view);
}
注意transcodeClass是GlideDrawable.class
先进入:
glide.buildImageViewTarget(view, transcodeClass)
通过一个ImageView和GlideDrawable.classbuildTarget
private final ImageViewTargetFactory imageViewTargetFactory = new ImageViewTargetFactory();
<R> Target<R> buildImageViewTarget(ImageView imageView, Class<R> transcodedClass) {
return imageViewTargetFactory.buildTarget(imageView, transcodedClass);
}
public <Z> Target<Z> buildTarget(ImageView view, Class<Z> clazz) {
if (GlideDrawable.class.isAssignableFrom(clazz)) {
return (Target<Z>) new GlideDrawableImageViewTarget(view);
} else if (Bitmap.class.equals(clazz)) {
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)");
}
}
可见返回的是GlideDrawableImageViewTarget
然后进入into方法
GenericRequestBuilder.into()
//传入的是GlideDrawableImageViewTarget
public <Y extends Target<TranscodeType>> Y into(Y target) {
Util.assertMainThread();
if (target == null) {
throw new IllegalArgumentException("You must pass in a non null Target");
}
if (!isModelSet) {
throw new IllegalArgumentException("You must first set a model (try #load())");
}
Request previous = target.getRequest();
if (previous != null) {
previous.clear();
requestTracker.removeRequest(previous);
previous.recycle();
}
//核心在创造一个Request
Request request = buildRequest(target);
target.setRequest(request);
lifecycle.addListener(target);
//这一波说明RequestTracker添加了该请求&运行
requestTracker.runRequest(request);
return target;
}
核心就是构造一个请求,然后设置请求然后运行
target : GlideDrawableImageViewTarget
在buildRequest中最主要是执行了
当请求设置好之后就进行runRequest的操作了
public void runRequest(Request request) {
requests.add(request);
if (!isPaused) {
request.begin();
} else {
//如果是暂停状态则放入稍后启动请求列表
pendingRequests.add(request);
}
}
GenericRequest.begin()
public void begin() {
startTime = LogTime.getLogTime();
if (model == null) {
onException(null);
return;
}
status = Status.WAITING_FOR_SIZE;
if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
onSizeReady(overrideWidth, overrideHeight);//符合大小规范
} else {
target.getSize(this);
}
if (!isComplete() && !isFailed() && canNotifyStatusChanged()) {
target.onLoadStarted(getPlaceholderDrawable());
}
if (Log.isLoggable(TAG, Log.VERBOSE)) {
logV("finished run method in " + LogTime.getElapsedMillis(startTime));
}
}
最后进入onSizeReady()
分析下里面的传参
header 1 | header 2 |
---|---|
signature | EmptySignature |
dataFetcher | DataFetcher有若干中实现 |
ModelLoader<A, T> modelLoader = loadProvider.getModelLoader();
final DataFetcher<T> dataFetcher = modelLoader.getResourceFetcher(model, width, height);
所以在ImageVideoModelLoader中寻找
总之最后是HttpUrlFetcher对象
@Override
public DataFetcher<ImageVideoWrapper> getResourceFetcher(A model, int width, int height) {
DataFetcher<InputStream> streamFetcher = null;
if (streamLoader != null) {
//StreamStringLoader
streamFetcher = streamLoader.getResourceFetcher(model, width, height);
}
DataFetcher<ParcelFileDescriptor> fileDescriptorFetcher = null;
if (fileDescriptorLoader != null) {
//FileDescriptorStringLoader
fileDescriptorFetcher = fileDescriptorLoader.getResourceFetcher(model, width, height);
}
if (streamFetcher != null || fileDescriptorFetcher != null) {
return new ImageVideoFetcher(streamFetcher, fileDescriptorFetcher);
} else {
return null;
}
}
针对streamFetcher = streamLoader.getResourceFetcher(model, width, height);
所以在glide的参数列表中找到
所以走到load里面
核心方法上图
其中最核心的是:
final A data = fetcher.loadData(priority);
真正的链接
所以A是个InputStream
所以后面就是根据流来获取一个Resource对象。
- 转换,转化长和宽等
- 写入缓存
- 是否将其编码成其他对象
callback执行这里
找下target,知道当时是GlideDrawableImageViewTarget,所以走到如下
我们看到轮播gif,到这里super.onResourceReady(resource, animation);
最后执行
显示图片。