Q: why a captured image bitmap from Android camera is rotated I am using IMAGE_CAPTURE camera intent to capture and image and storing it in a file using MediaStore.EXTRA_OUTPUT. When I receive the image in onActivityResult, the bitmap is rotated.
Any suggestions on how to resolve this please.
Intent and passing the uri where I want the file to be stored
private fun capturePhoto() {
    val capturedImage = File(this.requireContext().externalCacheDir, "utility_bill.jpg")
    if (capturedImage.exists()) {
        capturedImage.delete()
    }
    capturedImage.createNewFile()
    mUri = if (Build.VERSION.SDK_INT >= 24) {
        FileProvider.getUriForFile(
            this.requireContext(),
            this.requireContext().applicationContext.packageName,
            capturedImage
        )
    } else {
        Uri.fromFile(capturedImage)
    }

    val intent = Intent("android.media.action.IMAGE_CAPTURE")
    intent.putExtra(MediaStore.EXTRA_OUTPUT, mUri)
    startActivityForResult(intent, CAMERA_REQUEST_CODE)
}

in onActivityResult bitmap is rotated.
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        hideScreen.visibility = View.GONE
        if (resultCode == Activity.RESULT_OK && requestCode == CAMERA_REQUEST_CODE) {
            uploadedImageCount++
            val bitmap = BitmapFactory.decodeStream(
                this.requireContext().contentResolver.openInputStream(mUri!!)
            )
}}

Image that I captured

when I debugged the bitmap received in the code, it is rotataed

Any suggestions on how I can resolve this please
Thanks in advance
R

A: I Faced The Same issue when i was developing the app most this was the case for devices like Samsung, HTC and some devices....This Happens because of Exif Interface which is different for the devices mentioned Above so make a separate Java class ExifUtil.java and the code goes like this
Note This Code Is In Java
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import android.graphics.Bitmap;
import android.graphics.Matrix;
import android.os.Build;

public class ExifUtil {
    /**
//     * @see https://sylvana.net/jpegcrop/exif_orientation.html
     */
    public static Bitmap rotateBitmap(String src, Bitmap bitmap) {
        try {
            int orientation = getExifOrientation(src);

            if (orientation == 1) {
                return bitmap;
            }

            Matrix matrix = new Matrix();
            switch (orientation) {
                case 2:
                    matrix.setScale(-1, 1);
                    break;
                case 3:
                    matrix.setRotate(180);
                    break;
                case 4:
                    matrix.setRotate(180);
                    matrix.postScale(-1, 1);
                    break;
                case 5:
                    matrix.setRotate(90);
                    matrix.postScale(-1, 1);
                    break;
                case 6:
                    matrix.setRotate(90);
                    break;
                case 7:
                    matrix.setRotate(-90);
                    matrix.postScale(-1, 1);
                    break;
                case 8:
                    matrix.setRotate(-90);
                    break;
                default:
                    return bitmap;
            }

            try {
                Bitmap oriented = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
                bitmap.recycle();
                return oriented;
            } catch (OutOfMemoryError e) {
                e.printStackTrace();
                return bitmap;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return bitmap;
    }

    private static int getExifOrientation(String src) throws IOException {
        int orientation = 1;

        try {
            /**
             * if your are targeting only api level >= 5
             * ExifInterface exif = new ExifInterface(src);
             * orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 1);
             */
            if (Build.VERSION.SDK_INT >= 5) {
                Class<?> exifClass = Class.forName("android.media.ExifInterface");
                Constructor<?> exifConstructor = exifClass.getConstructor(new Class[] { String.class });
                Object exifInstance = exifConstructor.newInstance(new Object[] { src });
                Method getAttributeInt = exifClass.getMethod("getAttributeInt", new Class[] { String.class, int.class });
                Field tagOrientationField = exifClass.getField("TAG_ORIENTATION");
                String tagOrientation = (String) tagOrientationField.get(null);
                orientation = (Integer) getAttributeInt.invoke(exifInstance, new Object[] { tagOrientation, 1});
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }

        return orientation;
    }
}

and OnActivityResult where save it like this
Bitmap orientedBitmap = ExifUtil.rotateBitmap(img_path, myBitmap);
this will automatically determine the orientation of the mage and rotate it to Potrait...!!

