本文来自http://blog.csdn.net/andywuchuanlong,转载请说明出处
对于图片的加载和处理基本上是Android应用软件项目中的常客,很多初学者在遇到图片加载这个问题是,总是喜欢自己写一个http请求,然后使用将流转换成bitmap,从而显示在项目的view中。其实对于图片的处理自己写固然是好,但是要想软件稳定的运行,里面还是需要很多细节东西需要处理的。在github上有很多的开源项目,处理图片的也不少,下面介绍一下imageLoader这个开源框架。
接触Imageloader这个框架已经很久了,在项目总也使用过,但是仅仅是使用,作为一个开发人员而言,虽然不提倡重复的造轮子,但是对于利用现有的轮子我们应该还是要知其所以然,才能将这个轮子的制造工艺转成我么自己的技术。废话不多说,我们一起从源码的角度来认识imageLoader。
在使用imageLoader加载图片之前,我们必须要先初始化一个loader:
<span style="white-space:pre"> </span>public static ImageLoader getInstance() {
if (instance == null) {
synchronized (ImageLoader.class) {
if (instance == null) {
instance = new ImageLoader();
}
}
}
return instance;
}
ImageLoader是一个单例,也就是说在一个项目中只会有一个imageLaoder存在。实例化ImageLoader之后紧接着使用imageLoader.init(ImageLoaderConfiguration)给图片加载器设置一些配置项并且初始化imageLoaderEngine引擎。这个配置里面指明了内存中图片的最大宽度和最大高度、任务执行器等:
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);
}
配置中涉及到的具体属性在后面的源码中都会涉及到,再具体分析。
上面两部分做完之后,就可以开始加载图片了,从ImageLoader的displayImage方法下手分析。在displayImage中首先是检查有没有给ImageLoader设置一些加载配置项。然后就是设置图片加载过程的监听,这个监听器可以监听图片加载的开始、取消、结束,这样我么就可以很灵活的使用它了。接下来就是判断要加载的图片uri是否为空了,为空就不去加载,但是这里还做了一个取消即将要显示的imageview,然后开始加载在配置里面指定的默认图片并显示,最后通知监听器执行onLoadingComplete方法:
<span style="white-space:pre"> </span>if (uri == null || uri.length() == 0) {
// 取消图片显示,取消是根据imageview的hashCode来取消的
// engine内部维护一个cacheKeysForImageViews,是一个map,key为imageView的hashcode,value为memoryCacheKey
engine.cancelDisplayTaskFor(imageView);
// 开始加载图片
listener.onLoadingStarted(uri, imageView);
if (options.shouldShowImageForEmptyUri()) {
imageView.setImageResource(options.getImageForEmptyUri());
} else {
imageView.setImageBitmap(null);
}
listener.onLoadingComplete(uri, imageView, null);
return;
}
如果uri不为空,则要通知引擎准备加载图片,并把imageview和imageview在缓存中对应的key大小作为参数传入
<span style="white-space:pre"> </span>ImageSize targetSize = ImageSizeUtils.defineTargetSizeForView(imageView, configuration.maxImageWidthForMemoryCache,
configuration.maxImageHeightForMemoryCache);
String memoryCacheKey = MemoryCacheUtil.generateKey(uri, targetSize);
// 通知引擎准备加载图片,并把图片的缓存的唯一识别key传入
engine.prepareDisplayTaskFor(imageView, memoryCacheKey);
上面的操作做完之后就开始加载了,首先判断内存中是否存在该图片,如果图片存在并且没有被置为回收的状态则显示图片,显示之前,判断是否需要对图片进行额外的处理,这个实在配置项中进行配置的,如果需要在显示前自己可以对图片进行处理就需要实现BitmapProcessor,并重写process(Bitmap bitmap)方法。在ProcessAndDisplayImageTask类中:
<span style="white-space:pre"> </span>@Override
public void run() {
if (engine.configuration.loggingEnabled) L.i(LOG_POSTPROCESS_IMAGE, imageLoadingInfo.memoryCacheKey);
BitmapProcessor processor = imageLoadingInfo.options.getPostProcessor();
final Bitmap processedBitmap = processor.process(bitmap);
if (processedBitmap != bitmap) {
bitmap.recycle();
}
handler.post(new DisplayBitmapTask(processedBitmap, imageLoadingInfo, engine));
}
根据配置项中指定图片处理器处理图片,处理完之后再显示,显示图片有四种策略,这些策略也是可以配置的。在DisplayBitmapTask类中首先判断图片是否错位,然后再显示图片
<span style="white-space:pre"> </span>public void run() {
if (isViewWasReused()) {
if (loggingEnabled) L.i(LOG_TASK_CANCELLED, memoryCacheKey);
listener.onLoadingCancelled(imageUri, imageView);
} else {
if (loggingEnabled) L.i(LOG_DISPLAY_IMAGE_IN_IMAGEVIEW, memoryCacheKey);
/**
* 开始显示图片,有四种显示策略
* SimpleBitmapDisplayer:简单的直接显示图片,setImageBitmap(imageView)
* RoundedBitmapDisplayer : 圆角图片显示,圆角处理roundCorners方法
* FadeInBitmapDisplayer:显示的时候使用fade in动画
* FakeBitmapDisplayer: 假动作显示,也就是不显示图片
*/
Bitmap displayedBitmap = displayer.display(bitmap, imageView);
listener.onLoadingComplete(imageUri, imageView, displayedBitmap);
engine.cancelDisplayTaskFor(imageView);
}
}
如果不需要额外处理图片的话就直接显示图片。
<span style="white-space:pre"> </span>if (bmp != null && !bmp.isRecycled()) {
// 如果图片不为空,并且没有被回收,则可以直接显示
if (configuration.loggingEnabled) L.i(LOG_LOAD_IMAGE_FROM_MEMORY_CACHE, memoryCacheKey);
// 判断图片是否需要额外的处理 ,是否需要使用户自己配置的
// 如果需要在现实之前做另外的处理,可以实现接口BitmapProcessor,并重写process(Bitmap bitmap)方法
if (options.shouldPostProcess()) {
// 一个实体类,里面持有uri、imageview、size、缓存key、配置选项等属性
ImageLoadingInfo imageLoadingInfo = new ImageLoadingInfo(uri, imageView, targetSize,
memoryCacheKey, options, listener,engine.getLockForUri(uri));
// 处理图片并且显示图片,这个是runnable,在里面又由handler执行了post(DisplayBitmapTask)
ProcessAndDisplayImageTask displayTask = new ProcessAndDisplayImageTask(engine, bmp,
imageLoadingInfo, options.getHandler());
engine.submit(displayTask);
} else {
// 显示图片
options.getDisplayer().display(bmp, imageView);
// 通知监听器加载完毕
listener.onLoadingComplete(uri, imageView, bmp);
}
}
如果图片不存在缓存中,就需要尝试从硬盘和网络中加载了,加载之前判断是否需要在加载的过程中显示默认的图片,然后开启LoadAndDisplayImageTask自行任务
<span style="white-space:pre"> </span>// 内存缓存中不存在图片,需要进行网络加载
// 判断加载图的过程中是否需要显示图片
if (options.shouldShowStubImage()) {
imageView.setImageResource(options.getStubImage());
} else {
if (options.isResetViewBeforeLoading()) {
<span style="white-space:pre"> </span>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);
在LoadAndDisplayImageTask类的run方法中:
<span style="white-space:pre"> </span>@Override
public void run() {
//是否需要等待
if (waitIfPaused()) return;
// 是否需要延时
if (delayIfNeed()) return;
ReentrantLock loadFromUriLock = imageLoadingInfo.loadFromUriLock;
log(LOG_START_DISPLAY_IMAGE_TASK);
if (loadFromUriLock.isLocked()) {
log(LOG_WAITING_FOR_IMAGE_LOADED);
}
// 如果锁已经被其他线程持有,则会阻塞,当其他的线程执行完毕后会释放该锁,此时在等待的线程会获得该所继续向下面执行
loadFromUriLock.lock();
Bitmap bmp;
try {
if (checkTaskIsNotActual()) return;
// 先从内存中查找
bmp = configuration.memoryCache.get(memoryCacheKey);
if (bmp == null) {
// 在硬盘中查找,再从网络中查找图片
bmp = tryLoadBitmap();
if (bmp == null) return;
.......
if (bmp != null && options.isCacheInMemory()) {
log(LOG_CACHE_IMAGE_IN_MEMORY);
configuration.memoryCache.put(memoryCacheKey, bmp);
}
} else {
log(LOG_GET_IMAGE_FROM_MEMORY_CACHE_AFTER_WAITING);
}
........
} finally {
loadFromUriLock.unlock();
}
if (checkTaskIsNotActual() || checkTaskIsInterrupted()) return;
// 有四种策略可以显示图片
DisplayBitmapTask displayBitmapTask = new DisplayBitmapTask(bmp, imageLoadingInfo, engine);
displayBitmapTask.setLoggingEnabled(loggingEnabled);
handler.post(displayBitmapTask);
}
大家应该注意到有这样的代码ReentrantLock loadFromUriLock = imageLoadingInfo.loadFromUriLock;都知道这是一个锁机制,为什么这里会出现锁呢?在加载图片之前会判断loadFromUriLock.isLocked()是否被上锁了,如果上锁了也就意味着同一个uri对应的图片加载任务已经在执行了,大家可以想象一下这个场景,在listview中当你快速上下滑动列表,同一个uri对对应的图片是否应该被加载多次呢,所以这里当第二次加载同样的uri的时候这里通过判断loadFromUriLock.isLocked()返回true,执行这行代码loadFromUriLock.lock();的时候就会造成堵塞,当这个uri对应的第一个加载任务执行完毕后,这个锁是会释放掉的,所以后面的任务往下执行,第一个任务执行完毕后,是会把图片放入缓存中,所以之后的任务就会再从内粗缓存中查找是否有uri对应的图片,至此,已经从内存缓存中查找了两次。
如果是第一次加载这个uri,那么两次查找缓存肯定都是空的,那么就要从文件和网络中查找了,所以会执行 tryLoadBitmap();方法,加载完毕之后会根据指定的图片显示策略显示图片。
我们重点关注一下
tryLoadBitmap这个方法
<span style="white-space:pre"> </span>private Bitmap tryLoadBitmap() {
// 硬盘缓存中查找文件
File imageFile = getImageFileInDiscCache();
Bitmap bitmap = null;
try {
if (imageFile.exists()) {
// 硬盘缓存中存在
log(LOG_LOAD_IMAGE_FROM_DISC_CACHE);
bitmap = decodeImage(Scheme.FILE.wrap(imageFile.getAbsolutePath()));
}
if (bitmap == null) {
log(LOG_LOAD_IMAGE_FROM_NETWORK);
String imageUriForDecoding = options.isCacheOnDisc() ? tryCacheImageOnDisc(imageFile) : uri;
// 根据uri中指定的协议从何处加载图片,http、assert、file等协议
bitmap = decodeImage(imageUriForDecoding);
if (bitmap == null) {
fireImageLoadingFailedEvent(FailType.DECODING_ERROR, null);
}
}
} catch (IllegalStateException e) {
........
}
return bitmap;
}
首先根据uri从文件中查找,存在就直接解码图片显示,不存在的话就要根据指定的协议去加载,这个协议可以使http、assert、file等,关注的方法是BaseImageDecoder类中的decode方法:
<span style="white-space:pre"> </span>public Bitmap decode(ImageDecodingInfo decodingInfo) throws IOException {
// 返回代表图片的输入流,这里也有几种策略,缓慢网络、基本下载器等策略
InputStream imageStream = getImageStream(decodingInfo);
ImageFileInfo imageInfo = defineImageSizeAndRotation(imageStream, decodingInfo.getImageUri());
Options decodingOptions = prepareDecodingOptions(imageInfo.imageSize, decodingInfo);
imageStream = getImageStream(decodingInfo);
Bitmap decodedBitmap = decodeStream(imageStream, decodingOptions);
if (decodedBitmap == null) {
L.e(ERROR_CANT_DECODE_IMAGE, decodingInfo.getImageKey());
} else {
decodedBitmap = considerExactScaleAndOrientaiton(decodedBitmap, decodingInfo, imageInfo.exif.rotation, imageInfo.exif.flipHorizontal);
}
return decodedBitmap;
}
<span style="white-space:pre"> </span>protected InputStream getImageStream(ImageDecodingInfo decodingInfo) throws IOException {
<span style="white-space:pre"> </span>return decodingInfo.getDownloader().getStream(decodingInfo.getImageUri(), decodingInfo.getExtraForDownloader());
<span style="white-space:pre"> </span>}
getDownLoader()获取下载器可能会返回几种下载器,一个是SlowNetworkImageDownloader加载器、NetworkDeniedImageDownloader加载器、HttpClientImageDownloader加载器。HttpClientImageDownloader下载器中使用的是HttpGet请求网络。我们重点关注的是
SlowNetworkImageDownloader加载器,SlowNetworkImageDownloader原型如下:
<span style="white-space:pre"> </span>@Override
public InputStream getStream(String imageUri, Object extra) throws IOException {
InputStream imageStream = wrappedDownloader.getStream(imageUri, extra);
switch (Scheme.ofUri(imageUri)) {
case HTTP:
case HTTPS:
return new FlushedInputStream(imageStream);
default:
return imageStream;
}
}
是通过FlushedInputStream来获取流数据的:
<span style="white-space:pre"> </span>public class FlushedInputStream extends FilterInputStream {
<span style="white-space:pre"> </span>public FlushedInputStream(InputStream inputStream) {
<span style="white-space:pre"> </span>super(inputStream);
<span style="white-space:pre"> </span>}
<span style="white-space:pre"> </span>@Override
<span style="white-space:pre"> </span>public long skip(long n) throws IOException {
<span style="white-space:pre"> </span>long totalBytesSkipped = 0L;
<span style="white-space:pre"> </span>while (totalBytesSkipped < n) {
<span style="white-space:pre"> </span>long bytesSkipped = in.skip(n - totalBytesSkipped);
<span style="white-space:pre"> </span>if (bytesSkipped == 0L) {
<span style="white-space:pre"> </span>int by_te = read();
<span style="white-space:pre"> </span>if (by_te < 0) {
<span style="white-space:pre"> </span>break; // we reached EOF
<span style="white-space:pre"> </span>} else {
<span style="white-space:pre"> </span>bytesSkipped = 1; // we read one byte
<span style="white-space:pre"> </span>}
<span style="white-space:pre"> </span>}
<span style="white-space:pre"> </span>totalBytesSkipped += bytesSkipped;
<span style="white-space:pre"> </span>}
<span style="white-space:pre"> </span>return totalBytesSkipped;
<span style="white-space:pre"> </span>}
}
为什么使用FlushedInputStream呢?大家想想以前你们是怎么请求网络图片的,一般是通过http请求,请求完后使用BitmapFactory的decodeStream方法来获得一个bitmap。但是这个方法有个致命的bug就是在网络很慢的请看下面会无法获取完整的数据,从而导致imageview失真或者显示出问题,处理这个问题我们可以继承FilterInputStream来处理skip方法强制实现flush流中的数据。主要原理就是检查文件是否到文件末端,告诉http是否需要继续请求。
上述步骤执行完毕后,一个图片的数据正常获取,讲该图片放入缓存中,释放锁。