+ * 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; + if (!mPauseWork) { + mPauseWorkLock.notifyAll(); + } + } + } + + /** + * Decode and sample down a bitmap from a file input stream to the requested width and height. + * + * @param fileDescriptor The file descriptor to read from + * @param reqWidth The requested width of the resulting bitmap + * @param reqHeight The requested height of the resulting bitmap + * @return A bitmap sampled down from the original with the same aspect ratio and dimensions + * that are equal to or greater than the requested width and height + */ + public static Bitmap decodeSampledBitmapFromDescriptor( + FileDescriptor fileDescriptor, int reqWidth, int reqHeight) { + + // First decode with inJustDecodeBounds=true to check dimensions + final BitmapFactory.Options options = new BitmapFactory.Options(); + options.inJustDecodeBounds = true; + BitmapFactory.decodeFileDescriptor(fileDescriptor, null, options); + + // Calculate inSampleSize + options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight); + + // Decode bitmap with inSampleSize set + options.inJustDecodeBounds = false; + return BitmapFactory.decodeFileDescriptor(fileDescriptor, null, options); + } + + /** + * Calculate an inSampleSize for use in a {@link BitmapFactory.Options} object when decoding + * bitmaps using the decode* methods from {@link BitmapFactory}. This implementation calculates + * the closest inSampleSize that will result in the final decoded bitmap having a width and + * height equal to or larger than the requested width and height. This implementation does not + * ensure a power of 2 is returned for inSampleSize which can be faster when decoding but + * results in a larger bitmap which isn't as useful for caching purposes. + * + * @param options An options object with out* params already populated (run through a decode* + * method with inJustDecodeBounds==true + * @param reqWidth The requested width of the resulting bitmap + * @param reqHeight The requested height of the resulting bitmap + * @return The value to be used for inSampleSize + */ + public static int calculateInSampleSize(BitmapFactory.Options options, + int reqWidth, int reqHeight) { + // Raw height and width of image + final int height = options.outHeight; + final int width = options.outWidth; + int inSampleSize = 1; + + if (height > reqHeight || width > 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 + // width than height. In these cases the total pixels might still + // end up being too large to fit comfortably in memory, so we should + // be more aggressive with sample down the image (=larger inSampleSize). + + final float totalPixels = width * height; + + // Anything more than 2x the requested pixels we'll sample down further + final float totalReqPixelsCap = reqWidth * reqHeight * 2; + + while (totalPixels / (inSampleSize * inSampleSize) > totalReqPixelsCap) { + inSampleSize++; + } + } + return inSampleSize; + } +} diff --git a/samples/training/ContactsList/src/com/example/android/contactslist/util/Utils.java b/samples/training/ContactsList/src/com/example/android/contactslist/util/Utils.java new file mode 100644 index 000000000..9c0cc443a --- /dev/null +++ b/samples/training/ContactsList/src/com/example/android/contactslist/util/Utils.java @@ -0,0 +1,103 @@ +/* + * Copyright (C) 2013 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.example.android.contactslist.util; + +import android.annotation.TargetApi; +import android.os.Build; +import android.os.StrictMode; + +import com.example.android.contactslist.ui.ContactDetailActivity; +import com.example.android.contactslist.ui.ContactsListActivity; + +/** + * This class contains static utility methods. + */ +public class Utils { + + // Prevents instantiation. + private Utils() {} + + /** + * Enables strict mode. This should only be called when debugging the application and is useful + * for finding some potential bugs or best practice violations. + */ + @TargetApi(11) + public static void enableStrictMode() { + // Strict mode is only available on gingerbread or later + if (Utils.hasGingerbread()) { + + // Enable all thread strict mode policies + StrictMode.ThreadPolicy.Builder threadPolicyBuilder = + new StrictMode.ThreadPolicy.Builder() + .detectAll() + .penaltyLog(); + + // Enable all VM strict mode policies + StrictMode.VmPolicy.Builder vmPolicyBuilder = + new StrictMode.VmPolicy.Builder() + .detectAll() + .penaltyLog(); + + // Honeycomb introduced some additional strict mode features + if (Utils.hasHoneycomb()) { + // Flash screen when thread policy is violated + threadPolicyBuilder.penaltyFlashScreen(); + // For each activity class, set an instance limit of 1. Any more instances and + // there could be a memory leak. + vmPolicyBuilder + .setClassInstanceLimit(ContactsListActivity.class, 1) + .setClassInstanceLimit(ContactDetailActivity.class, 1); + } + + // Use builders to enable strict mode policies + StrictMode.setThreadPolicy(threadPolicyBuilder.build()); + StrictMode.setVmPolicy(vmPolicyBuilder.build()); + } + } + + /** + * Uses static final constants to detect if the device's platform version is Gingerbread or + * later. + */ + public static boolean hasGingerbread() { + return Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD; + } + + /** + * Uses static final constants to detect if the device's platform version is Honeycomb or + * later. + */ + public static boolean hasHoneycomb() { + return Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB; + } + + /** + * Uses static final constants to detect if the device's platform version is Honeycomb MR1 or + * later. + */ + public static boolean hasHoneycombMR1() { + return Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR1; + } + + /** + * Uses static final constants to detect if the device's platform version is ICS or + * later. + */ + public static boolean hasICS() { + return Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH; + } +}