Android开源框架Universal-Image-Loader源码解析

概述

本文主要是用来探究Universal-Image-Loader内部源码构造，进一步了解作者的设计思想，当然不了解里面的代码结构，也并不会影响对这个开源框架的运用，关于如何使用可以关注我的上一篇文章Android开源框架Universal-Image-Loader应用。

源码阅读

关于源码阅读的方式，我采用框架使用的步骤顺序，这样便能更方便追踪代码的运行逻辑。

1.关于ImageLoaderConfiguration的配置

我们先从运用的第一步入手，在使用该框架加载网络图片之前(当然也可以加载本地图片资源)，需要设置其中的全局变量，该类的名称为：ImageLoaderConfiguration。
在上一篇文章中，我们知道该类中可以使用框架中默认的配置，调用方式为：ImageLoaderConfiguration configuration = ImageLoaderConfiguration.createDefault(context);
进去方法中的代码：

    /**     * Creates default configuration for {@link ImageLoader} <br />     * <b>Default values:</b>     * <ul>     * <li>maxImageWidthForMemoryCache = device's screen width</li>     * <li>maxImageHeightForMemoryCache = device's screen height</li>     * <li>maxImageWidthForDiscCache = unlimited</li>     * <li>maxImageHeightForDiscCache = unlimited</li>     * <li>threadPoolSize = {@link Builder#DEFAULT_THREAD_POOL_SIZE this}</li>     * <li>threadPriority = {@link Builder#DEFAULT_THREAD_PRIORITY this}</li>     * <li>allow to cache different sizes of image in memory</li>     * <li>memoryCache = {@link DefaultConfigurationFactory#createMemoryCache(int)}</li>     * <li>discCache = {@link UnlimitedDiscCache}</li>     * <li>imageDownloader = {@link DefaultConfigurationFactory#createImageDownloader(Context)}</li>     * <li>imageDecoder = {@link DefaultConfigurationFactory#createImageDecoder(boolean)}</li>     * <li>discCacheFileNameGenerator = {@link DefaultConfigurationFactory#createFileNameGenerator()}</li>     * <li>defaultDisplayImageOptions = {@link DisplayImageOptions#createSimple() Simple options}</li>     * <li>tasksProcessingOrder = {@link QueueProcessingType#FIFO}</li>     * <li>detailed logging disabled</li>     * </ul>     * */    public static ImageLoaderConfiguration createDefault(Context context) {        return new Builder(context).build();    }

上述方法是ImageLoaderConfiguration的静态方法，主要是用来实例化静态内部类Builder，并调用build方法。我们继续进入build方法中查看。

/** Builds configured {@link ImageLoaderConfiguration} object */    public ImageLoaderConfiguration build() {            initEmptyFiledsWithDefaultValues();            return new ImageLoaderConfiguration(this);    }

从方法名称中我们可以看出，里面的方法使用来给Builder类中的变量设置默认值，进入这个方法中

private void initEmptyFiledsWithDefaultValues() {            if (taskExecutor == null) {                taskExecutor = DefaultConfigurationFactory.createExecutor(threadPoolSize, threadPriority, tasksProcessingType);            } else {                customExecutor = true;            }            if (taskExecutorForCachedImages == null) {                taskExecutorForCachedImages = DefaultConfigurationFactory.createExecutor(threadPoolSize, threadPriority, tasksProcessingType);            } else {                customExecutorForCachedImages = true;            }            if (discCache == null) {                if (discCacheFileNameGenerator == null) {                    discCacheFileNameGenerator = DefaultConfigurationFactory.createFileNameGenerator();                }                discCache = DefaultConfigurationFactory.createDiscCache(context, discCacheFileNameGenerator, discCacheSize, discCacheFileCount);            }            if (memoryCache == null) {                memoryCache = DefaultConfigurationFactory.createMemoryCache(memoryCacheSize);            }            if (denyCacheImageMultipleSizesInMemory) {                memoryCache = new FuzzyKeyMemoryCache<String, Bitmap>(memoryCache, MemoryCacheUtil.createFuzzyKeyComparator());            }            if (downloader == null) {                downloader = DefaultConfigurationFactory.createImageDownloader(context);            }            if (decoder == null) {                decoder = DefaultConfigurationFactory.createImageDecoder(loggingEnabled);            }            if (defaultDisplayImageOptions == null) {                defaultDisplayImageOptions = DisplayImageOptions.createSimple();            }        }

