| /* |
| * 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.util; |
| |
| import android.app.ActivityManager; |
| import android.content.ContentResolver; |
| import android.content.Context; |
| import android.database.Cursor; |
| import android.graphics.Bitmap; |
| import android.graphics.BitmapFactory; |
| import android.graphics.BitmapShader; |
| import android.graphics.Canvas; |
| import android.graphics.Matrix; |
| import android.graphics.Paint; |
| import android.graphics.PorterDuff; |
| import android.graphics.Rect; |
| import android.graphics.RectF; |
| import android.graphics.Shader.TileMode; |
| import android.graphics.drawable.Drawable; |
| import android.net.Uri; |
| import android.provider.MediaStore; |
| import androidx.annotation.Nullable; |
| import android.text.TextUtils; |
| import android.view.View; |
| |
| import com.android.messaging.Factory; |
| import com.android.messaging.datamodel.MediaScratchFileProvider; |
| import com.android.messaging.datamodel.MessagingContentProvider; |
| import com.android.messaging.datamodel.media.ImageRequest; |
| import com.android.messaging.util.Assert.DoesNotRunOnMainThread; |
| import com.android.messaging.util.exif.ExifInterface; |
| import com.google.common.annotations.VisibleForTesting; |
| import com.google.common.io.Files; |
| |
| import java.io.ByteArrayOutputStream; |
| import java.io.File; |
| import java.io.FileNotFoundException; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.nio.charset.Charset; |
| import java.util.Arrays; |
| |
| public class ImageUtils { |
| private static final String TAG = LogUtil.BUGLE_TAG; |
| private static final int MAX_OOM_COUNT = 1; |
| private static final byte[] GIF87_HEADER = "GIF87a".getBytes(Charset.forName("US-ASCII")); |
| private static final byte[] GIF89_HEADER = "GIF89a".getBytes(Charset.forName("US-ASCII")); |
| |
| // Used for drawBitmapWithCircleOnCanvas. |
| // Default color is transparent for both circle background and stroke. |
| public static final int DEFAULT_CIRCLE_BACKGROUND_COLOR = 0; |
| public static final int DEFAULT_CIRCLE_STROKE_COLOR = 0; |
| |
| private static volatile ImageUtils sInstance; |
| |
| public static ImageUtils get() { |
| if (sInstance == null) { |
| synchronized (ImageUtils.class) { |
| if (sInstance == null) { |
| sInstance = new ImageUtils(); |
| } |
| } |
| } |
| return sInstance; |
| } |
| |
| @VisibleForTesting |
| public static void set(final ImageUtils imageUtils) { |
| sInstance = imageUtils; |
| } |
| |
| /** |
| * Transforms a bitmap into a byte array. |
| * |
| * @param quality Value between 0 and 100 that the compressor uses to discern what quality the |
| * resulting bytes should be |
| * @param bitmap Bitmap to convert into bytes |
| * @return byte array of bitmap |
| */ |
| public static byte[] bitmapToBytes(final Bitmap bitmap, final int quality) |
| throws OutOfMemoryError { |
| boolean done = false; |
| int oomCount = 0; |
| byte[] imageBytes = null; |
| while (!done) { |
| try { |
| final ByteArrayOutputStream os = new ByteArrayOutputStream(); |
| bitmap.compress(Bitmap.CompressFormat.JPEG, quality, os); |
| imageBytes = os.toByteArray(); |
| done = true; |
| } catch (final OutOfMemoryError e) { |
| LogUtil.w(TAG, "OutOfMemory converting bitmap to bytes."); |
| oomCount++; |
| if (oomCount <= MAX_OOM_COUNT) { |
| Factory.get().reclaimMemory(); |
| } else { |
| done = true; |
| LogUtil.w(TAG, "Failed to convert bitmap to bytes. Out of Memory."); |
| } |
| throw e; |
| } |
| } |
| return imageBytes; |
| } |
| |
| /** |
| * Given the source bitmap and a canvas, draws the bitmap through a circular |
| * mask. Only draws a circle with diameter equal to the destination width. |
| * |
| * @param bitmap The source bitmap to draw. |
| * @param canvas The canvas to draw it on. |
| * @param source The source bound of the bitmap. |
| * @param dest The destination bound on the canvas. |
| * @param bitmapPaint Optional Paint object for the bitmap |
| * @param fillBackground when set, fill the circle with backgroundColor |
| * @param strokeColor draw a border outside the circle with strokeColor |
| */ |
| public static void drawBitmapWithCircleOnCanvas(final Bitmap bitmap, final Canvas canvas, |
| final RectF source, final RectF dest, @Nullable Paint bitmapPaint, |
| final boolean fillBackground, final int backgroundColor, int strokeColor) { |
| // Draw bitmap through shader first. |
| final BitmapShader shader = new BitmapShader(bitmap, TileMode.CLAMP, TileMode.CLAMP); |
| final Matrix matrix = new Matrix(); |
| |
| // Fit bitmap to bounds. |
| matrix.setRectToRect(source, dest, Matrix.ScaleToFit.CENTER); |
| |
| shader.setLocalMatrix(matrix); |
| |
| if (bitmapPaint == null) { |
| bitmapPaint = new Paint(); |
| } |
| |
| bitmapPaint.setAntiAlias(true); |
| if (fillBackground) { |
| bitmapPaint.setColor(backgroundColor); |
| canvas.drawCircle(dest.centerX(), dest.centerX(), dest.width() / 2f, bitmapPaint); |
| } |
| |
| bitmapPaint.setShader(shader); |
| canvas.drawCircle(dest.centerX(), dest.centerX(), dest.width() / 2f, bitmapPaint); |
| bitmapPaint.setShader(null); |
| |
| if (strokeColor != 0) { |
| final Paint stroke = new Paint(); |
| stroke.setAntiAlias(true); |
| stroke.setColor(strokeColor); |
| stroke.setStyle(Paint.Style.STROKE); |
| final float strokeWidth = 6f; |
| stroke.setStrokeWidth(strokeWidth); |
| canvas.drawCircle(dest.centerX(), |
| dest.centerX(), |
| dest.width() / 2f - stroke.getStrokeWidth() / 2f, |
| stroke); |
| } |
| } |
| |
| /** |
| * Sets a drawable to the background of a view. setBackgroundDrawable() is deprecated since |
| * JB and replaced by setBackground(). |
| */ |
| @SuppressWarnings("deprecation") |
| public static void setBackgroundDrawableOnView(final View view, final Drawable drawable) { |
| if (OsUtil.isAtLeastJB()) { |
| view.setBackground(drawable); |
| } else { |
| view.setBackgroundDrawable(drawable); |
| } |
| } |
| |
| /** |
| * Based on the input bitmap bounds given by BitmapFactory.Options, compute the required |
| * sub-sampling size for loading a scaled down version of the bitmap to the required size |
| * @param options a BitmapFactory.Options instance containing the bounds info of the bitmap |
| * @param reqWidth the desired width of the bitmap. Can be ImageRequest.UNSPECIFIED_SIZE. |
| * @param reqHeight the desired height of the bitmap. Can be ImageRequest.UNSPECIFIED_SIZE. |
| * @return |
| */ |
| public int calculateInSampleSize( |
| final BitmapFactory.Options options, final int reqWidth, final int reqHeight) { |
| // Raw height and width of image |
| final int height = options.outHeight; |
| final int width = options.outWidth; |
| int inSampleSize = 1; |
| |
| final boolean checkHeight = reqHeight != ImageRequest.UNSPECIFIED_SIZE; |
| final boolean checkWidth = reqWidth != ImageRequest.UNSPECIFIED_SIZE; |
| if ((checkHeight && height > reqHeight) || |
| (checkWidth && width > reqWidth)) { |
| |
| final int halfHeight = height / 2; |
| final int halfWidth = width / 2; |
| |
| // Calculate the largest inSampleSize value that is a power of 2 and keeps both |
| // height and width larger than the requested height and width. |
| while ((!checkHeight || (halfHeight / inSampleSize) > reqHeight) |
| && (!checkWidth || (halfWidth / inSampleSize) > reqWidth)) { |
| inSampleSize *= 2; |
| } |
| } |
| |
| return inSampleSize; |
| } |
| |
| private static final String[] MEDIA_CONTENT_PROJECTION = new String[] { |
| MediaStore.MediaColumns.MIME_TYPE |
| }; |
| |
| private static final int INDEX_CONTENT_TYPE = 0; |
| |
| @DoesNotRunOnMainThread |
| public static String getContentType(final ContentResolver cr, final Uri uri) { |
| // Figure out the content type of media. |
| String contentType = null; |
| Cursor cursor = null; |
| if (UriUtil.isMediaStoreUri(uri)) { |
| try { |
| cursor = cr.query(uri, MEDIA_CONTENT_PROJECTION, null, null, null); |
| |
| if (cursor != null && cursor.moveToFirst()) { |
| contentType = cursor.getString(INDEX_CONTENT_TYPE); |
| } |
| } finally { |
| if (cursor != null) { |
| cursor.close(); |
| } |
| } |
| } |
| if (contentType == null) { |
| // Last ditch effort to get the content type. Look at the file extension. |
| contentType = ContentType.getContentTypeFromExtension(uri.toString(), |
| ContentType.IMAGE_UNSPECIFIED); |
| } |
| return contentType; |
| } |
| |
| /** |
| * @param context Android context |
| * @param uri Uri to the image data |
| * @return The exif orientation value for the image in the specified uri |
| */ |
| public static int getOrientation(final Context context, final Uri uri) { |
| try { |
| return getOrientation(context.getContentResolver().openInputStream(uri)); |
| } catch (FileNotFoundException e) { |
| LogUtil.e(TAG, "getOrientation couldn't open: " + uri, e); |
| } |
| return android.media.ExifInterface.ORIENTATION_UNDEFINED; |
| } |
| |
| /** |
| * @param inputStream The stream to the image file. Closed on completion |
| * @return The exif orientation value for the image in the specified stream |
| */ |
| public static int getOrientation(final InputStream inputStream) { |
| int orientation = android.media.ExifInterface.ORIENTATION_UNDEFINED; |
| if (inputStream != null) { |
| try { |
| final ExifInterface exifInterface = new ExifInterface(); |
| exifInterface.readExif(inputStream); |
| final Integer orientationValue = |
| exifInterface.getTagIntValue(ExifInterface.TAG_ORIENTATION); |
| if (orientationValue != null) { |
| orientation = orientationValue.intValue(); |
| } |
| } catch (IOException e) { |
| // If the image if GIF, PNG, or missing exif header, just use the defaults |
| } finally { |
| try { |
| if (inputStream != null) { |
| inputStream.close(); |
| } |
| } catch (IOException e) { |
| LogUtil.e(TAG, "getOrientation error closing input stream", e); |
| } |
| } |
| } |
| return orientation; |
| } |
| |
| /** |
| * Returns whether the resource is a GIF image. |
| */ |
| public static boolean isGif(String contentType, Uri contentUri) { |
| if (TextUtils.equals(contentType, ContentType.IMAGE_GIF)) { |
| return true; |
| } |
| if (ContentType.isImageType(contentType)) { |
| try { |
| ContentResolver contentResolver = Factory.get().getApplicationContext() |
| .getContentResolver(); |
| InputStream inputStream = contentResolver.openInputStream(contentUri); |
| return ImageUtils.isGif(inputStream); |
| } catch (Exception e) { |
| LogUtil.w(TAG, "Could not open GIF input stream", e); |
| } |
| } |
| // Assume anything with a non-image content type is not a GIF |
| return false; |
| } |
| |
| /** |
| * @param inputStream The stream to the image file. Closed on completion |
| * @return Whether the image stream represents a GIF |
| */ |
| public static boolean isGif(InputStream inputStream) { |
| if (inputStream != null) { |
| try { |
| byte[] gifHeaderBytes = new byte[6]; |
| int value = inputStream.read(gifHeaderBytes, 0, 6); |
| if (value == 6) { |
| return Arrays.equals(gifHeaderBytes, GIF87_HEADER) |
| || Arrays.equals(gifHeaderBytes, GIF89_HEADER); |
| } |
| } catch (IOException e) { |
| return false; |
| } finally { |
| try { |
| inputStream.close(); |
| } catch (IOException e) { |
| // Ignore |
| } |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Read an image and compress it to particular max dimensions and size. |
| * Used to ensure images can fit in an MMS. |
| * TODO: This uses memory very inefficiently as it processes the whole image as a unit |
| * (rather than slice by slice) but system JPEG functions do not support slicing and dicing. |
| */ |
| public static class ImageResizer { |
| |
| /** |
| * The quality parameter which is used to compress JPEG images. |
| */ |
| private static final int IMAGE_COMPRESSION_QUALITY = 95; |
| /** |
| * The minimum quality parameter which is used to compress JPEG images. |
| */ |
| private static final int MINIMUM_IMAGE_COMPRESSION_QUALITY = 50; |
| |
| /** |
| * Minimum factor to reduce quality value |
| */ |
| private static final double QUALITY_SCALE_DOWN_RATIO = 0.85f; |
| |
| /** |
| * Maximum passes through the resize loop before failing permanently |
| */ |
| private static final int NUMBER_OF_RESIZE_ATTEMPTS = 6; |
| |
| /** |
| * Amount to scale down the picture when it doesn't fit |
| */ |
| private static final float MIN_SCALE_DOWN_RATIO = 0.75f; |
| |
| /** |
| * When computing sampleSize target scaling of no more than this ratio |
| */ |
| private static final float MAX_TARGET_SCALE_FACTOR = 1.5f; |
| |
| |
| // Current sample size for subsampling image during initial decode |
| private int mSampleSize; |
| // Current bitmap holding initial decoded source image |
| private Bitmap mDecoded; |
| // If scaling is needed this holds the scaled bitmap (else should equal mDecoded) |
| private Bitmap mScaled; |
| // Current JPEG compression quality to use when compressing image |
| private int mQuality; |
| // Current factor to scale down decoded image before compressing |
| private float mScaleFactor; |
| // Flag keeping track of whether cache memory has been reclaimed |
| private boolean mHasReclaimedMemory; |
| |
| // Initial size of the image (typically provided but can be UNSPECIFIED_SIZE) |
| private int mWidth; |
| private int mHeight; |
| // Orientation params of image as read from EXIF data |
| private final ExifInterface.OrientationParams mOrientationParams; |
| // Matrix to undo orientation and scale at the same time |
| private final Matrix mMatrix; |
| // Size limit as provided by MMS library |
| private final int mWidthLimit; |
| private final int mHeightLimit; |
| private final int mByteLimit; |
| // Uri from which to read source image |
| private final Uri mUri; |
| // Application context |
| private final Context mContext; |
| // Cached value of bitmap factory options |
| private final BitmapFactory.Options mOptions; |
| private final String mContentType; |
| |
| private final int mMemoryClass; |
| |
| /** |
| * Return resized (compressed) image (else null) |
| * |
| * @param width The width of the image (if known) |
| * @param height The height of the image (if known) |
| * @param orientation The orientation of the image as an ExifInterface constant |
| * @param widthLimit The width limit, in pixels |
| * @param heightLimit The height limit, in pixels |
| * @param byteLimit The binary size limit, in bytes |
| * @param uri Uri to the image data |
| * @param context Needed to open the image |
| * @param contentType of image |
| * @return encoded image meeting size requirements else null |
| */ |
| public static byte[] getResizedImageData(final int width, final int height, |
| final int orientation, final int widthLimit, final int heightLimit, |
| final int byteLimit, final Uri uri, final Context context, |
| final String contentType) { |
| final ImageResizer resizer = new ImageResizer(width, height, orientation, |
| widthLimit, heightLimit, byteLimit, uri, context, contentType); |
| return resizer.resize(); |
| } |
| |
| /** |
| * Create and initialize an image resizer |
| */ |
| private ImageResizer(final int width, final int height, final int orientation, |
| final int widthLimit, final int heightLimit, final int byteLimit, final Uri uri, |
| final Context context, final String contentType) { |
| mWidth = width; |
| mHeight = height; |
| mOrientationParams = ExifInterface.getOrientationParams(orientation); |
| mMatrix = new Matrix(); |
| mWidthLimit = widthLimit; |
| mHeightLimit = heightLimit; |
| mByteLimit = byteLimit; |
| mUri = uri; |
| mWidth = width; |
| mContext = context; |
| mQuality = IMAGE_COMPRESSION_QUALITY; |
| mScaleFactor = 1.0f; |
| mHasReclaimedMemory = false; |
| mOptions = new BitmapFactory.Options(); |
| mOptions.inScaled = false; |
| mOptions.inDensity = 0; |
| mOptions.inTargetDensity = 0; |
| mOptions.inSampleSize = 1; |
| mOptions.inJustDecodeBounds = false; |
| mOptions.inMutable = false; |
| final ActivityManager am = |
| (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE); |
| mMemoryClass = Math.max(16, am.getMemoryClass()); |
| mContentType = contentType; |
| } |
| |
| /** |
| * Try to compress the image |
| * |
| * @return encoded image meeting size requirements else null |
| */ |
| private byte[] resize() { |
| return ImageUtils.isGif(mContentType, mUri) ? resizeGifImage() : resizeStaticImage(); |
| } |
| |
| private byte[] resizeGifImage() { |
| byte[] bytesToReturn = null; |
| final String inputFilePath; |
| if (MediaScratchFileProvider.isMediaScratchSpaceUri(mUri)) { |
| inputFilePath = MediaScratchFileProvider.getFileFromUri(mUri).getAbsolutePath(); |
| } else { |
| if (!TextUtils.equals(mUri.getScheme(), ContentResolver.SCHEME_FILE)) { |
| Assert.fail("Expected a GIF file uri, but actual uri = " + mUri.toString()); |
| } |
| inputFilePath = mUri.getPath(); |
| } |
| |
| if (GifTranscoder.canBeTranscoded(mWidth, mHeight)) { |
| // Needed to perform the transcoding so that the gif can continue to play in the |
| // conversation while the sending is taking place |
| final Uri tmpUri = MediaScratchFileProvider.buildMediaScratchSpaceUri("gif"); |
| final File outputFile = MediaScratchFileProvider.getFileFromUri(tmpUri); |
| final String outputFilePath = outputFile.getAbsolutePath(); |
| |
| final boolean success = |
| GifTranscoder.transcode(mContext, inputFilePath, outputFilePath); |
| if (success) { |
| try { |
| bytesToReturn = Files.toByteArray(outputFile); |
| } catch (IOException e) { |
| LogUtil.e(TAG, "Could not create FileInputStream with path of " |
| + outputFilePath, e); |
| } |
| } |
| |
| // Need to clean up the new file created to compress the gif |
| mContext.getContentResolver().delete(tmpUri, null, null); |
| } else { |
| // We don't want to transcode the gif because its image dimensions would be too |
| // small so just return the bytes of the original gif |
| try { |
| bytesToReturn = Files.toByteArray(new File(inputFilePath)); |
| } catch (IOException e) { |
| LogUtil.e(TAG, |
| "Could not create FileInputStream with path of " + inputFilePath, e); |
| } |
| } |
| |
| return bytesToReturn; |
| } |
| |
| private byte[] resizeStaticImage() { |
| if (!ensureImageSizeSet()) { |
| // Cannot read image size |
| return null; |
| } |
| // Find incoming image size |
| if (!canBeCompressed()) { |
| return null; |
| } |
| |
| // Decode image - if out of memory - reclaim memory and retry |
| try { |
| for (int attempts = 0; attempts < NUMBER_OF_RESIZE_ATTEMPTS; attempts++) { |
| final byte[] encoded = recodeImage(attempts); |
| |
| // Only return data within the limit |
| if (encoded != null && encoded.length <= mByteLimit) { |
| return encoded; |
| } else { |
| final int currentSize = (encoded == null ? 0 : encoded.length); |
| updateRecodeParameters(currentSize); |
| } |
| } |
| } catch (final FileNotFoundException e) { |
| LogUtil.e(TAG, "File disappeared during resizing"); |
| } finally { |
| // Release all bitmaps |
| if (mScaled != null && mScaled != mDecoded) { |
| mScaled.recycle(); |
| } |
| if (mDecoded != null) { |
| mDecoded.recycle(); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Ensure that the width and height of the source image are known |
| * @return flag indicating whether size is known |
| */ |
| private boolean ensureImageSizeSet() { |
| if (mWidth == MessagingContentProvider.UNSPECIFIED_SIZE || |
| mHeight == MessagingContentProvider.UNSPECIFIED_SIZE) { |
| // First get the image data (compressed) |
| final ContentResolver cr = mContext.getContentResolver(); |
| InputStream inputStream = null; |
| // Find incoming image size |
| try { |
| mOptions.inJustDecodeBounds = true; |
| inputStream = cr.openInputStream(mUri); |
| BitmapFactory.decodeStream(inputStream, null, mOptions); |
| |
| mWidth = mOptions.outWidth; |
| mHeight = mOptions.outHeight; |
| mOptions.inJustDecodeBounds = false; |
| |
| return true; |
| } catch (final FileNotFoundException e) { |
| LogUtil.e(TAG, "Could not open file corresponding to uri " + mUri, e); |
| } catch (final NullPointerException e) { |
| LogUtil.e(TAG, "NPE trying to open the uri " + mUri, e); |
| } finally { |
| if (inputStream != null) { |
| try { |
| inputStream.close(); |
| } catch (final IOException e) { |
| // Nothing to do |
| } |
| } |
| } |
| |
| return false; |
| } |
| return true; |
| } |
| |
| /** |
| * Choose an initial subsamplesize that ensures the decoded image is no more than |
| * MAX_TARGET_SCALE_FACTOR bigger than largest supported image and that it is likely to |
| * compress to smaller than the target size (assuming compression down to 1 bit per pixel). |
| * @return whether the image can be down subsampled |
| */ |
| private boolean canBeCompressed() { |
| final boolean logv = LogUtil.isLoggable(LogUtil.BUGLE_IMAGE_TAG, LogUtil.VERBOSE); |
| |
| int imageHeight = mHeight; |
| int imageWidth = mWidth; |
| |
| // Assume can use half working memory to decode the initial image (4 bytes per pixel) |
| final int workingMemoryPixelLimit = (mMemoryClass * 1024 * 1024 / 8); |
| // Target 1 bits per pixel in final compressed image |
| final int finalSizePixelLimit = mByteLimit * 8; |
| // When choosing to halve the resolution - only do so the image will still be too big |
| // after scaling by MAX_TARGET_SCALE_FACTOR |
| final int heightLimitWithSlop = (int) (mHeightLimit * MAX_TARGET_SCALE_FACTOR); |
| final int widthLimitWithSlop = (int) (mWidthLimit * MAX_TARGET_SCALE_FACTOR); |
| final int pixelLimitWithSlop = (int) (finalSizePixelLimit * |
| MAX_TARGET_SCALE_FACTOR * MAX_TARGET_SCALE_FACTOR); |
| final int pixelLimit = Math.min(pixelLimitWithSlop, workingMemoryPixelLimit); |
| |
| int sampleSize = 1; |
| boolean fits = (imageHeight < heightLimitWithSlop && |
| imageWidth < widthLimitWithSlop && |
| imageHeight * imageWidth < pixelLimit); |
| |
| // Compare sizes to compute sub-sampling needed |
| while (!fits) { |
| sampleSize = sampleSize * 2; |
| // Note that recodeImage may try using mSampleSize * 2. Hence we use the factor of 4 |
| if (sampleSize >= (Integer.MAX_VALUE / 4)) { |
| LogUtil.w(LogUtil.BUGLE_IMAGE_TAG, String.format( |
| "Cannot resize image: widthLimit=%d heightLimit=%d byteLimit=%d " + |
| "imageWidth=%d imageHeight=%d", mWidthLimit, mHeightLimit, mByteLimit, |
| mWidth, mHeight)); |
| Assert.fail("Image cannot be resized"); // http://b/18926934 |
| return false; |
| } |
| if (logv) { |
| LogUtil.v(LogUtil.BUGLE_IMAGE_TAG, |
| "computeInitialSampleSize: Increasing sampleSize to " + sampleSize |
| + " as h=" + imageHeight + " vs " + heightLimitWithSlop |
| + " w=" + imageWidth + " vs " + widthLimitWithSlop |
| + " p=" + imageHeight * imageWidth + " vs " + pixelLimit); |
| } |
| imageHeight = mHeight / sampleSize; |
| imageWidth = mWidth / sampleSize; |
| fits = (imageHeight < heightLimitWithSlop && |
| imageWidth < widthLimitWithSlop && |
| imageHeight * imageWidth < pixelLimit); |
| } |
| |
| if (logv) { |
| LogUtil.v(LogUtil.BUGLE_IMAGE_TAG, |
| "computeInitialSampleSize: Initial sampleSize " + sampleSize |
| + " for h=" + imageHeight + " vs " + heightLimitWithSlop |
| + " w=" + imageWidth + " vs " + widthLimitWithSlop |
| + " p=" + imageHeight * imageWidth + " vs " + pixelLimit); |
| } |
| |
| mSampleSize = sampleSize; |
| return true; |
| } |
| |
| /** |
| * Recode the image from initial Uri to encoded JPEG |
| * @param attempt Attempt number |
| * @return encoded image |
| */ |
| private byte[] recodeImage(final int attempt) throws FileNotFoundException { |
| byte[] encoded = null; |
| try { |
| final ContentResolver cr = mContext.getContentResolver(); |
| final boolean logv = LogUtil.isLoggable(LogUtil.BUGLE_IMAGE_TAG, LogUtil.VERBOSE); |
| if (logv) { |
| LogUtil.v(LogUtil.BUGLE_IMAGE_TAG, "getResizedImageData: attempt=" + attempt |
| + " limit (w=" + mWidthLimit + " h=" + mHeightLimit + ") quality=" |
| + mQuality + " scale=" + mScaleFactor + " sampleSize=" + mSampleSize); |
| } |
| if (mScaled == null) { |
| if (mDecoded == null) { |
| mOptions.inSampleSize = mSampleSize; |
| try (final InputStream inputStream = cr.openInputStream(mUri)) { |
| mDecoded = BitmapFactory.decodeStream(inputStream, null, mOptions); |
| } catch (IOException e) { |
| // Ignore |
| } |
| if (mDecoded == null) { |
| if (logv) { |
| LogUtil.v(LogUtil.BUGLE_IMAGE_TAG, |
| "getResizedImageData: got empty decoded bitmap"); |
| } |
| return null; |
| } |
| } |
| if (logv) { |
| LogUtil.v(LogUtil.BUGLE_IMAGE_TAG, "getResizedImageData: decoded w,h=" |
| + mDecoded.getWidth() + "," + mDecoded.getHeight()); |
| } |
| // Make sure to scale the decoded image if dimension is not within limit |
| final int decodedWidth = mDecoded.getWidth(); |
| final int decodedHeight = mDecoded.getHeight(); |
| if (decodedWidth > mWidthLimit || decodedHeight > mHeightLimit) { |
| final float minScaleFactor = Math.max( |
| mWidthLimit == 0 ? 1.0f : |
| (float) decodedWidth / (float) mWidthLimit, |
| mHeightLimit == 0 ? 1.0f : |
| (float) decodedHeight / (float) mHeightLimit); |
| if (mScaleFactor < minScaleFactor) { |
| mScaleFactor = minScaleFactor; |
| } |
| } |
| if (mScaleFactor > 1.0 || mOrientationParams.rotation != 0) { |
| mMatrix.reset(); |
| mMatrix.postRotate(mOrientationParams.rotation); |
| mMatrix.postScale(mOrientationParams.scaleX / mScaleFactor, |
| mOrientationParams.scaleY / mScaleFactor); |
| mScaled = Bitmap.createBitmap(mDecoded, 0, 0, decodedWidth, decodedHeight, |
| mMatrix, false /* filter */); |
| if (mScaled == null) { |
| if (logv) { |
| LogUtil.v(LogUtil.BUGLE_IMAGE_TAG, |
| "getResizedImageData: got empty scaled bitmap"); |
| } |
| return null; |
| } |
| if (logv) { |
| LogUtil.v(LogUtil.BUGLE_IMAGE_TAG, "getResizedImageData: scaled w,h=" |
| + mScaled.getWidth() + "," + mScaled.getHeight()); |
| } |
| } else { |
| mScaled = mDecoded; |
| } |
| } |
| // Now encode it at current quality |
| encoded = ImageUtils.bitmapToBytes(mScaled, mQuality); |
| if (encoded != null && logv) { |
| LogUtil.v(LogUtil.BUGLE_IMAGE_TAG, |
| "getResizedImageData: Encoded down to " + encoded.length + "@" |
| + mScaled.getWidth() + "/" + mScaled.getHeight() + "~" |
| + mQuality); |
| } |
| } catch (final OutOfMemoryError e) { |
| LogUtil.w(LogUtil.BUGLE_IMAGE_TAG, |
| "getResizedImageData - image too big (OutOfMemoryError), will try " |
| + " with smaller scale factor"); |
| // fall through and keep trying with more compression |
| } |
| return encoded; |
| } |
| |
| /** |
| * When image recode fails this method updates compression parameters for the next attempt |
| * @param currentSize encoded image size (will be 0 if OOM) |
| */ |
| private void updateRecodeParameters(final int currentSize) { |
| final boolean logv = LogUtil.isLoggable(LogUtil.BUGLE_IMAGE_TAG, LogUtil.VERBOSE); |
| // Only return data within the limit |
| if (currentSize > 0 && |
| mQuality > MINIMUM_IMAGE_COMPRESSION_QUALITY) { |
| // First if everything succeeded but failed to hit target size |
| // Try quality proportioned to sqrt of size over size limit |
| mQuality = Math.max(MINIMUM_IMAGE_COMPRESSION_QUALITY, |
| Math.min((int) (mQuality * Math.sqrt((1.0 * mByteLimit) / currentSize)), |
| (int) (mQuality * QUALITY_SCALE_DOWN_RATIO))); |
| if (logv) { |
| LogUtil.v(LogUtil.BUGLE_IMAGE_TAG, |
| "getResizedImageData: Retrying at quality " + mQuality); |
| } |
| } else if (currentSize > 0 && |
| mScaleFactor < 2.0 * MIN_SCALE_DOWN_RATIO * MIN_SCALE_DOWN_RATIO) { |
| // JPEG compression failed to hit target size - need smaller image |
| // First try scaling by a little (< factor of 2) just so long resulting scale down |
| // ratio is still significantly bigger than next subsampling step |
| // i.e. mScaleFactor/MIN_SCALE_DOWN_RATIO (new scaling factor) < |
| // 2.0 / MIN_SCALE_DOWN_RATIO (arbitrary limit) |
| mQuality = IMAGE_COMPRESSION_QUALITY; |
| mScaleFactor = mScaleFactor / MIN_SCALE_DOWN_RATIO; |
| if (logv) { |
| LogUtil.v(LogUtil.BUGLE_IMAGE_TAG, |
| "getResizedImageData: Retrying at scale " + mScaleFactor); |
| } |
| // Release scaled bitmap to trigger rescaling |
| if (mScaled != null && mScaled != mDecoded) { |
| mScaled.recycle(); |
| } |
| mScaled = null; |
| } else if (currentSize <= 0 && !mHasReclaimedMemory) { |
| // Then before we subsample try cleaning up our cached memory |
| Factory.get().reclaimMemory(); |
| mHasReclaimedMemory = true; |
| if (logv) { |
| LogUtil.v(LogUtil.BUGLE_IMAGE_TAG, |
| "getResizedImageData: Retrying after reclaiming memory "); |
| } |
| } else { |
| // Last resort - subsample image by another factor of 2 and try again |
| mSampleSize = mSampleSize * 2; |
| mQuality = IMAGE_COMPRESSION_QUALITY; |
| mScaleFactor = 1.0f; |
| if (logv) { |
| LogUtil.v(LogUtil.BUGLE_IMAGE_TAG, |
| "getResizedImageData: Retrying at sampleSize " + mSampleSize); |
| } |
| // Release all bitmaps to trigger subsampling |
| if (mScaled != null && mScaled != mDecoded) { |
| mScaled.recycle(); |
| } |
| mScaled = null; |
| if (mDecoded != null) { |
| mDecoded.recycle(); |
| mDecoded = null; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Scales and center-crops a bitmap to the size passed in and returns the new bitmap. |
| * |
| * @param source Bitmap to scale and center-crop |
| * @param newWidth destination width |
| * @param newHeight destination height |
| * @return Bitmap scaled and center-cropped bitmap |
| */ |
| public static Bitmap scaleCenterCrop(final Bitmap source, final int newWidth, |
| final int newHeight) { |
| final int sourceWidth = source.getWidth(); |
| final int sourceHeight = source.getHeight(); |
| |
| // Compute the scaling factors to fit the new height and width, respectively. |
| // To cover the final image, the final scaling will be the bigger |
| // of these two. |
| final float xScale = (float) newWidth / sourceWidth; |
| final float yScale = (float) newHeight / sourceHeight; |
| final float scale = Math.max(xScale, yScale); |
| |
| // Now get the size of the source bitmap when scaled |
| final float scaledWidth = scale * sourceWidth; |
| final float scaledHeight = scale * sourceHeight; |
| |
| // Let's find out the upper left coordinates if the scaled bitmap |
| // should be centered in the new size give by the parameters |
| final float left = (newWidth - scaledWidth) / 2; |
| final float top = (newHeight - scaledHeight) / 2; |
| |
| // The target rectangle for the new, scaled version of the source bitmap will now |
| // be |
| final RectF targetRect = new RectF(left, top, left + scaledWidth, top + scaledHeight); |
| |
| // Finally, we create a new bitmap of the specified size and draw our new, |
| // scaled bitmap onto it. |
| final Bitmap dest = Bitmap.createBitmap(newWidth, newHeight, source.getConfig()); |
| final Canvas canvas = new Canvas(dest); |
| canvas.drawBitmap(source, null, targetRect, null); |
| |
| return dest; |
| } |
| |
| /** |
| * The drawable can be a Nine-Patch. If we directly use the same drawable instance for each |
| * drawable of different sizes, then the drawable sizes would interfere with each other. The |
| * solution here is to create a new drawable instance for every time with the SAME |
| * ConstantState (i.e. sharing the same common state such as the bitmap, so that we don't have |
| * to recreate the bitmap resource), and apply the different properties on top (nine-patch |
| * size and color tint). |
| * |
| * TODO: we are creating new drawable instances here, but there are optimizations that |
| * can be made. For example, message bubbles shouldn't need the mutate() call and the |
| * play/pause buttons shouldn't need to create new drawable from the constant state. |
| */ |
| public static Drawable getTintedDrawable(final Context context, final Drawable drawable, |
| final int color) { |
| // For some reason occassionally drawables on JB has a null constant state |
| final Drawable.ConstantState constantStateDrawable = drawable.getConstantState(); |
| final Drawable retDrawable = (constantStateDrawable != null) |
| ? constantStateDrawable.newDrawable(context.getResources()).mutate() |
| : drawable; |
| retDrawable.setColorFilter(color, PorterDuff.Mode.SRC_ATOP); |
| return retDrawable; |
| } |
| |
| /** |
| * Decodes image resource header and returns the image size. |
| */ |
| public static Rect decodeImageBounds(final Context context, final Uri imageUri) { |
| final ContentResolver cr = context.getContentResolver(); |
| try { |
| final InputStream inputStream = cr.openInputStream(imageUri); |
| if (inputStream != null) { |
| try { |
| BitmapFactory.Options options = new BitmapFactory.Options(); |
| options.inJustDecodeBounds = true; |
| BitmapFactory.decodeStream(inputStream, null, options); |
| return new Rect(0, 0, options.outWidth, options.outHeight); |
| } finally { |
| try { |
| inputStream.close(); |
| } catch (IOException e) { |
| // Do nothing. |
| } |
| } |
| } |
| } catch (FileNotFoundException e) { |
| LogUtil.e(TAG, "Couldn't open input stream for uri = " + imageUri); |
| } |
| return new Rect(0, 0, ImageRequest.UNSPECIFIED_SIZE, ImageRequest.UNSPECIFIED_SIZE); |
| } |
| } |
