Android处理网络和图片的工具类

import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.ref.SoftReference;
import java.util.HashMap;
import java.util.concurrent.RejectedExecutionException;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.methods.HttpGet;
import xiaogang.enif.utils.HttpManager;
import xiaogang.enif.utils.IOUtils;
import xiaogang.enif.utils.LogUtils;
import xiaogang.enif.utils.LruCache;
import android.app.ActivityManager;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.BitmapFactory.Options;
import android.graphics.Canvas;
import android.graphics.drawable.BitmapDrawable;
import android.os.AsyncTask;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.widget.ImageView;
public class CacheView extends ImageView {
    private static final int DEFAULT_RES_ID = 0;
    private int mDefaultImage = DEFAULT_RES_ID;

private static LruCache<String, Bitmap> mLruCache;
private static HashMap<Integer, SoftReference<Bitmap>> mResImage;


private Context mContext;
private LogUtils mLog = LogUtils.getLog(CacheView.class);


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


public CacheView(Context context, AttributeSet attrs) {
    super(context, attrs);
    init(context);


}


public CacheView(Context context) {
    super(context);
    init(context);
}


private void init(Context context) {
    mContext = context;


    if (mLruCache == null) {
        final int cacheSize = getCacheSize(context);
        mLruCache = new LruCache<String, Bitmap>(cacheSize) {
            @Override
            protected int sizeOf(String key, Bitmap bitmap) {
                // The cache size will be measured in bytes rather than
                // number of items.
                return bitmap.getRowBytes() * bitmap.getHeight();
            }


            @Override
            protected void entryRemoved(boolean evicted, String key, Bitmap oldValue,
                    Bitmap newValue) {
                if (evicted && oldValue != null && !oldValue.isRecycled()) {
                    oldValue.recycle();
                    oldValue = null;
                }
            }
        };
    }


    if (mResImage == null) {
        mResImage = new HashMap<Integer, SoftReference<Bitmap>>();
    }
}


@Override
protected void onDraw(Canvas canvas) {
    BitmapDrawable drawable = (BitmapDrawable)getDrawable();
    if (drawable == null) {
        setDefaultImage();
    } else {
        if (drawable.getBitmap() == null || drawable.getBitmap().isRecycled()) {
            setDefaultImage();
        }
    }
    try {
        super.onDraw(canvas);
    } catch(RuntimeException ex) {


    }
}


public void setImageUrl(String url, int resId) {
    setTag(url);
    Bitmap bitmap = getBitmapFromCache(url);
    if (bitmap == null || bitmap.isRecycled()) {
        mDefaultImage = resId;
        setDefaultImage();
        try {
            new DownloadTask().execute(url);
        } catch (RejectedExecutionException e) {
            // do nothing, just keep not crash
        }
    } else {
        setImageBitmap(bitmap);
    }
}


private void setDefaultImage() {
    if (mDefaultImage != DEFAULT_RES_ID) {
        setImageBitmap(getDefaultBitmap(mContext));
    }
}


private Bitmap getDefaultBitmap(Context context) {
    SoftReference<Bitmap> loading = mResImage.get(mDefaultImage);
    if (loading == null || loading.get() == null || loading.get().isRecycled()) {
        loading = new SoftReference<Bitmap>(BitmapFactory.decodeResource(
                context.getResources(), mDefaultImage));
        mResImage.put(mDefaultImage, loading);
    }
    return loading.get();
}


private class DownloadTask extends AsyncTask<String, Void, Bitmap> {
    private String mParams;


    @Override
    public Bitmap doInBackground(String... params) {
        mParams = params[0];
        final Bitmap bm = download(mParams);
        addBitmapToCache(mParams, bm);
        return bm;
    }


    @Override
    public void onPostExecute(Bitmap bitmap) {
        String tag = (String)getTag();
        if (!TextUtils.isEmpty(tag) && tag.equals(mParams)) {
            if (bitmap != null) {
                setImageBitmap(bitmap);
            }
        }
    }
};


/*
 * An InputStream that skips the exact number of bytes provided, unless it
 * reaches EOF.
 */
static class FlushedInputStream extends FilterInputStream {
    public FlushedInputStream(InputStream inputStream) {
        super(inputStream);
    }


    @Override
    public long skip(long n) throws IOException {
        long totalBytesSkipped = 0L;
        while (totalBytesSkipped < n) {
            long bytesSkipped = in.skip(n - totalBytesSkipped);
            if (bytesSkipped == 0L) {
                int b = read();
                if (b < 0) {
                    break; // we reached EOF
                } else {
                    bytesSkipped = 1; // we read one byte
                }
            }
            totalBytesSkipped += bytesSkipped;
        }
        return totalBytesSkipped;
    }
}


private Bitmap download(String url) {
    InputStream in = null;
    HttpEntity entity = null;
    Bitmap bmp = null;
    try {
        final HttpGet get = new HttpGet(url);
        final HttpResponse response = HttpManager.execute(mContext, get);
        if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
            entity = response.getEntity();
            in = entity.getContent();
            try {
                bmp = getDecodeBitmap(in, url);
            } catch (OutOfMemoryError err) {
                Runtime.getRuntime().gc();
                bmp = getDecodeBitmap(in, url);
            }
        } else {
            get.abort();
            return bmp;
        }
        addBitmapToCache(url, bmp);
    } catch (IOException e) {
        return bmp;
    } finally {
        IOUtils.closeStream(in);
    }
    return bmp;
}


private final Bitmap getDecodeBitmap(InputStream in, String url) {
    Options options = new Options();
    options.inPurgeable = true;
    options.inInputShareable = true;
    return BitmapFactory.decodeStream(new FlushedInputStream(in), null, options);
}


private final void addBitmapToCache(String url, Bitmap bitmap) {
    if (bitmap != null) {
        mLruCache.put(url, bitmap);
        Runtime.getRuntime().gc();
    }
}


private final Bitmap getBitmapFromCache(String url) {
    return mLruCache.get(url);
}


private int getCacheSize(Context context) {
    // According to the phone memory, set a proper cache size for LRU cache
    // dynamically.
    final ActivityManager am = (ActivityManager)context
            .getSystemService(Context.ACTIVITY_SERVICE);
    final int memClass = am.getMemoryClass();


    int cacheSize;
    if (memClass <= 24) {
        cacheSize = (memClass << 20) / 24;
    } else if (memClass <= 36) {
        cacheSize = (memClass << 20) / 18;
    } else if (memClass <= 48) {
        cacheSize = (memClass << 20) / 12;
    } else {
        cacheSize = (memClass << 20) >> 3;
    }
    mLog.debug("cacheSize == "+cacheSize);
    System.out.println("cacheSize == "+cacheSize);
    return cacheSize;
}


public static void recycle() {
    if (mLruCache != null && !mLruCache.isEmpty()) {
        mLruCache.evictAll();
        mLruCache = null;
    }


    if (mResImage != null) {
        for (SoftReference<Bitmap> reference : mResImage.values()) {
            Bitmap bitmap = reference.get();
            if (bitmap != null && !bitmap.isRecycled()) {
                bitmap.recycle();
                bitmap = null;
            }
        }
        mResImage = null;
    }
}

}
说明：
1）entryRemoved 在做Bitmap recyle 的时候的三个条件缺一不可
2）onDraw 里面判断图片是否被回收，如果回收  需要设置默认的图片
3）add bitmap 到cache 的时候 Runtime.getRuntime().gc 的调用</pre>