DataFetcherGenerator
数据提取器生成器，虽然名字是这样叫，但是实际上在实现类你是看不到它生成数据提取器的。它只有两个方法，有三个类实现了它，分别为 ResourceCacheGenerator、DataCacheGenerator、SourceGenerator。
interface DataFetcherGenerator {
/**
* 数据提取器执行工作则返回true，否则返回false
*/
boolean startNext();
/**
* 取消数据提取器的执行
*/
void cancel();
}
ResourceCacheGenerator
资源缓存生成器，主要是从磁盘缓存中获取经过转化过的资源。因为磁盘缓存不仅可以缓存原图，也可以缓存转化过的图片，原图的获取则是由 DataCacheGenerator 实现，由于 DataCacheGenerator 的获取和这个类差不多就不再另写一篇了。
首先会去磁盘缓存中获取图片，如果有则获取 File 类型的 ModelLoader ，并由它生成对应的 LoadData ， LoadData 又包含了 DataFetcher ，最终的数据提取操作就交给它。
该类使用的数据大多数由DecodeHelper提供，要是不熟悉的可以看下 Glide 源码解析之 DecodeHelper
class ResourceCacheGenerator implements DataFetcherGenerator,
DataFetcher.DataCallback<Object> {
private final FetcherReadyCallback cb;
private final DecodeHelper<?> helper;
private int sourceIdIndex;
private int resourceClassIndex = -1;
private Key sourceKey;
private List<ModelLoader<File, ?>> modelLoaders; //默认为 null
@Override
public boolean startNext() {
List<Key> sourceIds = helper.getCacheKeys(); //至少会有一个 GlideUrl 的 key
if (sourceIds.isEmpty()) {
return false;
}
List<Class<?>> resourceClasses = helper.getRegisteredResourceClasses();
if (resourceClasses.isEmpty()) {
// helper.getTranscodeClass() 是 Drawable.class
if (File.class.equals(helper.getTranscodeClass())) {
return false;
}
throw new IllegalStateException(
"Failed to find any load path from " + helper.getModelClass() + " to "
+ helper.getTranscodeClass());
}
//一开始 modelLoaders 是null的，所以会进入循环
while (modelLoaders == null || !hasNextModelLoader()) {
resourceClassIndex++;
if (resourceClassIndex >= resourceClasses.size()) {
sourceIdIndex++;
if (sourceIdIndex >= sourceIds.size()) {
return false;
}
resourceClassIndex = 0;
}
Key sourceId = sourceIds.get(sourceIdIndex);
Class<?> resourceClass = resourceClasses.get(resourceClassIndex);
Transformation<?> transformation = helper.getTransformation(resourceClass); // DrawableTransformation
//根据当前配置生成一个 key
currentKey =
new ResourceCacheKey(
helper.getArrayPool(),
sourceId,
helper.getSignature(),
helper.getWidth(),
helper.getHeight(),
transformation,
resourceClass,
helper.getOptions());
//获取磁盘缓存文件
cacheFile = helper.getDiskCache().get(currentKey);
if (cacheFile != null) {
sourceKey = sourceId;
//获取 File 类型的 ModelLoaders ，有 ByteBufferFileLoader、FileLoader、UnitModelLoader
modelLoaders = helper.getModelLoaders(cacheFile);
modelLoaderIndex = 0;
}
}
loadData = null;
boolean started = false;
//上面对 modelLoaders 进行了赋值，所以会进入循环
while (!started && hasNextModelLoader()) {
ModelLoader<File, ?> modelLoader = modelLoaders.get(modelLoaderIndex++);
//第一次循环由 ByteBufferFileLoader 生成的 LoadData 为 LoadData<>(new ObjectKey(file), new ByteBufferFetcher(file))
loadData = modelLoader.buildLoadData(cacheFile,
helper.getWidth(), helper.getHeight(), helper.getOptions());
if (loadData != null && helper.hasLoadPath(loadData.fetcher.getDataClass())) {
started = true; //结束循环的标志
//所以这里调用的是 ByteBufferFetcher
loadData.fetcher.loadData(helper.getPriority(), this);
}
}
return started;
}
}
DataFetcher 的生成
首先对应 File 类型的 ModelLoader 有几个，这里我们只看第一个 ByteBufferFileLoader ，它由 ByteBufferFileLoader 的内部类 Factory 用工厂模式生成。接着又会调用它的 buildLoadData 方法生成参数为 ObjectKey 和 ByteBufferFetcher 的 LoadData ，所以上面最终调用的 DataFetcher 为 ByteBufferFetcher 。
// ModelLoader 是由 Factory 去 builde 出来的
Glide(){
registry
.append(File.class, ByteBuffer.class, new ByteBufferFileLoader.Factory())
.append(File.class, InputStream.class, new FileLoader.StreamFactory())
.append(File.class, ParcelFileDescriptor.class, new FileLoader.FileDescriptorFactory())
.append(File.class, File.class, UnitModelLoader.Factory.<File>getInstance())
}
// ByteBufferFileLoader.Factory()
public static class Factory implements ModelLoaderFactory<File, ByteBuffer> {
@NonNull
@Override
public ModelLoader<File, ByteBuffer> build(@NonNull MultiModelLoaderFactory multiFactory) {
return new ByteBufferFileLoader();
}
}
public class ByteBufferFileLoader implements ModelLoader<File, ByteBuffer> {
@Override
public LoadData<ByteBuffer> buildLoadData(@NonNull File file, int width, int height,
@NonNull Options options) {
return new LoadData<>(new ObjectKey(file), new ByteBufferFetcher(file));
}
}
资源的提取
在 LoadData() 中调用了 ByteBufferUtil.fromFile(file) ，里面使用 NIO 的类 FileChannel 以只读的形式进行内存映射，这样能加速读取的速度。
最后就会把结果回调给 callback 了，这个 callback 是由 ResourceCacheGenerator 来实现的，也就是加载完后会通知到 ResourceCacheGenerator 。
private static final class ByteBufferFetcher implements DataFetcher<ByteBuffer> {
private final File file;
@Synthetic
@SuppressWarnings("WeakerAccess")
ByteBufferFetcher(File file) {
this.file = file;
}
@Override
public void loadData(@NonNull Priority priority,
@NonNull DataCallback<? super ByteBuffer> callback) {
ByteBuffer result;
try {
result = ByteBufferUtil.fromFile(file);
} catch (IOException e) {
if (Log.isLoggable(TAG, Log.DEBUG)) {
Log.d(TAG, "Failed to obtain ByteBuffer for file", e);
}
callback.onLoadFailed(e);
return;
}
callback.onDataReady(result);
}
}
//ByteBufferUtil
@NonNull
public static ByteBuffer fromFile(@NonNull File file) throws IOException {
RandomAccessFile raf = null;
FileChannel channel = null;
try {
long fileLength = file.length();
if (fileLength > Integer.MAX_VALUE) {
throw new IOException("File too large to map into memory");
}
if (fileLength == 0) {
throw new IOException("File unsuitable for memory mapping");
}
raf = new RandomAccessFile(file, "r");
channel = raf.getChannel();
return channel.map(FileChannel.MapMode.READ_ONLY, 0, fileLength).load();
} finally {
if (channel != null) {
try {
channel.close();
} catch (IOException e) {
// Ignored.
}
}
if (raf != null) {
try {
raf.close();
} catch (IOException e) {
// Ignored.
}
}
}
}
资源加载完成
在 ResourceCacheGenerator 的回调中实际上调用的是 DecodeJob 实现的 FetcherReadyCallback 接口，这样资源最终会交给 DecodeJob 来处理。
@Override
public void onDataReady(Object data) {
cb.onDataFetcherReady(sourceKey, data, loadData.fetcher, DataSource.RESOURCE_DISK_CACHE,
currentKey);
}
