1 /* 2 * Copyright (C) 2012 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.example.android.displayingbitmaps.util; 18 19 import android.annotation.TargetApi; 20 import android.content.Context; 21 import android.content.res.Resources; 22 import android.graphics.Bitmap; 23 import android.graphics.BitmapFactory; 24 import android.os.Build; 25 26 import com.example.android.common.logger.Log; 27 import com.example.android.displayingbitmaps.BuildConfig; 28 29 import java.io.FileDescriptor; 30 31 /** 32 * A simple subclass of {@link ImageWorker} that resizes images from resources given a target width 33 * and height. Useful for when the input images might be too large to simply load directly into 34 * memory. 35 */ 36 public class ImageResizer extends ImageWorker { 37 private static final String TAG = "ImageResizer"; 38 protected int mImageWidth; 39 protected int mImageHeight; 40 41 /** 42 * Initialize providing a single target image size (used for both width and height); 43 * 44 * @param context 45 * @param imageWidth 46 * @param imageHeight 47 */ 48 public ImageResizer(Context context, int imageWidth, int imageHeight) { 49 super(context); 50 setImageSize(imageWidth, imageHeight); 51 } 52 53 /** 54 * Initialize providing a single target image size (used for both width and height); 55 * 56 * @param context 57 * @param imageSize 58 */ 59 public ImageResizer(Context context, int imageSize) { 60 super(context); 61 setImageSize(imageSize); 62 } 63 64 /** 65 * Set the target image width and height. 66 * 67 * @param width 68 * @param height 69 */ 70 public void setImageSize(int width, int height) { 71 mImageWidth = width; 72 mImageHeight = height; 73 } 74 75 /** 76 * Set the target image size (width and height will be the same). 77 * 78 * @param size 79 */ 80 public void setImageSize(int size) { 81 setImageSize(size, size); 82 } 83 84 /** 85 * The main processing method. This happens in a background task. In this case we are just 86 * sampling down the bitmap and returning it from a resource. 87 * 88 * @param resId 89 * @return 90 */ 91 private Bitmap processBitmap(int resId) { 92 if (BuildConfig.DEBUG) { 93 Log.d(TAG, "processBitmap - " + resId); 94 } 95 return decodeSampledBitmapFromResource(mResources, resId, mImageWidth, 96 mImageHeight, getImageCache()); 97 } 98 99 @Override 100 protected Bitmap processBitmap(Object data) { 101 return processBitmap(Integer.parseInt(String.valueOf(data))); 102 } 103 104 /** 105 * Decode and sample down a bitmap from resources to the requested width and height. 106 * 107 * @param res The resources object containing the image data 108 * @param resId The resource id of the image data 109 * @param reqWidth The requested width of the resulting bitmap 110 * @param reqHeight The requested height of the resulting bitmap 111 * @param cache The ImageCache used to find candidate bitmaps for use with inBitmap 112 * @return A bitmap sampled down from the original with the same aspect ratio and dimensions 113 * that are equal to or greater than the requested width and height 114 */ 115 public static Bitmap decodeSampledBitmapFromResource(Resources res, int resId, 116 int reqWidth, int reqHeight, ImageCache cache) { 117 119 // First decode with inJustDecodeBounds=true to check dimensions 120 final BitmapFactory.Options options = new BitmapFactory.Options(); 121 options.inJustDecodeBounds = true; 122 BitmapFactory.decodeResource(res, resId, options); 123 124 // Calculate inSampleSize 125 options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight); 127 128 // If we're running on Honeycomb or newer, try to use inBitmap 129 if (Utils.hasHoneycomb()) { 130 addInBitmapOptions(options, cache); 131 } 132 133 // Decode bitmap with inSampleSize set 134 options.inJustDecodeBounds = false; 135 return BitmapFactory.decodeResource(res, resId, options); 136 } 137 138 /** 139 * Decode and sample down a bitmap from a file to the requested width and height. 140 * 141 * @param filename The full path of the file to decode 142 * @param reqWidth The requested width of the resulting bitmap 143 * @param reqHeight The requested height of the resulting bitmap 144 * @param cache The ImageCache used to find candidate bitmaps for use with inBitmap 145 * @return A bitmap sampled down from the original with the same aspect ratio and dimensions 146 * that are equal to or greater than the requested width and height 147 */ 148 public static Bitmap decodeSampledBitmapFromFile(String filename, 149 int reqWidth, int reqHeight, ImageCache cache) { 150 151 // First decode with inJustDecodeBounds=true to check dimensions 152 final BitmapFactory.Options options = new BitmapFactory.Options(); 153 options.inJustDecodeBounds = true; 154 BitmapFactory.decodeFile(filename, options); 155 156 // Calculate inSampleSize 157 options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight); 158 159 // If we're running on Honeycomb or newer, try to use inBitmap 160 if (Utils.hasHoneycomb()) { 161 addInBitmapOptions(options, cache); 162 } 163 164 // Decode bitmap with inSampleSize set 165 options.inJustDecodeBounds = false; 166 return BitmapFactory.decodeFile(filename, options); 167 } 168 169 /** 170 * Decode and sample down a bitmap from a file input stream to the requested width and height. 171 * 172 * @param fileDescriptor The file descriptor to read from 173 * @param reqWidth The requested width of the resulting bitmap 174 * @param reqHeight The requested height of the resulting bitmap 175 * @param cache The ImageCache used to find candidate bitmaps for use with inBitmap 176 * @return A bitmap sampled down from the original with the same aspect ratio and dimensions 177 * that are equal to or greater than the requested width and height 178 */ 179 public static Bitmap decodeSampledBitmapFromDescriptor( 180 FileDescriptor fileDescriptor, int reqWidth, int reqHeight, ImageCache cache) { 181 182 // First decode with inJustDecodeBounds=true to check dimensions 183 final BitmapFactory.Options options = new BitmapFactory.Options(); 184 options.inJustDecodeBounds = true; 185 BitmapFactory.decodeFileDescriptor(fileDescriptor, null, options); 186 187 // Calculate inSampleSize 188 options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight); 189 190 // Decode bitmap with inSampleSize set 191 options.inJustDecodeBounds = false ; 192 193 // If we're running on Honeycomb or newer, try to use inBitmap 194 if (Utils.hasHoneycomb()) { 195 addInBitmapOptions(options, cache); 196 } 197 198 return BitmapFactory.decodeFileDescriptor(fileDescriptor, null, options); 199 } 200 201 @TargetApi(Build.VERSION_CODES.HONEYCOMB) 202 private static void addInBitmapOptions(BitmapFactory.Options options, ImageCache cache) { 204 // inBitmap only works with mutable bitmaps so force the decoder to 205 // return mutable bitmaps. 206 options.inMutable = true; 207 208 if (cache != null) { 209 // Try and find a bitmap to use for inBitmap 210 Bitmap inBitmap = cache.getBitmapFromReusableSet(options); 211 212 if (inBitmap != null) { 213 options.inBitmap = inBitmap; 214 } 215 } 217 } 218 219 /** 220 * Calculate an inSampleSize for use in a {@link android.graphics.BitmapFactory.Options} object when decoding 221 * bitmaps using the decode* methods from {@link android.graphics.BitmapFactory}. This implementation calculates 222 * the closest inSampleSize that is a power of 2 and will result in the final decoded bitmap 223 * having a width and height equal to or larger than the requested width and height. 224 * 225 * @param options An options object with out* params already populated (run through a decode* 226 * method with inJustDecodeBounds==true 227 * @param reqWidth The requested width of the resulting bitmap 228 * @param reqHeight The requested height of the resulting bitmap 229 * @return The value to be used for inSampleSize 230 */ 231 public static int calculateInSampleSize(BitmapFactory.Options options, 232 int reqWidth, int reqHeight) { 234 // Raw height and width of image 235 final int height = options.outHeight; 236 final int width = options.outWidth; 237 int inSampleSize = 1; 238 239 if (height > reqHeight || width > reqWidth) { 240 241 final int halfHeight = height / 2; 242 final int halfWidth = width / 2; 243 244 // Calculate the largest inSampleSize value that is a power of 2 and keeps both 245 // height and width larger than the requested height and width. 246 while ((halfHeight / inSampleSize) > reqHeight 247 && (halfWidth / inSampleSize) > reqWidth) { 248 inSampleSize *= 2; 249 } 250 251 // This offers some additional logic in case the image has a strange 252 // aspect ratio. For example, a panorama may have a much larger 253 // width than height. In these cases the total pixels might still 254 // end up being too large to fit comfortably in memory, so we should 255 // be more aggressive with sample down the image (=larger inSampleSize). 256 257 long totalPixels = width * height / inSampleSize; 258 259 // Anything more than 2x the requested pixels we'll sample down further 260 final long totalReqPixelsCap = reqWidth * reqHeight * 2; 261 262 while (totalPixels > totalReqPixelsCap) { 263 inSampleSize *= 2; 264 totalPixels /= 2; 265 } 266 } 267 return inSampleSize; 269 } 270 }