Android中UniversalImageLoader面试问题讲解

1.UIL基本用法

DisplayImageOptions options = new DisplayImageOptions.Builder()
    .cacheInMemory(true)
    .cacheOnDisk(true)
    .bitmapConfig(Bitmap.Config.RGB_565)
    .build();
ImageLoader.getInstance().displayImage(imageUrl,mImageView,options);

我们可以看到，UniversalImageLoader的用法还是很简单的，还有更多的配置我这里就不赘述了。这个示例中用到的设置主要是cacheInMemory(true)允许使用内存缓存，cacheOnDisk(true)允许使用磁盘缓存。

2.displayImage()方法源码分析

我们可以看到，在使用UIL时，我们最终调用了ImageLoader中的displayImage方法。方法源码如下：

public void displayImage(String uri, ImageView imageView, DisplayImageOptions options) {
    displayImage(uri, new ImageViewAware(imageView), options, null, null);
}

其实这个是个重载方法，我这里只是抽取了一个最简单的示例。可以看到，Universal Image Loader是将ImageView包装成了ImageViewAware来进行后续逻辑的。

3.ImageViewAware类分析

/**
 * Wrapper for Android {@link android.widget.ImageView ImageView}. Keeps weak reference of ImageView to prevent memory
 * leaks.
 *
 * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
 * @since 1.9.0
 */
public class ImageViewAware extends ViewAware {

从该类的注释可以看出，它是将ImageView做了一个封装，同时它会将ImageView的强引用改为弱引用。即当内存不足时可以更好地对ImageView进行回收。同时该类还可以获取到ImageView的宽高，对ImageView进行裁剪，减少内存的使用。 

4.继续回到displayImage()方法源码

多个displayImage()方法其实是在不断向深层次调用。我们进入最终一层的displayImage()方法，完整方法的源码如下：

public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options,
			ImageSize targetSize, ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {
    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());
        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());
    }
    String memoryCacheKey = MemoryCacheUtils.generateKey(uri, targetSize);
    engine.prepareDisplayTaskFor(imageAware, memoryCacheKey);

    listener.onLoadingStarted(uri, imageAware.getWrappedView());

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

<1>从源码中可以看到，首先我们调用了checkConfiguration()方法，代码如下：

public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options,
			ImageSize targetSize, ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {
    checkConfiguration();
    ...
}

该方法对全局变量configuration进行了判断，如果为null，则抛出异常。

<2>接着源码中调用了如下代码：

public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options,
			ImageSize targetSize, ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {
    ...
    if (TextUtils.isEmpty(uri)) {
        ...
    }
    ...
}

这里主要是判断url为空时，我们如何处理。

<3>在<2>中的if判断中，有如下代码

public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options,
			ImageSize targetSize, ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {
    ...
    if (TextUtils.isEmpty(uri)) {
        engine.cancelDisplayTaskFor(imageAware);
        ...
    }
    ...
}

这里会记录我们加载的任务，加载图片的时候我们会将ImageView的id和图片的url，加上尺寸，加载到一个集合队列当中。

看一下engine到底是一个什么集合队列。在ImageLoader的全局变量中，我们找到了这个engine

private ImageLoaderEngine engine;

接着我们进入ImageLoaderEngine类中，我们在ImageLoaderEngine类的全局变量中又找到了如下属性

private final Map uriLocks = new WeakHashMap();

这里我们就可以看到它的实现还是通过一个HashMap实现的。这就说明我们所有的属性都会添加到这个HashMap当中。

那么我们回到ImageLoader类中，再看刚才的代码，我们就明白了，当我们判断我们的url为空后，我们会把ImageView的一些属性添加到这个HashMap当中，加载完之后我们会移除这个方法，因为它是cancelDisplay，说明加载完之后它会移除，这是对我们内存的一种优化，它不会将我们所有的配置全放入内存中占用内存空间。

<4>我们接着往后看

public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options,
			ImageSize targetSize, ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {
    ...
    if (TextUtils.isEmpty(uri)) {
        ...
        if (options.shouldShowImageForEmptyUri()) {
            imageAware.setImageDrawable(options.getImageForEmptyUri(configuration.resources));
        } else {
            ...
        }
        ...
    }
    ...
}

这里我们会调用getImageForEmptyUri将我们的属性配置给ImageView。

<5>我们接着往后看

