ListView 图片加载+内存缓存+图片压缩

package com.tarena.musicplayer.util;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.security.MessageDigest;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.Semaphore;

import android.content.Context;
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.util.Log;
import android.widget.ImageView;

public class ImageLoader {
    //线程池中，线程的数量。为了保证最好的并发性
    //这个数量与设备CPU的核数一样
    private static int threadCount;
    //线程池
    private static ExecutorService exec;
    //上下文对象
    private static Context context;
    //当线程池中的工作线程获得图像后
    //需要将图像通过uiHandler提交到主线程
    //进而在ImageView中进行显示
    private static Handler uiHandler;
    //当生产者向任务队列中添加了需要执行的任务后
    //生产者会向该pollHandler发送一个Message
    //通知它去任务队列中取任务放到线程池中执行
    private static Handler pollHandler;
    //与pollHandler相依相偎的一个工作线程
    //pollHandler把收到的Message都提交到该线程
    //该线程的Looper从MessageQueue中把消息取出
    //再返回给pollHandler执行
    private static Thread pollThread;
    //任务队列
    //生产者将任务放到该队列中
    //消费中从该队列中取任务执行
    private static LinkedBlockingDeque<Runnable> tasks;
    //为下载的图片提供内存缓存
    //其中键为图片的url地址转的MD5字符串，值为图片本身
    private static LruCache<String, Bitmap> memCache;
    //如果所有的相关属性都未做初始化，则isFirst为true
    //一旦做了初始化，isFrist的值就为false
    private static boolean isFirst = true;

