图片加载类ImageLoader

import java.lang.reflect.Field;
import java.util.LinkedList;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.BitmapFactory.Options;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.support.v4.util.LruCache;
import android.support.v4.view.ViewPager.LayoutParams;
import android.util.DisplayMetrics;
import android.widget.ImageView;

//图片加载类
public class ImageLoader {
private static ImageLoader mInstance;
//图片缓存的核心对象
private LruCache<String, Bitmap> mLruCache;
//线程池
private ExecutorService mThreadPool;
private static final int DEAFULT_THREAD_COUNT=1;
//队列的调度方式
private Type mType =Type.LIFO;
//任务队列
private LinkedList<Runnable> mTaskQueue;
//后台轮询线程
private Thread mPoolThread;
private Handler mPoolThreadHandler;
//UI线程中的Handler
private Handler mUIHandler;

private Semaphore mSemaphorePoolThreadHandler =new Semaphore(0);

private Semaphore mSemaphoreThreadPool;
public enum Type{
FIFO,LIFO;
}

private ImageLoader(int threadCount,Type type){
init(threadCount,type);
}

//初始化
private void init(int threadCount, Type type) {
//后台轮询线程
mPoolThread=new Thread(){
public void run(){
Looper.prepare();
mPoolThreadHandler =new Handler(){
@Override
public void handleMessage(Message msg) {
//线程池取出一个任务进行执行
mThreadPool.execute(getTask());

try {
mSemaphoreThreadPool.acquire();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

};
//释放一个信号量
mSemaphorePoolThreadHandler.release();
Looper.loop();
}
};
mPoolThread.start();
//获取我们应用的最大可用内存
int maxMemory =(int) Runtime.getRuntime().maxMemory();
int cacheMemory =maxMemory/8;

mLruCache =new LruCache<String, Bitmap>(cacheMemory){
@Override
protected int sizeOf(String key, Bitmap value) {
// TODO Auto-generated method stub
return value.getRowBytes()*value.getHeight();
}
};
//创建线程池
mThreadPool =Executors.newFixedThreadPool(threadCount);
mTaskQueue =new LinkedList<Runnable>();
mType = type;

mSemaphoreThreadPool =new Semaphore(threadCount);
}
//从任务队列取出一个方法
private Runnable getTask() {
if(mType == Type.FIFO){
return mTaskQueue.removeFirst();
}else if(mType == Type.LIFO){
return mTaskQueue.removeLast();
}
return null;
}

public static ImageLoader getInstance(int i, Type lifo){
if(mInstance == null){
synchronized (ImageLoader.class) {
if(mInstance == null){
mInstance = new ImageLoader(DEAFULT_THREAD_COUNT,Type.LIFO);
}
}
}
return mInstance;
}
//根据path为imageview设置图片
public void loadImage(final String path, final ImageView imageView){
imageView.setTag(path);
if(mUIHandler==null){
mUIHandler =new Handler(){
@Override
public void handleMessage(Message msg) {
//获取得到的图片，为imageView的、回调设置图片
ImgBeanHolder holder =(ImgBeanHolder) msg.obj;
Bitmap bm =holder.bitmap;
ImageView imageView = holder.imageView;
String  path =holder.path;
//将path与getTag存储路径进行比较
if(imageView.getTag().toString().equals(path)){
imageView.setImageBitmap(bm);
}
}
};

}
//根据path在缓存中获取bitmap
Bitmap bm =getBitmapFromLruCache(path);

if(bm!=null){
reflash(path, imageView, bm);
}else{
addTasks(new Runnable() {

@Override
public void run() {
//加载图片
//图片的压缩
//1.获取图片所需要的大小
ImageSize imageSize=getImageViewSize(imageView);
//2.压缩图片
Bitmap bm=decodeSamledBitmapFromPath(path,imageSize.width,imageSize.height);
//3.把图片加入到缓存
addBitmapToLruCache(path,bm);

reflash(path, imageView, bm);

mSemaphoreThreadPool.release();
}

});
}

}
private void reflash(String path, ImageView imageView,
Bitmap bm) {
Message message =Message.obtain();
ImgBeanHolder holder =new ImgBeanHolder();
holder.bitmap=bm;
holder.path=path;
holder.imageView=imageView;
message.obj=holder;
mUIHandler.sendMessage(message);
}
//将图片加入缓存
protected void addBitmapToLruCache(String path, Bitmap bm) {
if(getBitmapFromLruCache(path)==null){
if(bm!=null){
mLruCache.put(path, bm);
}
}

}

//根据图片需要显示的宽和高对图片进行压缩
protected Bitmap decodeSamledBitmapFromPath(String path, int width,
int height) {
//获取图片的宽和高，并不把图片加载到内存中
BitmapFactory.Options options =new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeFile(path, options);
options.inSampleSize =caculateSampleSize(options,width,height);
//使用获取到的simplesize再次解析图片
options.inJustDecodeBounds=false;
Bitmap bitmap=BitmapFactory.decodeFile(path, options);
return bitmap;
}
//根据需求的宽和高以及图片实际的宽高计算SampleSize
private int caculateSampleSize(Options options, int reqWidth, int reqHeight) {
int width= options.outWidth;
int height =options.outHeight;

int inSampleSize=1;

if(width>reqWidth||height>reqHeight){
int widthRadio =Math.round(width*1.0f/reqWidth);
int heightRadio =Math.round(height*1.0f/reqHeight);

inSampleSize =Math.max(widthRadio, heightRadio);

}

return inSampleSize;
}

//根据ImageView获取适当的压缩的宽和高
protected ImageSize getImageViewSize(ImageView imageView) {
ImageSize imageSize =new ImageSize();

DisplayMetrics displayMetrics = imageView.getContext().getResources().getDisplayMetrics();
android.view.ViewGroup.LayoutParams lp =imageView.getLayoutParams();
//int width =(lp.width == LayoutParams.WRAP_CONTENT?0:imageView.getWidth());
int width=imageView.getWidth();//获取imageview的实际宽度
if(width<=0){
width =lp.width;//获取imageview在layout中声明的宽度
}
if(width<=0){
width=getImageViewFieldValue(imageView, "mMaxWidth");//检查最大值
}
if(width<=0){
width=displayMetrics.widthPixels;
}

int height=imageView.getHeight();//获取imageview的实际宽度
//int height =getImageViewFieldValue(imageView, "mMaxHeight");
if(height<=0){
width =lp.height;//获取imageview在layout中声明的宽度
}
if(height<=0){
height=getImageViewFieldValue(imageView, "mMaxHeight");//检查最大值
}
if(width<=0){
height=displayMetrics.heightPixels;
}

imageSize.width =width;
imageSize.height=height;
return imageSize;

}
//通过反射获取imageview的某个属性值
private static int getImageViewFieldValue(Object object,String fieldName){
int value=0;
try {
Field field =ImageView.class.getDeclaredField(fieldName);
field.setAccessible(true);

int fieldValue =field.getInt(object);
if(fieldValue>0&&fieldValue<Integer.MAX_VALUE){
value=fieldValue;
}
}  catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return value;
}

private synchronized void addTasks(Runnable runnable) {
mTaskQueue.add(runnable);
try {
if(mPoolThreadHandler==null)
mSemaphorePoolThreadHandler.acquire();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
mPoolThreadHandler.sendEmptyMessage(0x110);

}

//根据path在缓存中获取bitmap
private Bitmap getBitmapFromLruCache(String key) {

return mLruCache.get(key);
}
private class ImageSize{
int width;
int height;
}

private class ImgBeanHolder{
Bitmap bitmap;
ImageView imageView;
String path;
}

}