异步图片加载、内存、磁盘缓存

该类实现的功能：

1. 异步加载远程图片

2. 图片内存缓存

3. 异步图片磁盘缓存

package com.ai9475.util;

import android.graphics.Bitmap;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.Handler;
import android.os.Message;

import com.ai9475.meitian.AppConfig;
import com.ai9475.meitian.AppException;
import com.ai9475.meitian.AppManager;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.ref.SoftReference;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Date;
import java.util.HashMap;

/**
* 图片加载管理器
*
* Created by ZHOUZ on 14-2-7.
*/
public final class ZImageLoader
{
private static final String TAG = "ZImageLoader";
private static final ZImageLoader INSTANCE = new ZImageLoader();
private static String mCacheBasePath = null;
private boolean mUseDiskCache = false;
private int mExpireTime = 86400;
private String mCacheSubDir = "common";
private HashMap<String, SoftReference<Drawable>> mImageCache = new HashMap<String, SoftReference<Drawable>>();

public static ZImageLoader getInstance() {
return INSTANCE;
}

/**
* 设置 SD 卡中的图片缓存有效时长（单位:秒）
*
* @param time
*/
public void setExpireTime(int time) {
this.mExpireTime = time;
}

/**
* 设置是否使用存储卡缓存图片
*
* @param isUse
*/
public void setUseDiskCache(Boolean isUse) {
this.mUseDiskCache = isUse;
}

/**
* 设置缓存根目录
*
* @param path
*/
public static void setCacheBasePath(String path) {
mCacheBasePath = path;
}

/**
* 设置缓存根目录下的子目录
*
* @param dir
*/
public void setmCacheSubDir(String dir) {
this.mCacheSubDir = dir;
}

/**
* 加载图片的多线程控制
*
* @param imageUrl
* @param tag
* @param listener
*/
public void loadDrawable(final String imageUrl, final String tag, final OnImageLoadListener listener)
{
// 异步多线程加载图片后的数据传递处理
final Handler handler = new Handler() {
@Override
public void handleMessage(Message message) {
if (message.what == 1) {
listener.onSuccess((Drawable) message.obj, imageUrl, tag);
} else {
listener.onFailure((IOException) message.obj, imageUrl, tag);
}
}
};

// 通过线程池来控制管理图片加载
AppManager.getFixedExecutorsService().submit(new Runnable() {
@Override
public void run() {
Message msg;
try {
Drawable drawable = null;
// 是否已缓存过图片, 是则从缓存中直接获取, 若缓存中数据丢失则重新远程加载
if (mImageCache.containsKey(imageUrl)) {
SoftReference<Drawable> softReference = mImageCache.get(imageUrl);
if (softReference != null) {
Drawable d = softReference.get();
if (d != null) {
ZLog.i(TAG, "load image from memory cache");
drawable = d;
}
}
}
if (drawable == null) {
drawable = loadImageFromUrl(imageUrl);
if (drawable != null) {
mImageCache.remove(imageUrl);
mImageCache.put(imageUrl, new SoftReference<Drawable>(drawable));
}
}
msg = handler.obtainMessage(1, drawable);
} catch (IOException e) {
msg = handler.obtainMessage(0, e);
}
handler.sendMessage(msg);
}
});

}

/**
* 加载远程图片或本地图片缓存文件
*
* @param imageUrl
* @return
* @throws java.io.IOException
*/
public Drawable loadImageFromUrl(String imageUrl) throws IOException
{
// 检查 SD 卡是否可用并将图片缓存到 SD 卡上
if (mUseDiskCache && mCacheBasePath != null)
{
File d = new File(mCacheBasePath + mCacheSubDir);
if (! d.exists()) {
d.mkdirs();
}

final File f = new File(d.getPath() + File.separator + ZHelper.md5(imageUrl));
long time = (new Date()).getTime();
long expire = time - (mExpireTime * 1000L);

// 文件存在且在有效期内则直接读取
if (f.exists() && f.lastModified() > expire) {
ZLog.i(TAG, "load image file disk cache");
FileInputStream fis = new FileInputStream(f);
return Drawable.createFromStream(fis, "src");
}

// 远程加载图片后写入到 SD 卡上
InputStream i = this.getImageInputStream(imageUrl);
if (i == null) {
return null;
}

final Drawable drawable = Drawable.createFromStream(i, "src");
if (drawable == null) {
return null;
}

// 将图片异步写入到本地 SD 卡中缓存, 避免阻塞UI线程, 导致图片不能显示
new Thread(new Runnable() {
@Override
public void run() {
ZLog.i(TAG, "async write image file disk cache");
try {
BitmapDrawable bd = (BitmapDrawable) drawable;
Bitmap bitmap = bd.getBitmap();
FileOutputStream out = new FileOutputStream(f);
bitmap.compress(Bitmap.CompressFormat.JPEG, 90, out);
out.close();
} catch (IOException e) {
ZLog.e(TAG, "write image cache IOException: "+ e.getMessage());
AppException.io(e);
}
}
}).start();

return drawable;
}
// 只读取远程图片不缓存
else {
InputStream i = this.getImageInputStream(imageUrl);
if (i == null) {
return null;
}
return Drawable.createFromStream(i, "src");
}
}

/**
* 远程加载图片数据
*
* @param imageUrl
* @return
* @throws java.io.IOException
*/
public InputStream getImageInputStream(String imageUrl) throws IOException
{
ZLog.i(TAG, "load image from url");
if (! ZConnectivity.isNetworkConnected()) {
ZLog.i(TAG, "net work not connected");
return null;
}
URL m = new URL(imageUrl);
HttpURLConnection conn = (HttpURLConnection) m.openConnection();
conn.setRequestMethod("GET");
conn.setUseCaches(false);
conn.setDoInput(true);
conn.setConnectTimeout(5000);
conn.setReadTimeout(30000);
conn.setInstanceFollowRedirects(true);
return conn.getInputStream();
}

/**
* 加载图片的事件监听器
*/
public interface OnImageLoadListener {
/**
* 图片加载完成事件处理
*
* @param imageDrawable
* @param imageUrl
* @param tag
*/
public void onSuccess(Drawable imageDrawable, String imageUrl, String tag);

/**
* 图片加载失败的事件处理
*
* @param e
* @param imageUrl
* @param tag
*/
public void onFailure(IOException e, String imageUrl, String tag);
}
}

