Как сохранить правильное повернутое изображение с помощью фронтальной камеры camerax?

Вам необходимо прочитать данные EXIF ​​созданного изображения и написать свои собственные пользовательские контроллеры в соответствии с требованиями и потребностями. На большинстве устройств Android и iOS это нормально, что захваченные изображения поворачиваются, и с этим нужно обращаться соответственно. В большинстве устройств ориентация камеры по умолчанию установлена ​​в альбомный режим, поэтому даже если вы делаете снимок в портретном режиме, он поворачивается на 90 градусов.

Из данных EXIF ​​вы можете получить степень поворота изображения или его зеркального отражения, а затем вы можете обработать его в бэкэнде.

Чтобы повернуть изображение, вы можете попробовать

private static Bitmap rotateImageIfRequired(Bitmap img, Uri selectedImage) throws IOException 
{
    ExifInterface ei = new ExifInterface(selectedImage.getPath());
    int orientation = ei.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);

    switch (orientation) {
        case ExifInterface.ORIENTATION_ROTATE_90:
            return rotateImage(img, 90);
        case ExifInterface.ORIENTATION_ROTATE_180:
            return rotateImage(img, 180);
        case ExifInterface.ORIENTATION_ROTATE_270:
            return rotateImage(img, 270);
        default:
            return img;
    }
 }

private static Bitmap rotateImage(Bitmap img, int degree)
{
    Matrix matrix = new Matrix();
    matrix.postRotate(degree);
    Bitmap rotatedImg = Bitmap.createBitmap(img, 0, 0, img.getWidth(), img.getHeight(), matrix, true);
    img.recycle();
    return rotatedImg;
}

Для проблемы с переворачиванием изображения вы можете попробовать это

public static Bitmap flip(Bitmap src, int type) 
{
     // create new matrix for transformation
     Matrix matrix = new Matrix();
     matrix.preScale(-1.0f, 1.0f);

     // return transformed image
     return Bitmap.createBitmap(src, 0, 0, src.getWidth(), src.getHeight(), matrix, true);
 }

А затем установите изображение в ImageView как

imgPreview.setImageBitmap(flip(bitmap)); 

Не совсем ответ, но может пригодиться, если вам нужно прочитать информацию EXIF ​​из байта [] вместо уже распакованного растрового изображения.

 /**
 * Returns the degrees, counted clockwise, from a byte[] instead of a already saved file.<br>
 *
 * @param jpeg the JPEG image byte[]
 * @return Exif orientation as either <b>0</b>, <b>90</b>, <b>180</b> or <b>270</b>
 */
public static int getExifOrientation(byte[] jpeg) {
    if (jpeg == null) {
        return 0;
    }

    int offset = 0;
    int length = 0;

    // ISO/IEC 10918-1:1993(E)
    while (offset + 3 < jpeg.length && (jpeg[offset++] & 0xFF) == 0xFF) {
        int marker = jpeg[offset] & 0xFF;

        // Check if the marker is a padding.
        if (marker == 0xFF) {
            continue;
        }
        offset++;

        // Check if the marker is SOI or TEM.
        if (marker == 0xD8 || marker == 0x01) {
            continue;
        }
        // Check if the marker is EOI or SOS.
        if (marker == 0xD9 || marker == 0xDA) {
            break;
        }

        // Get the length and check if it is reasonable.
        length = pack(jpeg, offset, 2, false);
        if (length < 2 || offset + length > jpeg.length) {
            Log.e(TAG, "Invalid JPEG length");
            return 0;
        }

        // Break if the marker is EXIF in APP1.
        if (marker == 0xE1 && length >= 8 &&
                pack(jpeg, offset + 2, 4, false) == 0x45786966 &&
                pack(jpeg, offset + 6, 2, false) == 0) {
            offset += 8;
            length -= 8;
            break;
        }

        // Skip other markers.
        offset += length;
        length = 0;
    }

    // JEITA CP-3451 Exif Version 2.2
    if (length > 8) {
        // Identify the byte order.
        int tag = pack(jpeg, offset, 4, false);
        if (tag != 0x49492A00 && tag != 0x4D4D002A) {
            Log.e(TAG, "Invalid JPEG EXIF byte order");
            return 0;
        }
        boolean littleEndian = (tag == 0x49492A00);

        // Get the offset and check if it is reasonable.
        int count = pack(jpeg, offset + 4, 4, littleEndian) + 2;
        if (count < 10 || count > length) {
            Log.e(TAG, "Invalid JPEG EXIF offset");
            return 0;
        }
        offset += count;
        length -= count;

        // Get the count and go through all the elements.
        count = pack(jpeg, offset - 2, 2, littleEndian);
        while (count-- > 0 && length >= 12) {
            // Get the tag and check if it is orientation.
            tag = pack(jpeg, offset, 2, littleEndian);
            if (tag == 0x0112) {
                // We do not really care about type and count, do we?
                int orientation = pack(jpeg, offset + 8, 2, littleEndian);
                switch (orientation) {
                    case 1:
                        return 0;
                    case 3:
                        return 180;
                    case 6:
                        return 90;
                    case 8:
                        return 270;
                }
                Log.i(TAG, "Unsupported EXIF orientation");
                return 0;
            }
            offset += 12;
            length -= 12;
        }
    }

    Log.i(TAG, "EXIF Orientation not found");
    return 0;
}

private static int pack(byte[] bytes, int offset, int length,
                        boolean littleEndian) {
    int step = 1;
    if (littleEndian) {
        offset += length - 1;
        step = -1;
    }

    int value = 0;
    while (length-- > 0) {
        value = (value << 8) | (bytes[offset] & 0xFF);
        offset += step;
    }
    return value;
}