path: root/src/main/java/de/thedevstack/conversationsplus/utils/ImageUtil.java

package de.thedevstack.conversationsplus.utils;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.RectF;
import android.media.ExifInterface;
import android.net.Uri;
import android.util.LruCache;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

import de.thedevstack.android.logcat.Logging;
import de.thedevstack.conversationsplus.exceptions.ImageResizeException;
import de.thedevstack.conversationsplus.Config;
import de.thedevstack.conversationsplus.R;
import de.thedevstack.conversationsplus.entities.Message;
import de.thedevstack.conversationsplus.persistance.FileBackend;

/**
 * This util provides
 */
public final class ImageUtil {

    private static int IMAGE_SIZE = 1920;
    private static LruCache<String, Bitmap> BITMAP_CACHE;

    /**
     * Returns a bitmap from the cache.
     * @see LruCache#get(Object) for details
     * @param key the key of the bitmap to get
     * @return the bitmap
     */
    public static Bitmap getBitmapFromCache(String key) {
        return BITMAP_CACHE.get(key);
    }

    /**
     * Adds a bitmap with the given key to the cache.
     * @see LruCache#put(Object, Object) for details
     * @param key the key to identify this bitmap
     * @param bitmap the bitmap to cache
     */
    public static void addBitmapToCache(String key, Bitmap bitmap) {
        BITMAP_CACHE.put(key, bitmap);
    }

    /**
     * Removes the bitmap with given key from the cache.
     * @param key the key of the bitmap to remove
     */
    public static void removeBitmapFromCache(String key) {
        BITMAP_CACHE.remove(key);
    }

    /**
     * Clears the cache.
     * @see LruCache#evictAll() for more details.
     */
    public static void evictBitmapCache() {
        BITMAP_CACHE.evictAll();
    }

    /**
     * Initializes the bitmap cache.
     * This has to be executed once on application start.
     * @see LruCache#LruCache(int) for details
     */
    public static void initBitmapCache() {
        Logging.i("Conversations+ImageUtil", "Initializing BitmapCache");
        final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
        final int cacheSize = maxMemory / 8;
        BITMAP_CACHE = new LruCache<String, Bitmap>(cacheSize) {
            @Override
            protected int sizeOf(final String key, final Bitmap bitmap) {
                return bitmap.getByteCount() / 1024;
            }
        };
    }

    /**
     * Resizes a given bitmap and return a new and resized bitmap.
     * The bitmap is only resized if either the width or the height of the original bitmap is smaller than the given size.
     * @param originalBitmap the bitmap to resize
     * @param size the size to scale to
     * @return new and resized bitmap or the original bitmap if width and height are smaller than size
     */
    public static Bitmap resize(Bitmap originalBitmap, int size) {
        int w = originalBitmap.getWidth();
        int h = originalBitmap.getHeight();
        if (Math.max(w, h) > size) {
            int scalledW;
            int scalledH;
            if (w <= h) {
                scalledW = (int) (w / ((double) h / size));
                scalledH = size;
            } else {
                scalledW = size;
                scalledH = (int) (h / ((double) w / size));
            }
            return Bitmap.createScaledBitmap(originalBitmap, scalledW, scalledH, true);
        } else {
            return originalBitmap;
        }
    }

    /**
     * Resizes and rotates an image given by uri and returns the bitmap.
     * @param image the uri of the image to be resized and rotated
     * @return resized and rotated bitmap
     * @throws ImageResizeException
     */
    public static Bitmap resizeAndRotateImage(Uri image) throws ImageResizeException {
        return ImageUtil.resizeAndRotateImage(image, 0);
    }

