PhotoFunctions.java

package com.eralp.profilephoto;

/**
 * Created by EralpPC on 22.2.2015.
 */
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

import android.content.Context;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.media.ExifInterface;
import android.net.Uri;
import android.provider.MediaStore;

public class PhotoFunctions {
    private static final int MAX_IMAGE_DIMENSION = 1000;

    public static byte[] bitmapFromUriToByteArray(Context context, Uri photoUri)
            throws IOException {
        Bitmap srcBitmap = bitmapFromUri(context, photoUri);
        String type = context.getContentResolver().getType(photoUri);
        byte[] bMapArray = bitmapToByteArray(srcBitmap, type);
        return bMapArray;
    }

    public static Bitmap bitmapFromUri(Context context, Uri photoUri)
            throws FileNotFoundException, IOException {
        InputStream is = context.getContentResolver().openInputStream(photoUri);
        BitmapFactory.Options dbo = new BitmapFactory.Options();
        dbo.inJustDecodeBounds = true;
        BitmapFactory.decodeStream(is, null, dbo);
        is.close();

        int rotatedWidth, rotatedHeight;

        int orientation = 0;

        if (photoUri.toString().contains("content:/")){
            orientation = getOrientation(context, photoUri);
        } else {
            int orientationFormExif = getOrientationFromExif(photoUri, context);
            orientation = decodeExifOrientation(orientationFormExif);
        }

        if (orientation == 90 || orientation == 270) {
            rotatedWidth = dbo.outHeight;
            rotatedHeight = dbo.outWidth;
        } else {
            rotatedWidth = dbo.outWidth;
            rotatedHeight = dbo.outHeight;
        }

        Bitmap srcBitmap = readScaledBitmapFromUri(photoUri, context,
                rotatedWidth, rotatedHeight);

        srcBitmap = setProperOrientation(orientation, srcBitmap);
        return srcBitmap;
    }

    public static byte[] bitmapToByteArray(Bitmap srcBitmap, String type)
            throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        if (type.equals("image/png")) {
            srcBitmap.compress(Bitmap.CompressFormat.PNG, 100, baos);
        } else if (type.equals("image/jpg") || type.equals("image/jpeg")) {
            srcBitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos);
        }
        byte[] bMapArray = baos.toByteArray();
        baos.close();
        return bMapArray;
    }

    private static Bitmap setProperOrientation(int orientation, Bitmap srcBitmap) {
        if (orientation > 0) {
            Matrix matrix = new Matrix();
            matrix.postRotate(orientation);

            srcBitmap = Bitmap.createBitmap(srcBitmap, 0, 0,
                    srcBitmap.getWidth(), srcBitmap.getHeight(), matrix, true);
        }
        return srcBitmap;
    }

    private static Bitmap readScaledBitmapFromUri(Uri photoUri,Context context, int width, int height)
            throws FileNotFoundException, IOException {
        InputStream is;
        Bitmap srcBitmap;
        is = context.getContentResolver().openInputStream(photoUri);
        if (width > MAX_IMAGE_DIMENSION || height > MAX_IMAGE_DIMENSION) {
            float ratio = calculateScaleRatio(width, height);
            srcBitmap = readRoughScaledBitmap(is, ratio);
            ratio = calculateScaleRatio(srcBitmap.getWidth(),
                    srcBitmap.getHeight());
            srcBitmap = scaleBitmap(srcBitmap, ratio);
        } else {
            srcBitmap = BitmapFactory.decodeStream(is);
        }
        is.close();
        return srcBitmap;
    }

    private static float calculateScaleRatio(int width, int height) {
        float widthRatio = ((float) width) / ((float) MAX_IMAGE_DIMENSION);
        float heightRatio = ((float) height) / ((float) MAX_IMAGE_DIMENSION);
        float maxRatio = Math.max(widthRatio, heightRatio);
        return maxRatio;
    }

    private static Bitmap readRoughScaledBitmap(InputStream is, float maxRatio) {
        Bitmap result;
        // Create the bitmap from file
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inSampleSize = (int) maxRatio;
        result = BitmapFactory.decodeStream(is, null, options);
        return result;
    }

    private static Bitmap scaleBitmap(Bitmap bitmap, float ratio) {
        int width = bitmap.getWidth();
        int height = bitmap.getHeight();

        Matrix matrix = new Matrix();
        matrix.postScale(1f / ratio, 1f / ratio);

        Bitmap result = Bitmap.createBitmap(bitmap, 0, 0, width, height,
                matrix, true);
        return result;
    }

    private static int getOrientation(Context context, Uri photoUri) {
		/* it's on the external media. */
        Cursor cursor = context.getContentResolver().query(photoUri,
                new String[] { MediaStore.Images.ImageColumns.ORIENTATION },
                null, null, null);

        if (cursor.getCount() != 1) {
            return -1;
        }

        cursor.moveToFirst();
        return cursor.getInt(0);
    }

    private static int getOrientationFromExif(Uri imageUri, Context context) {
        int orientation = -1;
        File imageFile = new File(imageUri.getPath());
        try {
            ExifInterface exif;
            exif = new ExifInterface(imageFile.getAbsolutePath());
            orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION,
                    ExifInterface.ORIENTATION_NORMAL);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return orientation;
    }



    private static int decodeExifOrientation(int orientation) {
        switch (orientation) {
            case ExifInterface.ORIENTATION_NORMAL:
                orientation = 0;
                break;
            case ExifInterface.ORIENTATION_ROTATE_90:
                orientation = 90;
                break;
            case ExifInterface.ORIENTATION_ROTATE_180:
                orientation = 180;
                break;
            case ExifInterface.ORIENTATION_ROTATE_270:
                orientation = 270;
                break;
            default:
                break;
        }
        return orientation;
    }

}