Glide源码解析四（解码和转码）
本文基于Glide 4.11.0
Glide加载过程有一个解码过程，比如将url加载为inputStream后，要将inputStream解码为Bitmap。
从Glide源码解析一我们大致知道了Glide加载的过程，所以我们可以直接从这里看起，在这个过程中我们以从文件中加载bitmap为例：
DecodeJob的一个方法：
private void decodeFromRetrievedData() { if (Log.isLoggable(TAG, Log.VERBOSE)) { logWithTimeAndKey("Retrieved data", startFetchTime, "data: " + currentData + ", cache key: " + currentSourceKey + ", fetcher: " + currentFetcher); } Resource<R> resource = null; try { resource = decodeFromData(currentFetcher, currentData, currentDataSource); } catch (GlideException e) { e.setLoggingDetails(currentAttemptingKey, currentDataSource); throwables.add(e); } if (resource != null) { notifyEncodeAndRelease(resource, currentDataSource); } else { runGenerators(); } }
主要是这个方法：resource = decodeFromData(currentFetcher, currentData, currentDataSource);
这时候currentData为FileInputStream，因为我们加载的是本地文件。
currentDateSource为LOCAL，即为本地的资源
我们继续找下去
resource = decodeFromData(currentFetcher, currentData, currentDataSource);
----------------->
Resource<R> result = decodeFromFetcher(data, dataSource);
------------------>
private <Data> Resource<R> decodeFromFetcher(Data data, DataSource dataSource) throws GlideException { LoadPath<Data, ?, R> path = decodeHelper.getLoadPath((Class<Data>) data.getClass()); return runLoadPath(data, dataSource, path);
这里获取到LoadPath的对象，我么先看看LoadPath有什么？
我们可以看到一个DecodePaths：
DecodePath里面又保存着decoders
decoders便是我们需要的解码器，拿到解码器后就可以进行解码了。
那怎么拿到？
在Glide源码解析三中我们知道这些解码器都注册在Register中，所以我们也是要通过它来拿：
<Data> LoadPath<Data, ?, Transcode> getLoadPath(Class<Data> dataClass) { return glideContext.getRegistry().getLoadPath(dataClass, resourceClass, transcodeClass); }
---------------->
@Nullable 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)) { return null; } else if (result == null) { List<DecodePath<Data, TResource, Transcode>> decodePaths = getDecodePaths(dataClass, resourceClass, transcodeClass); // It's possible there is no way to decode or transcode to the desired types from a given // data class. if (decodePaths.isEmpty()) { result = null; } else { result = new LoadPath<>( dataClass, resourceClass, transcodeClass, decodePaths, throwableListPool); } loadPathCache.put(dataClass, resourceClass, transcodeClass, result); } return result; }
首先会先从缓存中拿，缓存中拿不到再通过下面的方法去拿：
List<DecodePath<Data, TResource, Transcode>> decodePaths = getDecodePaths(dataClass, resourceClass, transcodeClass);
private <Data, TResource, Transcode> List<DecodePath<Data, TResource, Transcode>> getDecodePaths( @NonNull Class<Data> dataClass, @NonNull Class<TResource> resourceClass, @NonNull Class<Transcode> transcodeClass) { List<DecodePath<Data, TResource, Transcode>> decodePaths = new ArrayList<>(); List<Class<TResource>> registeredResourceClasses = decoderRegistry.getResourceClasses(dataClass, resourceClass); for (Class<TResource> registeredResourceClass : registeredResourceClasses) { List<Class<Transcode>> registeredTranscodeClasses = transcoderRegistry.getTranscodeClasses(registeredResourceClass, transcodeClass); for (Class<Transcode> registeredTranscodeClass : registeredTranscodeClasses) { List<ResourceDecoder<Data, TResource>> decoders = decoderRegistry.getDecoders(dataClass, registeredResourceClass); ResourceTranscoder<TResource, Transcode> transcoder = transcoderRegistry.get(registeredResourceClass, registeredTranscodeClass); @SuppressWarnings("PMD.AvoidInstantiatingObjectsInLoops") DecodePath<Data, TResource, Transcode> path = new DecodePath<>(dataClass, registeredResourceClass, registeredTranscodeClass, decoders, transcoder, throwableListPool); decodePaths.add(path); } } return decodePaths; }
该方法各个参数如下：
dataClass为InputStream，这是被解码的对象
resourceClass为Object，要解码成为Object
transcodeClass为Drawable，要转码为Drawable
我们看这个方法：
decoderRegistry.getResourceClasses：
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((Class<R>) entry.resourceClass)) { result.add((Class<R>) entry.resourceClass); } } } return result; }
该方法是为了获取解码器中的resourceClass，即解码后的资源类型。
我们可以看到decoder这个map里面的内容：
各种类型对应的解码器。
只有满足entry.handles(dataClass, resourceClass)，才能被添加返回：
public boolean handles(@NonNull Class<?> dataClass, @NonNull Class<?> resourceClass) { return this.dataClass.isAssignableFrom(dataClass) && resourceClass .isAssignableFrom(this.resourceClass); }
由于我们的resourceClass是Object，因此resourceClass .isAssignableFrom(this.resourceClass)总是成立的，所以就看：this.dataClass.isAssignableFrom(dataClass)
而我们的dataClass是InputStream，打开各种类型，可以看到哪些的dataClass是InputStream：
上面框错了，应该框resourceClass，另外FrameSequenceDrawable是我自定义后注册进去的，所以Glide原生的是没有的。
所以最终返回的resource为：
接下来是针对每一种resourceClass获取对应的转码类（要转成的对象）：
public synchronized <Z, R> List<Class<R>> getTranscodeClasses( @NonNull Class<Z> resourceClass, @NonNull Class<R> transcodeClass) { List<Class<R>> transcodeClasses = new ArrayList<>(); // GifDrawable -> Drawable is just the UnitTranscoder, as is GifDrawable -> GifDrawable. if (transcodeClass.isAssignableFrom(resourceClass)) { transcodeClasses.add(transcodeClass); return transcodeClasses; } for (Entry<?, ?> entry : transcoders) { if (entry.handles(resourceClass, transcodeClass)) { transcodeClasses.add(transcodeClass); } } return transcodeClasses; }
如果transcodeClass是resourceClass的父类那就直接返回。
第一个GifDrawable，返回的registeredTranscodeClasses为：
然后根据dataClass, registeredResourceClass获取decoders：
然后根据registeredResourceClass和registeredTranscodeClass获取transcoder
上面具体的获取过程是类似的，就不过多分析了。
然后构造DecodePath，放进下面的集合里面：
List<DecodePath<Data, TResource, Transcode>> decodePaths = new ArrayList<>();
循环获取之后，最终得到的decodePaths如下：
大致流程：
1、先根据传进来的resourceClass获取注册表中所有注册的resourceClass得到List<Class<TResource>> registeredResourceClasses
2、两层for循环：
（1）外层：根据registeredResourceClasses获取转码的class ：List<Class<Transcode>> registeredTranscodeClasses
（2）内层：
a、根据资源resourceClass获取所有的解码器。
b、根据资源resourceClass和转码transcodeClass获取所有的转码器。
c、构造DecodePath，放进集合里面。
最后得到的List<DecodePath<Data, TResource, Transcode>> decodePaths被放到LoadPath对象里面（上一层方法可看到）
我们又回到DecodeJob中的方法：
private <Data> Resource<R> decodeFromFetcher(Data data, DataSource dataSource) throws GlideException { LoadPath<Data, ?, R> path = decodeHelper.getLoadPath((Class<Data>) data.getClass()); return runLoadPath(data, dataSource, path); }
获取到LoadPath后接下来就是要开始执行了runLoadPath了。
找下去可以看到该方法：
return path.load( rewinder, options, width, height, new DecodeCallback<ResourceType>(dataSource));
该方法属于LoadPath对象。
层层追溯后，最终来到下面的方法：
private Resource<Transcode> loadWithExceptionList(DataRewinder<Data> rewinder, @NonNull Options options, int width, int height, DecodePath.DecodeCallback<ResourceType> decodeCallback, List<Throwable> exceptions) throws GlideException { Resource<Transcode> result = null; //noinspection ForLoopReplaceableByForEach to improve perf for (int i = 0, size = decodePaths.size(); i < size; i++) { DecodePath<Data, ResourceType, Transcode> path = decodePaths.get(i); try { result = path.decode(rewinder, width, height, options, decodeCallback); } catch (GlideException e) { exceptions.add(e); } if (result != null) { break; } } if (result == null) { throw new GlideException(failureMessage, new ArrayList<>(exceptions)); } return result; }
该方法在LoadPath里面，遍历decodePaths（这是我们之前获取后放在LoadPath中的）进行解码：
result = path.decode(rewinder, width, height, options, decodeCallback);
然后来到：
public Resource<Transcode> decode(DataRewinder<DataType> rewinder, int width, int height, @NonNull Options options, DecodeCallback<ResourceType> callback) throws GlideException { Resource<ResourceType> decoded = decodeResource(rewinder, width, height, options); Resource<ResourceType> transformed = callback.onResourceDecoded(decoded); return transcoder.transcode(transformed, options); }
我们这里需要看的就是：decodeResource：
最终来到DecodePath里面的方法：
@NonNull private Resource<ResourceType> decodeResourceWithList(DataRewinder<DataType> rewinder, int width, int height, @NonNull Options options, List<Throwable> exceptions) throws GlideException { Resource<ResourceType> result = null; //noinspection ForLoopReplaceableByForEach to improve perf for (int i = 0, size = decoders.size(); i < size; i++) { ResourceDecoder<DataType, ResourceType> decoder = decoders.get(i); try { DataType data = rewinder.rewindAndGet(); if (decoder.handles(data, options)) { data = rewinder.rewindAndGet(); result = decoder.decode(data, width, height, options); } // Some decoders throw unexpectedly. If they do, we shouldn't fail the entire load path, but // instead log and continue. See #2406 for an example. } catch (IOException | RuntimeException | OutOfMemoryError e) { if (Log.isLoggable(TAG, Log.VERBOSE)) { Log.v(TAG, "Failed to decode data for " + decoder, e); } exceptions.add(e); } if (result != null) { break; } } if (result == null) { throw new GlideException(failureMessage, new ArrayList<>(exceptions)); } return result; }
这个方法：decoder.handles(data, options)是判断该解码器是否可以对该资源进行解码，这个方法写在每个解码器里面。
DataRewinder里面放着需要进行解码的数据。
解码后将资源返回。
又回到这个方法：
public Resource<Transcode> decode(DataRewinder<DataType> rewinder, int width, int height, @NonNull Options options, DecodeCallback<ResourceType> callback) throws GlideException { Resource<ResourceType> decoded = decodeResource(rewinder, width, height, options); Resource<ResourceType> transformed = callback.onResourceDecoded(decoded); return transcoder.transcode(transformed, options); }
这一句Resource<ResourceType> transformed = callback.onResourceDecoded(decoded);
是对资源进行变换处理，比如图片的缩放，剪裁等等，这个功能单独拎出来讲。
接下来便是运用转码器进行资源的转码：
transcoder.transcode(transformed, options)
到此就结束了。