我们首先分析taskExecutor的初始化，继续进入createExecutor的方法中，如下：

    /** Creates default implementation of task executor */    public static Executor createExecutor(int threadPoolSize, int threadPriority, QueueProcessingType tasksProcessingType) {        boolean lifo = tasksProcessingType == QueueProcessingType.LIFO;        BlockingQueue<Runnable> taskQueue = lifo ? new LIFOLinkedBlockingDeque<Runnable>() : new LinkedBlockingQueue<Runnable>();        return new ThreadPoolExecutor(threadPoolSize, threadPoolSize, 0L, TimeUnit.MILLISECONDS, taskQueue, createThreadFactory(threadPriority));    }

从传入的参数threadPoolSize=3，得知创建一个大小为3的工作线程池。同理，taskExecutorForCachedImages同样是一个大小为3的线程池。
接着分析discCacheFileNameGenerator的初始化，这个类主要是为磁盘高速缓存中生成文件名称，进入代码中分析:

    /** Creates {@linkplain HashCodeFileNameGenerator default implementation} of FileNameGenerator */    public static FileNameGenerator createFileNameGenerator() {        return new HashCodeFileNameGenerator();    }/** * Names image file as image URI {@linkplain String#hashCode() hashcode} *  * @author Sergey Tarasevich (nostra13[at]gmail[dot]com) * @since 1.3.1 */    public class HashCodeFileNameGenerator implements FileNameGenerator {    @Override    public String generate(String imageUri) {        return String.valueOf(imageUri.hashCode());    }}

从上面代码中可以看出，该文件的名称主要是从传入的图片地址的的hashcode得来，确保文件的名称的唯一性。
完成discCacheFileNameGenerator的初始化之后，就开始磁盘缓存对象discCache，接着看代码：

    /** Creates default implementation of {@link DisckCacheAware} depends on incoming parameters */    public static DiscCacheAware createDiscCache(Context context, FileNameGenerator discCacheFileNameGenerator, int discCacheSize, int discCacheFileCount) {        if (discCacheSize > 0) {            File individualCacheDir = StorageUtils.getIndividualCacheDirectory(context);            return new TotalSizeLimitedDiscCache(individualCacheDir, discCacheFileNameGenerator, discCacheSize);        } else if (discCacheFileCount > 0) {            File individualCacheDir = StorageUtils.getIndividualCacheDirectory(context);            return new FileCountLimitedDiscCache(individualCacheDir, discCacheFileNameGenerator, discCacheFileCount);        } else {            File cacheDir = StorageUtils.getCacheDirectory(context);            return new UnlimitedDiscCache(cacheDir, discCacheFileNameGenerator);        }    }        /**     * Returns application cache directory. Cache directory will be created on SD card     * <i>("/Android/data/[app_package_name]/cache")</i> if card is mounted. Else - Android defines cache directory on     * device's file system.     *      * @param context Application context     * @return Cache {@link File directory}     */    public static File getCacheDirectory(Context context) {        File appCacheDir = null;        if (Environment.getExternalStorageState().equals(android.os.Environment.MEDIA_MOUNTED)) {            appCacheDir = getExternalCacheDir(context);        }        if (appCacheDir == null) {            appCacheDir = context.getCacheDir();        }        return appCacheDir;    }        private static File getExternalCacheDir(Context context) {        File dataDir = new File(new File(Environment.getExternalStorageDirectory(), "Android"), "data");        File appCacheDir = new File(new File(dataDir, context.getPackageName()), "cache");        if (!appCacheDir.exists()) {            if (!appCacheDir.mkdirs()) {                L.w("Unable to create external cache directory");                return null;            }            try {                new File(appCacheDir, ".nomedia").createNewFile();            } catch (IOException e) {                L.i("Can't create \".nomedia\" file in application external cache directory");            }        }        return appCacheDir;    }

