src/com/android/messaging/datamodel/BitmapPool.java - platform/packages/apps/Messaging - Git at Google

 /*
  * Copyright (C) 2015 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.messaging.datamodel;

 import android.content.res.Resources;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.support.annotation.NonNull;
 import android.text.TextUtils;
 import android.util.SparseArray;

 import com.android.messaging.datamodel.MemoryCacheManager.MemoryCache;
 import com.android.messaging.util.Assert;
 import com.android.messaging.util.LogUtil;

 import java.io.InputStream;

 /**
  * Class for creating / loading / reusing bitmaps. This class allow the user to create a new bitmap,
  * reuse an bitmap from the pool and to return a bitmap for future reuse.  The pool of bitmaps
  * allows for faster decode and more efficient memory usage.
  * Note: consumers should not create BitmapPool directly, but instead get the pool they want from
  * the BitmapPoolManager.
  */
 public class BitmapPool implements MemoryCache {
     public static final int MAX_SUPPORTED_IMAGE_DIMENSION = 0xFFFF;

     protected static final boolean VERBOSE = false;

     /**
      * Number of reuse failures to skip before reporting.
      */
     private static final int FAILED_REPORTING_FREQUENCY = 100;

     /**
      * Count of reuse failures which have occurred.
      */
     private static volatile int sFailedBitmapReuseCount = 0;

     /**
      * Overall pool data structure which currently only supports rectangular bitmaps. The size of
      * one of the sides is used to index into the SparseArray.
      */
     private final SparseArray<SingleSizePool> mPool;
     private final Object mPoolLock = new Object();
     private final String mPoolName;
     private final int mMaxSize;

     /**
      * Inner structure which holds a pool of bitmaps all the same size (i.e. all have the same
      * width as each other and height as each other, but not necessarily the same).
      */
     private class SingleSizePool {
         int mNumItems;
         final Bitmap[] mBitmaps;

         SingleSizePool(final int maxPoolSize) {
             mNumItems = 0;
             mBitmaps = new Bitmap[maxPoolSize];
         }
     }

     /**
      * Creates a pool of reused bitmaps with helper decode methods which will attempt to use the
      * reclaimed bitmaps. This will help speed up the creation of bitmaps by using already allocated
      * bitmaps.
      * @param maxSize The overall max size of the pool. When the pool exceeds this size, all calls
      * to reclaimBitmap(Bitmap) will result in recycling the bitmap.
      * @param name Name of the bitmap pool and only used for logging. Can not be null.
      */
     BitmapPool(final int maxSize, @NonNull final String name) {
         Assert.isTrue(maxSize > 0);
         Assert.isTrue(!TextUtils.isEmpty(name));
         mPoolName = name;
         mMaxSize = maxSize;
         mPool = new SparseArray<SingleSizePool>();
     }

     @Override
     public void reclaim() {
         synchronized (mPoolLock) {
             for (int p = 0; p < mPool.size(); p++) {
                 final SingleSizePool singleSizePool = mPool.valueAt(p);
                 for (int i = 0; i < singleSizePool.mNumItems; i++) {
                     singleSizePool.mBitmaps[i].recycle();
                     singleSizePool.mBitmaps[i] = null;
                 }
                 singleSizePool.mNumItems = 0;
             }
             mPool.clear();
         }
     }

     /**
      * Creates a new BitmapFactory.Options.
      */
     public static BitmapFactory.Options getBitmapOptionsForPool(final boolean scaled,
             final int inputDensity, final int targetDensity) {
         final BitmapFactory.Options options = new BitmapFactory.Options();
         options.inScaled = scaled;
         options.inDensity = inputDensity;
         options.inTargetDensity = targetDensity;
         options.inSampleSize = 1;
         options.inJustDecodeBounds = false;
         options.inMutable = true;
         return options;
     }

     /**
      * @return The pool key for the provided image dimensions or 0 if either width or height is
      * greater than the max supported image dimension.
      */
     private int getPoolKey(final int width, final int height) {
         if (width > MAX_SUPPORTED_IMAGE_DIMENSION || height > MAX_SUPPORTED_IMAGE_DIMENSION) {
             return 0;
         }
         return (width << 16) | height;
     }

     /**
      *
      * @return A bitmap in the pool with the specified dimensions or null if no bitmap with the
      * specified dimension is available.
      */
     private Bitmap findPoolBitmap(final int width, final int height) {
         final int poolKey = getPoolKey(width, height);
         if (poolKey != 0) {
             synchronized (mPoolLock) {
                 // Take a bitmap from the pool if one is available
                 final SingleSizePool singlePool = mPool.get(poolKey);
                 if (singlePool != null && singlePool.mNumItems > 0) {
                     singlePool.mNumItems--;
                     final Bitmap foundBitmap = singlePool.mBitmaps[singlePool.mNumItems];
                     singlePool.mBitmaps[singlePool.mNumItems] = null;
                     return foundBitmap;
                 }
             }
         }
         return null;
     }

     /**
      * Internal function to try and find a bitmap in the pool which matches the desired width and
      * height and then set that in the bitmap options properly.
      *
      * TODO: Why do we take a width/height? Shouldn't this already be in the
      * BitmapFactory.Options instance? Can we assert that they match?
      * @param optionsTmp The BitmapFactory.Options to update with the bitmap for the system to try
      * to reuse.
      * @param width The width of the reusable bitmap.
      * @param height The height of the reusable bitmap.
      */
     private void assignPoolBitmap(final BitmapFactory.Options optionsTmp, final int width,
             final int height) {
         if (optionsTmp.inJustDecodeBounds) {
             return;
         }
         optionsTmp.inBitmap = findPoolBitmap(width, height);
     }

     /**
      * Load a resource into a bitmap. Uses a bitmap from the pool if possible to reduce memory
      * turnover.
      * @param resourceId Resource id to load.
      * @param resources Application resources. Cannot be null.
      * @param optionsTmp Should be the same options returned from getBitmapOptionsForPool(). Cannot
      * be null.
      * @param width The width of the bitmap.
      * @param height The height of the bitmap.
      * @return The decoded Bitmap with the resource drawn in it.
      */
     public Bitmap decodeSampledBitmapFromResource(final int resourceId,
             @NonNull final Resources resources, @NonNull final BitmapFactory.Options optionsTmp,
             final int width, final int height) {
         Assert.notNull(resources);
         Assert.notNull(optionsTmp);
         Assert.isTrue(width > 0);
         Assert.isTrue(height > 0);
         assignPoolBitmap(optionsTmp, width, height);
         Bitmap b = null;
         try {
             b = BitmapFactory.decodeResource(resources, resourceId, optionsTmp);
         } catch (final IllegalArgumentException e) {
             // BitmapFactory couldn't decode the file, try again without an inputBufferBitmap.
             if (optionsTmp.inBitmap != null) {
                 optionsTmp.inBitmap = null;
                 b = BitmapFactory.decodeResource(resources, resourceId, optionsTmp);
                 sFailedBitmapReuseCount++;
                 if (sFailedBitmapReuseCount % FAILED_REPORTING_FREQUENCY == 0) {
                     LogUtil.w(LogUtil.BUGLE_TAG,
                             "Pooled bitmap consistently not being reused count = " +
                             sFailedBitmapReuseCount);
                 }
             }
         } catch (final OutOfMemoryError e) {
             LogUtil.w(LogUtil.BUGLE_TAG, "Oom decoding resource " + resourceId);
             reclaim();
         }
         return b;
     }

     /**
      * Load an input stream into a bitmap. Uses a bitmap from the pool if possible to reduce memory
      * turnover.
      * @param inputStream InputStream load. Cannot be null.
      * @param optionsTmp Should be the same options returned from getBitmapOptionsForPool(). Cannot
      * be null.
      * @param width The width of the bitmap.
      * @param height The height of the bitmap.
      * @return The decoded Bitmap with the resource drawn in it.
      */
     public Bitmap decodeSampledBitmapFromInputStream(@NonNull final InputStream inputStream,
             @NonNull final BitmapFactory.Options optionsTmp,
             final int width, final int height) {
         Assert.notNull(inputStream);
         Assert.isTrue(width > 0);
         Assert.isTrue(height > 0);
         assignPoolBitmap(optionsTmp, width, height);
         Bitmap b = null;
         try {
             b = BitmapFactory.decodeStream(inputStream, null, optionsTmp);
         } catch (final IllegalArgumentException e) {
             // BitmapFactory couldn't decode the file, try again without an inputBufferBitmap.
             if (optionsTmp.inBitmap != null) {
                 optionsTmp.inBitmap = null;
                 b = BitmapFactory.decodeStream(inputStream, null, optionsTmp);
                 sFailedBitmapReuseCount++;
                 if (sFailedBitmapReuseCount % FAILED_REPORTING_FREQUENCY == 0) {
                     LogUtil.w(LogUtil.BUGLE_TAG,
                             "Pooled bitmap consistently not being reused count = " +
                             sFailedBitmapReuseCount);
                 }
             }
         } catch (final OutOfMemoryError e) {
             LogUtil.w(LogUtil.BUGLE_TAG, "Oom decoding inputStream");
             reclaim();
         }
         return b;
     }

     /**
      * Turn encoded bytes into a bitmap. Uses a bitmap from the pool if possible to reduce memory
      * turnover.
      * @param bytes Encoded bytes to draw on the bitmap. Cannot be null.
      * @param optionsTmp The bitmap will set here and the input should be generated from
      * getBitmapOptionsForPool(). Cannot be null.
      * @param width The width of the bitmap.
      * @param height The height of the bitmap.
      * @return A Bitmap with the encoded bytes drawn in it.
      */
     public Bitmap decodeByteArray(@NonNull final byte[] bytes,
             @NonNull final BitmapFactory.Options optionsTmp, final int width,
             final int height) throws OutOfMemoryError {
         Assert.notNull(bytes);
         Assert.notNull(optionsTmp);
         Assert.isTrue(width > 0);
         Assert.isTrue(height > 0);
         assignPoolBitmap(optionsTmp, width, height);
         Bitmap b = null;
         try {
             b = BitmapFactory.decodeByteArray(bytes, 0, bytes.length, optionsTmp);
         } catch (final IllegalArgumentException e) {
             if (VERBOSE) {
                 LogUtil.v(LogUtil.BUGLE_TAG, "BitmapPool(" + mPoolName +
                         ") Unable to use pool bitmap");
             }
             // BitmapFactory couldn't decode the file, try again without an inputBufferBitmap.
             // (i.e. without the bitmap from the pool)
             if (optionsTmp.inBitmap != null) {
                 optionsTmp.inBitmap = null;
                 b = BitmapFactory.decodeByteArray(bytes, 0, bytes.length, optionsTmp);
                 sFailedBitmapReuseCount++;
                 if (sFailedBitmapReuseCount % FAILED_REPORTING_FREQUENCY == 0) {
                     LogUtil.w(LogUtil.BUGLE_TAG,
                             "Pooled bitmap consistently not being reused count = " +
                             sFailedBitmapReuseCount);
                 }
             }
         }
         return b;
     }

     /**
      * Creates a bitmap with the given size, this will reuse a bitmap in the pool, if one is
      * available, otherwise this will create a new one.
      * @param width The desired width of the bitmap.
      * @param height The desired height of the bitmap.
      * @return A bitmap with the desired width and height, this maybe a reused bitmap from the pool.
      */
     public Bitmap createOrReuseBitmap(final int width, final int height) {
         Bitmap b = findPoolBitmap(width, height);
         if (b == null) {
             b = createBitmap(width, height);
         }
         return b;
     }

     /**
      * This will create a new bitmap regardless of pool state.
      * @param width The desired width of the bitmap.
      * @param height The desired height of the bitmap.
      * @return A bitmap with the desired width and height.
      */
     private Bitmap createBitmap(final int width, final int height) {
         return Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
     }

     /**
      * Called when a bitmap is finished being used so that it can be used for another bitmap in the
      * future or recycled. Any bitmaps returned should not be used by the caller again.
      * @param b The bitmap to return to the pool for future usage or recycled. This cannot be null.
      */
     public void reclaimBitmap(@NonNull final Bitmap b) {
         Assert.notNull(b);
         final int poolKey = getPoolKey(b.getWidth(), b.getHeight());
         if (poolKey == 0 || !b.isMutable()) {
             // Unsupported image dimensions or a immutable bitmap.
             b.recycle();
             return;
         }
         synchronized (mPoolLock) {
             SingleSizePool singleSizePool = mPool.get(poolKey);
             if (singleSizePool == null) {
                 singleSizePool = new SingleSizePool(mMaxSize);
                 mPool.append(poolKey, singleSizePool);
             }
             if (singleSizePool.mNumItems < singleSizePool.mBitmaps.length) {
                 singleSizePool.mBitmaps[singleSizePool.mNumItems] = b;
                 singleSizePool.mNumItems++;
             } else {
                 b.recycle();
             }
         }
     }

     /**
      * @return whether the pool is full for a given width and height.
      */
     public boolean isFull(final int width, final int height) {
         final int poolKey = getPoolKey(width, height);
         synchronized (mPoolLock) {
             final SingleSizePool singleSizePool = mPool.get(poolKey);
             if (singleSizePool != null &&
                     singleSizePool.mNumItems >= singleSizePool.mBitmaps.length) {
                 return true;
             }
             return false;
         }
     }
 }
	/*
	* Copyright (C) 2015 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.messaging.datamodel;

	import android.content.res.Resources;
	import android.graphics.Bitmap;
	import android.graphics.BitmapFactory;
	import android.support.annotation.NonNull;
	import android.text.TextUtils;
	import android.util.SparseArray;

	import com.android.messaging.datamodel.MemoryCacheManager.MemoryCache;
	import com.android.messaging.util.Assert;
	import com.android.messaging.util.LogUtil;

	import java.io.InputStream;

	/**
	* Class for creating / loading / reusing bitmaps. This class allow the user to create a new bitmap,
	* reuse an bitmap from the pool and to return a bitmap for future reuse. The pool of bitmaps
	* allows for faster decode and more efficient memory usage.
	* Note: consumers should not create BitmapPool directly, but instead get the pool they want from
	* the BitmapPoolManager.
	*/
	public class BitmapPool implements MemoryCache {
	public static final int MAX_SUPPORTED_IMAGE_DIMENSION = 0xFFFF;

	protected static final boolean VERBOSE = false;

	/**
	* Number of reuse failures to skip before reporting.
	*/
	private static final int FAILED_REPORTING_FREQUENCY = 100;

	/**
	* Count of reuse failures which have occurred.
	*/
	private static volatile int sFailedBitmapReuseCount = 0;

	/**
	* Overall pool data structure which currently only supports rectangular bitmaps. The size of
	* one of the sides is used to index into the SparseArray.
	*/
	private final SparseArray<SingleSizePool> mPool;
	private final Object mPoolLock = new Object();
	private final String mPoolName;
	private final int mMaxSize;

	/**
	* Inner structure which holds a pool of bitmaps all the same size (i.e. all have the same
	* width as each other and height as each other, but not necessarily the same).
	*/
	private class SingleSizePool {
	int mNumItems;
	final Bitmap[] mBitmaps;

	SingleSizePool(final int maxPoolSize) {
	mNumItems = 0;
	mBitmaps = new Bitmap[maxPoolSize];
	}
	}

	/**
	* Creates a pool of reused bitmaps with helper decode methods which will attempt to use the
	* reclaimed bitmaps. This will help speed up the creation of bitmaps by using already allocated
	* bitmaps.
	* @param maxSize The overall max size of the pool. When the pool exceeds this size, all calls
	* to reclaimBitmap(Bitmap) will result in recycling the bitmap.
	* @param name Name of the bitmap pool and only used for logging. Can not be null.
	*/
	BitmapPool(final int maxSize, @NonNull final String name) {
	Assert.isTrue(maxSize > 0);
	Assert.isTrue(!TextUtils.isEmpty(name));
	mPoolName = name;
	mMaxSize = maxSize;
	mPool = new SparseArray<SingleSizePool>();
	}

	@Override
	public void reclaim() {
	synchronized (mPoolLock) {
	for (int p = 0; p < mPool.size(); p++) {
	final SingleSizePool singleSizePool = mPool.valueAt(p);
	for (int i = 0; i < singleSizePool.mNumItems; i++) {
	singleSizePool.mBitmaps[i].recycle();
	singleSizePool.mBitmaps[i] = null;
	}
	singleSizePool.mNumItems = 0;
	}
	mPool.clear();
	}
	}

	/**
	* Creates a new BitmapFactory.Options.
	*/
	public static BitmapFactory.Options getBitmapOptionsForPool(final boolean scaled,
	final int inputDensity, final int targetDensity) {
	final BitmapFactory.Options options = new BitmapFactory.Options();
	options.inScaled = scaled;
	options.inDensity = inputDensity;
	options.inTargetDensity = targetDensity;
	options.inSampleSize = 1;
	options.inJustDecodeBounds = false;
	options.inMutable = true;
	return options;
	}

	/**
	* @return The pool key for the provided image dimensions or 0 if either width or height is
	* greater than the max supported image dimension.
	*/
	private int getPoolKey(final int width, final int height) {
	if (width > MAX_SUPPORTED_IMAGE_DIMENSION \|\| height > MAX_SUPPORTED_IMAGE_DIMENSION) {
	return 0;
	}
	return (width << 16) \| height;
	}

	/**
	*
	* @return A bitmap in the pool with the specified dimensions or null if no bitmap with the
	* specified dimension is available.
	*/
	private Bitmap findPoolBitmap(final int width, final int height) {
	final int poolKey = getPoolKey(width, height);
	if (poolKey != 0) {
	synchronized (mPoolLock) {
	// Take a bitmap from the pool if one is available
	final SingleSizePool singlePool = mPool.get(poolKey);
	if (singlePool != null && singlePool.mNumItems > 0) {
	singlePool.mNumItems--;
	final Bitmap foundBitmap = singlePool.mBitmaps[singlePool.mNumItems];
	singlePool.mBitmaps[singlePool.mNumItems] = null;
	return foundBitmap;
	}
	}
	}
	return null;
	}

	/**
	* Internal function to try and find a bitmap in the pool which matches the desired width and
	* height and then set that in the bitmap options properly.
	*
	* TODO: Why do we take a width/height? Shouldn't this already be in the
	* BitmapFactory.Options instance? Can we assert that they match?
	* @param optionsTmp The BitmapFactory.Options to update with the bitmap for the system to try
	* to reuse.
	* @param width The width of the reusable bitmap.
	* @param height The height of the reusable bitmap.
	*/
	private void assignPoolBitmap(final BitmapFactory.Options optionsTmp, final int width,
	final int height) {
	if (optionsTmp.inJustDecodeBounds) {
	return;
	}
	optionsTmp.inBitmap = findPoolBitmap(width, height);
	}

	/**
	* Load a resource into a bitmap. Uses a bitmap from the pool if possible to reduce memory
	* turnover.
	* @param resourceId Resource id to load.
	* @param resources Application resources. Cannot be null.
	* @param optionsTmp Should be the same options returned from getBitmapOptionsForPool(). Cannot
	* be null.
	* @param width The width of the bitmap.
	* @param height The height of the bitmap.
	* @return The decoded Bitmap with the resource drawn in it.
	*/
	public Bitmap decodeSampledBitmapFromResource(final int resourceId,
	@NonNull final Resources resources, @NonNull final BitmapFactory.Options optionsTmp,
	final int width, final int height) {
	Assert.notNull(resources);
	Assert.notNull(optionsTmp);
	Assert.isTrue(width > 0);
	Assert.isTrue(height > 0);
	assignPoolBitmap(optionsTmp, width, height);
	Bitmap b = null;
	try {
	b = BitmapFactory.decodeResource(resources, resourceId, optionsTmp);
	} catch (final IllegalArgumentException e) {
	// BitmapFactory couldn't decode the file, try again without an inputBufferBitmap.
	if (optionsTmp.inBitmap != null) {
	optionsTmp.inBitmap = null;
	b = BitmapFactory.decodeResource(resources, resourceId, optionsTmp);
	sFailedBitmapReuseCount++;
	if (sFailedBitmapReuseCount % FAILED_REPORTING_FREQUENCY == 0) {
	LogUtil.w(LogUtil.BUGLE_TAG,
	"Pooled bitmap consistently not being reused count = " +
	sFailedBitmapReuseCount);
	}
	}
	} catch (final OutOfMemoryError e) {
	LogUtil.w(LogUtil.BUGLE_TAG, "Oom decoding resource " + resourceId);
	reclaim();
	}
	return b;
	}

	/**
	* Load an input stream into a bitmap. Uses a bitmap from the pool if possible to reduce memory
	* turnover.
	* @param inputStream InputStream load. Cannot be null.
	* @param optionsTmp Should be the same options returned from getBitmapOptionsForPool(). Cannot
	* be null.
	* @param width The width of the bitmap.
	* @param height The height of the bitmap.
	* @return The decoded Bitmap with the resource drawn in it.
	*/
	public Bitmap decodeSampledBitmapFromInputStream(@NonNull final InputStream inputStream,
	@NonNull final BitmapFactory.Options optionsTmp,
	final int width, final int height) {
	Assert.notNull(inputStream);
	Assert.isTrue(width > 0);
	Assert.isTrue(height > 0);
	assignPoolBitmap(optionsTmp, width, height);
	Bitmap b = null;
	try {
	b = BitmapFactory.decodeStream(inputStream, null, optionsTmp);
	} catch (final IllegalArgumentException e) {
	// BitmapFactory couldn't decode the file, try again without an inputBufferBitmap.
	if (optionsTmp.inBitmap != null) {
	optionsTmp.inBitmap = null;
	b = BitmapFactory.decodeStream(inputStream, null, optionsTmp);
	sFailedBitmapReuseCount++;
	if (sFailedBitmapReuseCount % FAILED_REPORTING_FREQUENCY == 0) {
	LogUtil.w(LogUtil.BUGLE_TAG,
	"Pooled bitmap consistently not being reused count = " +
	sFailedBitmapReuseCount);
	}
	}
	} catch (final OutOfMemoryError e) {
	LogUtil.w(LogUtil.BUGLE_TAG, "Oom decoding inputStream");
	reclaim();
	}
	return b;
	}

	/**
	* Turn encoded bytes into a bitmap. Uses a bitmap from the pool if possible to reduce memory
	* turnover.
	* @param bytes Encoded bytes to draw on the bitmap. Cannot be null.
	* @param optionsTmp The bitmap will set here and the input should be generated from
	* getBitmapOptionsForPool(). Cannot be null.
	* @param width The width of the bitmap.
	* @param height The height of the bitmap.
	* @return A Bitmap with the encoded bytes drawn in it.
	*/
	public Bitmap decodeByteArray(@NonNull final byte[] bytes,
	@NonNull final BitmapFactory.Options optionsTmp, final int width,
	final int height) throws OutOfMemoryError {
	Assert.notNull(bytes);
	Assert.notNull(optionsTmp);
	Assert.isTrue(width > 0);
	Assert.isTrue(height > 0);
	assignPoolBitmap(optionsTmp, width, height);
	Bitmap b = null;
	try {
	b = BitmapFactory.decodeByteArray(bytes, 0, bytes.length, optionsTmp);
	} catch (final IllegalArgumentException e) {
	if (VERBOSE) {
	LogUtil.v(LogUtil.BUGLE_TAG, "BitmapPool(" + mPoolName +
	") Unable to use pool bitmap");
	}
	// BitmapFactory couldn't decode the file, try again without an inputBufferBitmap.
	// (i.e. without the bitmap from the pool)
	if (optionsTmp.inBitmap != null) {
	optionsTmp.inBitmap = null;
	b = BitmapFactory.decodeByteArray(bytes, 0, bytes.length, optionsTmp);
	sFailedBitmapReuseCount++;
	if (sFailedBitmapReuseCount % FAILED_REPORTING_FREQUENCY == 0) {
	LogUtil.w(LogUtil.BUGLE_TAG,
	"Pooled bitmap consistently not being reused count = " +
	sFailedBitmapReuseCount);
	}
	}
	}
	return b;
	}

	/**
	* Creates a bitmap with the given size, this will reuse a bitmap in the pool, if one is
	* available, otherwise this will create a new one.
	* @param width The desired width of the bitmap.
	* @param height The desired height of the bitmap.
	* @return A bitmap with the desired width and height, this maybe a reused bitmap from the pool.
	*/
	public Bitmap createOrReuseBitmap(final int width, final int height) {
	Bitmap b = findPoolBitmap(width, height);
	if (b == null) {
	b = createBitmap(width, height);
	}
	return b;
	}

	/**
	* This will create a new bitmap regardless of pool state.
	* @param width The desired width of the bitmap.
	* @param height The desired height of the bitmap.
	* @return A bitmap with the desired width and height.
	*/
	private Bitmap createBitmap(final int width, final int height) {
	return Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
	}

	/**
	* Called when a bitmap is finished being used so that it can be used for another bitmap in the
	* future or recycled. Any bitmaps returned should not be used by the caller again.
	* @param b The bitmap to return to the pool for future usage or recycled. This cannot be null.
	*/
	public void reclaimBitmap(@NonNull final Bitmap b) {
	Assert.notNull(b);
	final int poolKey = getPoolKey(b.getWidth(), b.getHeight());
	if (poolKey == 0 \|\| !b.isMutable()) {
	// Unsupported image dimensions or a immutable bitmap.
	b.recycle();
	return;
	}
	synchronized (mPoolLock) {
	SingleSizePool singleSizePool = mPool.get(poolKey);
	if (singleSizePool == null) {
	singleSizePool = new SingleSizePool(mMaxSize);
	mPool.append(poolKey, singleSizePool);
	}
	if (singleSizePool.mNumItems < singleSizePool.mBitmaps.length) {
	singleSizePool.mBitmaps[singleSizePool.mNumItems] = b;
	singleSizePool.mNumItems++;
	} else {
	b.recycle();
	}
	}
	}

	/**
	* @return whether the pool is full for a given width and height.
	*/
	public boolean isFull(final int width, final int height) {
	final int poolKey = getPoolKey(width, height);
	synchronized (mPoolLock) {
	final SingleSizePool singleSizePool = mPool.get(poolKey);
	if (singleSizePool != null &&
	singleSizePool.mNumItems >= singleSizePool.mBitmaps.length) {
	return true;
	}
	return false;
	}
	}
	}