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线程的流程就分析完毕了。

其实，整个流程非常的简单，清晰。只不过在考虑到了多种情况，使得代码看上去很多。

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