解决ListView异步加载图片错乱问题 .

发一个异步图片加载控件。网上也有大把的异步网络加载图片的控件，但是有一个问题，异步加载会造成列表中的图片混乱，因为列表的每一项的View都可能被重用，异步加载的时候多个异步线程引用到了同一个View将造成图片加载错乱。该控件解决这个问题：

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URL;
import java.net.URLConnection;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import android.os.AsyncTask;
import android.util.AttributeSet;
import android.widget.ImageView;

/**
 * 异步图片控件
 * 使用：new AsyncImageView().asyncLoadBitmapFromUrl("http://xxxx","缓存路径"){
 *
 * @author gaoomei@gmail.com
 * @site http://obatu.sinaapp.com
 * @version 1.0
 * @2011-12-3
 */
public class AsyncImageView extends ImageView {

    /**
     * 异步task加载器
     */
    private AsyncLoadImage mAsyncLoad;

    /**
     * 下载回来的图片缓存存活时间，单位：秒(s),默认30分钟
     */
    private long mCacheLiveTime = 1800;

    public AsyncImageView(Context context) {
        super(context);
    }

    public AsyncImageView(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    public AsyncImageView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
    }

    /**
     *
     */
    @Override
    public void setImageDrawable(Drawable drawable) {
        if (mAsyncLoad != null) {
            mAsyncLoad.cancel(true);
            mAsyncLoad = null;
        }
        super.setImageDrawable(drawable);
    }

    /**
     * 重写下面几个设置图片资源的方法，目地是取消网络加载
     */
    @Override
    public void setImageResource(int resId) {
        cancelLoad();
        super.setImageResource(resId);
    }

    @Override
    public void setImageURI(Uri uri) {
        cancelLoad();
        super.setImageURI(uri);
    }

    @Override
    public void setImageBitmap(Bitmap bitmap) {
        cancelLoad();
        super.setImageBitmap(bitmap);
    }

    /**
     * 取消正在进行的异步task
     */
    public void cancelLoad() {
        if (mAsyncLoad != null) {
            mAsyncLoad.cancel(true);
            mAsyncLoad = null;
        }
    }

    /**
     * 设置图片存活时间
     *
     * @param second
     *            存活时间，单位【秒】，如果等于0或null，则不缓存
     */
    public void setCacheLiveTime(long second) {
        if (second == 0) {
            this.mCacheLiveTime = 0;
        } else if (second >= 0) {
            this.mCacheLiveTime = second * 1000;
        }
    }

    /**
     * 从网络异步加载
     *
     * @param url
     * @param saveFileName
     */
    public void asyncLoadBitmapFromUrl(String url, String saveFileName) {
        if (mAsyncLoad != null) {
            mAsyncLoad.cancel(true);
        }
        // AsyncTask不可重用，所以每次重新实例
        mAsyncLoad = new AsyncLoadImage();
        mAsyncLoad.execute(url, saveFileName);
    }

    /**
     * 异步加载器
     */
    private class AsyncLoadImage extends AsyncTask {
        /**
         * 是否取消
         */
        private boolean isCancel = false;

        @Override
        protected Bitmap doInBackground(String... params) {
            if (isCancel) {
                return null;
            }
            String url = params[0];
            String fileName = params[1];
            try {
                return getBitmap(url, fileName);
            } catch (IOException e) {
                e.printStackTrace();
            }
            return null;
        }

        @Override
        protected void onCancelled() {
            System.out.println("async load imgae cancel");
            isCancel = true;
        }

        @Override
        protected void onPostExecute(Bitmap result) {
            if (!isCancel && result != null) {
                AsyncImageView.this.setImageBitmap(result);
            }
        }
    }

    /**
     * 下载图片
     *
     * @param urlString
     *            url下载地址
     * @param fileName
     *            缓存文件路径
     * @throws IOException
     */
    private Bitmap getBitmap(String urlString, String fileName)
            throws IOException {
        if (fileName == null || fileName.trim().isEmpty()) {
            InputStream input = getBitmapInputStreamFromUrl(urlString);
            return BitmapFactory.decodeStream(input);
        }

        File file = new File(fileName);
        if (!file.isFile()
                || (mCacheLiveTime > 0 && (System.currentTimeMillis()
                        - file.lastModified() > mCacheLiveTime))) {
            InputStream input = getBitmapInputStreamFromUrl(urlString);
            file = saveImage(input, fileName);
            // 如果文件结构创建失败，则直接从输入流解码图片
            if (file == null || !file.exists() || !file.canWrite()
                    || !file.canRead()) {
                return BitmapFactory.decodeStream(input);
            }
        }
        return BitmapFactory.decodeFile(file.getAbsolutePath());
    }

    /**
     * 下载图片，输入InputStream
     *
     * @param urlString
     * @return
     * @throws IOException
     */
    private InputStream getBitmapInputStreamFromUrl(String urlString)
            throws IOException {
        URL url = new URL(urlString);
        URLConnection connection = url.openConnection();
        connection.setConnectTimeout(25000);
        connection.setReadTimeout(90000);
        return connection.getInputStream();
    }

    /**
     * 从输入流保存图片到文件系统
     *
     * @param fileName
     * @param input
     * @return
     */
    private File saveImage(InputStream input, String fileName) {
        if (fileName.trim().isEmpty() || input == null) {
            return null;
        }
        File file = new File(fileName);
        OutputStream output = null;
        try {
            file.getParentFile().mkdirs();
            if (file.exists() && file.isFile()) {
                file.delete();
            }
            if (!file.createNewFile()) {
                return null;
            }
            output = new FileOutputStream(file);
            byte[] buffer = new byte[4 * 1024];
            do {
                // 循环读取
                int numread = input.read(buffer);
                if (numread == -1) {
                    break;
                }
                output.write(buffer, 0, numread);
            } while (true);
            output.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                output.close();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
        return file;
    }
}