Universal-Image-Loader源码分析(二)——载入图片的过程分析

之前的文章,在上面建立完config之后,UIl通过ImageLoader.getInstance().init(config.build());来初始化ImageLoader对象,之后就可以用ImageLoader来加载图片。

这里,采用到单例模式来获取ImageLoader对象,保证他全局初始化一次。再上面的分析中,我们可以看出单例模式的好处,创建ImageLoader对象的时候需要创建Config,而Config里面同样初始化了一堆对象。如果每次用到都现初始化ImageLoader,消耗太大。我们看一下ImageLoader的init的源码

public synchronized void init(ImageLoaderConfiguration configuration) {
        if (configuration == null) {
            throw new IllegalArgumentException(ERROR_INIT_CONFIG_WITH_NULL);
        }
        if (this.configuration == null) {
            L.d(LOG_INIT_CONFIG);
            //创建图片加载引擎
            engine = new ImageLoaderEngine(configuration);
            this.configuration = configuration;
        } else {
            L.w(WARNING_RE_INIT_CONFIG);
        }
    }
    

如果该对象还没有config,则将传入的config赋值给this.config。并且初始化图片加载引擎。

我们继续看图片加载引擎主要执行的工作。

class ImageLoaderEngine {
    /*ImageLoader加载配置*/
    final ImageLoaderConfiguration configuration;
    /*任务执行者*/
    private Executor taskExecutor;
    /*图片缓存任务执行则*/
    private Executor taskExecutorForCachedImages;
    /*任务分配者*/
    private Executor taskDistributor;

    private final Map<Integer, String> cacheKeysForImageAwares = Collections
            .synchronizedMap(new HashMap<Integer, String>());
    private final Map<String, ReentrantLock> uriLocks = new WeakHashMap<String, ReentrantLock>();
    /*暂停*/
    private final AtomicBoolean paused = new AtomicBoolean(false);
    /*网络拒绝访问*/
    private final AtomicBoolean networkDenied = new AtomicBoolean(false);
    /*网络慢*/
    private final AtomicBoolean slowNetwork = new AtomicBoolean(false);

    private final Object pauseLock = new Object();

    /**
     * ImageLoader引擎构造器
     * @param configuration
     */
    ImageLoaderEngine(ImageLoaderConfiguration configuration) {
        //初始化ImageLoader配置参数
        this.configuration = configuration;
        //初始化三个不同任务的执行者
        taskExecutor = configuration.taskExecutor;
        taskExecutorForCachedImages = configuration.taskExecutorForCachedImages;
        taskDistributor = DefaultConfigurationFactory.createTaskDistributor();
    }

    /** Submits task to execution pool */
    /**
     * 提交图片加载和显示任务到执行线程池中,进行运行
     * @param task   具体需要执行的任务
     */
    void submit(final LoadAndDisplayImageTask task) {
        taskDistributor.execute(new Runnable() {
            @Override
            public void run() {
                //从文件系统缓存中获取图片文件
                File image = configuration.diskCache.get(task.getLoadingUri());
                //判断是否已经取得了图片
                boolean isImageCachedOnDisk = image != null && image.exists();
                initExecutorsIfNeed();
                if (isImageCachedOnDisk) {
                    //如果当前图片已经缓存在本地文件系统了,直接采用taskExecutorForCachedImages来进行执行任务
                    taskExecutorForCachedImages.execute(task);
                } else {
                    //当天图片在本地文件系统中没有缓存,直接采用taskExecutor来进行执行任务
                    taskExecutor.execute(task);
                }
            }
        });
    }

    /**
     * Submits task to execution pool
     * 提交图片显示任务并且执行 (该图片从内存缓存中取得)
     */
    void submit(ProcessAndDisplayImageTask task) {
        initExecutorsIfNeed();
        taskExecutorForCachedImages.execute(task);
    }

    /**
     * 根据需要进行初始化执行者
     */
    private void initExecutorsIfNeed() {
        if (!configuration.customExecutor && ((ExecutorService) taskExecutor).isShutdown()) {
            taskExecutor = createTaskExecutor();
        }
        if (!configuration.customExecutorForCachedImages && ((ExecutorService) taskExecutorForCachedImages)
                .isShutdown()) {
            taskExecutorForCachedImages = createTaskExecutor();
        }
    }

