Android Camera Orientation Issue

pictures taken in vertical format are saved in landscape format and vice-versa. I am using Android camera by using this intent Intent captureImage = new Intent(android.provider.Med

Solution 1:

Some devices doesn't rotate image after it was taken but just write its orientation information into Exif data. So before using taken photo you should call method like :

privateintresolveBitmapOrientation(File bitmapFile)throws IOException {
        ExifInterfaceexif=null;
        exif = newExifInterface(bitmapFile.getAbsolutePath());

        return exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
    }

to check its orientation. Then apply:

private Bitmap applyOrientation(Bitmap bitmap, int orientation) {
        introtate=0;
        switch (orientation) {
            case ExifInterface.ORIENTATION_ROTATE_270:
                rotate = 270;
                break;
            case ExifInterface.ORIENTATION_ROTATE_180:
                rotate = 180;
                break;
            case ExifInterface.ORIENTATION_ROTATE_90:
                rotate = 90;
                break;
            default:
                return bitmap;
        }

        intw= bitmap.getWidth();
        inth= bitmap.getHeight();
        Matrixmtx=newMatrix();
        mtx.postRotate(rotate);
        return Bitmap.createBitmap(bitmap, 0, 0, w, h, mtx, true);
    }

and use this new bitmap in your listview. Or it's even better to call this methods just after your photo was taken and override it with new rotated one.

In case if you are receiving Bitmap data as Uri the following method can be used to retrieve its filepath:

publicstaticStringgetPathFromURI(Context context, Uri contentUri) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT &&
            DocumentsContract.isDocumentUri(context, contentUri)) {
        returngetPathForV19AndUp(context, contentUri);
    } else {
        returngetPathForPreV19(context, contentUri);
    }
}

privatestaticStringgetPathForPreV19(Context context, Uri contentUri) {
    String[] projection = { MediaStore.Images.Media.DATA };
    Cursor cursor = context.getContentResolver().query(contentUri, projection, null, null, null);
    if (cursor != null && cursor.moveToFirst()) {
        try {
            int columnIndex = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
            return cursor.getString(columnIndex);
        } finally {
            cursor.close();
        }
    }

    returnnull;
}

@TargetApi(Build.VERSION_CODES.KITKAT)
privatestaticStringgetPathForV19AndUp(Context context, Uri contentUri) {
    String documentId = DocumentsContract.getDocumentId(contentUri);
    String id = documentId.split(":")[1];

    String[] column = { MediaStore.Images.Media.DATA };
    String sel = MediaStore.Images.Media._ID + "=?";
    Cursor cursor = context.getContentResolver().
            query(MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
                    column, sel, newString[]{ id }, null);

    if (cursor != null) {
        try {
            int columnIndex = cursor.getColumnIndex(column[0]);
            if (cursor.moveToFirst()) {
                return cursor.getString(columnIndex);
            }
        } finally {
            cursor.close();
        }
    }

    returnnull;
}

Solution 2:

You can also follow by this way:

static Uri image_uri;
static  Bitmap taken_image=null;

                image_uri=fileUri; // file where image has been saved

          taken_image=BitmapFactory.decodeFile(image_uri.getPath());
          try
            {
                ExifInterfaceexif=newExifInterface(image_uri.getPath()); 
//Since API Level 5intorientation= exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);


                switch(orientation) {
                    case ExifInterface.ORIENTATION_ROTATE_90:
                        taken_image=decodeScaledBitmapFromSdCard(image_uri.getPath(), 200, 200);
                        RotateBitmap(taken_image, 90);
                        break;
                    case ExifInterface.ORIENTATION_ROTATE_180:
                        taken_image=decodeScaledBitmapFromSdCard(image_uri.getPath(), 200, 200);
                        RotateBitmap(taken_image, 180);

                        break;
                    case ExifInterface.ORIENTATION_ROTATE_270:
                        taken_image=decodeScaledBitmapFromSdCard(image_uri.getPath(), 200, 200);
                        RotateBitmap(taken_image, 270);

                        break;
                    case ExifInterface.ORIENTATION_NORMAL:
                        taken_image=decodeScaledBitmapFromSdCard(image_uri.getPath(), 200, 200);
                        RotateBitmap(taken_image, 0);

                        break;
                }

            }
            catch (OutOfMemoryError e)
            {
                Toast.makeText(getActivity(),e+"\"memory exception occured\"",Toast.LENGTH_LONG).show();


            }



public Bitmap RotateBitmap(Bitmap source, float angle) {
    Matrixmatrix=newMatrix();
    matrix.postRotate(angle);

    round_Image = source;
    round_Image = Bitmap.createBitmap(source, 0, 0, source.getWidth(), source.getHeight(), matrix, true);


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