安卓图片下载及存储

网上找到一个下载图片的工具类，下载到的图片是Drawable类型的。

package com.cn.gordon.exhibition.walk.utils;

import java.io.InputStream;
import java.lang.ref.SoftReference;
import java.net.URL;
import java.net.URLConnection;
import java.util.HashMap;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import android.graphics.drawable.Drawable;
import android.os.Handler;
import android.os.Looper;
/**
 * 加载图片类
 * @author jialg
 *
 */
public class AsyncImageLoader {
    private static final String TAG = "AsyncImageLoader";
    private ThreadPoolExecutor mPoolExecutor;
    private HashMap<String, SoftReference<Drawable>> imageCache;
    private Handler mMainThreadHandler;
 
    /**
     * 创建一个异步图片加载器，默认最大5个工作线程，最大等待队列20
     */
    public AsyncImageLoader() {
        this(5, 20);
    }
 
    /**
     * 创建一个异步图片加载器，当等待下载的图片超过设置的最大等待数量之后，会从等待队列中放弃一个最早加入队列的任务
     * 
     * @param maxPoolSize 最大工作线程数
     * @param queueSize 最大等待数
     */
    public AsyncImageLoader(int maxPoolSize, int queueSize) {
        this(2, maxPoolSize, 3, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(queueSize),
                new ThreadPoolExecutor.DiscardOldestPolicy());
    }
 
    /**
     * 自定义线程池的加载器,请参考:{@link ThreadPoolExecutor}
     * 
     * @param corePoolSize
     * @param maximumPoolSize
     * @param keepAliveTime
     * @param unit
     * @param workQueue
     * @param handler
     */
    public AsyncImageLoader(int corePoolSize, int maximumPoolSize, long keepAliveTime,
            TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
        imageCache = new HashMap<String, SoftReference<Drawable>>();
        mPoolExecutor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, unit,
                workQueue, handler);
        mMainThreadHandler = new Handler(Looper.getMainLooper());
    }
 
    /**
     * 异步加载一张图片
     * 
     * @param imageUrl
     * @param imageCallback
     */
    public void loadDrawable(final String imageUrl, final ImageCallback imageCallback) {
        if (imageCache.containsKey(imageUrl)) {
            SoftReference<Drawable> softReference = imageCache.get(imageUrl);
            Drawable drawable = softReference.get();
            if (drawable != null) {
                imageCallback.onLoaded(drawable);
                return;
            }
        }
        LoadImageTask task = new LoadImageTask(imageUrl, this, mMainThreadHandler, imageCallback);
        mPoolExecutor.execute(task);
    }
 
    /**
     * 停止线程池运行，停止之后，将不能在继续调用 {@link #loadDrawable(String, ImageCallback)}
     */
    public void shutdown() {
        mPoolExecutor.shutdown();
        imageCache.clear();
    }
 
    private void cache(String url, Drawable drawable) {
        imageCache.put(url, new SoftReference<Drawable>(drawable));
    }
 
    /**
     * 下载任务
     * 
     */
    private static final class LoadImageTask implements Runnable {
 
        private Handler mHandler;
        private ImageCallback mCallback;
        private AsyncImageLoader mLoader;
        private String mPath;
 
        /**
         * @param imgPath 要下载的图片地址
         * @param loader 图片加载器
         * @param handler 主线程Handler
         * @param imageCallback 图片加载回调
         */
        public LoadImageTask(String imgPath, AsyncImageLoader loader, Handler handler,
                ImageCallback imageCallback) {
            this.mHandler = handler;
            this.mPath = imgPath;
            this.mLoader = loader;
            this.mCallback = imageCallback;
        }
 
        @Override
        public void run() {
            URL url;
            InputStream is = null;
            try {
                url = new URL(mPath);
                URLConnection conn = url.openConnection();
                conn.connect();
                is = conn.getInputStream();
                final Drawable drawable = Drawable.createFromStream(is, "src");
                mLoader.cache(mPath, drawable);
                mHandler.post(new Runnable() {
 
                    @Override
                    public void run() {
                        mCallback.onLoaded(drawable);
                    }
                });
            } catch (final Exception e) {
                mHandler.post(new Runnable() {
 
                    @Override
                    public void run() {
                        mCallback.onError(e);
                    }
                });
            }
        }
    }
 
    /**
     * 回调接口,在主线程中运行
     * 
     */
    public static interface ImageCallback {
        /**
         * 加载成功
         * 
         * @param imageDrawable 下载下来的图片
         */
        public void onLoaded(Drawable drawable);
 
        /**
         * 加载失败
         * 
         * @param e 异常
         */
        public void onError(Exception e);
    }
}

图片下载之后，要进行存储，存储的类型是Bitmap，所以要将图片先转成BitmapDrawable,然后再转成Bitmap，运用上面的工具类进行图片的下载，并进行保存。

public class EntryActivity extends Activity {
    private AsyncImageLoader asyncImageLoader;
    private static String ALBUM_PATH = getSDPath() +         java.io.File.separator +  "exhibition_walk"; 
    
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.walkmain);
        asyncImageLoader= new AsyncImageLoader();
        init();
        
    }  
    private void init(){
        asyncImageLoader.loadDrawable(urlStr, new ImageCallback(){
                     @Override
                     public void onLoaded(Drawable imageDrawable) {
                         if(imageDrawable != null){
                             v1.setImageDrawable(imageDrawable);
                             BitmapDrawable draw = (BitmapDrawable) imageDrawable;
                             final Bitmap bitmap = draw.getBitmap();
                             try {  
                                 if (bitmap!=null) {
                                     Toast.makeText(EntryActivity.this, "下载的图片可用", Toast.LENGTH_SHORT).show();
                                     savePicture(bitmap, System.currentTimeMillis()+".jpg");  
                                    }else{
                                        
                                        Toast.makeText(EntryActivity.this, "下载的图片不可用", Toast.LENGTH_SHORT).show();
                                    }
                             } catch (IOException e) {  
                                 e.printStackTrace();  
                             }  
                         }
                     }

                    @Override
                    public void onError(Exception e) {
                        
                    }
                });
    }
    private void savePicture(Bitmap bitmap,String fileName) throws IOException{
        File dirFile = new File(ALBUM_PATH);  
        if(!dirFile.exists()){  
            dirFile.mkdirs();  
            Toast.makeText(EntryActivity.this, "创建文件夹", Toast.LENGTH_SHORT).show();
        }  
        File myCaptureFile = new File(ALBUM_PATH +  java.io.File.separator +fileName);  
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(myCaptureFile));  
        bitmap.compress(Bitmap.CompressFormat.JPEG, 80, bos);  
        bos.flush();  
        bos.close();  
    }
/**
     * 获取sd卡的路径
     * 
     * @return 路径的字符串
     */
    public static String getSDPath() {
        File sdDir = null;
        boolean sdCardExist = Environment.getExternalStorageState().equals(
                android.os.Environment.MEDIA_MOUNTED); // 判断sd卡是否存在
        if (sdCardExist) {
            sdDir = Environment.getExternalStorageDirectory();// 获取外存目录
        }
        return sdDir.toString();
    }

}  

最后，图片存储到sd卡上，要进行权限的声明：

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS" />