    /**
     * Resizes and rotates an image given by uri and returns the bitmap.
     * @param image the uri of the image to be resized and rotated
     * @return resized and rotated bitmap
     * @throws ImageResizeException
     */
    private static Bitmap resizeAndRotateImage(Uri image, int sampleSize) throws ImageResizeException {
        InputStream imageInputStream = null;
        try {
            imageInputStream = StreamUtil.openInputStreamFromContentResolver(image);
            Bitmap originalBitmap;
            BitmapFactory.Options options = new BitmapFactory.Options();
            int inSampleSize = (int) Math.pow(2, sampleSize);
            Logging.d(Config.LOGTAG, "reading bitmap with sample size " + inSampleSize);
            options.inSampleSize = inSampleSize;
            originalBitmap = BitmapFactory.decodeStream(imageInputStream, null, options);
            imageInputStream.close();
            if (originalBitmap == null) {
                throw new ImageResizeException(R.string.error_not_an_image_file);
            }
            Bitmap scaledBitmap = ImageUtil.resize(originalBitmap, IMAGE_SIZE);
            int rotation = ImageUtil.getRotation(image);
            if (rotation > 0) {
                scaledBitmap = ImageUtil.rotate(scaledBitmap, rotation);
            }

            return scaledBitmap;
        } catch (FileNotFoundException e) {
            throw new ImageResizeException(R.string.error_file_not_found);
        } catch (IOException e) {
            throw new ImageResizeException(R.string.error_io_exception);
        } catch (OutOfMemoryError e) {
            ++sampleSize;
            if (sampleSize <= 3) {
                return resizeAndRotateImage(image, sampleSize);
            } else {
                throw new ImageResizeException(R.string.error_out_of_memory);
            }
        } finally {
            StreamUtil.close(imageInputStream);
        }
    }

    /**
     * Returns the rotation from the exif information of an image identified with the given uri.
     * The orientation is retrieved by parsing the stream of the image.
     * FileNotFoundException is silently ignored.
     * @param image the uri of the image to get the rotation
     * @return the rotation value for the image, <code>0</code> if the file cannot be found.
     */
    public static int getRotation(Uri image) {
        InputStream is = null;
        try {
            is = StreamUtil.openInputStreamFromContentResolver(image);
            return ExifHelper.getOrientation(is);
        } catch (FileNotFoundException e) {
            return 0;
        } finally {
            StreamUtil.close(is);
        }
    }

    /**
     * Returns a thumbnail for a bitmap in a message.
     * @param message the message to get the thumbnail for
     * @param size the size to resize the original image to
     * @param cacheOnly whether only cached images should be returned or not
     * @return the resized thumbail
     * @throws FileNotFoundException if the original image does not exist anymore or an IOException occurs.
     */
    public static Bitmap getThumbnail(Message message, int size, boolean cacheOnly)
            throws FileNotFoundException {
        Bitmap thumbnail = ImageUtil.getBitmapFromCache(message.getUuid());
        if ((thumbnail == null) && (!cacheOnly)) {
            File file = FileBackend.getFile(message);
            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inSampleSize = calcSampleSize(file, size);
            Bitmap fullsize = BitmapFactory.decodeFile(file.getAbsolutePath(),options);
            if (fullsize == null) {
                throw new FileNotFoundException();
            }
            thumbnail = resize(fullsize, size);
            thumbnail = rotate(thumbnail, file.getAbsolutePath());

            ImageUtil.addBitmapToCache(message.getUuid(), thumbnail);
        }
        return thumbnail;
    }