public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options,
			ImageSize targetSize, ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {
    ...
    if (TextUtils.isEmpty(uri)) {
        ...
        listener.onLoadingComplete(uri, imageAware.getWrappedView(), null);
        return;
    }
    ...
}

在这个if判断的最后，UIL会通过一个listener的回调，告诉我们这次任务已经完成了。回顾整个整个if模块，代码如下：

public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options,
			ImageSize targetSize, ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {
    ...
    if (TextUtils.isEmpty(uri)) {
        engine.cancelDisplayTaskFor(imageAware);
        listener.onLoadingStarted(uri, imageAware.getWrappedView());
        if (options.shouldShowImageForEmptyUri()) {
            imageAware.setImageDrawable(options.getImageForEmptyUri(configuration.resources));
        } else {
            imageAware.setImageDrawable(null);
        }
        listener.onLoadingComplete(uri, imageAware.getWrappedView(), null);
        return;
    }
    ...
}

 它就是判断url为空时进行默认图片的加载。

<6>当url不为空时，我们继续往后看，会执行如下代码：

public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options,
			ImageSize targetSize, ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {
    ...
    if (targetSize == null) {
        targetSize = ImageSizeUtils.defineTargetSizeForView(imageAware,configuration.getMaxImageSize());
    }
    ...
}

这个方法主要是将ImageView的宽高封装成ImageSize这个类型。如果我们获取ImageView的高度、宽度为0的话，我们就会使用手机屏幕的宽度、高度。

<7>获取targetSize之后，它会进行MemoryCache的操作，即从内存中获取我们需要的图片。

public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options,
			ImageSize targetSize, ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {
    ...
    Bitmap bmp = configuration.memoryCache.get(memoryCacheKey);
    ...
}

这里注意用到的是get方法。跟入这个get方法，可以看到MemoryCache是个接口类，它的具体实现是LruMemoryCache。get方法源码如下：

@Override
public final Bitmap get(String key) {
    if (key == null) {
        throw new NullPointerException("key == null");
    }

    synchronized (this) {
        return map.get(key);
    }
}

这里其实就是从缓存中获取Bitmap对象，默认使用的是LruCache算法。LruCache算法就是最近最少使用缓存对象。我们会把最近最少缓存对象从队列中移除，然后把最新的所要使用的缓存对象添加到队列当中。

<8>回到displayImage方法

在从内存中获取到Bitmap后，我们要对这个Bitmap进行判断

if (bmp != null && !bmp.isRecycled()) {
    ★1
}else{
    ★2
}    

这个判断是Bitmap对象是否为空，是否已经进行了回收。

<9>在★1处，即Bitmap不为空并且未被回收时，我们进行如下判断

if (options.shouldPostProcess()) {
    ★★1
}else{
    ★★2
}

这个判断的意思是我们后期是否应当对图片进行处理。这里注意，这个postProcessor属性我们是可以在使用UniversalImageLoader的时候在Option中设置的。

<10>在★2处，即从内存中获取的bmp为空或已回收时，我们会执行如下代码：

LoadAndDisplayImageTask displayTask = new LoadAndDisplayImageTask(engine, imageLoadingInfo,defineHandler(options));

这里可以看出最后我们是通过这个Task进行图片的加载。其实所有图片加载的原理都是一样的，它都是内部需要一个线程池，然后不断发送消息给线程池，来进行图片的加载请求。

<11>我们进入LoadAndDisplayImageTask类来看一下它的内容

final class LoadAndDisplayImageTask implements Runnable, IoUtils.CopyListener {
    ...
}

这里该类实现的是一个Runnable接口，说明它就是一个线程，去执行图片的加载。

接着我们看一下它的run方法，代码如下：

@Override
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 {
				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);
}

可以看到，在run方法中它首先执行了如下代码：

@Override
public void run() {
    if (waitIfPaused()) return;
    ...
}

这个方法的场景主要用于滚动的ListView加载图片的时候。有时候为了使我们滑动更加流畅，我们会选择手指在滑动的时候，不去加载图片。所以才提供了这样的方法。ListView可以设置一个Listener，来使滑动时不加载图片。

在waitIfPaused()方法中，有如下代码：

private boolean waitIfPaused() {
    ...
    if (pause.get()) {
        synchronized (engine.getPauseLock()) {
		    ...
        }
    }
	return isTaskNotActual();
}

synchronized (engine.getPauseLock())其实就是获得找个栈的一个锁，即如果获得一个停止的锁就不去加载找个图片。这个方法最终返回isTaskNotActual()，即不仅要监听ListView的滑动，也要看这个图片加载Task是否是活动的。isTaskNotActual()方法源码如下：

