glide源码解析之GlideModule

GlideModule是对glide全局配置相关的类，这里介绍相关配置的源码解析

一般的用法是这样

public class GlideConfiguration implements GlideModule {

    @Override

    public void applyOptions(Context context, GlideBuilder builder) {

        builder.setDecodeFormat(DecodeFormat.PREFER_ARGB_8888);

        MemorySizeCalculator calculator = new MemorySizeCalculator(context);

        int defaultMemoryCacheSize = calculator.getMemoryCacheSize();

        int defaultBitmapPoolSize = calculator.getBitmapPoolSize();

        int customMemoryCacheSize = (int) (1.2 * defaultMemoryCacheSize);

        int customBitmapPoolSize = (int) (1.2 * defaultBitmapPoolSize);

        builder.setMemoryCache(new LruResourceCache(customMemoryCacheSize)); //设置图片缓存策略

        builder.setBitmapPool(new LruBitmapPool(customBitmapPoolSize));

        int cacheSize100MegaBytes = 104857600;  //100M

        String downloadDirectoryPath = Environment.getExternalStorageDirectory().getPath();

        builder.setDiskCache(new DiskLruCacheFactory(downloadDirectoryPath, "cache/", cacheSize100MegaBytes));

    }

    @Override

    public void registerComponents(Context context, Glide glide) {

        glide.register(GlideUrl.class, InputStream.class, new HttpUrlGlideUrlLoader.Factory());

    }

}

然后再manifest文件中加入这个配置

        <meta-data

            android:name=".GlideConfiguration"

            android:value="GlideModule"/>

先看看GlideMoudle接口源码

package com.bumptech.glide.module;

import android.content.Context;

import com.bumptech.glide.Glide;
import com.bumptech.glide.GlideBuilder;

/**
 * An interface allowing lazy configuration of Glide including setting options using
 * {@link com.bumptech.glide.GlideBuilder} and registering
 * {@link com.bumptech.glide.load.model.ModelLoader ModelLoaders}.
 *
 * <p>
 *     To use this interface:
 *     <ol>
 *         <li>
 *             Implement the GlideModule interface in a class with public visibility, calling
 *             {@link com.bumptech.glide.Glide#register(Class, Class, com.bumptech.glide.load.model.ModelLoaderFactory)}
 *             for each {@link com.bumptech.glide.load.model.ModelLoader} you'd like to register:
 *             <pre>
 *                  <code>
 *                      public class FlickrGlideModule implements GlideModule {
 *                          {@literal @}Override
 *                          public void applyOptions(Context context, GlideBuilder builder) {
 *                              buidler.setDecodeFormat(DecodeFormat.ALWAYS_ARGB_8888);
 *                          }
 *
 *                          {@literal @}Override
 *                          public void registerComponents(Context context, Glide glide) {
 *                              glide.register(Model.class, Data.class, new MyModelLoader());
 *                          }
 *                      }
 *                  </code>
 *             </pre>
 *         </li>
 *         <li>
 *              Add your implementation to your list of keeps in your proguard.cfg file:
 *              <pre>
 *                  {@code
 *                      -keepnames class * com.bumptech.glide.samples.flickr.FlickrGlideModule
 *                  }
 *              </pre>
 *         </li>
 *         <li>
 *             Add a metadata tag to your AndroidManifest.xml with your GlideModule implementation's fully qualified
 *             classname as the key, and {@code GlideModule} as the value:
 *             <pre>
 *                 {@code
 *                      <meta-data
 *                          android:name="com.bumptech.glide.samples.flickr.FlickrGlideModule"
 *                          android:value="GlideModule" />
 *                 }
 *             </pre>
 *         </li>
 *     </ol>
 * </p>
 *
 * <p>
 *     All implementations must be publicly visible and contain only an empty constructor so they can be instantiated
 *     via reflection when Glide is lazily initialized.
 * </p>
 *
 * <p>
 *     There is no defined order in which modules are called, so projects should be careful to avoid applying
 *     conflicting settings in different modules. If an application depends on libraries that have conflicting
 *     modules, the application should consider avoiding the library modules and instead providing their required
 *     dependencies in a single application module.
 * </p>
 */