    /**
     * Rotates an bitmap. Only the values 90°, 180° and 270° are considered to rotate the image.
     * The orientation information is read using the ExifInterface.
     * @param original the original bitmap
     * @param srcPath the path to the original bitmap (used to read the exif information)
     * @return rotated bitmap, or original bitmap if criteria are not met
     * @throws IOException
     */
    public static Bitmap rotate(Bitmap original, String srcPath) {
        try {
            ExifInterface exif = new ExifInterface(srcPath);
            int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_UNDEFINED);
            int rotation = 0;
            switch (orientation) {
                case ExifInterface.ORIENTATION_ROTATE_90:
                    rotation = 90;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_180:
                    rotation = 180;
                    break;
                case ExifInterface.ORIENTATION_ROTATE_270:
                    rotation = 270;
                    break;
            }
            if (rotation > 0) {
                return rotate(original, rotation);
            }
        } catch (IOException e) {
            Logging.w("filebackend", "Error while rotating image, returning original (" + e.getMessage() + ")");
        }
        return original;
    }

    /**
     * Rotates a bitmap with given degrees.
     * @param bitmap the bitmap to be rotated
     * @param degree the degrees to rotate the bitmap
     * @return a newly created bitmap
     */
    public static Bitmap rotate(Bitmap bitmap, int degree) {
        int w = bitmap.getWidth();
        int h = bitmap.getHeight();
        Matrix mtx = new Matrix();
        mtx.postRotate(degree);
        return Bitmap.createBitmap(bitmap, 0, 0, w, h, mtx, true);
    }


    public static Bitmap cropCenterSquare(Uri image, int size) {
        if (image == null) {
            return null;
        }
        InputStream is = null;
        try {
            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inSampleSize = calcSampleSize(image, size);
            is = StreamUtil.openInputStreamFromContentResolver(image);
            Bitmap input = BitmapFactory.decodeStream(is, null, options);
            if (input == null) {
                return null;
            } else {
                int rotation = getRotation(image);
                if (rotation > 0) {
                    input = rotate(input, rotation);
                }
                return cropCenterSquare(input, size);
            }
        } catch (FileNotFoundException e) {
            return null;
        } finally {
            StreamUtil.close(is);
        }
    }

    public static Bitmap cropCenter(Uri image, int newHeight, int newWidth) {
        if (image == null) {
            return null;
        }
        InputStream is = null;
        try {
            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inSampleSize = calcSampleSize(image,Math.max(newHeight, newWidth));
            is = StreamUtil.openInputStreamFromContentResolver(image);
            Bitmap source = BitmapFactory.decodeStream(is, null, options);
            if (source == null) {
                return null;
            }
            int sourceWidth = source.getWidth();
            int sourceHeight = source.getHeight();
            float xScale = (float) newWidth / sourceWidth;
            float yScale = (float) newHeight / sourceHeight;
            float scale = Math.max(xScale, yScale);
            float scaledWidth = scale * sourceWidth;
            float scaledHeight = scale * sourceHeight;
            float left = (newWidth - scaledWidth) / 2;
            float top = (newHeight - scaledHeight) / 2;

            RectF targetRect = new RectF(left, top, left + scaledWidth, top + scaledHeight);
            Bitmap dest = Bitmap.createBitmap(newWidth, newHeight, Bitmap.Config.ARGB_8888);
            Canvas canvas = new Canvas(dest);
            canvas.drawBitmap(source, null, targetRect, null);
            return dest;
        } catch (FileNotFoundException e) {
            return null;
        } finally {
            StreamUtil.close(is);
        }
    }

    public static Bitmap cropCenterSquare(Bitmap input, int size) {
        int w = input.getWidth();
        int h = input.getHeight();

        float scale = Math.max((float) size / h, (float) size / w);

        float outWidth = scale * w;
        float outHeight = scale * h;
        float left = (size - outWidth) / 2;
        float top = (size - outHeight) / 2;
        RectF target = new RectF(left, top, left + outWidth, top + outHeight);

        Bitmap output = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(output);
        canvas.drawBitmap(input, null, target, null);
        return output;
    }

    public static int calcSampleSize(Uri image, int size) throws FileNotFoundException {
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeStream(StreamUtil.openInputStreamFromContentResolver(image), null, options);
        return calcSampleSize(options, size);
    }

    public static int calcSampleSize(File image, int size) {
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(image.getAbsolutePath(), options);
        return calcSampleSize(options, size);
    }

    public static int calcSampleSize(BitmapFactory.Options options, int size) {
        int height = options.outHeight;
        int width = options.outWidth;
        int inSampleSize = 1;

        if (height > size || width > size) {
            int halfHeight = height / 2;
            int halfWidth = width / 2;

            while ((halfHeight / inSampleSize) > size
                    && (halfWidth / inSampleSize) > size) {
                inSampleSize *= 2;
            }
        }
        return inSampleSize;
    }

    private ImageUtil() {
        // Static helper class
    }
}