使用LruCache和DiskLruCache实现ListView双缓存

package com.example.listviewcache;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URL;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.HashSet;
import java.util.Set;
import libcore.io.DiskLruCache;
import libcore.io.DiskLruCache.Editor;
import libcore.io.DiskLruCache.Snapshot;
import android.content.Context;
import android.content.pm.PackageManager.NameNotFoundException;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.os.Environment;
import android.support.v4.util.LruCache;
import android.util.Log;
import android.widget.ImageView;
import android.widget.ListView;

public class ImageLoader {

/**
* URL字符串数组
*/
private String[] imageUrls;

/**
* LruCache 内存缓存
*/
private LruCache<String, Bitmap> mMemCache;

/**
* DiskLruCache 外存(SD)缓存
*/
private DiskLruCache mDiskCache;

/**
* ListView 对象
*/
private ListView mLv;

private Context mContext;

private final static String tag = "ImageLoader";

private Set<DownloadTask> mTaskPool;

// 程序内存1/8作为内存缓存
private final static int MEMORYCACHE_MAXSIZE = (int) (Runtime.getRuntime()
.maxMemory() / 8);
private final static int DISKORYCACHE_MAXSIZE = 1024 * 1024 * 8; // 8MB

/**
* construtor
* @param context
* @param imageUrl URL 字符串數組
* @param lv    ListView 对象
*/
public ImageLoader(Context context, String[] imageUrl, ListView lv) {
super();
Log.w(tag, "Constructor");
this.mContext = context;
this.mLv = lv;
this.imageUrls = imageUrl;
this.mTaskPool = new HashSet<ImageLoader.DownloadTask>();
this.mMemCache = new LruCache<String, Bitmap>(MEMORYCACHE_MAXSIZE) {
@Override
protected int sizeOf(String key, Bitmap value) {
return value.getByteCount();
}
};
this.mLv = lv;

String dirName = "ImageCache";
int version = getAppVersion();
try {
mDiskCache = DiskLruCache.open(getCacheDir(dirName), version, 1,
DISKORYCACHE_MAXSIZE);
} catch (IOException e) {
e.printStackTrace();
}
}

/**
* 获得缓存路径
*
* @param fileName
*            文件名
* @return 返回文件的绝对全路径
*/
public File getCacheDir(String fileName) {
String cachePath;
if (Environment.MEDIA_MOUNTED.equals(Environment
.getExternalStorageState())
|| !Environment.isExternalStorageRemovable()) {
cachePath = mContext.getExternalCacheDir().getPath();
} else {
cachePath = mContext.getCacheDir().getPath();
}
File absFile = new File(cachePath + File.separator + fileName);
Log.w(tag, "getCacheDir:"+absFile.toString());

return absFile;
}

/**
* 获得App版本号
*/
public int getAppVersion() {
Log.w(tag, "getAppVersion");
try {
int version = mContext.getPackageManager().getPackageInfo(
mContext.getPackageName(), 0).versionCode;
} catch (NameNotFoundException e) {
e.printStackTrace();
}
return 1;
}

/**
* 将Bitmap 对象存入内存缓存中
* @param urlStr
* @param bitmap
*/
public void putInMem(String urlStr, Bitmap bitmap) {
Log.w(tag, "putInMem");
if (mMemCache.get(urlStr) == null) {
mMemCache.put(urlStr, bitmap);
}
}

/**
* 通过URL字符串从内存中查找
* @param urlStr
* @return 如果找到，返回，否则，返回NULL
*/
public Bitmap getFromMemCache(String urlStr) {
Log.w(tag, "getFomMem");
Bitmap bitmap = mMemCache.get(urlStr);
if (bitmap != null) {
return bitmap;
} else
return null;
}

/**
* 这个方法效率很低，有待改进
* @param urlStr URL 字符串
* @param bitmap    URL字符串对应的Bitmap 对象
* @throws Exception
*/
public void putInDisk(String urlStr, Bitmap bitmap) throws Exception {
Log.w(tag, "putInDisk");
// 存入 内存缓存
long tick = System.currentTimeMillis();
String key = hashKeyForDisk(urlStr);
Editor editor = mDiskCache.edit(key);
if (editor != null) {
OutputStream os = editor.newOutputStream(0);

ByteArrayOutputStream baos = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos);
InputStream in = new ByteArrayInputStream(baos.toByteArray());

int len;
byte[] buffer = new byte[2048];
while ((len = in.read(buffer)) != -1) {
os.write(buffer, 0 ,len);
}
os.close();
in.close();
editor.commit();
long tock = System.currentTimeMillis();
Log.w(tag, "time "+(tock-tick));
}
}

/**
* 将Bitmap 对象存入外存(SD)缓存
* @param urlStr URL 字符串
* @param in    输入流，从中读取Bitmap
* @throws Exception
*/
public void putInDiskStream(String urlStr, InputStream in) throws Exception {
Log.w(tag, "putInDisk");
// 存入 内存缓存
long tick = System.currentTimeMillis();
String key = hashKeyForDisk(urlStr);
Editor editor = mDiskCache.edit(key);
if (editor != null) {
OutputStream os = editor.newOutputStream(0);

int len;
byte[] buffer = new byte[2048];
while ((len = in.read(buffer)) != -1) {
os.write(buffer, 0 ,len);
}
os.close();
in.close();
editor.commit();
long tock = System.currentTimeMillis();
Log.w(tag, "time "+(tock-tick));
}
}