public interface GlideModule {

    /**
     * Lazily apply options to a {@link com.bumptech.glide.GlideBuilder} immediately before the Glide singleton is
     * created.
     *
     * <p>
     *     This method will be called once and only once per implementation.
     * </p>
     *
     * @param context An Application {@link android.content.Context}.
     * @param builder The {@link com.bumptech.glide.GlideBuilder} that will be used to create Glide.
     */
    void applyOptions(Context context, GlideBuilder builder);

    /**
     * Lazily register components immediately after the Glide singleton is created but before any requests can be
     * started.
     *
     * <p>
     *     This method will be called once and only once per implementation.
     * </p>
     *
     * @param context An Application {@link android.content.Context}.
     * @param glide The newly created Glide singleton.
     */
    void registerComponents(Context context, Glide glide);
}

上面一堆注释介绍是怎么用的，最终就是两个方法需要实现。

一个是设置属性，一个是注册组件。

看设置属性的，先看参数GlideBuilder

/**
 * A builder class for setting default structural classes for Glide to use.
 */
public class GlideBuilder {

里边含有一些方法

/**
 * Sets the {@link com.bumptech.glide.load.engine.bitmap_recycle.BitmapPool} implementation to use to store and
 * retrieve reused {@link android.graphics.Bitmap}s.
 *
 * @param bitmapPool The pool to use.
 * @return This builder.
 */
public GlideBuilder setBitmapPool(BitmapPool bitmapPool) {
    this.bitmapPool = bitmapPool;
    return this;
}

这个是设置bitmap池的，是在内存中存储以bitmap形式，大家应该都知道这个是占用内存比较大的，但是速度是最快的。

/**
 * Sets the {@link com.bumptech.glide.load.engine.cache.MemoryCache} implementation to store
 * {@link com.bumptech.glide.load.engine.Resource}s that are not currently in use.
 *
 * @param memoryCache  The cache to use.
 * @return This builder.
 */
public GlideBuilder setMemoryCache(MemoryCache memoryCache) {
    this.memoryCache = memoryCache;
    return this;
}

这个是内存缓存的是以文件或者流的方式存在内存中的，没有上面那个处理速度快，但是比在磁盘读写和加载网络要快很多的。

上面两种都是在内存中存储的，在默认实现中，他们两种总共占内存的0.33-0.4的空间，如果在低内存下还有其他的处理，他们俩各占这部分内存的一半。

/**
 * Sets the {@link com.bumptech.glide.load.engine.cache.DiskCache.Factory} implementation to use to construct
 * the {@link com.bumptech.glide.load.engine.cache.DiskCache} to use to store
 * {@link com.bumptech.glide.load.engine.Resource} data on disk.
 *
 * @param diskCacheFactory The disk cche factory to use.
 * @return This builder.
 */
public GlideBuilder setDiskCache(DiskCache.Factory diskCacheFactory) {
    this.diskCacheFactory = diskCacheFactory;
    return this;

}

讲网络中下载的数据存储到磁盘中。不用重复下载，这个也可以自己去实现，如何存储以及存储的方式算法。

Glide是支持扩展性比较高的，基于接口去配置，可以实现对其灵活的扩展，上面是有一些默认实现的，如果需要更高级的用法，可以自己实现缓存策略，和硬盘存储策略。

/**
 * Sets the {@link com.bumptech.glide.load.DecodeFormat} that will be the default format for all the default
 * decoders that can change the {@link android.graphics.Bitmap.Config} of the {@link android.graphics.Bitmap}s they
 * decode.
 *
 * <p>
 *     Decode format is always a suggestion, not a requirement. See {@link com.bumptech.glide.load.DecodeFormat} for
 *     more details.
 * </p>
 *
 * <p>
 *     If you instantiate and use a custom decoder, it will use
 *     {@link com.bumptech.glide.load.DecodeFormat#DEFAULT} as its default.
 * </p>
 *
 * <p>
 *     Calls to this method are ignored on KitKat and Lollipop. See #301.
 * </p>
 *
 * @param decodeFormat The format to use.
 * @return This builder.
 */
public GlideBuilder setDecodeFormat(DecodeFormat decodeFormat) {
    this.decodeFormat = decodeFormat;
    return this;
}

设置全局的bitmap解码格式

解码格式源码在这里

package com.bumptech.glide.load;

/**
 * Options for setting the value of {@link android.graphics.Bitmap#getConfig()} for {@link android.graphics.Bitmap}s
 * returned by a {@link com.bumptech.glide.load.resource.bitmap.BitmapDecoder}.
 *
 * <p>
 *     Note - In some cases it may not be possible to obey the requested setting, not all
 *     {@link com.bumptech.glide.load.resource.bitmap.BitmapDecoder}s support setting formats and certain images may
 *     not be able to be loaded as certain configurations. Therefore this class represents a preference rather than a
 *     requirement.
 * </p>
 */
public enum DecodeFormat {
    /**
     * All bitmaps returned by the {@link com.bumptech.glide.load.resource.bitmap.BitmapDecoder} should return
     * {@link android.graphics.Bitmap.Config#ARGB_8888} for {@link android.graphics.Bitmap#getConfig()}.
     *
     * @deprecated Use the equivalent but less misleadingly named {@link #PREFER_ARGB_8888}. Scheduled to be removed
     * in Glide 4.0
     */
    @Deprecated
    ALWAYS_ARGB_8888,