private boolean isTaskNotActual() {
    return isViewCollected() || isViewReused();
}

该方法内部主要判断View是否已被回收，是否这个View被复用了。也就是它会判断ListView在滑动时，ImageView是否被垃圾回收机制回收了。如果回收了的话，刚才所说的Task中run方法就直接返回了，不会做相应的加载。同样，如果ImageView已经被复用了，这时候我们的run方法也会直接返回。为什么会提到复用？ListView当中有很多会复用item的对象，当我们加载ListView时，首先会加载第一页图片。第一页图片还没加载完成就快速滑动。这时候我们使用isViewReused()这个方法来避免这些没有可见的item去加载图片，而直接加载当前已经显示在桌面上的图片。

<11>让我们回到LoadAndDisplayImageTask的run方法中

执行完所有判断后，它会获得一个重入锁

@Override
public void run() {
    ...
    ReentrantLock loadFromUriLock = imageLoadingInfo.loadFromUriLock;
    ...
}

而这个重入锁它是通过ImageLoaderEngine类中的getLockForUri()方法获得的。

而重入锁有什么作用？在ListView中，某个item获取图片时，我们将这个item滚出界面后又滚进来，这时如果我们没有对它加锁，那这个item它又会加载一次图片。这样如果在短时间内频繁滚出滚进的话，那对我们的内存会有很大的消耗。所以在这里我们要判断一个重入锁，就是当ListView的item短时间内不断滚出滚进的时候，我们所进行的锁的判断。

<12>上一步我们根据url获取了一个重入锁对象，接着执行如下代码

@Override
public void run() {
    ...
    loadFromUriLock.lock();
    ...
}

即我们会让重入锁对象在这里进行等待。等到图片加载完成后我们这个锁就会被释放。而刚刚那些相同url的请求，就会执行到接下来的代码中。

<13>接着执行如下代码

@Override
public void run() {
    ...
    try {
        ...
        bmp = configuration.memoryCache.get(memoryCacheKey);
        ...
    } catch (TaskCancelledException e) {
        ...
    } finally {
        ...
    }
    ...
}

可以看到，它会首先从内存中获取Bitmap。

<14>接着会判断这个bmp是否为空，即从内存中有没有获取到图片

@Override
public void run() {
    ...
    try {
        ...
        if (bmp == null || bmp.isRecycled()) {
            ...
        } else {
            ...
        }
        ...
    } catch (TaskCancelledException e) {	
        ...
    } finally {
        ...
    }
    ...
}

如果内存中没有我们要的图片，我们执行如下代码

@Override
public void run() {
    ...
    try {
        ...
        if (bmp == null || bmp.isRecycled()) {
            bmp = tryLoadBitmap();
            ...
        } else {
            ...
        }
        ...
    } catch (TaskCancelledException e) {
        ...
    } finally {
        ...
    }
    ...
}

<15>我们进入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 = 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;
}

首先它执行了如下语句

private Bitmap tryLoadBitmap() throws TaskCancelledException {
    ...
    try {
        File imageFile = configuration.diskCache.get(uri);
        ...
    } catch (IllegalStateException e) {
        ...
    } catch (TaskCancelledException e) {
        ...
    } catch (IOException e) {
        ...
    } catch (OutOfMemoryError e) {
        ...
    } catch (Throwable e) {
        ...
    }
    ...
}

这句代码意思是我们先从disk中尝试获取该文件。

接着执行如下语句

private Bitmap tryLoadBitmap() throws TaskCancelledException {
    ...
    try {
        ...
        if (imageFile != null && imageFile.exists() && imageFile.length() > 0) {
            ...
        }
        ...
    } catch (IllegalStateException e) {
        ...
    } catch (TaskCancelledException e) {
        ...
    } catch (IOException e) {
        ...
    } catch (OutOfMemoryError e) {
        ...
    } catch (Throwable e) {
        ...
    }
    ...
}

这里可以看到，我们对刚刚尝试获取的imageFile对象进行了判断，如果进入该判断，则说明我们成功从disk中获取到了图片。

如果我们从磁盘中获取到了图片，则在if判断中执行了如下代码