/**
* 从外存(SD)根据URL 字符串查找
* @param urlStr
* @return 如果找到，返回Bitmap对象，否则，返回NULL
* @throws Exception
*/
public Bitmap getFromDiskCache(String urlStr) throws Exception {
Log.w(tag, "getFromDisk");
// 从内存读取，首先读取到的事快照
String key = hashKeyForDisk(urlStr);
Snapshot snapShot = mDiskCache.get(key);
if (snapShot == null) {
return null;
}
// 从外存读取，并存入内存缓存
snapShot = mDiskCache.get(key);
InputStream is = snapShot.getInputStream(0);
Bitmap bitmap = BitmapFactory.decodeStream(is);
if (bitmap != null) {
Log.w(tag, "Disk Fikd OK");
}
return bitmap;
}

/**
* 将byte数组转成16进制字符串
*
* @param digest
* @return
*/
private String bytesToHexString(byte[] digest) {
Log.w(tag, "bytesToHex");
String hex;
StringBuffer sb = new StringBuffer();
for (int i = 0; i < digest.length; i++) {
hex = Integer.toHexString(0xff & digest[i]);
if (hex.length() == 1) {
sb.append('0');
}
sb.append(hex);
}
return sb.toString();
}

/**
* 将URL字符串编码MD5
*
* @param urlStr
* @return
*/
private String hashKeyForDisk(String urlStr) {
Log.w(tag, "hashKeyForDisk");
String cacheStr;
try {
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(urlStr.getBytes());
cacheStr = bytesToHexString(md.digest());
} catch (NoSuchAlgorithmException e) {
cacheStr = String.valueOf(urlStr.hashCode());
e.printStackTrace();
}
return cacheStr;
}

/**
* 根据URL从网络下载图片
* @param urlStr URL 字符串
* @return 成功则返回Bitmap 对象，否则返回NULL
*/
private Bitmap getBitmapFromUrl(String urlStr) {
long tick = System.currentTimeMillis();
Log.w(tag, "getBitmapFromUrl");
URL url;
Bitmap bitmap = null;
try {
url = new URL(urlStr);
bitmap = BitmapFactory.decodeStream(url.openStream());
} catch (Exception e) {
Log.w(tag, "下载图片异常:"+e.getMessage());
e.printStackTrace();
}
long tock = System.currentTimeMillis();
Log.w(tag, "time2 "+(tock - tick));
return bitmap;
}

/**
* 通过URL设置ImageView
* @param iv ListView 对象，ImageView 的容器
* @param urlStr URL 字符串
*/
public void setImageView(ImageView iv, String urlStr) {
Log.w(tag, "setImageView");
Bitmap bitmap = null;
try {
bitmap = fetchImage(urlStr);
if (iv.getTag().equals(urlStr)) {
iv.setImageBitmap(bitmap);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

/**
* 获得Bitmap对象后，将其设置给URL对象的ImageView，
* 通过findViewWithTag找到URL对应的ImageView
* @param urlStr
* @param bitmap
*/
private void setImageViewBitmap(String urlStr, Bitmap bitmap) {
Log.w(tag, "setImageViewBitmap");
ImageView iv = (ImageView) mLv.findViewWithTag(urlStr);
if (iv != null) {
Log.w(tag, "----find iv----");
iv.setImageBitmap(bitmap);
}
}

/**
* 对外调用，获取图片，先查找内存，然后外存，然后网络
* 如果从外存找到，则存入内存
* 如果从网络找到，则存入内存和外存
* @param urlStr
* @return
* @throws Exception
*/
public Bitmap fetchImage(String urlStr) throws Exception {
Log.w(tag, "fetchImage");
//查找内存缓存，找到则返回
Bitmap bitmap = getFromMemCache(urlStr);
if (bitmap != null) {
return bitmap;
}
//查找外存(SD)缓存，找到则返回
bitmap = getFromDiskCache(urlStr);
if (bitmap != null) {
putInMem(urlStr, bitmap);
return bitmap;
}
//从网上下载，如果成功，则在onPostExecute() 中直接为ImageView设置Bitmap
DownloadTask task = new DownloadTask();
mTaskPool.add(task);
task.execute(urlStr);
return null;
}

/**
* 异步任务类下载图片
* @author zhouweixian
*
*/
public class DownloadTask extends AsyncTask<String, Void, Bitmap> {
Bitmap bitmap;
String urlStr;
@Override
protected Bitmap doInBackground(String... params) {
Log.w(tag, "doInBackground");
urlStr = params[0];
if(isCancelled()) return null;
bitmap = getBitmapFromUrl(params[0]);
return bitmap;
}
@Override
protected void onPostExecute(Bitmap result) {
Log.w(tag, "onPostExecute");
//下载成功，设置ImageView
setImageViewBitmap(urlStr, result);
try {
//存入缓存
putInMem(urlStr, result);
putInDisk(urlStr, result);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//任务完成，移除
mTaskPool.remove(this);
super.onPostExecute(result);
}
}

/**
* 取消所有任务
*/
public void cacelAllTasks() {
Log.w(tag, "cacelAllTasks");
for (DownloadTask task : mTaskPool) {
task.cancel(false);
}
}

/**
* 刷新DiskLruCache缓存
*/
public void flush() {
Log.w(tag, "flush");
try {
if (mDiskCache != null) {
mDiskCache.flush();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}