    /**
     * Bitmaps decoded from most image formats (other than GIFs with hidden configs), will be decoded with the
     * ARGB_8888 config.
     *
     * <p>
     *     {@link android.graphics.BitmapFactory} does not allow us to guarantee that all returned Bitmaps will
     *     be of a requested config without resorting to expensive copying. As a result, this is a preference only.
     *     Most GIFs, for example, will still produce {@link android.graphics.Bitmap}s with null
     *     {@link android.graphics.Bitmap.Config}s.
     * </p>
     */
    PREFER_ARGB_8888,

    /**
     * Bitmaps decoded from image formats that support and/or use alpha (some types of PNGs, GIFs etc) should
     * return {@link android.graphics.Bitmap.Config#ARGB_8888} for {@link android.graphics.Bitmap#getConfig()}. Bitmaps
     * decoded from formats that don't support or use alpha should return
     * {@link android.graphics.Bitmap.Config#RGB_565} for {@link android.graphics.Bitmap#getConfig()}.
     *
     */
    PREFER_RGB_565;

    /** The default value for DecodeFormat. */
    public static final DecodeFormat DEFAULT = PREFER_RGB_565;
}

这里默认是用Bitmap.option中国的565格式，我们也可以设置成888的格式，如下这样：

builder.setDecodeFormat(DecodeFormat.PREFER_ARGB_8888);

在GlideBuilder中的默认设置在此：

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);
    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;
    }

    return new Glide(engine, memoryCache, bitmapPool, context, decodeFormat);
}

下面是类的成员变量

private final Context context;

private Engine engine;
private BitmapPool bitmapPool;
private MemoryCache memoryCache;
private ExecutorService sourceService;
private ExecutorService diskCacheService;
private DecodeFormat decodeFormat;
private DiskCache.Factory diskCacheFactory;

也就是除了context以外都是可以设置的

sourceService是从服务器来去图片资源的时候的处理策略

diskCacheService是从磁盘缓存是的策略

这两个默认的都是带有优先级的先进先出方式

用的是这个

