Change default RecyclePolicy to PRE_HONEYCOMB, and enable inBitmap use when recycling is not enabled.

Author: Chris Banes

library/src/uk/co/senab/bitmapcache/BitmapLruCache.java

@@ -29,6 +29,8 @@
 import android.util.Log;
 
 import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
@@ -45,7 +47,7 @@
  *
  * <p> Instances of this class should ideally be kept globally with the application, for example in
  * the {@link android.app.Application Application} object. You should also use the bundled {@link
- * CacheableImageView} wherever possible, as the memory cache has a close relationship with it.
+ * CacheableImageView} wherever possible, as the memory cache has a closeStream relationship with it.
  * </p>
  *
  * <p> Clients can call {@link #get(String)} to retrieve a cached value from the given Url. This
@@ -84,6 +86,15 @@ public static enum RecyclePolicy {
          */
         ALWAYS;
 
+        boolean canInBitmap() {
+            switch (this) {
+                case PRE_HONEYCOMB_ONLY:
+                case DISABLED:
+                    return Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB;
+            }
+            return false;
+        }
+
         boolean canRecycle() {
             switch (this) {
                 case DISABLED:
@@ -257,24 +268,20 @@ public CacheableBitmapDrawable getFromDiskCache(final String url,
 
             try {
                 final String key = transformUrlForDiskCacheKey(url);
-                DiskLruCache.Snapshot snapshot = mDiskCache.get(key);
-                if (null != snapshot) {
-                    // Try and decode bitmap
-                    Bitmap bitmap = BitmapFactory
-                            .decodeStream(snapshot.getInputStream(0), null, decodeOpts);
-
-                    if (null != bitmap) {
-                        result = new CacheableBitmapDrawable(url, mResources, bitmap,
-                                mRecyclePolicy);
-                        if (null != mMemoryCache) {
-                            mMemoryCache.put(result);
-                        }
-                    } else {
-                        // If we get here, the file in the cache can't be
-                        // decoded. Remove it and schedule a flush.
-                        mDiskCache.remove(key);
-                        scheduleDiskCacheFlush();
+                // Try and decode bitmap
+                Bitmap bitmap = decodeBitmap(new SnapshotInputStreamProvider(key), decodeOpts);
+
+                if (null != bitmap) {
+                    result = new CacheableBitmapDrawable(url, mResources, bitmap,
+                            mRecyclePolicy);
+                    if (null != mMemoryCache) {
+                        mMemoryCache.put(result);
                     }
+                } else {
+                    // If we get here, the file in the cache can't be
+                    // decoded. Remove it and schedule a flush.
+                    mDiskCache.remove(key);
+                    scheduleDiskCacheFlush();
                 }
             } catch (IOException e) {
                 e.printStackTrace();
@@ -301,7 +308,7 @@ public CacheableBitmapDrawable getFromMemoryCache(final String url) {
                 result = mMemoryCache.get(url);
 
                 // If we get a value, but it has a invalid bitmap, remove it
-                if (null != result && !result.hasValidBitmap()) {
+                if (null != result && !result.isBitmapValid()) {
                     mMemoryCache.remove(url);
                     result = null;
                 }
@@ -379,14 +386,7 @@ public CacheableBitmapDrawable put(final String url, final Bitmap bitmap,
             } catch (IOException e) {
                 Log.e(Constants.LOG_TAG, "Error while writing to disk cache", e);
             } finally {
-                if (null != os) {
-                    try {
-                        os.close();
-                    } catch (IOException e) {
-                        Log.e(Constants.LOG_TAG, "Failed to close output stream", e);
-                    }
-                }
-
+                IoUtils.closeStream(os);
                 lock.unlock();
                 scheduleDiskCacheFlush();
             }
@@ -448,7 +448,7 @@ public CacheableBitmapDrawable put(final String url, final InputStream inputStre
 
         if (null != tmpFile) {
             // Try and decode File
-            Bitmap bitmap = BitmapFactory.decodeFile(tmpFile.getAbsolutePath(), decodeOpts);
+            Bitmap bitmap = decodeBitmap(new FileInputStreamProvider(tmpFile), decodeOpts);
 
             if (null != bitmap) {
                 d = new CacheableBitmapDrawable(url, mResources, bitmap, mRecyclePolicy);
@@ -525,9 +525,9 @@ synchronized void setDiskCache(DiskLruCache diskCache) {
         }
     }
 
-    void setMemoryCache(BitmapMemoryLruCache memoryCache, RecyclePolicy recyclePolicy) {
+    void setMemoryCache(BitmapMemoryLruCache memoryCache) {
         mMemoryCache = memoryCache;
-        mRecyclePolicy = recyclePolicy;
+        mRecyclePolicy = memoryCache.getRecyclePolicy();
     }
 
     private ReentrantLock getLockForDiskCacheEdit(String url) {
@@ -553,6 +553,58 @@ private void scheduleDiskCacheFlush() {
                         TimeUnit.SECONDS);
     }
 
+    private Bitmap decodeBitmap(InputStreamProvider ip, BitmapFactory.Options opts) {
+        Bitmap bm = null;
+        InputStream is = null;
+
+        try {
+            if (mRecyclePolicy.canInBitmap()) {
+                // Create an options instance if we haven't been provided with one
+                if (opts == null) {
+                    opts = new BitmapFactory.Options();
+                }
+
+                if (opts.inSampleSize <= 1) {
+                    opts.inSampleSize = 1;
+                    addInBitmapOptions(ip, opts);
+                }
+            }
+
+            // Get InputStream for actual decode
+            is = ip.getInputStream();
+            // Decode stream
+            bm = BitmapFactory.decodeStream(is, null, opts);
+        } catch (Exception e) {
+            Log.e(Constants.LOG_TAG, "Unable to decode stream",  e);
+        } finally {
+            IoUtils.closeStream(is);
+        }
+        return bm;
+    }
+
+    private void addInBitmapOptions(InputStreamProvider ip, BitmapFactory.Options opts) {
+        // Create InputStream for decoding the bounds
+        final InputStream is = ip.getInputStream();
+        // Decode the bounds so we know what size Bitmap to look for
+        opts.inJustDecodeBounds = true;
+        BitmapFactory.decodeStream(is, null, opts);
+        IoUtils.closeStream(is);
+
+        // Turn off just decoding bounds
+        opts.inJustDecodeBounds = false;
+        // Make sure the decoded file is mutable
+        opts.inMutable = true;
+
+        // Try and find Bitmap to use for inBitmap
+        Bitmap reusableBm = mMemoryCache.getBitmapFromRemoved(opts.outWidth, opts.outHeight);
+        if (reusableBm != null) {
+            if (Constants.DEBUG) {
+                Log.i(Constants.LOG_TAG, "Using inBitmap");
+            }
+            SDK11.addInBitmapOption(opts, reusableBm);
+        }
+    }
+
     /**
      * Builder class for {link {@link BitmapLruCache}. An example call:
      *
@@ -578,7 +630,7 @@ public final static class Builder {
 
         static final int DEFAULT_MEM_CACHE_MAX_SIZE_MB = 3;
 
-        static final RecyclePolicy DEFAULT_RECYCLE_POLICY = RecyclePolicy.ALWAYS;
+        static final RecyclePolicy DEFAULT_RECYCLE_POLICY = RecyclePolicy.PRE_HONEYCOMB_ONLY;
 
         // Only used for Javadoc
         static final float DEFAULT_MEMORY_CACHE_HEAP_PERCENTAGE = DEFAULT_MEMORY_CACHE_HEAP_RATIO
@@ -635,7 +687,7 @@ public BitmapLruCache build() {
                 if (Constants.DEBUG) {
                     Log.d("BitmapLruCache.Builder", "Creating Memory Cache");
                 }
-                cache.setMemoryCache(new BitmapMemoryLruCache(mMemoryCacheMaxSize), mRecyclePolicy);
+                cache.setMemoryCache(new BitmapMemoryLruCache(mMemoryCacheMaxSize, mRecyclePolicy));
             }
 
             if (isValidOptionsForDiskCache()) {
@@ -799,4 +851,47 @@ public void run() {
             }
         }
     }
+
+    interface InputStreamProvider {
+        InputStream getInputStream();
+    }
+
+    static class FileInputStreamProvider implements InputStreamProvider {
+        final File mFile;
+
+        FileInputStreamProvider(File file) {
+            mFile = file;
+        }
+
+        @Override
+        public InputStream getInputStream() {
+            try {
+                return new FileInputStream(mFile);
+            } catch (FileNotFoundException e) {
+                Log.e(Constants.LOG_TAG, "Could not decode file: " + mFile.getAbsolutePath(), e);
+            }
+            return null;
+        }
+    }
+
+    final class SnapshotInputStreamProvider implements InputStreamProvider {
+        final String mKey;
+
+        SnapshotInputStreamProvider(String key) {
+            mKey = key;
+        }
+
+        @Override
+        public InputStream getInputStream() {
+            try {
+                DiskLruCache.Snapshot snapshot = mDiskCache.get(mKey);
+                if (snapshot != null) {
+                    return snapshot.getInputStream(0);
+                }
+            } catch (IOException e) {
+                Log.e(Constants.LOG_TAG, "Could open disk cache for url: " + mKey, e);
+            }
+            return null;
+        }
+    }
 }

library/src/uk/co/senab/bitmapcache/BitmapMemoryLruCache.java

@@ -15,15 +15,28 @@
  ******************************************************************************/
 package uk.co.senab.bitmapcache;
 
+import android.graphics.Bitmap;
 import android.support.v4.util.LruCache;
 
+import java.lang.ref.SoftReference;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
 import java.util.Map.Entry;
 import java.util.Set;
 
 final class BitmapMemoryLruCache extends LruCache<String, CacheableBitmapDrawable> {
 
-    BitmapMemoryLruCache(int maxSize) {
+    private final Set<SoftReference<CacheableBitmapDrawable>> mRemovedEntries;
+    private final BitmapLruCache.RecyclePolicy mRecyclePolicy;
+
+    BitmapMemoryLruCache(int maxSize, BitmapLruCache.RecyclePolicy policy) {
         super(maxSize);
+
+        mRecyclePolicy = policy;
+        mRemovedEntries = policy.canInBitmap()
+                ? Collections.synchronizedSet(new HashSet<SoftReference<CacheableBitmapDrawable>>())
+                : null;
     }
 
     CacheableBitmapDrawable put(CacheableBitmapDrawable value) {
@@ -35,6 +48,10 @@ CacheableBitmapDrawable put(CacheableBitmapDrawable value) {
         return null;
     }
 
+    BitmapLruCache.RecyclePolicy getRecyclePolicy() {
+        return mRecyclePolicy;
+    }
+
     @Override
     protected int sizeOf(String key, CacheableBitmapDrawable value) {
         return value.getMemorySize();
@@ -45,6 +62,41 @@ protected void entryRemoved(boolean evicted, String key, CacheableBitmapDrawable
             CacheableBitmapDrawable newValue) {
         // Notify the wrapper that it's no longer being cached
         oldValue.setCached(false);
+
+        if (mRemovedEntries != null && oldValue.isBitmapValid() && oldValue.isBitmapMutable()) {
+            synchronized (mRemovedEntries) {
+                mRemovedEntries.add(new SoftReference<CacheableBitmapDrawable>(oldValue));
+            }
+        }
+    }
+
+    Bitmap getBitmapFromRemoved(final int width, final int height) {
+        if (mRemovedEntries == null) {
+            return null;
+        }
+
+        Bitmap result = null;
+
+        synchronized (mRemovedEntries) {
+            final Iterator<SoftReference<CacheableBitmapDrawable>> it = mRemovedEntries.iterator();
+
+            while (it.hasNext()) {
+                CacheableBitmapDrawable value = it.next().get();
+
+                if (value != null && value.isBitmapValid() && value.isBitmapMutable()) {
+                    if (value.getIntrinsicWidth() == width
+                            && value.getIntrinsicHeight() == height) {
+                        it.remove();
+                        result = value.getBitmap();
+                        break;
+                    }
+                } else {
+                    it.remove();
+                }
+            }
+        }
+
+        return result;
     }
 
     void trimMemory() {

library/src/uk/co/senab/bitmapcache/CacheableBitmapDrawable.java

@@ -99,11 +99,16 @@ public String getUrl() {
      *
      * @return true - if the bitmap has not been recycled.
      */
-    public synchronized boolean hasValidBitmap() {
+    public synchronized boolean isBitmapValid() {
         Bitmap bitmap = getBitmap();
         return null != bitmap && !bitmap.isRecycled();
     }
 
+    public synchronized boolean isBitmapMutable() {
+        Bitmap bitmap = getBitmap();
+        return null != bitmap && bitmap.isMutable();
+    }
+
     /**
      * @return true - if the bitmap is currently being displayed by a {@link CacheableImageView}.
      */
@@ -194,7 +199,7 @@ private synchronized void checkState(final boolean ignoreBeenDisplayed) {
         cancelCheckStateCallback();
 
         // We're not being referenced or used anywhere
-        if (mCacheCount <= 0 && mDisplayingCount <= 0 && hasValidBitmap()) {
+        if (mCacheCount <= 0 && mDisplayingCount <= 0 && isBitmapValid()) {
 
             /**
              * If we have been displayed or we don't care whether we have

library/src/uk/co/senab/bitmapcache/IoUtils.java

@@ -26,6 +26,26 @@
 
 class IoUtils {
 
+    static void closeStream(InputStream is) {
+        if (is != null) {
+            try {
+                is.close();
+            } catch (IOException e) {
+                Log.i(Constants.LOG_TAG, "Failed to close InputStream", e);
+            }
+        }
+    }
+
+    static void closeStream(OutputStream os) {
+        if (os != null) {
+            try {
+                os.close();
+            } catch (IOException e) {
+                Log.i(Constants.LOG_TAG, "Failed to close OutputStream", e);
+            }
+        }
+    }
+
     static long copy(File in, OutputStream out) throws IOException {
         return copy(new FileInputStream(in), out);
     }
@@ -49,16 +69,8 @@ private static long copy(InputStream input, OutputStream output) throws IOExcept
             output.flush();
             return count;
         } finally {
-            try {
-                input.close();
-            } catch (IOException e) {
-                Log.i(Constants.LOG_TAG, "Failed to close InputStream", e);
-            }
-            try {
-                output.close();
-            } catch (IOException e) {
-                Log.i(Constants.LOG_TAG, "Failed to close OutputStream", e);
-            }
+            IoUtils.closeStream(input);
+            IoUtils.closeStream(output);
         }
     }