    /**
     * 进行创建任务执行者
     * @return
     */
    private Executor createTaskExecutor() {
        return DefaultConfigurationFactory
                .createExecutor(configuration.threadPoolSize, configuration.threadPriority,
                configuration.tasksProcessingType);
    }

    /**
     * 获取当前被加载ImageAware到图片的地址
     * Returns URI of image which is loading at this moment into passed {@link com.nostra13.universalimageloader.core.imageaware.ImageAware}
     */
    String getLoadingUriForView(ImageAware imageAware) {
        return cacheKeysForImageAwares.get(imageAware.getId());
    }

    /**
     *
     * Associates <b>memoryCacheKey</b> with <b>imageAware</b>. Then it helps to define image URI is loaded into View at
     * exact moment.
     */
    void prepareDisplayTaskFor(ImageAware imageAware, String memoryCacheKey) {
        cacheKeysForImageAwares.put(imageAware.getId(), memoryCacheKey);
    }

    /**
     * Cancels the task of loading and displaying image for incoming <b>imageAware</b>.
     *
     * @param imageAware {@link com.nostra13.universalimageloader.core.imageaware.ImageAware} for which display task
     *                   will be cancelled
     */
    void cancelDisplayTaskFor(ImageAware imageAware) {
        cacheKeysForImageAwares.remove(imageAware.getId());
    }

    /**
     * Denies or allows engine to download images from the network.<br /> <br /> If downloads are denied and if image
     * isn't cached then {@link ImageLoadingListener#onLoadingFailed(String, View, FailReason)} callback will be fired
     * with {@link FailReason.FailType#NETWORK_DENIED}
     *
     * @param denyNetworkDownloads pass <b>true</b> - to deny engine to download images from the network; <b>false</b> -
     *                             to allow engine to download images from network.
     */
    void denyNetworkDownloads(boolean denyNetworkDownloads) {
        networkDenied.set(denyNetworkDownloads);
    }

    /**
     * Sets option whether ImageLoader will use {@link FlushedInputStream} for network downloads to handle <a
     * href="http://code.google.com/p/android/issues/detail?id=6066">this known problem</a> or not.
     *
     * @param handleSlowNetwork pass <b>true</b> - to use {@link FlushedInputStream} for network downloads; <b>false</b>
     *                          - otherwise.
     */
    void handleSlowNetwork(boolean handleSlowNetwork) {
        slowNetwork.set(handleSlowNetwork);
    }

    /**
     * Pauses engine. All new "load&display" tasks won't be executed until ImageLoader is {@link #resume() resumed}.<br
     * /> Already running tasks are not paused.
     * 暂停任务运行
     */
    void pause() {
        paused.set(true);
    }

    /**
     * Resumes engine work. Paused "load&display" tasks will continue its work.
     * 任务恢复运行
     */
    void resume() {
        paused.set(false);
        synchronized (pauseLock) {
            pauseLock.notifyAll();
        }
    }

    /**
     * 停止ImageLoader引擎,取消所有正在运行或者挂起的图片显示任务,并且清除内部的数据
     * Stops engine, cancels all running and scheduled display image tasks. Clears internal data.
     * <br />
     * <b>NOTE:</b> This method doesn't shutdown
     * {@linkplain com.nostra13.universalimageloader.core.ImageLoaderConfiguration.Builder#taskExecutor(java.util.concurrent.Executor)
     * custom task executors} if you set them.
     */
    void stop() {
        if (!configuration.customExecutor) {
            ((ExecutorService) taskExecutor).shutdownNow();
        }
        if (!configuration.customExecutorForCachedImages) {
            ((ExecutorService) taskExecutorForCachedImages).shutdownNow();
        }
        cacheKeysForImageAwares.clear();
        uriLocks.clear();
    }

    void fireCallback(Runnable r) {
        taskDistributor.execute(r);
    }