public class FifoPriorityThreadPoolExecutor extends ThreadPoolExecutor {

下面是bitmapPool处理方式

MemorySizeCalculator calculator = new MemorySizeCalculator(context);
if (bitmapPool == null) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
        int size = calculator.getBitmapPoolSize();
        bitmapPool = new LruBitmapPool(size);
    } else {
        bitmapPool = new BitmapPoolAdapter();
    }
}

默认是根据SDK的版本处理不同的方式 Build.VERSION_CODES.HONEYCOMB = 11

MemorySizeCalculator 这个类是池大小计算的类，有感兴趣的可以读下，看看怎么计算的。

实现大概就是图片缓存占用整个APP内存的0.33-0.4的，其中的一半是给BitmapPool用的，另一半是给cache用的

这个bitmapPool要是自己实现要实现BitmapPool接口就可以了。

/**
 * An interface for a pool that allows users to reuse {@link android.graphics.Bitmap} objects.
 */
public interface BitmapPool {

那个小于sdk11版本的默认是实现，就是什么都没有实现，下面是源码

/**
 * An {@link com.bumptech.glide.load.engine.bitmap_recycle.BitmapPool BitmapPool} implementation that rejects all
 * {@link android.graphics.Bitmap Bitmap}s added to it and always returns {@code null} from get.
 */
public class BitmapPoolAdapter implements BitmapPool {
    @Override
    public int getMaxSize() {
        return 0;
    }

    @Override
    public void setSizeMultiplier(float sizeMultiplier) {
        // Do nothing.
    }

    @Override
    public boolean put(Bitmap bitmap) {
        return false;
    }

    @Override
    public Bitmap get(int width, int height, Bitmap.Config config) {
        return null;
    }

    @Override
    public Bitmap getDirty(int width, int height, Bitmap.Config config) {
        return null;
    }

    @Override
    public void clearMemory() {
        // Do nothing.
    }

    @Override
    public void trimMemory(int level) {
        // Do nothing.
    }

然后看下LRU算法实现的bitmapPool。

/**
 * Constructor for LruBitmapPool.
 *
 * @param maxSize The initial maximum size of the pool in bytes.
 */
public LruBitmapPool(int maxSize) {
    this(maxSize, getDefaultStrategy(), getDefaultAllowedConfigs());
}

第一个是缓存池大小单位bytes

第二个是默认的缓存策略，

第三个是允许的配置，如ARGB565、ARGB888等

然后第二个缓存策略

private static LruPoolStrategy getDefaultStrategy() {
    final LruPoolStrategy strategy;
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
        strategy = new SizeConfigStrategy();
    } else {
        strategy = new AttributeStrategy();
    }
    return strategy;
}

也是根据sdk版本不同的实现

@TargetApi(Build.VERSION_CODES.KITKAT)
public class SizeConfigStrategy implements LruPoolStrategy {

class AttributeStrategy implements LruPoolStrategy {

他们两个都实现了LruPoolStrategy接口

看下这个接口

interface LruPoolStrategy {
    void put(Bitmap bitmap);
    Bitmap get(int width, int height, Bitmap.Config config);
    Bitmap removeLast();
    String logBitmap(Bitmap bitmap);
    String logBitmap(int width, int height, Bitmap.Config config);
    int getSize(Bitmap bitmap);
}

看第get方法,是获得key的方式，width,height config

下面是AttributeStrategy 的实现

下面是key的代码

static class Key implements Poolable {
    private final KeyPool pool;
    private int width;
    private int height;
    // Config can be null :(
    private Bitmap.Config config;

    public Key(KeyPool pool) {
        this.pool = pool;
    }

    public void init(int width, int height, Bitmap.Config config) {
        this.width = width;
        this.height = height;
        this.config = config;
    }

    @Override
    public boolean equals(Object o) {
        if (o instanceof Key) {
            Key other = (Key) o;
            return width == other.width
                    && height == other.height
                    && config == other.config;
        }
        return false;
    }

