add memory cache and image loader

Author: anod

src/main/java/info/anodsplace/android/cache/MemoryCache.java

@@ -0,0 +1,80 @@
+package info.anodsplace.android.cache;
+
+import android.graphics.Bitmap;
+import android.util.Log;
+
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+public class MemoryCache {
+
+    private static final String TAG = "MemoryCache";
+
+    private Map<String, Bitmap> cache = Collections.synchronizedMap(
+            new LinkedHashMap<String, Bitmap>(10, 1.5f, true));//Last argument true for LRU ordering
+
+    private long size = 0;//current allocated size
+
+    private long limit = 1000000;//max memory in bytes
+
+    public MemoryCache() {
+        //use 25% of available heap size
+        setLimit(Runtime.getRuntime().maxMemory() / 4);
+    }
+
+    public void setLimit(long new_limit) {
+        limit = new_limit;
+        Log.i(TAG, "MemoryCache will use up to " + limit / 1024. / 1024. + "MB");
+    }
+
+    public Bitmap get(String id) {
+        if (!cache.containsKey(id)) {
+            return null;
+        }
+        return cache.get(id);
+    }
+
+    public void put(String id, Bitmap bitmap) {
+        try {
+            if (cache.containsKey(id)) {
+                size -= getSizeInBytes(cache.get(id));
+            }
+            cache.put(id, bitmap);
+            size += getSizeInBytes(bitmap);
+            checkSize();
+        } catch (Throwable th) {
+            th.printStackTrace();
+        }
+    }
+
+    private void checkSize() {
+        Log.i(TAG, "cache size=" + size + " length=" + cache.size());
+        if (size > limit) {
+            Iterator<Entry<String, Bitmap>> iter = cache.entrySet()
+                    .iterator();//least recently accessed item will be the first one iterated
+            while (iter.hasNext()) {
+                Entry<String, Bitmap> entry = iter.next();
+                size -= getSizeInBytes(entry.getValue());
+                iter.remove();
+                if (size <= limit) {
+                    break;
+                }
+            }
+            Log.i(TAG, "Clean cache. New size " + cache.size());
+        }
+    }
+
+    public void clear() {
+        cache.clear();
+    }
+
+    long getSizeInBytes(Bitmap bitmap) {
+        if (bitmap == null) {
+            return 0;
+        }
+        return bitmap.getRowBytes() * bitmap.getHeight();
+    }
+}

src/main/java/info/anodsplace/android/image/ImageLoader.java

@@ -0,0 +1,132 @@
+package info.anodsplace.android.image;
+
+import android.app.Activity;
+import android.graphics.Bitmap;
+import android.widget.ImageView;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.WeakHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import info.anodsplace.android.cache.MemoryCache;
+
+abstract public class ImageLoader {
+
+    private MemoryCache mMemoryCache = new MemoryCache();
+
+    private Map<ImageView, String> mImageViews = Collections
+            .synchronizedMap(new WeakHashMap<ImageView, String>());
+
+    private ExecutorService mExecutorService;
+
+    public ImageLoader() {
+        mExecutorService = Executors.newFixedThreadPool(5);
+    }
+
+    abstract protected Bitmap loadBitmap(String imgUID);
+
+    public Bitmap getCachedImage(String imgUID) {
+        return mMemoryCache.get(imgUID);
+    }
+
+    protected void cacheImage(String imgUID, Bitmap bmp) {
+        mMemoryCache.put(imgUID, bmp);
+    }
+
+    public void releaseImageView(ImageView imageView) {
+        mImageViews.remove(imageView);
+    }
+
+    public void loadImage(String imgUID, ImageView imageView) {
+        mImageViews.put(imageView, imgUID);
+        Bitmap bitmap = mMemoryCache.get(imgUID);
+        if (bitmap != null) {
+            imageView.setImageBitmap(bitmap);
+        } else {
+            queuePhoto(imgUID, imageView);
+        }
+    }
+
+    private void queuePhoto(String imgUID, ImageView imageView) {
+        PhotoToLoad p = new PhotoToLoad(imgUID, imageView);
+        mExecutorService.submit(new PhotosLoader(p));
+    }
+
+    //Task for the queue
+    private class PhotoToLoad {
+
+        public String imgUID;
+
+        public ImageView imageView;
+
+        public PhotoToLoad(String u, ImageView i) {
+            imgUID = u;
+            imageView = i;
+        }
+    }
+
+    class PhotosLoader implements Runnable {
+
+        PhotoToLoad mPhotoToLoad;
+
+        PhotosLoader(PhotoToLoad photoToLoad) {
+            mPhotoToLoad = photoToLoad;
+        }
+
+        @Override
+        public void run() {
+            if (imageViewReused(mPhotoToLoad)) {
+                return;
+            }
+            Bitmap bmp = loadBitmap(mPhotoToLoad.imgUID);
+            cacheImage(mPhotoToLoad.imgUID, bmp);
+            if (imageViewReused(mPhotoToLoad)) {
+                return;
+            }
+            Activity a = (Activity) mPhotoToLoad.imageView.getContext();
+            if (bmp == null) {
+                mImageViews.remove(mPhotoToLoad.imageView);
+                return;
+            }
+            BitmapDisplayer bd = new BitmapDisplayer(bmp, mPhotoToLoad);
+            a.runOnUiThread(bd);
+        }
+    }
+
+    boolean imageViewReused(PhotoToLoad photoToLoad) {
+        String tag = mImageViews.get(photoToLoad.imageView);
+        if (tag == null || !tag.equals(photoToLoad.imgUID)) {
+            return true;
+        }
+        return false;
+    }
+
+    //Used to display mBitmap in the UI thread
+    class BitmapDisplayer implements Runnable {
+
+        Bitmap mBitmap;
+
+        PhotoToLoad mPhotoToLoad;
+
+        public BitmapDisplayer(Bitmap b, PhotoToLoad p) {
+            mBitmap = b;
+            mPhotoToLoad = p;
+        }
+
+        public void run() {
+            if (imageViewReused(mPhotoToLoad)) {
+                return;
+            }
+            if (mBitmap != null) {
+                mPhotoToLoad.imageView.setImageBitmap(mBitmap);
+            }
+        }
+    }
+
+    public void clearCache() {
+        mMemoryCache.clear();
+    }
+
+}