private Bitmap tryLoadBitmap() throws TaskCancelledException {
    ...
    try {
        ...
        if (imageFile != null && imageFile.exists() && imageFile.length() > 0) {
            ...
            bitmap = decodeImage(Scheme.FILE.wrap(imageFile.getAbsolutePath()));
        }
        ...
    } catch (IllegalStateException e) {
        ...
    } catch (TaskCancelledException e) {
        ...
    } catch (IOException e) {
        ...
    } catch (OutOfMemoryError e) {
        ...
    } catch (Throwable e) {
        ...
    }
    ...
}

 在执行完这个if语句后，我们又执行一个判断

private Bitmap tryLoadBitmap() throws TaskCancelledException {
    ...
    try {
        ...
        if (imageFile != null && imageFile.exists() && imageFile.length() > 0) {
		    ...
		}
        if (bitmap == null || bitmap.getWidth() <= 0 || bitmap.getHeight() <= 0) {
            ...
        }
    } catch (IllegalStateException e) {
        ...
    } catch (TaskCancelledException e) {
        ...
    } catch (IOException e) {
        ...
    } catch (OutOfMemoryError e) {
        ...
    } catch (Throwable e) {
        ...
    }
    ...
}

如果进入这个判断，说明我们从磁盘中没有获取到相应的图片，只能从网络中去获取图片。

我们可以看一下它是如何做的。在这个if判断中有如下方法

private Bitmap tryLoadBitmap() throws TaskCancelledException {
    ...
    try {
        ...
        if (bitmap == null || bitmap.getWidth() <= 0 || bitmap.getHeight() <= 0) {
            ...
            if (options.isCacheOnDisk() && tryCacheImageOnDisk()) {
                ...
			}
            ...
        }
    } catch (IllegalStateException e) {
        ...
    } catch (TaskCancelledException e) {
        ...
    } catch (IOException e) {
        ...
    } catch (OutOfMemoryError e) {
        ...
    } catch (Throwable e) {
        ...
    }
    ...
}

 可以看到我们调用了一个tryCacheImageOnDisk()方法，该方法源码如下

private boolean tryCacheImageOnDisk() throws TaskCancelledException {
    ...
    try {
        loaded = downloadImage();
        if (loaded) {
            ...
            if (width > 0 || height > 0) {
                ...
                resizeAndSaveImage(width, height); 
            }
        }
    } catch (IOException e) {
        ...
    }
    ...
}

在该方法中又调用了downloadImage方法，之后调用了resizeAndSaveImage方法把图片保存下来。resizeAndSaveImage方法就是将图片分别保存在了磁盘和内存当中。

<16>我们回到LoadAndDisplayImageTask的run方法中

@Override
public void run() {
    ...
    DisplayBitmapTask displayBitmapTask = new DisplayBitmapTask(bmp, imageLoadingInfo, engine, loadedFrom);
    runTask(displayBitmapTask, syncLoading, handler, engine);
}

这是最后两行代码，如果图片已经保存到缓存中，此时就要进行Bitmap的处理。我们进入DisplayBitmapTask的run方法中，代码如下：

@Override
public void run() {
		if (imageAware.isCollected()) {
			L.d(LOG_TASK_CANCELLED_IMAGEAWARE_COLLECTED, memoryCacheKey);
			listener.onLoadingCancelled(imageUri, imageAware.getWrappedView());
		} else if (isViewWasReused()) {
			L.d(LOG_TASK_CANCELLED_IMAGEAWARE_REUSED, memoryCacheKey);
			listener.onLoadingCancelled(imageUri, imageAware.getWrappedView());
		} else {
			L.d(LOG_DISPLAY_IMAGE_IN_IMAGEAWARE, loadedFrom, memoryCacheKey);
			displayer.display(bitmap, imageAware, loadedFrom);
			engine.cancelDisplayTaskFor(imageAware);
			listener.onLoadingComplete(imageUri, imageAware.getWrappedView(), bitmap);
		}
}

这里判断了我们的ImageView是否被回收，是否被重用，如果有此类情况，就调用listener的cancel接口取消，如果没有，就调用displayer.display(bitmap, imageAware, loadedFrom);

@Override
public void run() {
    if (imageAware.isCollected()) {
        ...
    } else if (isViewWasReused()) {
        ...
    } else {
        ...
    	displayer.display(bitmap, imageAware, loadedFrom);
        ...
        listener.onLoadingComplete(imageUri, imageAware.getWrappedView(), bitmap);
    }
}

这句代码是把图片显示出来，之后调用listener.onLoadingComplete(imageUri, imageAware.getWrappedView(), bitmap);告诉我们整个图片加载已完成。