src/com/android/messaging/datamodel/media/ImageRequest.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.media;

 import android.content.Context;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.graphics.Canvas;
 import android.graphics.Paint;
 import android.graphics.RectF;

 import com.android.messaging.datamodel.data.MessagePartData;
 import com.android.messaging.datamodel.media.PoolableImageCache.ReusableImageResourcePool;
 import com.android.messaging.util.Assert;
 import com.android.messaging.util.ImageUtils;
 import com.android.messaging.util.exif.ExifInterface;

 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.List;

 /**
  * Base class that serves an image request for resolving, retrieving and decoding bitmap resources.
  *
  * Subclasses may choose to load images from different medium, such as from the file system or
  * from the local content resolver, by overriding the abstract getInputStreamForResource() method.
  */
 public abstract class ImageRequest<D extends ImageRequestDescriptor>
         implements MediaRequest<ImageResource> {
     public static final int UNSPECIFIED_SIZE = MessagePartData.UNSPECIFIED_SIZE;

     protected final Context mContext;
     protected final D mDescriptor;
     protected int mOrientation;

     /**
      * Creates a new image request with the given descriptor.
      */
     public ImageRequest(final Context context, final D descriptor) {
         mContext = context;
         mDescriptor = descriptor;
     }

     /**
      * Gets a key that uniquely identify the underlying image resource to be loaded (e.g. Uri or
      * file path).
      */
     @Override
     public String getKey() {
         return mDescriptor.getKey();
     }

     /**
      * Returns the image request descriptor attached to this request.
      */
     @Override
     public D getDescriptor() {
         return mDescriptor;
     }

     @Override
     public int getRequestType() {
         return MediaRequest.REQUEST_LOAD_MEDIA;
     }

     /**
      * Allows sub classes to specify that they want us to call getBitmapForResource rather than
      * getInputStreamForResource
      */
     protected boolean hasBitmapObject() {
         return false;
     }

     protected Bitmap getBitmapForResource() throws IOException {
         return null;
     }

     /**
      * Retrieves an input stream from which image resource could be loaded.
      * @throws FileNotFoundException
      */
     protected abstract InputStream getInputStreamForResource() throws FileNotFoundException;

     /**
      * Loads the image resource. This method is final; to override the media loading behavior
      * the subclass should override {@link #loadMediaInternal(List)}
      */
     @Override
     public final ImageResource loadMediaBlocking(List<MediaRequest<ImageResource>> chainedTask)
             throws IOException {
         Assert.isNotMainThread();
         final ImageResource loadedResource = loadMediaInternal(chainedTask);
         return postProcessOnBitmapResourceLoaded(loadedResource);
     }

     protected ImageResource loadMediaInternal(List<MediaRequest<ImageResource>> chainedTask)
             throws IOException {
         if (!mDescriptor.isStatic() && isGif()) {
             final GifImageResource gifImageResource =
                     GifImageResource.createGifImageResource(getKey(), getInputStreamForResource());
             if (gifImageResource == null) {
                 throw new RuntimeException("Error decoding gif");
             }
             return gifImageResource;
         } else {
             final Bitmap loadedBitmap = loadBitmapInternal();
             if (loadedBitmap == null) {
                 throw new RuntimeException("failed decoding bitmap");
             }
             return new DecodedImageResource(getKey(), loadedBitmap, mOrientation);
         }
     }

     protected boolean isGif() throws FileNotFoundException {
         return ImageUtils.isGif(getInputStreamForResource());
     }

     /**
      * The internal routine for loading the image. The caller may optionally provide the width
      * and height of the source image if known so that we don't need to manually decode those.
      */
     protected Bitmap loadBitmapInternal() throws IOException {

         final boolean unknownSize = mDescriptor.sourceWidth == UNSPECIFIED_SIZE ||
                 mDescriptor.sourceHeight == UNSPECIFIED_SIZE;

         // If the ImageRequest has a Bitmap object rather than a stream, there's little to do here
         if (hasBitmapObject()) {
             final Bitmap bitmap = getBitmapForResource();
             if (bitmap != null && unknownSize) {
                 mDescriptor.updateSourceDimensions(bitmap.getWidth(), bitmap.getHeight());
             }
             return bitmap;
         }

         mOrientation = ImageUtils.getOrientation(getInputStreamForResource());

         final BitmapFactory.Options options = PoolableImageCache.getBitmapOptionsForPool(
                 false /* scaled */, 0 /* inputDensity */, 0 /* targetDensity */);
         // First, check dimensions of the bitmap if not already known.
         if (unknownSize) {
             final InputStream inputStream = getInputStreamForResource();
             if (inputStream != null) {
                 try {
                     options.inJustDecodeBounds = true;
                     BitmapFactory.decodeStream(inputStream, null, options);
                     // This is called when dimensions of image were unknown to allow db update
                     if (ExifInterface.getOrientationParams(mOrientation).invertDimensions) {
                         mDescriptor.updateSourceDimensions(options.outHeight, options.outWidth);
                     } else {
                         mDescriptor.updateSourceDimensions(options.outWidth, options.outHeight);
                     }
                 } finally {
                     inputStream.close();
                 }
             } else {
                 throw new FileNotFoundException();
             }
         } else {
             options.outWidth = mDescriptor.sourceWidth;
             options.outHeight = mDescriptor.sourceHeight;
         }

         // Calculate inSampleSize
         options.inSampleSize = ImageUtils.get().calculateInSampleSize(options,
                 mDescriptor.desiredWidth, mDescriptor.desiredHeight);
         Assert.isTrue(options.inSampleSize > 0);

         // Reopen the input stream and actually decode the bitmap. The initial
         // BitmapFactory.decodeStream() reads the header portion of the bitmap stream and leave
         // the input stream at the last read position. Since this input stream doesn't support
         // mark() and reset(), the only viable way to reload the input stream is to re-open it.
         // Alternatively, we could decode the bitmap into a byte array first and act on the byte
         // array, but that also means the entire bitmap (for example a 10MB image from the gallery)
         // without downsampling will have to be loaded into memory up front, which we don't want
         // as it gives a much bigger possibility of OOM when handling big images. Therefore, the
         // solution here is to close and reopen the bitmap input stream.
         // For inline images the size is cached in DB and this hit is only taken once per image
         final InputStream inputStream = getInputStreamForResource();
         if (inputStream != null) {
             try {
                 options.inJustDecodeBounds = false;

                 // Actually decode the bitmap, optionally using the bitmap pool.
                 final ReusableImageResourcePool bitmapPool = getBitmapPool();
                 if (bitmapPool == null) {
                     return BitmapFactory.decodeStream(inputStream, null, options);
                 } else {
                     final int sampledWidth = (options.outWidth + options.inSampleSize - 1) /
                             options.inSampleSize;
                     final int sampledHeight = (options.outHeight + options.inSampleSize - 1) /
                             options.inSampleSize;
                     return bitmapPool.decodeSampledBitmapFromInputStream(
                             inputStream, options, sampledWidth, sampledHeight);
                 }
             } finally {
                 inputStream.close();
             }
         } else {
             throw new FileNotFoundException();
         }
     }

     private ImageResource postProcessOnBitmapResourceLoaded(final ImageResource loadedResource) {
         if (mDescriptor.cropToCircle && loadedResource instanceof DecodedImageResource) {
             final int width = mDescriptor.desiredWidth;
             final int height = mDescriptor.desiredHeight;
             final Bitmap sourceBitmap = loadedResource.getBitmap();
             final Bitmap targetBitmap = getBitmapPool().createOrReuseBitmap(width, height);
             final RectF dest = new RectF(0, 0, width, height);
             final RectF source = new RectF(0, 0, sourceBitmap.getWidth(), sourceBitmap.getHeight());
             final int backgroundColor = mDescriptor.circleBackgroundColor;
             final int strokeColor = mDescriptor.circleStrokeColor;
             ImageUtils.drawBitmapWithCircleOnCanvas(sourceBitmap, new Canvas(targetBitmap), source,
                     dest, null, backgroundColor == 0 ? false : true /* fillBackground */,
                             backgroundColor, strokeColor);
             return new DecodedImageResource(getKey(), targetBitmap,
                     loadedResource.getOrientation());
         }
         return loadedResource;
     }

     /**
      * Returns the bitmap pool for this image request.
      */
     protected ReusableImageResourcePool getBitmapPool() {
         return MediaCacheManager.get().getOrCreateBitmapPoolForCache(getCacheId());
     }

     @SuppressWarnings("unchecked")
     @Override
     public MediaCache<ImageResource> getMediaCache() {
         return (MediaCache<ImageResource>) MediaCacheManager.get().getOrCreateMediaCacheById(
                 getCacheId());
     }

     /**
      * Returns the cache id. Subclasses may override this to use a different cache.
      */
     @Override
     public int getCacheId() {
         return BugleMediaCacheManager.DEFAULT_IMAGE_CACHE;
     }
 }
	/*
	* 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.media;

	import android.content.Context;
	import android.graphics.Bitmap;
	import android.graphics.BitmapFactory;
	import android.graphics.Canvas;
	import android.graphics.Paint;
	import android.graphics.RectF;

	import com.android.messaging.datamodel.data.MessagePartData;
	import com.android.messaging.datamodel.media.PoolableImageCache.ReusableImageResourcePool;
	import com.android.messaging.util.Assert;
	import com.android.messaging.util.ImageUtils;
	import com.android.messaging.util.exif.ExifInterface;

	import java.io.FileNotFoundException;
	import java.io.IOException;
	import java.io.InputStream;
	import java.util.List;

	/**
	* Base class that serves an image request for resolving, retrieving and decoding bitmap resources.
	*
	* Subclasses may choose to load images from different medium, such as from the file system or
	* from the local content resolver, by overriding the abstract getInputStreamForResource() method.
	*/
	public abstract class ImageRequest<D extends ImageRequestDescriptor>
	implements MediaRequest<ImageResource> {
	public static final int UNSPECIFIED_SIZE = MessagePartData.UNSPECIFIED_SIZE;

	protected final Context mContext;
	protected final D mDescriptor;
	protected int mOrientation;

	/**
	* Creates a new image request with the given descriptor.
	*/
	public ImageRequest(final Context context, final D descriptor) {
	mContext = context;
	mDescriptor = descriptor;
	}

	/**
	* Gets a key that uniquely identify the underlying image resource to be loaded (e.g. Uri or
	* file path).
	*/
	@Override
	public String getKey() {
	return mDescriptor.getKey();
	}

	/**
	* Returns the image request descriptor attached to this request.
	*/
	@Override
	public D getDescriptor() {
	return mDescriptor;
	}

	@Override
	public int getRequestType() {
	return MediaRequest.REQUEST_LOAD_MEDIA;
	}

	/**
	* Allows sub classes to specify that they want us to call getBitmapForResource rather than
	* getInputStreamForResource
	*/
	protected boolean hasBitmapObject() {
	return false;
	}

	protected Bitmap getBitmapForResource() throws IOException {
	return null;
	}

	/**
	* Retrieves an input stream from which image resource could be loaded.
	* @throws FileNotFoundException
	*/
	protected abstract InputStream getInputStreamForResource() throws FileNotFoundException;

	/**
	* Loads the image resource. This method is final; to override the media loading behavior
	* the subclass should override {@link #loadMediaInternal(List)}
	*/
	@Override
	public final ImageResource loadMediaBlocking(List<MediaRequest<ImageResource>> chainedTask)
	throws IOException {
	Assert.isNotMainThread();
	final ImageResource loadedResource = loadMediaInternal(chainedTask);
	return postProcessOnBitmapResourceLoaded(loadedResource);
	}

	protected ImageResource loadMediaInternal(List<MediaRequest<ImageResource>> chainedTask)
	throws IOException {
	if (!mDescriptor.isStatic() && isGif()) {
	final GifImageResource gifImageResource =
	GifImageResource.createGifImageResource(getKey(), getInputStreamForResource());
	if (gifImageResource == null) {
	throw new RuntimeException("Error decoding gif");
	}
	return gifImageResource;
	} else {
	final Bitmap loadedBitmap = loadBitmapInternal();
	if (loadedBitmap == null) {
	throw new RuntimeException("failed decoding bitmap");
	}
	return new DecodedImageResource(getKey(), loadedBitmap, mOrientation);
	}
	}

	protected boolean isGif() throws FileNotFoundException {
	return ImageUtils.isGif(getInputStreamForResource());
	}

	/**
	* The internal routine for loading the image. The caller may optionally provide the width
	* and height of the source image if known so that we don't need to manually decode those.
	*/
	protected Bitmap loadBitmapInternal() throws IOException {

	final boolean unknownSize = mDescriptor.sourceWidth == UNSPECIFIED_SIZE \|\|
	mDescriptor.sourceHeight == UNSPECIFIED_SIZE;

	// If the ImageRequest has a Bitmap object rather than a stream, there's little to do here
	if (hasBitmapObject()) {
	final Bitmap bitmap = getBitmapForResource();
	if (bitmap != null && unknownSize) {
	mDescriptor.updateSourceDimensions(bitmap.getWidth(), bitmap.getHeight());
	}
	return bitmap;
	}

	mOrientation = ImageUtils.getOrientation(getInputStreamForResource());

	final BitmapFactory.Options options = PoolableImageCache.getBitmapOptionsForPool(
	false /* scaled /, 0 / inputDensity /, 0 / targetDensity */);
	// First, check dimensions of the bitmap if not already known.
	if (unknownSize) {
	final InputStream inputStream = getInputStreamForResource();
	if (inputStream != null) {
	try {
	options.inJustDecodeBounds = true;
	BitmapFactory.decodeStream(inputStream, null, options);
	// This is called when dimensions of image were unknown to allow db update
	if (ExifInterface.getOrientationParams(mOrientation).invertDimensions) {
	mDescriptor.updateSourceDimensions(options.outHeight, options.outWidth);
	} else {
	mDescriptor.updateSourceDimensions(options.outWidth, options.outHeight);
	}
	} finally {
	inputStream.close();
	}
	} else {
	throw new FileNotFoundException();
	}
	} else {
	options.outWidth = mDescriptor.sourceWidth;
	options.outHeight = mDescriptor.sourceHeight;
	}

	// Calculate inSampleSize
	options.inSampleSize = ImageUtils.get().calculateInSampleSize(options,
	mDescriptor.desiredWidth, mDescriptor.desiredHeight);
	Assert.isTrue(options.inSampleSize > 0);

	// Reopen the input stream and actually decode the bitmap. The initial
	// BitmapFactory.decodeStream() reads the header portion of the bitmap stream and leave
	// the input stream at the last read position. Since this input stream doesn't support
	// mark() and reset(), the only viable way to reload the input stream is to re-open it.
	// Alternatively, we could decode the bitmap into a byte array first and act on the byte
	// array, but that also means the entire bitmap (for example a 10MB image from the gallery)
	// without downsampling will have to be loaded into memory up front, which we don't want
	// as it gives a much bigger possibility of OOM when handling big images. Therefore, the
	// solution here is to close and reopen the bitmap input stream.
	// For inline images the size is cached in DB and this hit is only taken once per image
	final InputStream inputStream = getInputStreamForResource();
	if (inputStream != null) {
	try {
	options.inJustDecodeBounds = false;

	// Actually decode the bitmap, optionally using the bitmap pool.
	final ReusableImageResourcePool bitmapPool = getBitmapPool();
	if (bitmapPool == null) {
	return BitmapFactory.decodeStream(inputStream, null, options);
	} else {
	final int sampledWidth = (options.outWidth + options.inSampleSize - 1) /
	options.inSampleSize;
	final int sampledHeight = (options.outHeight + options.inSampleSize - 1) /
	options.inSampleSize;
	return bitmapPool.decodeSampledBitmapFromInputStream(
	inputStream, options, sampledWidth, sampledHeight);
	}
	} finally {
	inputStream.close();
	}
	} else {
	throw new FileNotFoundException();
	}
	}

	private ImageResource postProcessOnBitmapResourceLoaded(final ImageResource loadedResource) {
	if (mDescriptor.cropToCircle && loadedResource instanceof DecodedImageResource) {
	final int width = mDescriptor.desiredWidth;
	final int height = mDescriptor.desiredHeight;
	final Bitmap sourceBitmap = loadedResource.getBitmap();
	final Bitmap targetBitmap = getBitmapPool().createOrReuseBitmap(width, height);
	final RectF dest = new RectF(0, 0, width, height);
	final RectF source = new RectF(0, 0, sourceBitmap.getWidth(), sourceBitmap.getHeight());
	final int backgroundColor = mDescriptor.circleBackgroundColor;
	final int strokeColor = mDescriptor.circleStrokeColor;
	ImageUtils.drawBitmapWithCircleOnCanvas(sourceBitmap, new Canvas(targetBitmap), source,
	dest, null, backgroundColor == 0 ? false : true /* fillBackground */,
	backgroundColor, strokeColor);
	return new DecodedImageResource(getKey(), targetBitmap,
	loadedResource.getOrientation());
	}
	return loadedResource;
	}

	/**
	* Returns the bitmap pool for this image request.
	*/
	protected ReusableImageResourcePool getBitmapPool() {
	return MediaCacheManager.get().getOrCreateBitmapPoolForCache(getCacheId());
	}

	@SuppressWarnings("unchecked")
	@Override
	public MediaCache<ImageResource> getMediaCache() {
	return (MediaCache<ImageResource>) MediaCacheManager.get().getOrCreateMediaCacheById(
	getCacheId());
	}

	/**
	* Returns the cache id. Subclasses may override this to use a different cache.
	*/
	@Override
	public int getCacheId() {
	return BugleMediaCacheManager.DEFAULT_IMAGE_CACHE;
	}
	}