异步图片加载工具类

package com.su.doubanrise.widget;

import java.io.File;
import java.lang.ref.SoftReference;
import java.util.HashMap;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;

import android.os.Handler;
import android.os.Message;
import android.widget.ImageView;

import com.su.doubanrise.DoubanApp;
import com.su.doubanrise.R;
import com.su.doubanrise.overall.Constant;
import com.su.doubanrise.util.FileDownLoader;
import com.su.doubanrise.util.Str;

public class AsyncImageLoader {
    private Context mcontext;
    private HashMap<String, SoftReference<Bitmap>> imageCache = new HashMap<String, SoftReference<Bitmap>>();;

    public AsyncImageLoader() {
        this.mcontext = DoubanApp.getContext();

    }

    /**
     * 异步加载sd卡的图片 ，
     * 
     * @param uri
     * @param imageView
     * @param imageCallback
     * @return
     */
    private Bitmap loadBitmapFromSD(final String uri,
            final ImageView imageView, final ImageCallback imageCallback) {
        if (imageCache.containsKey(uri)) {
            SoftReference<Bitmap> SoftReference = imageCache.get(uri);
            Bitmap bitmap = SoftReference.get();
            if (bitmap != null) {
                return bitmap;
            }
        }
        final Handler handler = new Handler() {
            public void handleMessage(Message msg) {
                imageCallback.imageLoaded((Bitmap) msg.obj, imageView, uri);
            }
        };
        new Thread() {
            public void run() {
                Bitmap bitmap = null;
                bitmap = getBitmapFromFile(uri);
                imageCache.put(uri, new SoftReference<Bitmap>(bitmap));
                if (!new File(uri).isFile()) {
                    bitmap = BitmapFactory.decodeResource(
                            mcontext.getResources(), R.drawable.ic_launcher);

                }
                Message msg = handler.obtainMessage(0, bitmap);
                handler.sendMessage(msg);
                bitmap = null;
            }
        }.start();
        return null;
    }

    private Bitmap loadBitmapFromNet(final String url,
            final ImageView imageView, final int opsize,
            final ImageCallback imageCallback) {

        final String savePath = Constant.PICPATH + Str.md5(url);

        if (imageCache.containsKey(url)) {

            Bitmap bitmap = imageCache.get(url).get();
            if (bitmap != null) {
                return bitmap;
            }
        }
        final Handler handler = new Handler() {
            public void handleMessage(Message msg) {
                imageCallback.imageLoaded((Bitmap) msg.obj, imageView, url);
            }
        };
        new Thread() {
            public void run() {
                try {
                    FileDownLoader.downloadImg(url, savePath);

                } catch (Exception e) {
                    e.printStackTrace();
                }
                Bitmap bitmap = null;
                bitmap = getBitmapFromFile(savePath, opsize);

                imageCache.put(url, new SoftReference<Bitmap>(bitmap));
                if (!new File(savePath).isFile()) {
                    bitmap = BitmapFactory.decodeResource(
                            mcontext.getResources(), R.drawable.ic_launcher);
                }
                Message msg = handler.obtainMessage(0, bitmap);
                handler.sendMessage(msg);

            }
        }.start();
        return null;
    }

    private interface ImageCallback {
        public void imageLoaded(Bitmap imageBitmap, ImageView imageView,
                String uri);
    }

    /**
     * 从本读读取图片
     * 
     * @param uri
     * @return
     */
    private Bitmap getBitmapFromFile(String uri) {
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inSampleSize = 8;
        Bitmap bitmap = BitmapFactory.decodeFile(uri, options);
        return bitmap;
    }

    /**
     * 从本读读取图片 添加opt参数
     * 
     * @param uri
     * @return
     */
    private Bitmap getBitmapFromFile(String uri, int opsize) {
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inSampleSize = opsize;
        options.inPurgeable = true;
        Bitmap bitmap = BitmapFactory.decodeFile(uri, options);// 这里还是会出现oom??
        return bitmap;
    }

    /**
     * 最终暴露给用户的接口
     * 
     * @param url
     * @param imageView
     */

    public void setAsyncBitmapFromNet(String url, ImageView imageView) {
        if (url == null) {
            return;
        }

        imageView.setImageBitmap(loadBitmapFromNet(url, imageView, 1,
                new ImageCallback() {
                    public void imageLoaded(Bitmap imageBitmap,
                            ImageView imageView, String imageUrl) {
                        imageView.setImageBitmap(imageBitmap);
                    }
                }));
    }

    /**
     * 异步加载本地图片
     * 
     * @param uri
     * @param imageView
     */
    public void setAsyncBitmapFromSD(String uri, ImageView imageView) {
        if (uri == null) {
            return;
        }

        imageView.setImageBitmap(loadBitmapFromSD(uri, imageView,
                new ImageCallback() {
                    public void imageLoaded(Bitmap imageBitmap,
                            ImageView imageView, String imageUrl) {
                        imageView.setImageBitmap(imageBitmap);
                    }
                }));
    }

    /**
     * 由于加载本地图片时间较短 ，其实可以不使用这个方法减小线程的开销
     * 
     * @param uri
     * @param imageView
     */
    public void setBitmapFromSD(String uri, ImageView imageView) {
        if (uri == null) {
            return;
        }

        imageView.setImageBitmap(getBitmapFromFile(uri));
    }
}