    @Override
    public int hashCode() {
        int result = width;
        result = 31 * result + height;
        result = 31 * result + (config != null ? config.hashCode() : 0);
        return result;
    }

    @Override
    public String toString() {
        return getBitmapString(width, height, config);
    }

    @Override
    public void offer() {
        pool.offer(this);
    }
}

AttributeStrategy实现的get和put实现方法

private final KeyPool keyPool = new KeyPool();
private final GroupedLinkedMap<Key, Bitmap> groupedMap = new GroupedLinkedMap<Key, Bitmap>();

public void put(Bitmap bitmap) {
    final Key key = keyPool.get(bitmap.getWidth(), bitmap.getHeight(), bitmap.getConfig());

    groupedMap.put(key, bitmap);
}

@Override
public Bitmap get(int width, int height, Bitmap.Config config) {
    final Key key = keyPool.get(width, height, config);

    return groupedMap.get(key);
}

这个是用了一个 GroupedLinkedMap

来存储的，里边的实现是和LinkedHashMap相似的方式，LinkedHashMap本身是有对LRU算法相应的实现的，读一下他的构造方法就明白了。

然后再看下cache

if (memoryCache == null) {
    memoryCache = new LruResourceCache(calculator.getMemoryCacheSize());
}

默认是LruResourceCache

/**
 * An LRU in memory cache for {@link com.bumptech.glide.load.engine.Resource}s.
 */
public class LruResourceCache extends LruCache<Key, Resource<?>> implements MemoryCache {

咱们自己实现的cache要实现MemoryCache接口，把源码贴出来下

/**
 * An interface for adding and removing resources from an in memory cache.
 */
public interface MemoryCache {
    /**
     * An interface that will be called whenever a bitmap is removed from the cache.
     */
    interface ResourceRemovedListener {
        void onResourceRemoved(Resource<?> removed);
    }

    /**
     * Returns the sum of the sizes of all the contents of the cache in bytes.
     */
    int getCurrentSize();

    /**
     * Returns the current maximum size in bytes of the cache.
     */
    int getMaxSize();

    /**
     * Adjust the maximum size of the cache by multiplying the original size of the cache by the given multiplier.
     *
     * <p>
     *     If the size multiplier causes the size of the cache to be decreased, items will be evicted until the cache
     *     is smaller than the new size.
     * </p>
     *
     * @param multiplier A size multiplier >= 0.
     */
    void setSizeMultiplier(float multiplier);

    /**
     * Removes the value for the given key and returns it if present or null otherwise.
     *
     * @param key The key.
     */
    Resource<?> remove(Key key);

    /**
     * Add bitmap to the cache with the given key.
     *
     * @param key The key to retrieve the bitmap.
     * @param resource The {@link com.bumptech.glide.load.engine.EngineResource} to store.
     * @return The old value of key (null if key is not in map).
     */
    Resource<?> put(Key key, Resource<?> resource);

    /**
     * Set the listener to be called when a bitmap is removed from the cache.
     *
     * @param listener The listener.
     */
    void setResourceRemovedListener(ResourceRemovedListener listener);

    /**
     * Evict all items from the memory cache.
     */
    void clearMemory();