    ReentrantLock getLockForUri(String uri) {
        ReentrantLock lock = uriLocks.get(uri);
        if (lock == null) {
            lock = new ReentrantLock();
            uriLocks.put(uri, lock);
        }
        return lock;
    }

    AtomicBoolean getPause() {
        return paused;
    }

    Object getPauseLock() {
        return pauseLock;
    }

    boolean isNetworkDenied() {
        return networkDenied.get();
    }

    boolean isSlowNetwork() {
        return slowNetwork.get();
    }
}

上面的代码中,核心的部分就是创建了任务执行器和图片缓存执行器,并且在submit方法中针对提交的任务,选择不同的执行器执行。

ImageLoader关于加载显示图片,有如下几种用法,我们依次分析一下。

displayImage(), loadImage()

先看loadImage()

下面的loadImage所有的重载方法。

    public void loadImage(String uri, ImageLoadingListener listener) {
        loadImage(uri, null, null, listener, null);
    }
    
    public void loadImage(String uri, ImageSize targetImageSize, ImageLoadingListener listener) {
        loadImage(uri, targetImageSize, null, listener, null);
    }
    
    public void loadImage(String uri, DisplayImageOptions options, ImageLoadingListener listener) {
        loadImage(uri, null, options, listener, null);
    }
    
    public void loadImage(String uri, ImageSize targetImageSize, DisplayImageOptions options,
            ImageLoadingListener listener) {
        loadImage(uri, targetImageSize, options, listener, null);
    }
    public void loadImage(String uri, ImageSize targetImageSize, DisplayImageOptions options,
            ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {
    }

不管是几个参数的loadImage,最后都会重载下面的方法。

public void loadImage(String uri, ImageSize targetImageSize, DisplayImageOptions options,
            ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {
        checkConfiguration();
        if (targetImageSize == null) {
            targetImageSize = configuration.getMaxImageSize();
        }
        if (options == null) {
            options = configuration.defaultDisplayImageOptions;
        }

        NonViewAware imageAware = new NonViewAware(uri, targetImageSize, ViewScaleType.CROP);
        displayImage(uri, imageAware, options, listener, progressListener);
    }

如果没有指定targetImageSize以及options就会采用config默认的提供,然后根据targetImageSize以及uri生成一个NonViewAware,最终通过displayImage来加载。

targetImageSize是一个ImageSize对象,该类是image尺寸的封装类,config的默认值是屏幕的宽高。
options是采用config默认创建,config的默认值是faultDisplayImageOptions = DisplayImageOptions.createSimple();
这个初始化都是创建的DisplayImageOptions都是默认值,基本什么属性都是false或者null或者0

接下来,我们看一下NonViewAware类,NonViewAware是实现了ImageAware接口的一个类,ImageAware接口主要定义了图片处理和显示所需要的方法和属性。所以NonViewAware也只是对传入的参数进行封装,来提供一个外部访问的接口。

真正显示图片的方法都是displayImage,displayImage方法和loadImage一样,提供了多种参数,displayImage的重载方法要多一些,因为displayImage方法有一类是接受ImageView而另一类是接受ImageAware。
下面是无论如何都是最终调用的方法:
代码如下:

public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options,
            ImageSize targetSize, ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {
        //进行检查ImageLoader全局相关配置
        checkConfiguration();
        if (imageAware == null) {
            throw new IllegalArgumentException(ERROR_WRONG_ARGUMENTS);
        }
        if (listener == null) {
            listener = defaultListener;
        }
        //检查图片显示配置
        if (options == null) {
            options = configuration.defaultDisplayImageOptions;
        }
        //==============图片地址为空=================
        if (TextUtils.isEmpty(uri)) {
            engine.cancelDisplayTaskFor(imageAware);
            //接口方法回调,当前图片加载任务开始
            listener.onLoadingStarted(uri, imageAware.getWrappedView());
            //进行判断是否给imageview添加一个空地址的资源图片
            if (options.shouldShowImageForEmptyUri()) {
                imageAware.setImageDrawable(options.getImageForEmptyUri(configuration.resources));
            } else {
                imageAware.setImageDrawable(null);
            }
            //直接加载回调加载成功
            listener.onLoadingComplete(uri, imageAware.getWrappedView(), null);
            return;
        }
        //=============图片地址存在=====================
        if (targetSize == null) {
            //如果图片显示的目标大小没有设置的,那么就使用默认大小尺寸即可
            targetSize = ImageSizeUtils.defineTargetSizeForView(imageAware, configuration.getMaxImageSize());
        }
        //根据地址和图片目标尺寸信息,生成缓存key
        String memoryCacheKey = MemoryCacheUtils.generateKey(uri, targetSize);
        engine.prepareDisplayTaskFor(imageAware, memoryCacheKey);
        //开始进行加载图片
        listener.onLoadingStarted(uri, imageAware.getWrappedView());

        //首先根据key去缓存中获取是否还存在该图片
        Bitmap bmp = configuration.memoryCache.get(memoryCacheKey);
        if (bmp != null && !bmp.isRecycled()) {
            //缓存中该图片存在
            L.d(LOG_LOAD_IMAGE_FROM_MEMORY_CACHE, memoryCacheKey);
            if (options.shouldPostProcess()) {
                ImageLoadingInfo imageLoadingInfo = new ImageLoadingInfo(uri, imageAware, targetSize, memoryCacheKey,
                        options, listener, progressListener, engine.getLockForUri(uri));
                ProcessAndDisplayImageTask displayTask = new ProcessAndDisplayImageTask(engine, bmp, imageLoadingInfo,
                        defineHandler(options));
                //是否允许同步加载
                if (options.isSyncLoading()) {
                    displayTask.run();
                } else {
                    //提交进行显示
                    engine.submit(displayTask);
                }
            } else {
                options.getDisplayer().display(bmp, imageAware, LoadedFrom.MEMORY_CACHE);
                listener.onLoadingComplete(uri, imageAware.getWrappedView(), bmp);
            }
        } else {
            //缓存中不存在该图片 通过网络加载
            if (options.shouldShowImageOnLoading()) {
                imageAware.setImageDrawable(options.getImageOnLoading(configuration.resources));
            } else if (options.isResetViewBeforeLoading()) {
                imageAware.setImageDrawable(null);
            }
            //进行构造图片加载任务相关的所有信息对象
            ImageLoadingInfo imageLoadingInfo = new ImageLoadingInfo(uri, imageAware, targetSize, memoryCacheKey,
                    options, listener, progressListener, engine.getLockForUri(uri));
            //分装图片加载和显示任务对象 然后进行开启执行任务
            LoadAndDisplayImageTask displayTask = new LoadAndDisplayImageTask(engine, imageLoadingInfo,
                    defineHandler(options));
            if (options.isSyncLoading()) {
                displayTask.run();
            } else {
                engine.submit(displayTask);
            }
        }
    }

具体的执行过程已经通过代码注释了,下面梳理下流程。
首先,针对为null的属性,初始化这些属性,然后判断传入的uri是不是为空,如果为空,则根据options.shouldShowImageForEmptyUri来判断是否显示先设置好的图片。
如果传入的uri是存在的,则根据地址和图片目标尺寸的信息来生成缓存key,然后执行
prepareDisplayTaskFor方法。
再根据key来判断缓存中是否存在该图片,如果存在,就判断options的shouldPostProcess,如果为true就创建一个ProcessAndDisplayImageTask对象,通过图片加载引擎来加载。如果返回的值false,则调用options.getDisplayer().display(bmp, imageAware, LoadedFrom.MEMORY_CACHE);

如果缓存不存在,则直接通过网络加载该图片,加载的方式是构建LoadAndDisplayImageTask对象,通过图片加载引擎来判断。

在这里,关于图片的缓存相关的内容,先不分析。接下来主要分析的是图片如何执行这两种不同的任务的。

第一种,在有缓存的情况下,通过判断shouldPostProcess为true来让图片引擎处理任务,这里的shouldPostProcess是指在拿到bitmap之后是否进行后续的操作,判断标准就是postProcess是否为null.
如果不为null,也就是shouldPostProcess为true,则执行下面的代码:
下面,我们来看一下,图片引擎是如何执行ProcessAndDisplayImageTask。

void submit(ProcessAndDisplayImageTask task) {
        initExecutorsIfNeed();
        taskExecutorForCachedImages.execute(task);
    }

内部直接调用taskExecutorForCachedImages去执行task,所以主要看ProcessAndDisplayImageTask的task构造。

final class ProcessAndDisplayImageTask implements Runnable {

    private static final String LOG_POSTPROCESS_IMAGE = "PostProcess image before displaying [%s]";
    /*ImageLoader引擎*/
    private final ImageLoaderEngine engine;
    private final Bitmap bitmap;
    /*ImageLoader信息封装对象*/
    private final ImageLoadingInfo imageLoadingInfo;
    private final Handler handler;

    /**
     * 图片处理显示任务构造器
     * @param engine
     * @param bitmap
     * @param imageLoadingInfo
     * @param handler
     */
    public ProcessAndDisplayImageTask(ImageLoaderEngine engine, Bitmap bitmap, ImageLoadingInfo imageLoadingInfo,
            Handler handler) {
        this.engine = engine;
        this.bitmap = bitmap;
        this.imageLoadingInfo = imageLoadingInfo;
        this.handler = handler;
    }

    @Override
    public void run() {
        L.d(LOG_POSTPROCESS_IMAGE, imageLoadingInfo.memoryCacheKey);
        //获取图片处理器 然后取得加载的图片
        BitmapProcessor processor = imageLoadingInfo.options.getPostProcessor();
        Bitmap processedBitmap = processor.process(bitmap);
        //封装图片显示任务   其中图片来源设置成-来自内存缓存
        DisplayBitmapTask displayBitmapTask = new DisplayBitmapTask(processedBitmap, imageLoadingInfo, engine,
                LoadedFrom.MEMORY_CACHE);
        //执行任务
        LoadAndDisplayImageTask.runTask(displayBitmapTask, imageLoadingInfo.options.isSyncLoading(), handler, engine);
    }
}

这边可以看出,task内部run方法里面,首先得到一个BitmapProcessor,然后通过该processor去处理bitmap,然后将处理后的bitmap以及其他信息封装成了DisplayBitmapTask,然后最终还是执行了LoadAndDisplayImageTask的runTask方法

下面将看LoadAndDisplayImageTask.runTask方法

static void runTask(Runnable r, boolean sync, Handler handler, ImageLoaderEngine engine) {
        if (sync) {
            //如果同步 任务直接运行
            r.run();
        } else if (handler == null) {
            engine.fireCallback(r);
        } else {
            //任务通过Handler分发到主线程执行
            handler.post(r);
        }
    }

这边,直接在UI线程displayBitmapTask,后面再看displayBitmapTask的内部实现。
回到shouldPostProcess的判断那里,如果为false,则直接调用BitmapDisplay显示图片,这里传入的是SimpleBitmapDisplayer
再回到缓存判断那里,上面的代码都是在有内存缓存的情况下,执行的。看一下在无内存缓存时,执行的细节。

//缓存中不存在该图片 通过网络加载
            if (options.shouldShowImageOnLoading()) {
                imageAware.setImageDrawable(options.getImageOnLoading(configuration.resources));
            } else if (options.isResetViewBeforeLoading()) {
                imageAware.setImageDrawable(null);
            }
            //进行构造图片加载任务相关的所有信息对象
            ImageLoadingInfo imageLoadingInfo = new ImageLoadingInfo(uri, imageAware, targetSize, memoryCacheKey,
                    options, listener, progressListener, engine.getLockForUri(uri));
            //分装图片加载和显示任务对象 然后进行开启执行任务
            LoadAndDisplayImageTask displayTask = new LoadAndDisplayImageTask(engine, imageLoadingInfo,
                    defineHandler(options));
            if (options.isSyncLoading()) {
                displayTask.run();
            } else {
                engine.submit(displayTask);
            }

通过源码可以看出,首先判断要不要进行显示加载中的View,然后构建图片加载信息,通过图片加载信息构建LoadAndDisplayImageTask对象,执行去run方法。
上面,我们已经分析了其runTask方法,该方法比较简单,这次我们看一下run方法。

public void run() {
        //如果当前状态是暂停 当前任务直接返回
        if (waitIfPaused()) return;
        //如果当前状态需要等待  当前任务直接返回
        if (delayIfNeed()) return;

        ReentrantLock loadFromUriLock = imageLoadingInfo.loadFromUriLock;
        L.d(LOG_START_DISPLAY_IMAGE_TASK, memoryCacheKey);
        if (loadFromUriLock.isLocked()) {
            L.d(LOG_WAITING_FOR_IMAGE_LOADED, memoryCacheKey);
        }
        //任务加锁
        loadFromUriLock.lock();
        Bitmap bmp;
        try {
            //进行检查任务  判断当前要显示的引用对象是否已经被回收了
            checkTaskNotActual();
            //先从缓存中获取图片
            bmp = configuration.memoryCache.get(memoryCacheKey);
            if (bmp == null || bmp.isRecycled()) {
                //进行尝试获取加载图片(去文件中,文件中不存在去网络下载,然后缓存到文件)
                bmp = tryLoadBitmap();
                if (bmp == null) return; // listener callback already was fired

                checkTaskNotActual();
                checkTaskInterrupted();

                if (options.shouldPreProcess()) {
                    L.d(LOG_PREPROCESS_IMAGE, memoryCacheKey);
                    bmp = options.getPreProcessor().process(bmp);
                    if (bmp == null) {
                        L.e(ERROR_PRE_PROCESSOR_NULL, memoryCacheKey);
                    }
                }

                if (bmp != null && options.isCacheInMemory()) {
                    L.d(LOG_CACHE_IMAGE_IN_MEMORY, memoryCacheKey);
                    configuration.memoryCache.put(memoryCacheKey, bmp);
                }
            } else {
                //从缓存中获取到图片信息
                //设置图片来源信息 --Memory Cache
                loadedFrom = LoadedFrom.MEMORY_CACHE;
                L.d(LOG_GET_IMAGE_FROM_MEMORY_CACHE_AFTER_WAITING, memoryCacheKey);
            }

            if (bmp != null && options.shouldPostProcess()) {
                L.d(LOG_POSTPROCESS_IMAGE, memoryCacheKey);
                bmp = options.getPostProcessor().process(bmp);
                if (bmp == null) {
                    L.e(ERROR_POST_PROCESSOR_NULL, memoryCacheKey);
                }
            }
            checkTaskNotActual();
            checkTaskInterrupted();
        } catch (TaskCancelledException e) {
            fireCancelEvent();
            return;
        } finally {
            //任务取消锁
            loadFromUriLock.unlock();
        }
        //封装图片显示任务对象
        DisplayBitmapTask displayBitmapTask = new DisplayBitmapTask(bmp, imageLoadingInfo, engine, loadedFrom);
        //进行任务运行
        runTask(displayBitmapTask, syncLoading, handler, engine);
    }

其流程图如下:

可以看到这边,利用的图片三级缓存,第一级是内存缓存,如果内存缓存没有则利用二级缓存,从文件中去读取,如果文件中有,则从文件中取出bitmap,如果没有则从网络下载。
这边从文件中bitmap的方法是tryLoadBitmap,下面主要看一下这个方法

private Bitmap tryLoadBitmap() throws TaskCancelledException {
        Bitmap bitmap = null;
        try {
            //从本地文件缓存中获取图片
            File imageFile = configuration.diskCache.get(uri);
            if (imageFile != null && imageFile.exists() && imageFile.length() > 0) {
                L.d(LOG_LOAD_IMAGE_FROM_DISK_CACHE, memoryCacheKey);
                //文件存在设置图片来源
                loadedFrom = LoadedFrom.DISC_CACHE;
                //检查引用是否已经被回收了
                checkTaskNotActual();
                //图片解码,文件转换成bitmap对象
                bitmap = decodeImage(Scheme.FILE.wrap(imageFile.getAbsolutePath()));
            }
            if (bitmap == null || bitmap.getWidth() <= 0 || bitmap.getHeight() <= 0) {
                L.d(LOG_LOAD_IMAGE_FROM_NETWORK, memoryCacheKey);
                //本地文件系统中图片解码失败,尝试通过网络获取
                loadedFrom = LoadedFrom.NETWORK;
                String imageUriForDecoding = uri;
                //判断图片可以本地文件系统缓存以及尝试本地文本系统缓存(网络下载图片,下载成功图片缓存本地文件系统)
                if (options.isCacheOnDisk() && tryCacheImageOnDisk()) {
                    //从本地文件系统缓存中获取图片
                    imageFile = configuration.diskCache.get(uri);
                    if (imageFile != null) {
                        imageUriForDecoding = Scheme.FILE.wrap(imageFile.getAbsolutePath());
                    }
                }

                checkTaskNotActual();
                //图片解码
                bitmap = decodeImage(imageUriForDecoding);

                if (bitmap == null || bitmap.getWidth() <= 0 || bitmap.getHeight() <= 0) {
                    //回调图片解码失败
                    fireFailEvent(FailType.DECODING_ERROR, null);
                }
            }
        } catch (IllegalStateException e) {
            fireFailEvent(FailType.NETWORK_DENIED, null);
        } catch (TaskCancelledException e) {
            throw e;
        } catch (IOException e) {
            L.e(e);
            fireFailEvent(FailType.IO_ERROR, e);
        } catch (OutOfMemoryError e) {
            L.e(e);
            fireFailEvent(FailType.OUT_OF_MEMORY, e);
        } catch (Throwable e) {
            L.e(e);
            fireFailEvent(FailType.UNKNOWN, e);
        }
        //图片存在 返回
        return bitmap;
    }

首先是从diskcache中,取出File,然后对file进行转换。如果转换后的bitmap为null,则从网络获取图片,获取图片的方法调用是在options.isCacheOnDisk() && tryCacheImageOnDisk() 该判断首先判断是否存储在文件中,如果不存在文件中,就不执行后面的网络获取。

private boolean tryCacheImageOnDisk() throws TaskCancelledException {
        L.d(LOG_CACHE_IMAGE_ON_DISK, memoryCacheKey);
        boolean loaded;
        try {
            //图片下载并且保存本地
            loaded = downloadImage();
            if (loaded) {
                int width = configuration.maxImageWidthForDiskCache;
                int height = configuration.maxImageHeightForDiskCache;
                if (width > 0 || height > 0) {
                    L.d(LOG_RESIZE_CACHED_IMAGE_FILE, memoryCacheKey);
                    //根据尺寸大小配置 进行图片缩放和保存
                    resizeAndSaveImage(width, height); // TODO : process boolean result
                }
            }
        } catch (IOException e) {
            L.e(e);
            loaded = false;
        }
        return loaded;
    }

downloadImage是执行网络请求的方法,其内部通过BaseImageDownloader进行下载,其内部的网络库是HttpURLConnection,下载后的图片,根据设定的文件存储的最大宽高,进行缩放与保存。
这样,就在文件缓存中缓存了图片,在回到上面LoadAndDisplayTask的run方法,在得到bitmap之后,就会判断是否要 对bitmap进行预处理,预处理完的bitmap全部会缓存到内存缓存中。上面的操作都是建立在bitmap中内存缓存中取没有取出来的情况,如果取出来就直接得到bitmap,然后从bitmap判断是否进行后续的处理。

这里,简单说一下 preProcessor以及postProcessor,preProcessor是指对图片进行预处理,比如加水印,如果加水印的图片都会缓存到内存,postProcessor是对取出的bitmap做一些后续的操作,操作后将显示出来。
最后得到的Bitmap会封装成DisplayBitmapTask,调用上面提到的runtask方法,进行处理。

这样,到此,发起图片获取需求,到图片经过内存缓存,文件缓存,网络获取后得到,然后再通过Handler回到UI线程的流程就分析完毕了。
其实,整个流程非常的简单,清晰。只不过在考虑到了多种情况,使得代码看上去很多。

下面,将分析图片加载框架最重要的一部分,缓存的设计。

posted @ 2017-07-17 14:28 byhieg 阅读(...) 评论(...) 编辑 收藏