简单的图片加载缓存类

该类仅为了避免多次加载图片，做的一个图片加载的简单管理，适用于一些简单的需求。对于大内存的图片有OOM的风险。

package com.ldw.game;

import java.io.InputStream;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.util.Log;
import android.util.SparseArray;

/**
 * 图片资源加载缓存类
 * <br>可保证图片只在第一次使用时加载一次
 * <br>也可实现预先加载图片资源
 * @author ldw
 */
public class ResourceCache {
	
	//private HashMap<Integer, Bitmap> bitmapMap = new HashMap<Integer, Bitmap>();
	private SparseArray<Bitmap> bitmapMap = new SparseArray<Bitmap>();
	private static ResourceCache mResourceCache = null;
	private Context mContext;
	private BitmapFactory.Options opt = null;

	/**
	 * 获取单例类
	 * @param context
	 * @return
	 */
	public static ResourceCache getInstance(Context context){
		if(mResourceCache == null){
			mResourceCache = new ResourceCache(context);
		}
		return mResourceCache;
	}
	
	private ResourceCache(Context context) {
		mContext = context;
	}
	
	/**
	 * 获取一个Bitmap，先从缓存里面找，找不到再去加载
	 * @param resId
	 * @return
	 */
	public Bitmap getBitmap(int resId){
		if(getFromCache(resId) == null){Log.v("ldw", "-----getBitmap----null");
			Bitmap bitmap = readBitmap(mContext, resId);
			addToCache(resId, bitmap);
			return bitmap;
		}
		return getFromCache(resId);
	}
	
	/**
	 * 添加对象到缓存
	 * @param key
	 * @param bitmap
	 */
	public void addToCache(int key, Bitmap bitmap){
		if(bitmapMap.get(key) != null){
			return;
		}else {
			bitmapMap.put(Integer.valueOf(key), bitmap);
		}
	}
	
	/**
	 * 只从缓存里面获取对象。
	 * <br>建议用getBitmap(int resId)先从缓存查找，找不到再去创建新对象
	 * @param key
	 * @return	不存在则返回null
	 */
	public Bitmap getFromCache(int key){
		if(bitmapMap.get(key) != null){
			return bitmapMap.get(key);
		}else{
			return null;
		}
	}
	
	/**
	 * 通过key值添加Bitmap到缓存
	 */
	private void addToCacheByKey(int key){
		if(bitmapMap.get(key) == null){//缓存中不存在才需要添加
			bitmapMap.put(Integer.valueOf(key), readBitmap(mContext, key));
		}
	}
	
	/**
	 * 启动线程加载资源，可处理加载完成回调接口
	 * @param resIds	需要加载的资源id数组
	 * @param listener	加载完成的回调接口
	 */
	public void loadResource(final int[] resIds, final OnLoadListener listener){
		Thread thread = new Thread(new Runnable() {
			@Override
			public void run() {
				for(int i=0; i<resIds.length; i++){
					addToCacheByKey(resIds[i]);
				}
				listener.onFinish();
			}
		});
		thread.start();
	}
	
	/**
	 * 加载资源接口
	 * @author ldw
	 */
	public static abstract interface OnLoadListener{
		/**
		 * 资源加载完成回调
		 */
		public abstract void onFinish();
	}
	
	/**
	 * 释放缓存资源
	 */
	public void recycleCache(){
		 /*Iterator<Entry<Integer, Bitmap>> iter = bitmapMap.entrySet().iterator();
		 while (iter.hasNext()) {
			 Entry<Integer, Bitmap> entry = (Entry<Integer, Bitmap>) iter.next();
			 //int key = entry.getKey();
			 releaseBitmap((Bitmap)(entry.getValue()));
		 }
		 bitmapMap.clear();*/
		 //SparseArray稀疏数组遍历释放资源删除对象
		while(bitmapMap.size() > 0){
			releaseBitmap(bitmapMap.valueAt(0));
			bitmapMap.removeAt(0);
		}
	}
	
	/**
	 * name是全名，例如time/bg.png，暂时不支持从assets里面获取资源，因为key值是图片的ID号
	 * @param fileName
	 * @return
	 */
	/*private Bitmap readFromAssets(String fileName){
		AssetManager am = mContext.getAssets();
		InputStream is;
		try {
			is = am.open(fileName);
		} catch (IOException e) {
			e.printStackTrace();
			return null;
		}
		Bitmap bitmap = BitmapFactory.decodeStream(is);
		return bitmap;
	}*/
	
	/**
	 * 图片加载
	 * @param context	
	 * @param resId	图片的id
	 * @return	565格式的图片
	 */
	private Bitmap readBitmap(Context context, int resId)
	{
		if(opt == null){
			opt = new BitmapFactory.Options();
			opt.inPreferredConfig = Bitmap.Config.RGB_565;
			opt.inPurgeable = true;
		}
		InputStream is = context.getResources().openRawResource(resId);
		return BitmapFactory.decodeStream(is, null, opt);
	}
	
	/**
	 * 释放Bitmap资源
	 * @param bitmap	释放的对象
	 */
	private void releaseBitmap(Bitmap bitmap){
		if(bitmap != null){
			if(!bitmap.isRecycled()){
				bitmap.recycle();
			}
			bitmap = null;
		}
	}

}