    //用来控制线程池可以取任务的数量
    private static Semaphore pollLock;
    //当主线程加载图像时，向pollHandler发送消息
    //要保证发消息时，pollHandler必须被创建出来了
    private static Semaphore pollHandlerLock = new Semaphore(0);
    /**
     * ImageLoader的初始化方法
     * 把上述所有属性都要进行赋值
     * @param c
     */
    public static void init(Context c){
        if(!isFirst){
            return;
        }
        isFirst = false;
        context = c;
        tasks = new LinkedBlockingDeque<Runnable>();
        threadCount = getCoreNumbers();
        //创建与线程池中线程数量一样多的“许可”
        pollLock = new Semaphore(threadCount);
        //创建线程池
        exec = Executors.newFixedThreadPool(threadCount);
        pollThread = new Thread(){
            @Override
            public void run() {
                Looper.prepare();
                pollHandler = new Handler(){
                    @Override
                    public void handleMessage(Message msg) {
                        //一旦该pollHandler收到消息
                        //就意味着任务队列中有了任务
                        //就去取任务，放到线程池中执行
                        try {
                            Runnable task = tasks.getLast();
                            exec.execute(task);
                            pollLock.acquire();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                };
                //释放许可
                pollHandlerLock.release();
                Looper.loop();

            }
        };
        pollThread.start();
        //通过Handler(looper)这样的构造方式
        //保证uiHandler是与主线程相依相偎
        uiHandler = new Handler(Looper.getMainLooper()){
            @Override
            public void handleMessage(Message msg) {
                //TODO
                //用来将获得的图片放到ImageView中显示
                //需要解决一个“反复”显示的问题

                switch (msg.what) {
                case 101:
                    TaskBean bean = (TaskBean) msg.obj;
                    ImageView iv = bean.iv;
                    Bitmap bimtap = bean.bitmap;
                    String tag = bean.tag;
                    if(iv.getTag().toString().equals(tag)){
                        iv.setImageBitmap(bimtap);
                    }
                    break;

                default:
                    super.handleMessage(msg);
                    break;
                }
            }
        };
        //初始化内存缓存
        memCache = new LruCache<String, Bitmap>((int) (Runtime.getRuntime().maxMemory()/4)){
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getHeight()*value.getRowBytes();
            }
        };

    }
    /*
     * 加载制定位置的图形到ImageView中显示
     */
    public static void loadImage(final ImageView iv,final String url){
        Bitmap result = null;
        final String tag = getMD5(url);
        result = memCache.get(tag);

        iv.setTag(tag);

        if(result!=null){
            Log.d("TAG","图片从内存缓存中加载");
            iv.setImageBitmap(result);
            return;
        }
        //如果缓存中没有，添加到任务队列中，去做下载
        tasks.add(new Runnable() {

            @Override
            public void run() {
                //去url指定位置下载图片
                try{
                    URL u = new URL(url);
                    HttpURLConnection connection = (HttpURLConnection) u.openConnection();
                    connection.setDoInput(true);
                    connection.setRequestMethod("GET");
                    connection .connect();
                    InputStream in = connection.getInputStream();
                    //bitmap是经过压缩的图片
                    Bitmap bitmap = compress(iv,in);
                    in.close();
                    //将下载的图片放到缓存中缓存
                    memCache.put(tag, bitmap);
                    //????可以吗?
                    //用一个bean,两个属性，一个属性引用Bitmap，另一个属性引用要显示该Bitmap的ImageView
                    TaskBean bean = new TaskBean();
                    bean.bitmap = bitmap;
                    bean.iv = iv;
                    bean.tag = tag;
                    Message.obtain(uiHandler, 101, bean).sendToTarget();
                    //释放一个许可，允许线程池继续去取任务
                    pollLock.release();
                }catch(Exception e){
                    e.printStackTrace();
                }
            }
        });
        //添加了任务后，马上通知pollHandler去任务队列中取任务！
        if(pollHandler==null){
            //等待
            //获取一个“许可”
            try {
                pollHandlerLock.acquire();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        Message.obtain(pollHandler).sendToTarget();
    }
    /**
     * 根据ImageView的大小，对图像进行适当的压缩处理
     * @param iv
     * @param in
     * @return
     */
    protected static Bitmap compress(ImageView iv, InputStream in) {

        try {
            //先尝试获得ImageView的大小
            int width = iv.getWidth(); //有可能得到正确结果，有可能得到0
            int height = iv.getHeight();//同上

            if(width==0||height==0){
                //怎么办？
                //折中方式1)用固定尺寸100dp?150dp?
                //       2)用设备屏幕的宽/高
                //第一种方式，是使用TypedValue类，用法参考友录项目的CircleImageView写法
                //第二种方式
                //拿到当前设备屏幕的宽度
                width = context.getResources().getDisplayMetrics().widthPixels;
                //拿到当前设备屏幕的高度
                height = context.getResources().getDisplayMetrics().heightPixels;
            }

            //获得图像实际的宽/高
            //首先将InputStream转为byte[]数组
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int len = -1;
            while((len=in.read())!=-1){
                out.write(len);
            }
            byte[] bytes = out.toByteArray();
            out.close();

            Options opts = new Options();
            //让BitmapFactory仅仅取获得byte[]数组所
            //代表的Bitmap文件的尺寸值
            opts.inJustDecodeBounds = true;
            BitmapFactory.decodeByteArray(bytes, 0, bytes.length, opts );
            //利用opts获得byte[]数组表示的图形的宽和高
            int bitmapWidth = opts.outWidth;
            int bitmapHeight = opts.outHeight;
            //压缩。压缩的比例就取决于图片的宽高与前面计算的width和height的比值
            int sampleSize = 1;
            //如果图形的宽或图形高大于我希望的宽或者高
            //就需要进行压缩
            //压缩比就是bitmapWidth*1.0/width或bitmapHeight*1.0/height
            //中更大的哪个值！
            //比如希望尺寸是100*100，实际图形尺寸是3000*4800,压缩比取48
            if(bitmapWidth*1.0/width>1||bitmapHeight*1.0/height>1){
                sampleSize = (int) Math.ceil(Math.max(bitmapWidth*1.0/width, bitmapHeight*1.0/height));
            }
            opts.inSampleSize = sampleSize;
            opts.inJustDecodeBounds = false;
            Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length, opts);
            return bitmap;

        } catch (IOException e) {
            e.printStackTrace();
        }

        return null;
    }
    /**
     * 把一个普通的字符串转成MD5格式的字符串
     * 
     * @param str
     * @return
     */
    private static String getMD5(String str) {
        StringBuffer sb = new StringBuffer();

        try{
            //获得摘要对象
            MessageDigest md = MessageDigest.getInstance("md5");
            //转换str--->md5
            md.update(str.getBytes());
            byte[] bytes = md.digest();
            //如下直接转换是可以的，但是可读性太差，不推荐
            //String string = new String(bytes);
            for (byte b : bytes) {
                //把每一个byte数据做一下“格式化”
                // 1111 & 1010--->1010
                String temp = Integer.toHexString(b & 0xFF);
                if(temp.length()==1){
                    sb.append("0");
                }
                sb.append(temp);
            }
        }catch(Exception e){
            e.printStackTrace();
        }
        return sb.toString();
    }
    /*
     * 安卓下有一个神奇的路径/sys/devices/system
     * 该路径下有N多个文件用来描述系统的资源
     * 其中与CPU相关的描述文件都在
     * /sys/devices/system/cpu路径下面
     * 如果设备cpu是一个核，它的描述文件就是
     * /sys/devices/system/cpu/cpu0/XXXXX
     * 通过判断/sys/devices/system/cpu/下包含的文件数量
     * 就可以间接知道设备的CPU核数
     */
    private static int getCoreNumbers() {
        try {
            File file = new File("/sys/devices/system/cpu/");
            File[] files = file.listFiles(new FilenameFilter() {

                @Override
                public boolean accept(File dir, String filename) {
                    if(filename.contains("cpu")){
                        return true;
                    }
                    return false;
                }
            });
            return files.length;
        } catch (Exception e) {
            e.printStackTrace();
            return 1;
        }
    }
    /**
     * 持有bitmap，和要显示bitmap的imageView
     * @author pjy
     *
     */
    private static class TaskBean{
        Bitmap bitmap;
        ImageView iv;
        String tag;//就是bitmap属性对应的下载地址
    }
    /**
     * 如果返回true，意味着ImageLoader尚未初始化
     * 如果返回fasle，意味着ImageLoader初始化过了，不需要再次初始化了
     * @return
     */
    public static boolean isFirst(){
        return isFirst;
    }
}