由于我们这里传入的discCacheSize和discCacheFileCount都为0，所以首先去查看该设备是否存在SD卡，如果存在则生成SD卡缓存目录/Android/data/[app_package_name]/cache，否则使用应用程序内部的缓存目录
data/data/[app_package_name]/cache。接着初始化对象磁盘缓存对象UnlimitedDiscCache。
继续看memoryCache初始化，看代码：

    /**     * Creates default implementation of {@link MemoryCacheAware} depends on incoming parameters: <br />     * {@link LruMemoryCache} (for API >= 9) or {@link LRULimitedMemoryCache} (for API < 9).<br />     * Default cache size = 1/8 of available app memory.     */    public static MemoryCacheAware<String, Bitmap> createMemoryCache(int memoryCacheSize) {        if (memoryCacheSize == 0) {            memoryCacheSize = (int) (Runtime.getRuntime().maxMemory() / 8);        }        MemoryCacheAware<String, Bitmap> memoryCache;        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) {            memoryCache = new LruMemoryCache(memoryCacheSize);        } else {            memoryCache = new LRULimitedMemoryCache(memoryCacheSize);        }        return memoryCache;    }

从上面我们可以看出内存缓存使用的LRU缓存策略，缓存大小设置为app可使用内存的1/8大小。
继续看downloader对象的初始化，看代码：

    /** Creates default implementation of {@link ImageDownloader} - {@link BaseImageDownloader} */    public static ImageDownloader createImageDownloader(Context context) {        return new BaseImageDownloader(context);    }

得知实例化对象为BaseImageDownloader对象。看一下内部重要的方法：

    @Override    public InputStream getStream(String imageUri, Object extra) throws IOException {        switch (Scheme.ofUri(imageUri)) {            case HTTP:            case HTTPS:                return getStreamFromNetwork(imageUri, extra);            case FILE:                return getStreamFromFile(imageUri, extra);            case CONTENT:                return getStreamFromContent(imageUri, extra);            case ASSETS:                return getStreamFromAssets(imageUri, extra);            case DRAWABLE:                return getStreamFromDrawable(imageUri, extra);            case UNKNOWN:            default:                return getStreamFromOtherSource(imageUri, extra);        }    }

从上得知，该类可以读取各个目录下的图片资源，并转化为流，不仅仅是网络图片。
继续看decoder对象，代码如下：

    /** Creates default implementation of {@link ImageDecoder} - {@link BaseImageDecoder} */    public static ImageDecoder createImageDecoder(boolean loggingEnabled) {        return new BaseImageDecoder(loggingEnabled);    }

上面直接初始化对象BaseImageDecoder，继续看defaultDisplayImageOptions的类初始化，代码：

    /**     * Creates options appropriate for single displaying:     * <ul>     * <li>View will <b>not</b> be reset before loading</li>     * <li>Loaded image will <b>not</b> be cached in memory</li>     * <li>Loaded image will <b>not</b> be cached on disc</li>     * <li>{@link ImageScaleType#IN_SAMPLE_POWER_OF_2} decoding type will be used</li>     * <li>{@link Bitmap.Config#ARGB_8888} bitmap config will be used for image decoding</li>     * <li>{@link SimpleBitmapDisplayer} will be used for image displaying</li>     * </ul>     *      * These option are appropriate for simple single-use image (from drawables or from Internet) displaying.     */    public static DisplayImageOptions createSimple() {        return new Builder().build();    }    /** Builds configured {@link DisplayImageOptions} object */    public DisplayImageOptions build() {        return new DisplayImageOptions(this);    }

看以看出，直接创建一个DisplayImageOptions类，所有属性使用Builder中初始化的赋值。
方法执行到这里，就结束了。以上的属性赋值都是针对ImageLoaderConfiguration内部静态类Builder的属性的操作。完成对Builder中属性初始化之后，接着执行new ImageLoaderConfiguration(this)，将Builder自身传进构造方法中，看一下代码执行：

    private ImageLoaderConfiguration(final Builder builder) {        context = builder.context;        maxImageWidthForMemoryCache = builder.maxImageWidthForMemoryCache;        maxImageHeightForMemoryCache = builder.maxImageHeightForMemoryCache;        maxImageWidthForDiscCache = builder.maxImageWidthForDiscCache;        maxImageHeightForDiscCache = builder.maxImageHeightForDiscCache;        imageCompressFormatForDiscCache = builder.imageCompressFormatForDiscCache;        imageQualityForDiscCache = builder.imageQualityForDiscCache;        taskExecutor = builder.taskExecutor;        taskExecutorForCachedImages = builder.taskExecutorForCachedImages;        threadPoolSize = builder.threadPoolSize;        threadPriority = builder.threadPriority;        tasksProcessingType = builder.tasksProcessingType;        discCache = builder.discCache;        memoryCache = builder.memoryCache;        defaultDisplayImageOptions = builder.defaultDisplayImageOptions;        loggingEnabled = builder.loggingEnabled;        downloader = builder.downloader;        decoder = builder.decoder;        customExecutor = builder.customExecutor;        customExecutorForCachedImages = builder.customExecutorForCachedImages;        networkDeniedDownloader = new NetworkDeniedImageDownloader(downloader);        slowNetworkDownloader = new SlowNetworkImageDownloader(downloader);        reserveDiscCache = DefaultConfigurationFactory.createReserveDiscCache(context);    }