    /**
     * Trim the memory cache to the appropriate level. Typically called on the callback onTrimMemory.
     *
     * @param level This integer represents a trim level as specified in {@link android.content.ComponentCallbacks2}.
     */
    void trimMemory(int level);
}

默认实现的LruCache就是用的

private final LinkedHashMap<T, Y> cache = new LinkedHashMap<T, Y>(100, 0.75f, true);

/**
 * Constructs a new {@code LinkedHashMap} instance with the specified
 * capacity, load factor and a flag specifying the ordering behavior.
 *
 * @param initialCapacity
 *            the initial capacity of this hash map.
 * @param loadFactor
 *            the initial load factor.
 * @param accessOrder
 *            {@code true} if the ordering should be done based on the last
 *            access (from least-recently accessed to most-recently
 *            accessed), and {@code false} if the ordering should be the
 *            order in which the entries were inserted.
 * @throws IllegalArgumentException
 *             when the capacity is less than zero or the load factor is
 *             less or equal to zero.
 */
public LinkedHashMap(
        int initialCapacity, float loadFactor, boolean accessOrder) {
    super(initialCapacity, loadFactor);
    init();
    this.accessOrder = accessOrder;
}

这个是LinkedHashMap的构造方法，lru方式或者默认插入顺序

if (diskCacheFactory == null) {
    diskCacheFactory = new InternalCacheDiskCacheFactory(context);
}

磁盘缓存的处理方式 需要实现 DiskCache接口

Glide给出了默认实现，注意一提的是，读写文件要注意读写一致的问题。如果有相关的可以参考下这里。

if (engine == null) {
    engine = new Engine(memoryCache, diskCacheFactory, diskCacheService, sourceService);
}

这个Glide的引擎，目前的set方法还是test阶段，处理下载缓存等等的。

自己定义这个的话，就相当高级了，但是glide这边是支持扩展的哦。

if (decodeFormat == null) {
    decodeFormat = DecodeFormat.DEFAULT;
}

这个就是Bitmap的解码设置，默认是565的一个像素占2字节

/** The default value for DecodeFormat. */
public static final DecodeFormat DEFAULT = PREFER_RGB_565;

再来看下GlideModule怎么加载的，下面这个是Glide的创建

/**
 * Get the singleton.
 *
 * @return the singleton
 */
public static Glide get(Context context) {
    if (glide == null) {
        synchronized (Glide.class) {
            if (glide == null) {
                Context applicationContext = context.getApplicationContext();
                List<GlideModule> modules = new ManifestParser(applicationContext).parse();

                GlideBuilder builder = new GlideBuilder(applicationContext);
                for (GlideModule module : modules) {
                    module.applyOptions(applicationContext, builder);
                }
                glide = builder.createGlide();
                for (GlideModule module : modules) {
                    module.registerComponents(applicationContext, glide);
                }
            }
        }
    }

    return glide;
}

这GlideModule可以有多个，在多个模块进行加载。

/**
 * Parses {@link com.bumptech.glide.module.GlideModule} references out of the AndroidManifest file.
 */
public final class ManifestParser {
    private static final String GLIDE_MODULE_VALUE = "GlideModule";

    private final Context context;

    public ManifestParser(Context context) {
        this.context = context;
    }

    public List<GlideModule> parse() {
        List<GlideModule> modules = new ArrayList<GlideModule>();
        try {
            ApplicationInfo appInfo = context.getPackageManager().getApplicationInfo(
                    context.getPackageName(), PackageManager.GET_META_DATA);
            if (appInfo.metaData != null) {
                for (String key : appInfo.metaData.keySet()) {
                    if (GLIDE_MODULE_VALUE.equals(appInfo.metaData.get(key))) {
                        modules.add(parseModule(key));
                    }
                }
            }
        } catch (PackageManager.NameNotFoundException e) {
            throw new RuntimeException("Unable to find metadata to parse GlideModules", e);
        }

        return modules;
    }

    private static GlideModule parseModule(String className) {
        Class<?> clazz;
        try {
            clazz = Class.forName(className);
        } catch (ClassNotFoundException e) {
            throw new IllegalArgumentException("Unable to find GlideModule implementation", e);
        }

        Object module;
        try {
            module = clazz.newInstance();
        } catch (InstantiationException e) {
            throw new RuntimeException("Unable to instantiate GlideModule implementation for " + clazz, e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException("Unable to instantiate GlideModule implementation for " + clazz, e);
        }

        if (!(module instanceof GlideModule)) {
            throw new RuntimeException("Expected instanceof GlideModule, but found: " + module);
        }
        return (GlideModule) module;
    }
}

这个是对Module进行获取信息和转换的处理。