public class ImageLoader {
public static final int UNCONSTRAINED = -1;
private static final String TAG = "ImageLoader";
private static final boolean DEBUG = false;
// Queue of work to do in the worker thread. The work is done in order.
private final ArrayList<WorkItem> mQueue = new ArrayList<WorkItem>();
// the worker thread and a done flag so we know when to exit
private boolean mDone;
private Thread mDecodeThread;
private ContentResolver mCr;
private LruCache<String, Bitmap> memoryCache;
private static Handler handler = new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
Map<String, Object> data = (Map<String, Object>) msg.obj;
WorkItem workItem = (WorkItem) data.get("workItem");
Bitmap bitmap = (Bitmap) data.get("bitmap");
workItem.mOnLoadedRunnable.onLoadingComplete(bitmap);
if (DEBUG) Log.i(TAG, String.valueOf(workItem.mImage.getId()) + workItem.mIsThumb + " called listener");
return false;
}
});
public void getBitmap(ImageData image,
OnLoaderCompleteListener imageLoadedRunnable,
boolean isThumb) {
if (mDecodeThread == null) {
start();
}
synchronized (mQueue) {
WorkItem w = new WorkItem(image, imageLoadedRunnable, isThumb);
mQueue.add(w);
mQueue.notifyAll();
}
}
/**
* @param filePath 文件路径
* @return 文件数据
*/
public Bitmap getBitmapFromPath(int minSideLength, int maxNumOfPixels, String filePath) {
try {
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeFile(filePath, options);
if (options.mCancel || options.outWidth == -1
|| options.outHeight == -1) {
return null;
}
options.inSampleSize = computeSampleSize(
options, minSideLength, maxNumOfPixels);
options.inJustDecodeBounds = false;
options.inDither = false;
options.inPreferredConfig = Bitmap.Config.ARGB_8888;
return BitmapFactory.decodeFile(filePath, options);
} catch (OutOfMemoryError ex) {
Log.e(TAG, "Got oom exception ", ex);
return null;
}
}
public Bitmap makeBitmap(int minSideLength, int maxNumOfPixels,
Uri uri, ContentResolver cr, ParcelFileDescriptor pfd,
BitmapFactory.Options options) {
try {
if (pfd == null) pfd = makeInputStream(uri, cr);
if (pfd == null) return null;
if (options == null) options = new BitmapFactory.Options();
FileDescriptor fd = pfd.getFileDescriptor();
options.inJustDecodeBounds = true;
// BitmapManager.instance().decodeFileDescriptor(fd, options);
BitmapFactory.decodeFileDescriptor(fd, null, options);
if (options.mCancel || options.outWidth == -1
|| options.outHeight == -1) {
return null;
}
options.inSampleSize = computeSampleSize(
options, minSideLength, maxNumOfPixels);
options.inJustDecodeBounds = false;
options.inDither = false;
options.inPreferredConfig = Bitmap.Config.ARGB_8888;
return BitmapFactory.decodeFileDescriptor(fd, null, options);
} catch (OutOfMemoryError ex) {
Log.e(TAG, "Got oom exception ", ex);
return null;
} finally {
closeSilently(pfd);
}
}
public static int computeSampleSize(BitmapFactory.Options options,
int minSideLength, int maxNumOfPixels) {
int initialSize = computeInitialSampleSize(options, minSideLength,
maxNumOfPixels);
int roundedSize;
if (initialSize <= 8) {
roundedSize = 1;
while (roundedSize < initialSize) {
roundedSize <<= 1;
}
} else {
roundedSize = (initialSize + 7) / 8 * 8;
}
return roundedSize;
}
private static int computeInitialSampleSize(BitmapFactory.Options options,
int minSideLength, int maxNumOfPixels) {
double w = options.outWidth;
double h = options.outHeight;
int lowerBound = (maxNumOfPixels == UNCONSTRAINED) ? 1 :
(int) Math.ceil(Math.sqrt(w * h / maxNumOfPixels));
int upperBound = (minSideLength == UNCONSTRAINED) ? 128 :
(int) Math.min(Math.floor(w / minSideLength),
Math.floor(h / minSideLength));
if (upperBound < lowerBound) {
// return the larger one when there is no overlapping zone.
return lowerBound;
}
if ((maxNumOfPixels == UNCONSTRAINED) &&
(minSideLength == UNCONSTRAINED)) {
return 1;
} else if (minSideLength == UNCONSTRAINED) {
return lowerBound;
} else {
return upperBound;
}
}
private ParcelFileDescriptor makeInputStream(
Uri uri, ContentResolver cr) {
try {
return cr.openFileDescriptor(uri, "r");
} catch (IOException ex) {
return null;
}
}
public void closeSilently(ParcelFileDescriptor c) {
if (c == null) return;
try {
c.close();
} catch (Throwable t) {
// do nothing
}
}
public boolean cancel(final ImageData image) {
synchronized (mQueue) {
int index = findItem(image);
if (index >= 0) {
mQueue.remove(index);
return true;
} else {
return false;
}
}
}
// The caller should hold mQueue lock.
private int findItem(ImageData image) {
for (int i = 0; i < mQueue.size(); i++) {
if (mQueue.get(i).mImage == image) {
return i;
}
}
return -1;
}
// Clear the queue. Returns an array of tags that were in the queue.
public void clearQueue() {
synchronized (mQueue) {
for (WorkItem workItem : mQueue) {
workItem.mImage = null;
workItem.mOnLoadedRunnable = null;
}
mQueue.clear();
}
}
private static class WorkItem {
ImageData mImage;
OnLoaderCompleteListener mOnLoadedRunnable;
boolean mIsThumb;
WorkItem(ImageData image, OnLoaderCompleteListener onLoadedRunnable, boolean isThumb) {
mImage = image;
mOnLoadedRunnable = onLoadedRunnable;
mIsThumb = isThumb;
}
}
public ImageLoader(ContentResolver cr) {
mCr = cr;
//获取系统分配给每个应用程序的最大内存
int maxMemory = (int) Runtime.getRuntime().maxMemory();
int mCacheSize = maxMemory / 2;
//给LruCache分配1/2最大内存
memoryCache = new LruCache<String, Bitmap>(mCacheSize) {
//必须重写此方法，来测量Bitmap的大小
@Override
protected int sizeOf(String key, Bitmap value) {
return value.getRowBytes() * value.getHeight();
}
/**
* 当bitmap被清出缓存的时候，回收所占内存
*/
@Override
protected void entryRemoved(boolean evicted, String key, Bitmap oldValue, Bitmap newValue) {
if (key.contains("false")) {
oldValue.recycle();
oldValue = null;
}
if (DEBUG) Log.i(TAG, key + " is removed from cache");
}
};
start();
}
private void addBitmapToMemoryCache(String key, Bitmap bitmap) {
if (getBitmapFromMemCache(key) == null && bitmap != null) {
memoryCache.put(key, bitmap);
}
}
private Bitmap getBitmapFromMemCache(String key) {
return memoryCache.get(key);
}
private class WorkerThread implements Runnable {
// Pick off items on the queue, one by one, and compute their bitmap.
// Place the resulting bitmap in the cache, then call back by executing
// the given runnable so things can get updated appropriately.
public void run() {
while (true) {
WorkItem workItem = null;
synchronized (mQueue) {
if (mDone) {
break;
}
if (!mQueue.isEmpty()) {
workItem = mQueue.remove(0);
} else {
try {
mQueue.wait();
} catch (InterruptedException ex) {
// ignore the exception
}
continue;
}
}
Message msg = new Message();
Map<String, Object> msgMap = new HashMap<>();
msgMap.put("workItem", workItem);
Bitmap bitmap = getBitmapFromMemCache(String.valueOf(workItem.mImage.getId()) + workItem.mIsThumb);
if (bitmap == null) {
if (workItem.mImage.getType() == MediaStore.Files.FileColumns.MEDIA_TYPE_VIDEO) {
if (workItem.mIsThumb) {
long longId = workItem.mImage.getId();
BitmapFactory.Options bitmapOptions = new BitmapFactory.Options();
bitmap = MediaStore.Video.Thumbnails.getThumbnail(mCr, longId,
MediaStore.Images.Thumbnails.MINI_KIND, bitmapOptions);
} else {
try {
MediaMetadataRetriever media = new MediaMetadataRetriever();
media.setDataSource(workItem.mImage.getPath());
bitmap = media.getFrameAtTime();
} catch (Exception e) {
Log.e(TAG, "get video bitmap error.");
e.printStackTrace();
bitmap = null;
}
}
} else if (workItem.mImage.getType() == MediaStore.Files.FileColumns.MEDIA_TYPE_IMAGE) {
if (workItem.mIsThumb) {
long longId = workItem.mImage.getId();
BitmapFactory.Options bitmapOptions = new BitmapFactory.Options();
bitmap = MediaStore.Images.Thumbnails.getThumbnail(mCr, longId,
MediaStore.Images.Thumbnails.MINI_KIND, bitmapOptions);
} else {
bitmap = makeBitmap(UNCONSTRAINED, 3 * 1024 * 1024, workItem.mImage.getUri(), mCr, null, null);
}
}
if (bitmap != null) {
addBitmapToMemoryCache(String.valueOf(workItem.mImage.getId()) + workItem.mIsThumb, bitmap);
if (DEBUG) Log.i(TAG, String.valueOf(workItem.mImage.getId()) + workItem.mIsThumb + " is put in cache");
}
}
msgMap.put("bitmap", bitmap);
msg.obj = msgMap;
handler.sendMessage(msg);
}
}
}
private void start() {
if (mDecodeThread != null) {
return;
}
mDone = false;
Thread t = new Thread(new WorkerThread());
t.setName("image-loader");
mDecodeThread = t;
t.start();
}
public void stop() {
synchronized (mQueue) {
mDone = true;
mQueue.notifyAll();
}
if (mDecodeThread != null) {
try {
Thread t = mDecodeThread;
MediaStore.Images.Thumbnails.cancelThumbnailRequest(mCr, -1, t.getId());
MediaStore.Video.Thumbnails.cancelThumbnailRequest(mCr, -1, t.getId());
t.join();
mDecodeThread = null;
} catch (InterruptedException ex) {
// so now what?
}
}
}
public interface OnLoaderCompleteListener {
void onLoadingComplete(Bitmap bitmap);
}
}