使用方法：

/**
* 日记照片加载事件监听
*/
private class OnPicLoadListener extends OnImageLoadListener
{
private int mImageSource = R.drawable.default_pic;

/**
* 设置图片
*
* @param view
* @param imageUrl
* @param tag
* @param drawable
*/
public void setDrawable(ImageView view, String imageUrl, String tag, Drawable drawable)
{
if (view == null) return;
int height = 0;
if (mImagesHeight.containsKey(imageUrl)) {
height = mImagesHeight.get(imageUrl);
}
View ct = ((View) view.getParent()).findViewById(R.id.calendarCt);
if (ct != null) {
ct.setVisibility(View.INVISIBLE);
}
if (drawable != null) {
// 定义图片的最佳高度
if (height == 0) {
int minHeight = ZUI.dp2px(mContext, PIC_MIN_HEIGHT);
int maxHeight = ZUI.dp2px(mContext, PIC_MAX_HEIGHT);
height = (int) ((float) view.getWidth() / drawable.getMinimumWidth() * drawable.getMinimumHeight());
if (height > maxHeight) {
height = maxHeight;
} else if (height < minHeight) {
height = minHeight;
}
mImagesHeight.put(imageUrl, height);
}
// 现将图片完全透明
drawable.setAlpha(0);
view.setLayoutParams(new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.MATCH_PARENT, height));
view.setScaleType(ImageView.ScaleType.CENTER_CROP);
view.setImageDrawable(drawable);
// 添加透明渐变动画显示图片
AlphaAnimation alphaAnim = new AlphaAnimation(0.0f, 1.0f);
alphaAnim.setDuration(100);
view.setAnimation(alphaAnim);
if (ct != null) {
ct.setVisibility(View.VISIBLE);
}
} else {
int minHeight = ZUI.dp2px(mContext, PIC_MIN_HEIGHT);
height = height < minHeight ? minHeight : height;
view.setLayoutParams(new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.MATCH_PARENT, height));
view.setScaleType(ImageView.ScaleType.CENTER);
view.setImageResource(mImageSource);
}
}
}

/**
* 图片的加载监听事件
*/
abstract private class OnImageLoadListener implements ZImageLoader.OnImageLoadListener
{
/**
* 实现图片显示的抽象方法
*
* @param view
* @param tag
* @param drawable
*/
abstract public void setDrawable(ImageView view, String imageUrl, String tag, Drawable drawable);

@Override
public void onSuccess(Drawable drawable, String imageUrl, String tag) {
ImageView view = (ImageView) mDiaryListView.findViewWithTag(tag == null ? imageUrl : tag);
this.setDrawable(view, imageUrl, tag, drawable);
}

@Override
public void onFailure(IOException e, String imageUrl, String tag) {
//Toast.makeText(mContext, e.toString(), Toast.LENGTH_SHORT).show();
}
}

// 调用该方法
ZImageLoader.getInstance().loadDrawable(item.getPicUrl(), item.getPicTag(), this.mOnPicLoadListener);

这是之前自己实现的简单的图片加载缓存类，不过今天开始尝试使用开源的《Android Universal Image Loader》，先把代码贴在这儿也算做个备份吧

github项目地址：https://github.com/nostra13/Android-Universal-Image-Loader

功能很完善、很强大了