从上面代码知道，在这个构造方法中，将传入的Builder的属性一一赋值给ImageLoaderConfiguration对象的属性，从而完成了ImageLoaderConfiguration的初始化。该类内部采用的是一种建造者模式的设计模式。至此完成的ImageLoaderConfiguration配置初始化。
上面的操作就完成了ImageLoaderConfiguration configuration = ImageLoaderConfiguration.createDefault(this)这一步;
还有不少用户根据自己项目的需求配置ImageLoaderConfiguration的参数，比如：

ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(context)                .threadPriority(Thread.NORM_PRIORITY - 2)                .denyCacheImageMultipleSizesInMemory()                .diskCacheFileNameGenerator(new Md5FileNameGenerator())                .diskCacheSize(50 * 1024 * 1024)// 50 MiB                .tasksProcessingOrder(QueueProcessingType.LIFO)                .writeDebugLogs() // Remove for release app                .build();

上面这种形式其实与createDefault的方法差别不大，它主要是正对一些属性进行定制化，其他没有被设置的属性还是会继续调用系统默认设置的属性。

2.配置初始化生效

完成上述的配置初始化后，就要让配置生效。执行代码为：ImageLoader.getInstance().init(config);
关于这里面的操作，还是老规矩看代码：

    /**     * Initializes ImageLoader instance with configuration.<br />     * If configurations was set before ( {@link #isInited()} == true) then this method does nothing.<br />     * To force initialization with new configuration you should {@linkplain #destroy() destroy ImageLoader} at first.     *      * @param configuration {@linkplain ImageLoaderConfiguration ImageLoader configuration}     * @throws IllegalArgumentException if <b>configuration</b> parameter is null     */    public synchronized void init(ImageLoaderConfiguration configuration) {        if (configuration == null) {            throw new IllegalArgumentException(ERROR_INIT_CONFIG_WITH_NULL);        }        if (this.configuration == null) {            if (configuration.loggingEnabled) L.d(LOG_INIT_CONFIG);            engine = new ImageLoaderEngine(configuration);            this.configuration = configuration;        } else {            L.w(WARNING_RE_INIT_CONFIG);        }    }

从代码中看出来，源码ImageLoader对象持有ImageLoaderConfiguration的引用，这个方法的作用就是将ImageLoaderConfiguration的实例赋值到ImageLoader中configuration的属性。这个方法比较简单。

3.显示图片

完成上面两步之后，开始最后的步骤了，就是将图片资源显示到ImageView控件上来。使用的方法为：ImageLoader.getInstance().displayImage(url, imageView, options, listener );

