android图片缓存之softReference

softReference缓存的对象，只有当虚拟机内存不足的才会回收，很好的避免了OOM。

package cache;

import java.lang.ref.SoftReference;

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.concurrent.ConcurrentHashMap;

import android.graphics.Bitmap;

import android.os.Handler;

import android.widget.ImageView;

public class FileServiceByMemoary extends FileServiceAbstractDetails {

@Override

public void loadFileToMap() {

// for memory, nothing to do.

}

@Override

public void getBitmap(String url, ImageView imageView,

Bitmap defaultBitmap, Integer scrollState) {

resetPurgeTimer();

// scrollState 0:停止状态，需要加载图片(cache -> network)

// scrollState 1/2:滚动状态，此时就用cache图片，如果cache没有就用默认defaultBitmap

Bitmap bitmap = getBitmapFromCache(url);

if (scrollState != SCROLL_STATUS_STOP) {// 处于滚动状态

if (bitmap == null) {

imageView.setImageBitmap(defaultBitmap);

} else {

imageView.setImageBitmap(bitmap);

}

return;

}

if (bitmap == null) {

forceDownload(url, imageView, defaultBitmap);

} else {

cancelPotentialDownload(url, imageView);

imageView.setImageBitmap(bitmap);

}

}

// public void setMode(Mode mode) {

// this.mode = mode;

// clearCache();

// }

private static final int HARD_CACHE_CAPACITY = 30;

private static final int DELAY_BEFORE_PURGE = 10 * 1000; // in milliseconds

private final static HashMap<String, Bitmap> mHardBitmapCache = new LinkedHashMap<String, Bitmap>(

HARD_CACHE_CAPACITY, 0.75f, true) {

private static final long serialVersionUID = 1L;

@Override

protected boolean removeEldestEntry(

LinkedHashMap.Entry<String, Bitmap> eldest) {

if (size() > HARD_CACHE_CAPACITY) {

// Entries push-out of hard reference cache are transferred to

// soft reference cache

mSoftBitmapCache.put(eldest.getKey(),

new SoftReference<Bitmap>(eldest.getValue()));

return true;

} else

return false;

}

};

/*

* SoftReference 指到的对象，即使没有任何 Direct Reference，也不会被清除。 一直要到 JVM 内存不足时且 没有

* Direct Reference 时才会清除，SoftReference 是用来设计 object-cache 之用的。 不但可以把对象

* cache 起来，也不会造成内存不足的错误 （OutOfMemoryError）

*/

private final static ConcurrentHashMap<String, SoftReference<Bitmap>> mSoftBitmapCache = new ConcurrentHashMap<String, SoftReference<Bitmap>>(

HARD_CACHE_CAPACITY);

private final static Handler mPurgeHandler = new Handler();

private final static Runnable mPurgerRunnable = new Runnable() {

@Override

public void run() {

clearCache();

}

};

private static Bitmap getBitmapFromCache(String url) {

synchronized (mHardBitmapCache) {

final Bitmap bitmap = mHardBitmapCache.get(url);

if (bitmap != null) {

mHardBitmapCache.remove(url);

mHardBitmapCache.put(url, bitmap);

return bitmap;

}

}

SoftReference<Bitmap> bitmapReference = mSoftBitmapCache.get(url);

if (bitmapReference != null) {

final Bitmap bitmap = bitmapReference.get();

if (bitmap != null) {

return bitmap;

} else {

mSoftBitmapCache.remove(url);

}

}

return null;

}

public static void clearCache() {

mHardBitmapCache.clear();

mSoftBitmapCache.clear();

}

private static void resetPurgeTimer() {

mPurgeHandler.removeCallbacks(mPurgerRunnable);

mPurgeHandler.postDelayed(mPurgerRunnable, DELAY_BEFORE_PURGE);

}

@Override

public boolean getFile(String path, String targetPath) {

// TODO Auto-generated method stub

return false;

}

@Override

public boolean clearFile(String path) {

// TODO Auto-generated method stub

return false;

}

@Override

public void saveBitmap(String url, Bitmap bitmap) {

if (bitmap != null) {

synchronized (mHardBitmapCache) {

mHardBitmapCache.put(url, bitmap);

}

}

}

@Override

public int getCurrentCacheBitmapNumbers() {

int numbers = 0;

if (mHardBitmapCache != null) {

numbers = mHardBitmapCache.size();

}

if (mSoftBitmapCache != null) {

numbers = numbers + mSoftBitmapCache.size();

}

return numbers;

}

@Override

public boolean clearCacheBitmaps() {

try {

mHardBitmapCache.clear();

mSoftBitmapCache.clear();

} catch (Exception e) {

e.printStackTrace();

return false;

}

return true;

}

}