前言
由名字可以看出這是一個解碼的幫助類，里面緩存了LoadData和Key，以及很多從DecoderJob傳遞過來的參數。它的主要作用是提供解碼所需要的的數據，并不進行實際的解碼操作。
final class DecodeHelper<Transcode> {
private final List<LoadData<?>> loadData = new ArrayList<>();
private final List<Key> cacheKeys = new ArrayList<>();
private Map<Class<?>, Transformation<?>> transformations; //在BaseRequestOptions中為CachedHashCodeArrayMap
private Object model; //String
private Class<?> resourceClass; //Object.class
private Class<Transcode> transcodeClass; //Drawable.class
}
getCacheKeys()
在這里獲取緩存到的key，如果沒有則會先獲取LoadData，再獲取LoadData里面的key。在Glide源碼解析之RequestBuilder我們在load()傳入的為String類型的 url,所以我們的model為String，則最終cacheKeys會包含GlideUrl（實現了Key接口），在下面會進行分析。
List<Key> getCacheKeys() {
if (!isCacheKeysSet) {
isCacheKeysSet = true;
cacheKeys.clear();
List<LoadData<?>> loadData = getLoadData();
//將LoadData里面的key都緩存起來
for (int i = 0, size = loadData.size(); i < size; i++) {
LoadData<?> data = loadData.get(i);
if (!cacheKeys.contains(data.sourceKey)) {
cacheKeys.add(data.sourceKey);
}
for (int j = 0; j < data.alternateKeys.size(); j++) {
if (!cacheKeys.contains(data.alternateKeys.get(j))) {
cacheKeys.add(data.alternateKeys.get(j));
}
}
}
}
return cacheKeys;
}
getLoadData()
LoadData是一個封裝了Key、List<key>、DataFetcher<Data>的類，里面沒有任何操作。首先會獲取已注冊的加載器中所有可以加載當前模型的ModelLoader，再由它調用buildLoadData()生成LoadData。這里最終獲取到的modelLoaders會包含HttpGlideUrlLoader，它最終會build一個Key為GlideUrl和DataFetcher為HttpUrlFetcher的LoadData出來。
class LoadData<Data> {
public final Key sourceKey;
public final List<Key> alternateKeys; //默認會賦值為Collections.<Key>emptyList()
public final DataFetcher<Data> fetcher;
}
List<LoadData<?>> getLoadData() {
if (!isLoadDataSet) {
isLoadDataSet = true;
loadData.clear();
List<ModelLoader<Object, ?>> modelLoaders = glideContext.getRegistry().getModelLoaders(model);
for (int i = 0, size = modelLoaders.size(); i < size; i++) {
ModelLoader<Object, ?> modelLoader = modelLoaders.get(i);
LoadData<?> current =
modelLoader.buildLoadData(model, width, height, options);
if (current != null) {
loadData.add(current);
}
}
}
return loadData;
}
getModelLoaders()
獲取能處理當前類型的ModelLoaders，而ModelLoader實際是由MultiModelLoaderFactory去build出來的。在MultiModelLoaderFactory中，將ModelLoaderFactory、modelClass(要加載的model，這里是String.class)、dataClass(加載的數據類型，例如InputStream.class)包裝成一個Entry，就像上面的LoadData那樣。而Entry的來源則是在Glide初始化的時候，由Registry設置給ModelLoaderRegistry，再設置給MultiModelLoaderFactory。
//Registry
public <Model> List<ModelLoader<Model, ?>> getModelLoaders(@NonNull Model model) {
List<ModelLoader<Model, ?>> result = modelLoaderRegistry.getModelLoaders(model);
if (result.isEmpty()) {
throw new NoModelLoaderAvailableException(model);
}
return result;
}
//ModelLoaderRegistry
public <A> List<ModelLoader<A, ?>> getModelLoaders(@NonNull A model) {
List<ModelLoader<A, ?>> modelLoaders = getModelLoadersForClass(getClass(model));
int size = modelLoaders.size();
boolean isEmpty = true;
List<ModelLoader<A, ?>> filteredLoaders = Collections.emptyList();
for (int i = 0; i < size; i++) {
ModelLoader<A, ?> loader = modelLoaders.get(i);
if (loader.handles(model)) { //是否能處理model類型
if (isEmpty) {
filteredLoaders = new ArrayList<>(size - i);
isEmpty = false;
}
filteredLoaders.add(loader);
}
}
return filteredLoaders;
}
//首先從緩存獲取，獲取不到再build一個新的，并存入緩存
private synchronized <A> List<ModelLoader<A, ?>> getModelLoadersForClass(
@NonNull Class<A> modelClass) {
List<ModelLoader<A, ?>> loaders = cache.get(modelClass);
if (loaders == null) {
loaders = Collections.unmodifiableList(multiModelLoaderFactory.build(modelClass));
cache.put(modelClass, loaders);
}
return loaders;
}
public class MultiModelLoaderFactory {
private final List<Entry<?, ?>> entries = new ArrayList<>();
private static class Entry<Model, Data> {
private final Class<Model> modelClass;
@Synthetic
final Class<Data> dataClass;
@Synthetic
final ModelLoaderFactory<? extends Model, ? extends Data> factory;
public Entry(
@NonNull Class<Model> modelClass,
@NonNull Class<Data> dataClass,
@NonNull ModelLoaderFactory<? extends Model, ? extends Data> factory) {
this.modelClass = modelClass;
this.dataClass = dataClass;
this.factory = factory;
}
public boolean handles(@NonNull Class<?> modelClass) {
return this.modelClass.isAssignableFrom(modelClass); //this.modelClass是否是modelClass的父類或者接口
}
}
synchronized <Model> List<ModelLoader<Model, ?>> build(@NonNull Class<Model> modelClass) {
try {
List<ModelLoader<Model, ?>> loaders = new ArrayList<>();
for (Entry<?, ?> entry : entries) {
if (alreadyUsedEntries.contains(entry)) {
continue;
}
if (entry.handles(modelClass)) {
//由于modelClass是String.class，所以最終只有modelClass為String.class的Entry才能執行到這里。
//比如有Entry(String.class, InputStream.class, new StringLoader.StreamFactory())
//所以loaders會add一個由StreamFactory去build出來的StringLoader。
alreadyUsedEntries.add(entry);
loaders.add(this.<Model, Object>build(entry));
alreadyUsedEntries.remove(entry);
}
}
return loaders;
} catch (Throwable t) {
alreadyUsedEntries.clear();
throw t;
}
}
private <Model, Data> ModelLoader<Model, Data> build(@NonNull Entry<?, ?> entry) {
return (ModelLoader<Model, Data>) Preconditions.checkNotNull(entry.factory.build(this));
}
//Entry的來源
private <Model, Data> void add(
@NonNull Class<Model> modelClass,
@NonNull Class<Data> dataClass,
@NonNull ModelLoaderFactory<? extends Model, ? extends Data> factory,
boolean append) {
Entry<Model, Data> entry = new Entry<>(modelClass, dataClass, factory);
entries.add(append ? entries.size() : 0, entry);
}
synchronized <Model, Data> void append(
@NonNull Class<Model> modelClass,
@NonNull Class<Data> dataClass,
@NonNull ModelLoaderFactory<? extends Model, ? extends Data> factory) {
add(modelClass, dataClass, factory, /*append=*/ true);
}
}
//ModelLoaderRegistry
public synchronized <Model, Data> void append(
@NonNull Class<Model> modelClass,
@NonNull Class<Data> dataClass,
@NonNull ModelLoaderFactory<? extends Model, ? extends Data> factory) {
multiModelLoaderFactory.append(modelClass, dataClass, factory);
cache.clear();
}
//Registry
public <Model, Data> Registry append(
@NonNull Class<Model> modelClass, @NonNull Class<Data> dataClass,
@NonNull ModelLoaderFactory<Model, Data> factory) {
modelLoaderRegistry.append(modelClass, dataClass, factory);
return this;
}
//Glide
Glide(){
registry
.append(String.class, InputStream.class, new DataUrlLoader.StreamFactory<String>())
.append(Uri.class, InputStream.class, new HttpUriLoader.Factory())
.append(String.class, InputStream.class, new StringLoader.StreamFactory())
.append(String.class, ParcelFileDescriptor.class, new StringLoader.FileDescriptorFactory())
.append(GlideUrl.class, InputStream.class, new HttpGlideUrlLoader.Factory())
}
上面說到會由StreamFactory去build一個StringLoader，而StringLoader的構造函數又傳入了一個由MultiModelLoaderFactory去build出來的ModelLoader。由于傳給它的是Uri.class和InputStream.class，我們去Glide的構造函數找到對應的factory為HttpUriLoader的內部類Factory。它build了一個HttpUriLoader，但同時它的構造函數又傳入一個新的ModelLoader，根據類型不難找到實際為HttpGlideUrlLoader。
public static class StreamFactory implements ModelLoaderFactory<String, InputStream> {
@NonNull
@Override
public ModelLoader<String, InputStream> build(
@NonNull MultiModelLoaderFactory multiFactory) {
return new StringLoader<>(multiFactory.build(Uri.class, InputStream.class));
}
}
//MultiModelLoaderFactory
public synchronized <Model, Data> ModelLoader<Model, Data> build(@NonNull Class<Model> modelClass,
@NonNull Class<Data> dataClass) {
try {
List<ModelLoader<Model, Data>> loaders = new ArrayList<>();
boolean ignoredAnyEntries = false;
for (Entry<?, ?> entry : entries) {
if (alreadyUsedEntries.contains(entry)) {
ignoredAnyEntries = true;
continue;
}
if (entry.handles(modelClass, dataClass)) {
//匹配Uri.class和InputStream.class的Entry(Uri.class, InputStream.class, new HttpUriLoader.Factory())
alreadyUsedEntries.add(entry);
loaders.add(this.<Model, Data>build(entry));
alreadyUsedEntries.remove(entry);
}
}
if (loaders.size() > 1) {
return factory.build(loaders, throwableListPool);
} else if (loaders.size() == 1) {
return loaders.get(0);
} else {
if (ignoredAnyEntries) {
return emptyModelLoader();
} else {
throw new NoModelLoaderAvailableException(modelClass, dataClass);
}
}
} catch (Throwable t) {
alreadyUsedEntries.clear();
throw t;
}
}
//HttpUriLoader
public static class Factory implements ModelLoaderFactory<Uri, InputStream> {
@NonNull
@Override
public ModelLoader<Uri, InputStream> build(MultiModelLoaderFactory multiFactory) {
return new HttpUriLoader(multiFactory.build(GlideUrl.class, InputStream.class));
}
}
//HttpGlideUrlLoader
public static class Factory implements ModelLoaderFactory<GlideUrl, InputStream> {
private final ModelCache<GlideUrl, GlideUrl> modelCache = new ModelCache<>(500);
@NonNull
@Override
public ModelLoader<GlideUrl, InputStream> build(MultiModelLoaderFactory multiFactory) {
return new HttpGlideUrlLoader(modelCache);
}
}
StringLoader
StringLoader實現了ModelLoader接口，里面主要是兩個方法，handles()在上面ModelLoaderRegistry.getModelLoaders()進行了判斷，這里主要看下看下buildLoadData()。
由上面分析可知StringLoader傳入了HttpUriLoader，而HttpUriLoader又傳入了HttpGlideUrlLoader，所以這里實際上是使用了代理模式，將實際生成LoadData的操作最終交給了HttpGlideUrlLoader。所以最終生成的LoadData的sourceKey為GlideUrl，fetcher為HttpUrlFetcher。
public class StringLoader<Data> implements ModelLoader<String, Data> {
private final ModelLoader<Uri, Data> uriLoader;
public StringLoader(ModelLoader<Uri, Data> uriLoader) {
this.uriLoader = uriLoader;
}
@Override
public LoadData<Data> buildLoadData(@NonNull String model, int width, int height,
@NonNull Options options) {
Uri uri = parseUri(model);
if (uri == null || !uriLoader.handles(uri)) {
return null;
}
return uriLoader.buildLoadData(uri, width, height, options);
}
//是否能處理String類型的model
@Override
public boolean handles(@NonNull String model) {
return true;
}
}
//HttpUriLoader
public LoadData<InputStream> buildLoadData(@NonNull Uri model, int width, int height,
@NonNull Options options) {
//urlLoader為HttpGlideUrlLoader
return urlLoader.buildLoadData(new GlideUrl(model.toString()), width, height, options);
}
//HttpGlideUrlLoader
public LoadData<InputStream> buildLoadData(@NonNull GlideUrl model, int width, int height,
@NonNull Options options) {
GlideUrl url = model;
if (modelCache != null) {
url = modelCache.get(model, 0, 0);
if (url == null) {
modelCache.put(model, 0, 0, model);
url = model;
}
}
int timeout = options.get(TIMEOUT);
return new LoadData<>(url, new HttpUrlFetcher(url, timeout));
}
getRegisteredResourceClasses()
上面說過model.getClass()為String.class，在RequestBuilder的父類BaseRequestOptions中resourceClass默認為Object.class，在Glide源碼解析之RequestBuilder我們在load()傳入的為String Url,里面會調用asDrawable()，所以這里transcodeClass為Drawable.class。
首先會先從緩存中獲取，如果沒有則調用modelLoaderRegistry.getDataClasses(modelClass)獲取String.class對應的dataClass，然后遍歷它，再調用decoderRegistry.getResourceClasses(dataClass, resourceClass)獲取對應已注冊的resourceClass，最后也遍歷registeredResourceClasses，根據registeredResourceClass,和transcodeClass獲取最終能處理的registeredResourceClass。所以最后的List會包含Drawable.class。
List<Class<?>> getRegisteredResourceClasses() {
return glideContext.getRegistry()
.getRegisteredResourceClasses(model.getClass(), resourceClass, transcodeClass);
}
//Registry
public <Model, TResource, Transcode> List<Class<?>> getRegisteredResourceClasses(
@NonNull Class<Model> modelClass /*String*/,
@NonNull Class<TResource> resourceClass /*Object*/,
@NonNull Class<Transcode> transcodeClass /*Drawable*/) {
List<Class<?>> result =
modelToResourceClassCache.get(modelClass, resourceClass, transcodeClass);
if (result == null) {
result = new ArrayList<>();
List<Class<?>> dataClasses = modelLoaderRegistry.getDataClasses(modelClass); //InputStream.class、ParcelFileDescriptor.class和AssetFileDescriptor.class
for (Class<?> dataClass : dataClasses) {
List<? extends Class<?>> registeredResourceClasses =
decoderRegistry.getResourceClasses(dataClass, resourceClass); //GifDrawable.class、Bitmap.class、BitmapDrawable.class
for (Class<?> registeredResourceClass : registeredResourceClasses) {
List<Class<Transcode>> registeredTranscodeClasses = transcoderRegistry
.getTranscodeClasses(registeredResourceClass, transcodeClass); //Drawable.class
if (!registeredTranscodeClasses.isEmpty() && !result.contains(registeredResourceClass)) {
result.add(registeredResourceClass); //Drawable.class
}
}
}
modelToResourceClassCache.put(
modelClass, resourceClass, transcodeClass, Collections.unmodifiableList(result));
}
return result;
}
getDataClasses()
還是和上面獲取ModelLoader一樣，這里也是根據Entry中是否能handles()對應的modelClass來獲取dataClasses。
由于modelClass為String.class，所以最終返回的List會包含InputStream.class、ParcelFileDescriptor.class和AssetFileDescriptor.class。
//ModelLoaderRegistry
public synchronized List<Class<?>> getDataClasses(@NonNull Class<?> modelClass) {
return multiModelLoaderFactory.getDataClasses(modelClass);
}
//MultiModelLoaderFactory
synchronized List<Class<?>> getDataClasses(@NonNull Class<?> modelClass) {
List<Class<?>> result = new ArrayList<>();
for (Entry<?, ?> entry : entries) {
//上面說了Entry實際會在Glide的構造函數通過Registry的append()賦值，那么只要找出哪些modelClass為String.class對應的dataClass就行了。
if (!result.contains(entry.dataClass) && entry.handles(modelClass)) {
result.add(entry.dataClass);
}
}
return result;
}
Glide(){
registry
.append(String.class, InputStream.class, new DataUrlLoader.StreamFactory<String>())
.append(String.class, InputStream.class, new StringLoader.StreamFactory())
.append(String.class, ParcelFileDescriptor.class, new StringLoader.FileDescriptorFactory())
.append(
String.class, AssetFileDescriptor.class, new StringLoader.AssetFileDescriptorFactory())
}
getResourceClasses()
第一個參數為InputStream.class，第二個參數為Drawable.class。由于decoders保存了所有在Glide構造函數中注冊的bucket，所以在Glide的構造函數中找出對應dataClass為InputStream的resource即可。最終這里返回的List會包含GifDrawable.class、Bitmap.class、BitmapDrawable.class。
//ResouceDecoderRegistry
public synchronized <T, R> List<Class<R>> getResourceClasses(@NonNull Class<T> dataClass,
@NonNull Class<R> resourceClass) {
List<Class<R>> result = new ArrayList<>();
for (String bucket : bucketPriorityList) {
List<Entry<?, ?>> entries = decoders.get(bucket);
if (entries == null) {
continue;
}
for (Entry<?, ?> entry : entries) {
if (entry.handles(dataClass, resourceClass)
&& !result.contains(entry.resourceClass)) {
result.add((Class<R>) entry.resourceClass);
}
}
}
return result;
}
ResourceDecoderRegistry
資源解碼注冊表，和MultiModelLoaderFactory作用類似，它們里面都有一個Entry保存了幾個變量，并且都有handles()用來判斷這個Entry能否處理對應的類型。
ResourceDecoderRegistry里面有一個bucketPriorityList，它是在Registry在的構造函數里賦值的。同時還用Map來保存了Entry，它則是在Glide的構造函數里通過Registry賦值的。
public class ResourceDecoderRegistry {
private final List<String> bucketPriorityList = new ArrayList<>();
private final Map<String, List<Entry<?, ?>>> decoders = new HashMap<>();
public synchronized void setBucketPriorityList(@NonNull List<String> buckets) {
List<String> previousBuckets = new ArrayList<>(bucketPriorityList);
bucketPriorityList.clear();
bucketPriorityList.addAll(buckets);
//如果之前bucketPriorityList有的元素是現在沒有，則同樣保存下來
for (String previousBucket : previousBuckets) {
if (!buckets.contains(previousBucket)) {
bucketPriorityList.add(previousBucket);
}
}
}
private static class Entry<T, R> {
private final Class<T> dataClass;
@Synthetic
final Class<R> resourceClass;
@Synthetic
final ResourceDecoder<T, R> decoder;
public Entry(@NonNull Class<T> dataClass, @NonNull Class<R> resourceClass,
ResourceDecoder<T, R> decoder) {
this.dataClass = dataClass;
this.resourceClass = resourceClass;
this.decoder = decoder;
}
//由于resourceClass默認為Object.class，所以第二個判斷為true，只需要判斷dataClass就行了
public boolean handles(@NonNull Class<?> dataClass, @NonNull Class<?> resourceClass) {
return this.dataClass.isAssignableFrom(dataClass) && resourceClass
.isAssignableFrom(this.resourceClass);
}
}
}
public class Registry {
public static final String BUCKET_GIF = "Gif";
public static final String BUCKET_BITMAP = "Bitmap";
public static final String BUCKET_BITMAP_DRAWABLE = "BitmapDrawable";
private static final String BUCKET_PREPEND_ALL = "legacy_prepend_all";
private static final String BUCKET_APPEND_ALL = "legacy_append";
public Registry() {
setResourceDecoderBucketPriorityList(
Arrays.asList(BUCKET_GIF, BUCKET_BITMAP, BUCKET_BITMAP_DRAWABLE));
}
//所以ResourceDecoderRegistry的bucketPriorityList的值為[BUCKET_PREPEND_ALL,BUCKET_GIF,BUCKET_BITMAP,BUCKET_BITMAP_DRAWABLE,BUCKET_APPEND_ALL]
public final Registry setResourceDecoderBucketPriorityList(@NonNull List<String> buckets) {
List<String> modifiedBuckets = new ArrayList<>(buckets.size());
modifiedBuckets.addAll(buckets);
modifiedBuckets.add(0, BUCKET_PREPEND_ALL);
modifiedBuckets.add(BUCKET_APPEND_ALL);
decoderRegistry.setBucketPriorityList(modifiedBuckets);
return this;
}
}
decoders以bucket為key，List<Entry<?, ?>>為value，在Glide的構造函數中通過Registry賦值。
//ResouceDecoderRegistry
private synchronized List<Entry<?, ?>> getOrAddEntryList(@NonNull String bucket) {
if (!bucketPriorityList.contains(bucket)) {
bucketPriorityList.add(bucket);
}
List<Entry<?, ?>> entries = decoders.get(bucket);
if (entries == null) {
entries = new ArrayList<>();
decoders.put(bucket, entries);
}
return entries;
}
public synchronized <T, R> void append(@NonNull String bucket,
@NonNull ResourceDecoder<T, R> decoder,
@NonNull Class<T> dataClass, @NonNull Class<R> resourceClass) {
//將Entry添加到key為bucket的List里
getOrAddEntryList(bucket).add(new Entry<>(dataClass, resourceClass, decoder));
}
//Registry
public <Data, TResource> Registry append(
@NonNull String bucket,
@NonNull Class<Data> dataClass,
@NonNull Class<TResource> resourceClass,
@NonNull ResourceDecoder<Data, TResource> decoder) {
decoderRegistry.append(bucket, decoder, dataClass, resourceClass);
return this;
}
Glide(){
registry
/* Bitmaps */
.append(Registry.BUCKET_BITMAP, InputStream.class, Bitmap.class, streamBitmapDecoder)
/* BitmapDrawables */
.append(
Registry.BUCKET_BITMAP_DRAWABLE,
InputStream.class,
BitmapDrawable.class,
new BitmapDrawableDecoder<>(resources, streamBitmapDecoder))
/* GIFs */
.append(
Registry.BUCKET_GIF,
InputStream.class,
GifDrawable.class,
new StreamGifDecoder(imageHeaderParsers, byteBufferGifDecoder, arrayPool))
}
getTranscodeClasses()
熟悉的名字，熟悉的味道，這個類比上面那兩個簡單，自己按照規則看下就懂了。
public class TranscoderRegistry {
private final List<Entry<?, ?>> transcoders = new ArrayList<>();
public synchronized <Z, R> void register(
@NonNull Class<Z> decodedClass, @NonNull Class<R> transcodedClass,
@NonNull ResourceTranscoder<Z, R> transcoder) {
transcoders.add(new Entry<>(decodedClass, transcodedClass, transcoder));
}
public synchronized <Z, R> List<Class<R>> getTranscodeClasses(
@NonNull Class<Z> resourceClass, @NonNull Class<R> transcodeClass) {
List<Class<R>> transcodeClasses = new ArrayList<>();
//如果transcodeClass是resourceClass的父類（比如Drawable是BitmapDrawable和GifDrawable的父類）則為true。
//所以如果resourceClass傳入的是Drawable的子類，則最終只會添加Drawable.class
if (transcodeClass.isAssignableFrom(resourceClass)) {
transcodeClasses.add(transcodeClass);
return transcodeClasses;
}
for (Entry<?, ?> entry : transcoders) {
if (entry.handles(resourceClass, transcodeClass)) {
//這里有效的是當傳入Bitmap.class和Drawable.class的時候，所以最后會添加Drawable.calss
transcodeClasses.add(transcodeClass);
}
}
return transcodeClasses;
}
private static final class Entry<Z, R> {
private final Class<Z> fromClass;
private final Class<R> toClass;
@Synthetic
final ResourceTranscoder<Z, R> transcoder;
Entry(@NonNull Class<Z> fromClass, @NonNull Class<R> toClass,
@NonNull ResourceTranscoder<Z, R> transcoder) {
this.fromClass = fromClass;
this.toClass = toClass;
this.transcoder = transcoder;
}
public boolean handles(@NonNull Class<?> fromClass, @NonNull Class<?> toClass) {
return this.fromClass.isAssignableFrom(fromClass) && toClass.isAssignableFrom(this.toClass);
}
}
}
//Registry
public <TResource, Transcode> Registry register(
@NonNull Class<TResource> resourceClass, @NonNull Class<Transcode> transcodeClass,
@NonNull ResourceTranscoder<TResource, Transcode> transcoder) {
transcoderRegistry.register(resourceClass, transcodeClass, transcoder);
return this;
}
//Glide
Glide(){
registry
/* Transcoders */
.register(
Bitmap.class,
BitmapDrawable.class,
new BitmapDrawableTranscoder(resources))
}
getTransformation()
Transformation是一個接口，繼承了Key接口，同時自己有一個transform方法，用來將Resource轉換為另一個Resource。比如它的實現類CenterCrop，就是將Bitmap轉為centerCrop樣子的Bitmap。
getTransformation()則根據之前在transformations存好的鍵值對來獲取Transformation。
<Z> Transformation<Z> getTransformation(Class<Z> resourceClass) {
Transformation<Z> result = (Transformation<Z>) transformations.get(resourceClass); //由BaseRequestOptions的transformations傳遞進來
if (result == null) {
for (Entry<Class<?>, Transformation<?>> entry : transformations.entrySet()) {
if (entry.getKey().isAssignableFrom(resourceClass)) {
result = (Transformation<Z>) entry.getValue();
break;
}
}
}
if (result == null) {
if (transformations.isEmpty() && isTransformationRequired) {
throw new IllegalArgumentException(
"Missing transformation for " + resourceClass + ". If you wish to"
+ " ignore unknown resource types, use the optional transformation methods.");
} else {
return UnitTransformation.get(); //這個默認返回原Resource，不做轉換
}
}
return result;
}
在我們使用RequestBuilder顯式調用centerCrop()或者其他轉換時，最終會將對應的類型和Transformation存進transformations。如果沒有顯式調用，但是ImageView本身設置了轉換的（比如設置了android:scaleType="centerCrop"），會在into()時進行設置存進transformations。
Glide.with(this)
.load("")
.centerCrop()
.into(imageView);
//BaseRequestOptions
public T centerCrop() {
return transform(DownsampleStrategy.CENTER_OUTSIDE, new CenterCrop());
}
final T transform(@NonNull DownsampleStrategy downsampleStrategy,
@NonNull Transformation<Bitmap> transformation) {
if (isAutoCloneEnabled) {
//在clone()中會設置isAutoCloneEnabled為false，所以最終還是會走到下面的語句
return clone().transform(downsampleStrategy, transformation);
}
downsample(downsampleStrategy);
return transform(transformation);
}
public T transform(@NonNull Transformation<Bitmap> transformation) {
return transform(transformation, /*isRequired=*/ true);
}
T transform(
@NonNull Transformation<Bitmap> transformation, boolean isRequired) {
if (isAutoCloneEnabled) {
return clone().transform(transformation, isRequired);
}
DrawableTransformation drawableTransformation =
new DrawableTransformation(transformation, isRequired);
//最終transformations添加的鍵值對為下面這些
transform(Bitmap.class, transformation, isRequired);
transform(Drawable.class, drawableTransformation, isRequired);
transform(BitmapDrawable.class, drawableTransformation.asBitmapDrawable(), isRequired);
transform(GifDrawable.class, new GifDrawableTransformation(transformation), isRequired);
return selfOrThrowIfLocked();
}
<Y> T transform(
@NonNull Class<Y> resourceClass,
@NonNull Transformation<Y> transformation,
boolean isRequired) {
if (isAutoCloneEnabled) {
return clone().transform(resourceClass, transformation, isRequired);
}
transformations.put(resourceClass, transformation); //在這里添加進去
fields |= TRANSFORMATION;
isTransformationAllowed = true;
fields |= TRANSFORMATION_ALLOWED;
// Always set to false here. Known scale only transformations will call this method and then
// set isScaleOnlyOrNoTransform to true immediately after.
isScaleOnlyOrNoTransform = false;
if (isRequired) {
fields |= TRANSFORMATION_REQUIRED;
isTransformationRequired = true;
}
return selfOrThrowIfLocked();
}
hasLoadPath()
LoadPath主要是封裝了List<DecodePath<Data, ResourceType, Transcode>>，從而利用DecodePath根據給定的數據類型解碼和轉碼資源類型。
在getLoadPath中首先從緩存中獲取，如果沒獲取到則會繼續獲取decodePaths，如果decodePaths不為空，則創建一個新的LoadPath并傳入緩存，最后返回。
//DecodeHelper
boolean hasLoadPath(Class<?> dataClass) {
return getLoadPath(dataClass) != null;
}
//Registry
<Data> LoadPath<Data, ?, Transcode> getLoadPath(Class<Data> dataClass) {
return glideContext.getRegistry().getLoadPath(dataClass, resourceClass, transcodeClass);
}
public <Data, TResource, Transcode> LoadPath<Data, TResource, Transcode> getLoadPath(
@NonNull Class<Data> dataClass, @NonNull Class<TResource> resourceClass,
@NonNull Class<Transcode> transcodeClass) {
LoadPath<Data, TResource, Transcode> result =
loadPathCache.get(dataClass, resourceClass, transcodeClass);
if (loadPathCache.isEmptyLoadPath(result)) {
//返回的是一個特定的LoadPath，代表之前沒有發現可用的LoadPath。
//當下面的decodePaths.isEmpty()時，loadPathCache存入的result為null，這時實際存入的是一個特定的NO_PATHS_SIGNAL。
return null;
} else if (result == null) {
List<DecodePath<Data, TResource, Transcode>> decodePaths =
getDecodePaths(dataClass, resourceClass, transcodeClass);
if (decodePaths.isEmpty()) {
//從給定的數據類中可能無法解碼或轉碼為所需的類型。
result = null;
} else {
result = new LoadPath<>(
dataClass, resourceClass, transcodeClass, decodePaths, throwableListPool);
}
loadPathCache.put(dataClass, resourceClass, transcodeClass, result);
}
return result;
}
//DecodePath則主是封裝List<? extends ResourceDecoder<DataType, ResourceType>>和ResourceTranscoder<ResourceType, Transcode> transcoder來進行解碼和轉碼工作
private <Data, TResource, Transcode> List<DecodePath<Data, TResource, Transcode>> getDecodePaths(
@NonNull Class<Data> dataClass/*InputStream.class*/, @NonNull Class<TResource> resourceClass/*Object.class*/,
@NonNull Class<Transcode> transcodeClass/*Drawable.class*/) {
List<DecodePath<Data, TResource, Transcode>> decodePaths = new ArrayList<>();
//這些getXXXClasses獲取上面都有說過
List<Class<TResource>> registeredResourceClasses =
decoderRegistry.getResourceClasses(dataClass, resourceClass); //GifDrawable.class、Bitmap.class、BitmapDrawable.class
for (Class<TResource> registeredResourceClass : registeredResourceClasses) {
List<Class<Transcode>> registeredTranscodeClasses =
transcoderRegistry.getTranscodeClasses(registeredResourceClass, transcodeClass); //Drawable.class
for (Class<Transcode> registeredTranscodeClass : registeredTranscodeClasses) {
List<ResourceDecoder<Data, TResource>> decoders =
decoderRegistry.getDecoders(dataClass, registeredResourceClass); //StreamGifDecoder、BitmapDrawableDecoder
ResourceTranscoder<TResource, Transcode> transcoder =
transcoderRegistry.get(registeredResourceClass, registeredTranscodeClass); //BitmapDrawableTranscoder
@SuppressWarnings("PMD.AvoidInstantiatingObjectsInLoops")
DecodePath<Data, TResource, Transcode> path =
new DecodePath<>(dataClass/*InputStream.class*/, registeredResourceClass/*Bitmap.class*/, registeredTranscodeClass/*Drawable.class*/,
decoders/*StreamGifDecoder、BitmapDrawableDecoder*/, transcoder/*BitmapDrawableTranscoder*/, throwableListPool);
decodePaths.add(path);
}
}
return decodePaths;
}
getDiskCache()
獲取磁盤緩存，具體請看Glide源碼解析之DiskCache
DiskCache getDiskCache() {
return diskCacheProvider.getDiskCache();
}
