3 small updates:

Adam Koch · Adam Koch · commit a8a37f86ce0e · 2013-01-28T12:39:05.000-05:00
Update inSampleSize calculation - while this didn't affect iosched the existing
formula would calculate the wrong value in some cases.

Unpause the image loader when the activity/fragment is paused - the image loader
is paused while flinging the social stream fragment, however if the activity is
destroyed while the image loader is paused this can leave the background thread
in a hung state.

Change available app memory calculation from memory class to available runtime
memory - used to set the image memory cache size.
diff --git a/android/src/com/google/android/apps/iosched/ui/SocialStreamFragment.java b/android/src/com/google/android/apps/iosched/ui/SocialStreamFragment.java
@@ -165,6 +165,7 @@ public void onViewCreated(View view, Bundle savedInstanceState) {
     @Override
     public void onPause() {
         super.onPause();
+        mImageFetcher.setPauseWork(false);
         mImageFetcher.flushCache();
     }
 
diff --git a/android/src/com/google/android/apps/iosched/util/ImageCache.java b/android/src/com/google/android/apps/iosched/util/ImageCache.java
@@ -129,12 +129,13 @@ private void init(ImageCacheParams cacheParams) {
             LOGD(TAG, "Memory cache created (size = " + mCacheParams.memCacheSize + ")");
             mMemoryCache = new LruCache<String, Bitmap>(mCacheParams.memCacheSize) {
                 /**
-                 * Measure item size in bytes rather than units which is more practical
+                 * Measure item size in kilobytes rather than units which is more practical
                  * for a bitmap cache
                  */
                 @Override
                 protected int sizeOf(String key, Bitmap bitmap) {
-                    return getBitmapSize(bitmap);
+                    final int bitmapSize = getBitmapSize(bitmap) / 1024;
+                    return bitmapSize == 0 ? 1 : bitmapSize;
                 }
             };
         }
@@ -362,40 +363,41 @@ public static class ImageCacheParams {
         public boolean initDiskCacheOnCreate = DEFAULT_INIT_DISK_CACHE_ON_CREATE;
 
         public ImageCacheParams(Context context) {
-            init(context, getDiskCacheDir(context, DEFAULT_DISK_CACHE_DIR));
+            init(getDiskCacheDir(context, DEFAULT_DISK_CACHE_DIR));
         }
 
         public ImageCacheParams(Context context, String uniqueName) {
-            init(context, getDiskCacheDir(context, uniqueName));
+            init(getDiskCacheDir(context, uniqueName));
         }
 
-        public ImageCacheParams(Context context, File diskCacheDir) {
-            init(context, diskCacheDir);
+        public ImageCacheParams(File diskCacheDir) {
+            init(diskCacheDir);
         }
 
-        private void init(Context context, File diskCacheDir) {
-            setMemCacheSizePercent(context, DEFAULT_MEM_CACHE_PERCENT);
+        private void init(File diskCacheDir) {
+            setMemCacheSizePercent(DEFAULT_MEM_CACHE_PERCENT);
             this.diskCacheDir = diskCacheDir;
         }
 
         /**
-         * Sets the memory cache size based on a percentage of the device memory class.
-         * Eg. setting percent to 0.2 would set the memory cache to one fifth of the device memory
-         * class. Throws {@link IllegalArgumentException} if percent is < 0.05 or > .8.
+         * Sets the memory cache size based on a percentage of the max available VM memory.
+         * Eg. setting percent to 0.2 would set the memory cache to one fifth of the avilable
+         * memory. Throws {@link IllegalArgumentException} if percent is < 0.05 or > .8.
+         * memCacheSize is stored in kilobytes instead of bytes as this will eventually be passed
+         * to construct a LruCache which takes an int in its constructor.
          *
          * This value should be chosen carefully based on a number of factors
          * Refer to the corresponding Android Training class for more discussion:
          * http://developer.android.com/training/displaying-bitmaps/
          *
-         * @param context Context to use to fetch memory class
          * @param percent Percent of memory class to use to size memory cache
          */
-        public void setMemCacheSizePercent(Context context, float percent) {
+        public void setMemCacheSizePercent(float percent) {
             if (percent < 0.05f || percent > 0.8f) {
                 throw new IllegalArgumentException("setMemCacheSizePercent - percent must be "
                         + "between 0.05 and 0.8 (inclusive)");
             }
-            memCacheSize = Math.round(percent * getMemoryClass(context) * 1024 * 1024);
+            memCacheSize = Math.round(percent * Runtime.getRuntime().maxMemory() / 1024);
         }
 
         private static int getMemoryClass(Context context) {
diff --git a/android/src/com/google/android/apps/iosched/util/ImageFetcher.java b/android/src/com/google/android/apps/iosched/util/ImageFetcher.java
@@ -456,11 +456,14 @@ public static int calculateInSampleSize(BitmapFactory.Options options,
         int inSampleSize = 1;
 
         if (height > reqHeight || width > reqWidth) {
-            if (width > height) {
-                inSampleSize = Math.round((float) height / (float) reqHeight);
-            } else {
-                inSampleSize = Math.round((float) width / (float) reqWidth);
-            }
+            // Calculate ratios of height and width to requested height and width
+            final int heightRatio = Math.round((float) height / (float) reqHeight);
+            final int widthRatio = Math.round((float) width / (float) reqWidth);
+
+            // Choose the smallest ratio as inSampleSize value, this will guarantee
+            // a final image with both dimensions larger than or equal to the
+            // requested height and width.
+            inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
 
             // This offers some additional logic in case the image has a strange
             // aspect ratio. For example, a panorama may have a much larger
diff --git a/android/src/com/google/android/apps/iosched/util/ImageWorker.java b/android/src/com/google/android/apps/iosched/util/ImageWorker.java
@@ -229,6 +229,7 @@ public void setImageFadeIn(boolean fadeIn) {
      */
     public void setExitTasksEarly(boolean exitTasksEarly) {
         mExitTasksEarly = exitTasksEarly;
+        setPauseWork(false);
     }
 
     /**
@@ -439,6 +440,18 @@ private void setImageBitmap(ImageView imageView, Bitmap bitmap) {
         }
     }
 
+    /**
+     * Pause any ongoing background work. This can be used as a temporary
+     * measure to improve performance. For example background work could
+     * be paused when a ListView or GridView is being scrolled using a
+     * {@link android.widget.AbsListView.OnScrollListener} to keep
+     * scrolling smooth.
+     * <p>
+     * If work is paused, be sure setPauseWork(false) is called again
+     * before your fragment or activity is destroyed (for example during
+     * {@link android.app.Activity#onPause()}), or there is a risk the
+     * background thread will never finish.
+     */
     public void setPauseWork(boolean pauseWork) {
         synchronized (mPauseWorkLock) {
             mPauseWork = pauseWork;

Original file line number	Diff line number	Diff line change
`@@ -165,6 +165,7 @@ public void onViewCreated(View view, Bundle savedInstanceState) {`
`165`	`165`	`@Override`
`166`	`166`	`public void onPause() {`
`167`	`167`	`super.onPause();`
	`168`	`+ mImageFetcher.setPauseWork(false);`
`168`	`169`	`mImageFetcher.flushCache();`
`169`	`170`	`}`
`170`	`171`