android universal 缓存目录,Android Universal Image Loader 磁盘缓存分析

前言

图片加载方面UIL的确很好用，所有有空就看了看UIL的源码，方面自己了解原理并能更熟练的使用它。

源码版本：Android-Universal-Image-Loader-1.9.5

项目地址:Universal-Image-Loader

注意点：此版本discCache过时，用diskCache替换

磁盘缓存分析

DisplayImageOptions开启磁盘缓存

options.cacheOnDisk(true);

在ImageLoaderConfiguration的里面配置磁盘缓存空间

config.diskCacheSize(50 * 1024 * 1024); // 50 MiB

config.diskCache(new UnlimitedDiskCache(cacheDir)); // 你可以传入自己的磁盘缓存

1.磁盘缓存路径

如果使用的是自定义的缓存路径当然没啥问题，但是我觉得还是有必要知道默认缓存路径，不然我们怎么知道有没有缓存成功呢？

获取缓存目录

File file = ImageLoader.getInstance().getDiskCache().getDirectory();

String filePath = file.getAbsolutePath();

获得结果为：

/storage/emulated/0/Android/data/com.nostra13.universalimageloader/cache/uil-images

即：位于SD卡的Android/data/应用程序包名/cache/uil-images文件夹下

例如：

/Android/data/com.baidu.netdisk/cache/uil-images

将该文件夹下的文件复制出来，后缀名加上.jpg即可看到图片。

创建DiskCache的源码部分

DefaultConfigurationFactory.java

/**

* Creates default implementation of {@link DiskCache} depends on incoming parameters

*/

public static DiskCache createDiskCache(Context context,

FileNameGenerator diskCacheFileNameGenerator,

long diskCacheSize, int diskCacheFileCount) {

File reserveCacheDir = createReserveDiskCacheDir(context);

if (diskCacheSize > 0 || diskCacheFileCount > 0) {

File individualCacheDir = StorageUtils.getIndividualCacheDirectory(context);

try {

return new LruDiskCache(individualCacheDir, reserveCacheDir,

diskCacheFileNameGenerator, diskCacheSize,diskCacheFileCount);

//LruDiskCache 缓存满时优先删除最近最少使用的元素。

} catch (IOException e) {

L.e(e);

// continue and create unlimited cache

}

}

File cacheDir = StorageUtils.getCacheDirectory(context);

return new UnlimitedDiskCache(cacheDir, reserveCacheDir, diskCacheFileNameGenerator);

}

/** Creates reserve disk cache folder which will be used if primary disk cache folder becomes unavailable */

private static File createReserveDiskCacheDir(Context context) {

File cacheDir = StorageUtils.getCacheDirectory(context, false);

File individualDir = new File(cacheDir, "uil-images");//指定缓存目录

if (individualDir.exists() || individualDir.mkdir()) {

cacheDir = individualDir;

}

return cacheDir;

}

2.磁盘缓存时机

既然开启了磁盘缓存

即：cacheOnDisk = true;

在DisplayImageOptions.java 看看谁调用了

public boolean isCacheOnDisk() {

return cacheOnDisk;

}

毫无疑问，加载图片之前需要用到

LoadAndDisplayImageTask.java

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()) {

//判断是否需要磁盘缓存，如果是调用tryCacheImageOnDisk()

imageFile = configuration.diskCache.get(uri);

if (imageFile != null) {

imageUriForDecoding = Scheme.FILE.wrap(imageFile.getAbsolutePath());

}

}

checkTaskNotActual();

bitmap = decodeImage(imageUriForDecoding);

//如果imageUriForDecoding是磁盘的uri就从磁盘取流，否则网络取流

//decodeImage里面调用的是ImageDownloader.getStream()方法

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;

}

tryCacheImageOnDisk()方法

/**@return true - if image was downloaded successfully; false - otherwise */

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()

private boolean downloadImage() throws IOException {

InputStream is = getDownloader().getStream(uri, options.getExtraForDownloader());

if (is == null) {

L.e(ERROR_NO_IMAGE_STREAM, memoryCacheKey);

return false;

} else {

try {

return configuration.diskCache.save(uri, is, this);

//下载完毕，存进diskCache

} finally {

IoUtils.closeSilently(is);

}

}

}

图片根据用户配置重存 resizeAndSaveImage(int maxWidth, int maxHeight)

/** Decodes image file into Bitmap, resize it and save it back */

private boolean resizeAndSaveImage(int maxWidth, int maxHeight) throws IOException {

// Decode image file, compress and re-save it

boolean saved = false;

File targetFile = configuration.diskCache.get(uri);

//刚刚下载完不是存进去了吗？拿出来改造~

if (targetFile != null && targetFile.exists()) {

ImageSize targetImageSize = new ImageSize(maxWidth, maxHeight);

DisplayImageOptions specialOptions = new DisplayImageOptions.Builder().cloneFrom(options)

.imageScaleType(ImageScaleType.IN_SAMPLE_INT).build();

ImageDecodingInfo decodingInfo = new ImageDecodingInfo(memoryCacheKey,

Scheme.FILE.wrap(targetFile.getAbsolutePath()), uri, targetImageSize, ViewScaleType.FIT_INSIDE,

getDownloader(), specialOptions);

Bitmap bmp = decoder.decode(decodingInfo);

if (bmp != null && configuration.processorForDiskCache != null) {

L.d(LOG_PROCESS_IMAGE_BEFORE_CACHE_ON_DISK, memoryCacheKey);

bmp = configuration.processorForDiskCache.process(bmp);

if (bmp == null) {

L.e(ERROR_PROCESSOR_FOR_DISK_CACHE_NULL, memoryCacheKey);

}

}

if (bmp != null) {

saved = configuration.diskCache.save(uri, bmp);

//ok改造完再存回去

bmp.recycle();

}

}

return saved;

}

3磁盘缓存类型

LimitedAgeDiskCache和UnlimitedDiskCache

两个都是继承了BaseDiskCache

LimitedAgeDiskCache限制了缓存对象最长存活周期的磁盘缓存；

UnlimitedDiskCache与BaseDiskCache没啥区别只是命名更让人好理解。

DiskCache diskCache;

if (limit > 0) {//limit表示Max file age (in seconds)

diskCache = new LimitedAgeDiskCache(cacheDir, limit);

} else {

diskCache = new UnlimitedDiskCache(cacheDir);

}

config.diskCache(diskCache);