上代码：

    /**     * Adds display image task to execution pool. Image will be set to ImageView when it's turn.<br />     * <b>NOTE:</b> {@link #init(ImageLoaderConfiguration)} method must be called before this method call     *      * @param uri Image URI (i.e. "http://site.com/image.png", "file:///mnt/sdcard/image.png")     * @param imageView {@link ImageView} which should display image     * @param options {@linkplain DisplayImageOptions Display image options} for image displaying. If <b>null</b> -     *            default display image options     *            {@linkplain ImageLoaderConfiguration.Builder#defaultDisplayImageOptions(DisplayImageOptions) from     *            configuration} will be used.     * @param listener {@linkplain ImageLoadingListener Listener} for image loading process. Listener fires events on UI     *            thread.     *      * @throws IllegalStateException if {@link #init(ImageLoaderConfiguration)} method wasn't called before     * @throws IllegalArgumentException if passed <b>imageView</b> is null     */    public void displayImage(String uri, ImageView imageView, DisplayImageOptions options, ImageLoadingListener listener) {        checkConfiguration();        if (imageView == null) {            throw new IllegalArgumentException(ERROR_WRONG_ARGUMENTS);        }        if (listener == null) {            listener = emptyListener;        }        if (options == null) {            options = configuration.defaultDisplayImageOptions;        }        if (uri == null || uri.length() == 0) {            engine.cancelDisplayTaskFor(imageView);            listener.onLoadingStarted(uri, imageView);            if (options.shouldShowImageForEmptyUri()) {                imageView.setImageResource(options.getImageForEmptyUri());            } else {                imageView.setImageBitmap(null);            }            listener.onLoadingComplete(uri, imageView, null);            return;        }        ImageSize targetSize = ImageSizeUtils.defineTargetSizeForView(imageView, configuration.maxImageWidthForMemoryCache,                configuration.maxImageHeightForMemoryCache);        String memoryCacheKey = MemoryCacheUtil.generateKey(uri, targetSize);        engine.prepareDisplayTaskFor(imageView, memoryCacheKey);        listener.onLoadingStarted(uri, imageView);        Bitmap bmp = configuration.memoryCache.get(memoryCacheKey);        if (bmp != null && !bmp.isRecycled()) {            if (configuration.loggingEnabled) L.i(LOG_LOAD_IMAGE_FROM_MEMORY_CACHE, memoryCacheKey);            if (options.shouldPostProcess()) {                ImageLoadingInfo imageLoadingInfo = new ImageLoadingInfo(uri, imageView, targetSize, memoryCacheKey, options, listener,                        engine.getLockForUri(uri));                ProcessAndDisplayImageTask displayTask = new ProcessAndDisplayImageTask(engine, bmp, imageLoadingInfo, options.getHandler());                engine.submit(displayTask);            } else {                options.getDisplayer().display(bmp, imageView);                listener.onLoadingComplete(uri, imageView, bmp);            }        } else {            if (options.shouldShowStubImage()) {                imageView.setImageResource(options.getStubImage());            } else {                if (options.isResetViewBeforeLoading()) {                    imageView.setImageBitmap(null);                }            }            ImageLoadingInfo imageLoadingInfo = new ImageLoadingInfo(uri, imageView, targetSize, memoryCacheKey, options, listener, engine.getLockForUri(uri));            LoadAndDisplayImageTask displayTask = new LoadAndDisplayImageTask(engine, imageLoadingInfo, options.getHandler());            engine.submit(displayTask);        }    }

上面的代码中imageView就是你用来显示图片的控件，不能为空。listener如果为空，就会使用SimpleImageLoadingListener的实例化对象。看一下其中的代码：

/** * A convenient class to extend when you only want to listen for a subset of all the image loading events. This * implements all methods in the {@link ImageLoadingListener} but does nothing. *  * @author Sergey Tarasevich (nostra13[at]gmail[dot]com) * @since 1.4.0 */public class SimpleImageLoadingListener implements ImageLoadingListener {    @Override    public void onLoadingStarted(String imageUri, View view) {        // Empty implementation    }    @Override    public void onLoadingFailed(String imageUri, View view, FailReason failReason) {        // Empty implementation    }    @Override    public void onLoadingComplete(String imageUri, View view, Bitmap loadedImage) {        // Empty implementation    }    @Override    public void onLoadingCancelled(String imageUri, View view) {        // Empty implementation    }}

从上面我们知道，该类也是继承自ImageLoadingListener接口，并重写了接口的方法，方法提为空。接着如果options为空的化，就会调用之前configuration初始化时的默认配置。接着判断uri是否为空，如果为空，则取消线程中为该imageView显示图片的任务。直接将imageForEmptyUri中的图片传入其中（如果imageForEmptyUri不等于0的话），如果imageForEmptyUri为0，就直接设置imageView为空，跳出该方法。
如果上述条件都不符合的话，方法继续执行，定义imageview的大小，生成imageview在内存缓存中的key，然后通过key值，得到bitmap对象。如果bitmap不为空，生成一个显示任务，控制线程池提交该任务。至此便完成了imageView的图片显示功能。

以上就是Universal-Image-Loader框架的大体思路，里面涉及的知识点非常多，无法面面俱到，初次分析有很多的不足之处，还是要多多学习大牛们的源码来开阔自身的眼界，努力提高自己代码的设计能力，路漫漫其修远兮。