Masalah orientasi kamera di Android

100

Saya sedang membangun aplikasi yang menggunakan kamera untuk mengambil gambar. Berikut kode sumber saya untuk melakukan ini:

        File file = new File(Environment.getExternalStorageDirectory(),
            imageFileName);
    imageFilePath = file.getPath();
    Intent intent = new Intent("android.media.action.IMAGE_CAPTURE");
    //Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
    intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(file));
    startActivityForResult(intent, ACTIVITY_NATIVE_CAMERA_AQUIRE);

Pada onActivityResult()metode, saya menggunakan BitmapFactory.decodeStream()pickup gambar.

Saat saya menjalankan aplikasi saya di Nexus satu, itu berjalan dengan baik. Tetapi ketika saya menjalankan Samsung Galaxy S atau HTC Inspire 4G, arah gambarnya salah.

  • Tangkap dengan mode potret, gambar asli (simpan di kartu SD) selalu berputar 90 derajat.

pratinjau gambar setelah pengambilan gambar gambar nyata pada kartu SD

Pratinjau gambar setelah pemotretan --------- Gambar nyata pada kartu SD

  • Tangkap dengan mode lanskap, semuanya bagus.

Pratinjau gambar setelah pengambilan gambar Gambar nyata pada kartu SD

Pratinjau gambar setelah pemotretan --------- Gambar nyata pada kartu SD

Nguyen Minh Binh
sumber
1
setRotation (90) berhasil untuk saya di Samsung Galaxy Nexus, sementara itu tidak memutar gambar di Xperia S.
StarDust
adakah yang bisa membantu saya dengan ini? saya memiliki masalah yang sama stackoverflow.com/questions/28379130/…
Jawab di sini stackoverflow.com/questions/14066038/…
Shirish Herwade

Jawaban:

50

Ada beberapa topik dan masalah serupa di sekitar sini. Karena Anda tidak sedang menulis kamera Anda sendiri, saya pikir intinya adalah:

beberapa perangkat memutar gambar sebelum menyimpannya, sementara yang lain hanya menambahkan tag orientasi di data exif foto.

Saya akan merekomendasikan untuk memeriksa data exif foto dan mencari secara khusus

ExifInterface exif = new ExifInterface(SourceFileName);     //Since API Level 5
String exifOrientation = exif.getAttribute(ExifInterface.TAG_ORIENTATION);

Karena foto ditampilkan dengan benar di aplikasi Anda, saya tidak yakin di mana masalahnya, tetapi ini pasti akan membuat Anda berada di jalur yang benar!

ramz
sumber
33
Ini tampaknya tidak berfungsi pada beberapa perangkat, ini mengembalikan 0 untuk semua orientasi .. Saya tahu itu terjadi pada Galaxy S Infuse dan Sony Xperia Arc, dan S II .. Hal yang menarik di sini adalah ketika gambar yang sama ini dipilih dari galeri , penyedia konten memiliki nilai orientasi yang sesuai .. Ada ide?
Tolga E
3
@Abhijit Ya saya mencoba menyelesaikan ini (membuka tiket dengan Android dan sebagainya) Dan saya pikir saya menemukan solusi yang masuk akal untuk menangani kedua ponsel dengan informasi orientasi yang tepat dan salah. Lihat jawaban rinci saya yang saya posting ke pertanyaan saya sendiri di sini; stackoverflow.com/a/8864367/137404
Tolga E
1
@ramz Saya mencoba solusi ini untuk menemukan. tetapi mengembalikan 0 untuk semua orientasi. Apakah Anda tahu mengapa itu mengembalikan 0 untuk semua orientasi.
Dory
1
Alasan untuk solusi ini tidak bekerja terkadang adalah "jalur" yang salah digunakan dalam konstruktor ExifInterface. Sebagian besar di KitKat. Lihat di sini, cara mendapatkan jalur yang benar: stackoverflow.com/a/20559175/690777
peter.bartos
1
Itu selalu mengembalikan 0 (ExifInterface.ORIENTATION_UNDEFINED) pada Samsung Galaxy S4 saya ...
valerybodak
28

Saya baru saja mengalami masalah yang sama, dan menggunakan ini untuk memperbaiki orientasi:

public void fixOrientation() {
    if (mBitmap.getWidth() > mBitmap.getHeight()) {
        Matrix matrix = new Matrix();
        matrix.postRotate(90);
        mBitmap = Bitmap.createBitmap(mBitmap , 0, 0, mBitmap.getWidth(), mBitmap.getHeight(), matrix, true);
    }
}

Jika lebar Bitmap lebih besar dari tinggi, gambar yang dikembalikan dalam lanskap, jadi saya memutarnya 90 derajat.

Semoga membantu orang lain dengan masalah ini.


sumber
18
Bagaimana jika gambar itu benar-benar diambil dalam lanskap? Kode Anda masih akan memutarnya. Ini bukanlah jawaban atas pertanyaan.
Wladimir Palant
1
Aplikasi saya memaksa potret, jadi itu bukan masalah. Saya hanya memasukkan ini di sini sebagai solusi alternatif untuk masalah tersebut.
5
Tetapi jika aplikasi memaksa potret Anda masih dapat mengambil gambar lanskap (lebar> tinggi) dan itu akan diputar ... Setidaknya itulah yang saya dapatkan pengaturan screenOrientation = "potret" untuk semuanya ... kamera masih bisa mengambil lanskap foto.
Ixx
jawaban lengkap & benar ada di sini stackoverflow.com/questions/6069122/…
Shirish Herwade
21

Ada dua hal yang dibutuhkan:

  1. Pratinjau kamera harus sama dengan rotasi Anda. Atur ini dengancamera.setDisplayOrientation(result);

  2. Simpan gambar yang diambil sebagai pratinjau kamera Anda. Lakukan ini melalui Camera.Parameters.

    int mRotation = getCameraDisplayOrientation();
    
    Camera.Parameters parameters = camera.getParameters();
    
    parameters.setRotation(mRotation); //set rotation to save the picture
    
    camera.setDisplayOrientation(result); //set the rotation for preview camera
    
    camera.setParameters(parameters);

Semoga membantu.

Tran Khanh Tung
sumber
ini dia! Camera.parameters sangat nyaman untuk menyimpan snapshot tanpa merender ke bitmap menengah
rupps
Harap tandai ini sebagai jawaban termudah! Ini berhasil! Sangat senang dengan solusi mudah ini
Kai Burghardt
Jika cuplikan ini diambil sebagaimana mestinya, kita bisa mengatakan parameters.setRotation(result), bukan?
Matt Logan
10
Ini mengasumsikan Anda menggunakan kelas Kamera secara langsung, Anda tidak dapat menentukan opsi yang sama saat Anda menggunakan maksud ACTION_IMAGE_CAPTURE.
atap
1
Apa result dan getCameraDisplayOrientation ()?
venkat
10
            int rotate = 0;
            try {
                File imageFile = new File(sourcepath);
                ExifInterface exif = new ExifInterface(
                        imageFile.getAbsolutePath());
                int orientation = exif.getAttributeInt(
                        ExifInterface.TAG_ORIENTATION,
                        ExifInterface.ORIENTATION_NORMAL);

                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;
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            Matrix matrix = new Matrix();
    matrix.postRotate(rotate);
    bitmap = Bitmap.createBitmap(bitmap , 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
vineet pal
sumber
akan sangat membantu jika memiliki beberapa penjelasan tentang apa yang dilakukan kode Anda, dan bagaimana kode berfungsi dengan cara yang berbeda dari jawaban lain (pertanyaannya sudah cukup lama, dan oleh karena itu jawaban lainnya mungkin cukup matang).
codeling
7

Pilihan lainnya adalah memutar bitmap di layar hasil seperti ini:

ImageView img=(ImageView)findViewById(R.id.ImageView01);
Bitmap bmp = BitmapFactory.decodeResource(getResources(), R.drawable.refresh);
// Getting width & height of the given image.
int w = bmp.getWidth();
int h = bmp.getHeight();
// Setting post rotate to 90
Matrix mtx = new Matrix();
mtx.postRotate(90);
// Rotating Bitmap
Bitmap rotatedBMP = Bitmap.createBitmap(bmp, 0, 0, w, h, mtx, true);
BitmapDrawable bmd = new BitmapDrawable(rotatedBMP);

img.setImageDrawable(bmd);
PakitoV
sumber
30
Pendekatan ini tidak akan berfungsi, karena juga memutar gambar dari perangkat yang menangani orientasi dengan benar.
hanspeide
jawaban lengkap & benar ada di sini stackoverflow.com/questions/6069122/…
Shirish Herwade
3

Saya juga memiliki jenis masalah yang sama untuk beberapa perangkat:

private void rotateImage(final String path) {

    Bitmap scaledBitmap = Bitmap.createScaledBitmap(Conasants.bm1, 1000,
            700, true);
    Bitmap rotatedBitmap = null;
    try {
        ExifInterface ei = new ExifInterface(path);
        int orientation = ei.getAttributeInt(ExifInterface.TAG_ORIENTATION,
                ExifInterface.ORIENTATION_NORMAL);
        Matrix matrix = new Matrix();
        switch (orientation) {
        case ExifInterface.ORIENTATION_ROTATE_90:
            matrix.postRotate(90);
            rotatedBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0,
                    scaledBitmap.getWidth(), scaledBitmap.getHeight(),
                    matrix, true);
            break;
        case ExifInterface.ORIENTATION_ROTATE_180:
            matrix.postRotate(180);
            rotatedBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0,
                    scaledBitmap.getWidth(), scaledBitmap.getHeight(),
                    matrix, true);
            break;
        case ExifInterface.ORIENTATION_ROTATE_270:
            matrix.postRotate(270);
            rotatedBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0,
                    scaledBitmap.getWidth(), scaledBitmap.getHeight(),
                    matrix, true);
            break;
        default:
            rotatedBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0,
                    scaledBitmap.getWidth(), scaledBitmap.getHeight(),
                    matrix, true);
            break;
        }
    } catch (Throwable e) {
        e.printStackTrace();
    }
    cropImage.setImageBitmap(rotatedBitmap);
    rotatedBitmap = null;
    Conasants.bm1 = null;
}
patel135
sumber
1

Coba cara ini: static Uri image_uri; Bitmap statis diambil_image = null;

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

      taken_image=BitmapFactory.decodeFile(image_uri.getPath());
      try
        {
            ExifInterface exif = new ExifInterface(image_uri.getPath()); 

            int orientation = 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) {
      Matrix matrix = new Matrix();
      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);

}

sherin
sumber
1

Tidak perlu lagi memeriksa data exif foto. Lakukan dengan mudah dengan Glide .

Google memperkenalkan kami Perpustakaan Pemuat Gambar untuk Android yang dikembangkan oleh bumptech bernama Glide sebagai perpustakaan yang direkomendasikan oleh Google. Ini telah digunakan di banyak proyek sumber terbuka Google hingga sekarang termasuk aplikasi resmi Google I / O 2014.

Contoh: Glide.with (konteks) .load (uri) .into (imageview);

Untuk selengkapnya: https://github.com/bumptech/glide

S. Prapagorn
sumber
1
public void setCameraPicOrientation(){
        int rotate = 0;
        try {
            File imageFile = new File(mCurrentPhotoPath);
            ExifInterface exif = new ExifInterface(
                    imageFile.getAbsolutePath());
            int orientation = exif.getAttributeInt(
                    ExifInterface.TAG_ORIENTATION,
                    ExifInterface.ORIENTATION_NORMAL);

            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;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        Matrix matrix = new Matrix();
        matrix.postRotate(rotate);
        int targetW = 640;
        int targetH = 640;

        /* Get the size of the image */
        BitmapFactory.Options bmOptions = new BitmapFactory.Options();
        bmOptions.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(mCurrentPhotoPath, bmOptions);
        int photoW = bmOptions.outWidth;
        int photoH = bmOptions.outHeight;

        /* Figure out which way needs to be reduced less */
        int scaleFactor = 1;
        if ((targetW > 0) || (targetH > 0)) {
            scaleFactor = Math.min(photoW/targetW, photoH/targetH);
        }

        /* Set bitmap options to scale the image decode target */
        bmOptions.inJustDecodeBounds = false;
        bmOptions.inSampleSize = scaleFactor;
        bmOptions.inPurgeable = true;

        /* Decode the JPEG file into a Bitmap */
        Bitmap bitmap = BitmapFactory.decodeFile(mCurrentPhotoPath, bmOptions);
        bitmap= Bitmap.createBitmap(bitmap , 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
            /* Associate the Bitmap to the ImageView */
      imageView.setImageBitmap(bitmap);
    }

Semoga ini bisa membantu !! Terima kasih

Dear S
sumber
0
    public static  int mOrientation =  1;

    OrientationEventListener myOrientationEventListener;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);
        setContentView(R.layout.takephoto);

        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);


        myOrientationEventListener
        = new OrientationEventListener(getApplicationContext()) {

            @Override
            public void onOrientationChanged(int o) {
                // TODO Auto-generated method stub
                if(!isTablet(getApplicationContext()))
                {
                    if(o<=285 && o>=80)
                        mOrientation = 2;
                    else
                        mOrientation = 1;
                }
                else
                {
                    if(o<=285 && o>=80)
                        mOrientation = 1;
                    else
                        mOrientation = 2;
                }

            }
        };

        myOrientationEventListener.enable();

    }



    public static boolean isTablet(Context context) {
        return (context.getResources().getConfiguration().screenLayout
                & Configuration.SCREENLAYOUT_SIZE_MASK)
                >= Configuration.SCREENLAYOUT_SIZE_LARGE;
    }

}

Saya harap ini akan membantu. Terima kasih!

jagdish
sumber
0

Hanya mengalami masalah yang sama di sini, cuplikan kode di bawah ini berfungsi untuk saya:

private static final String[] CONTENT_ORIENTATION = new String[] {
        MediaStore.Images.ImageColumns.ORIENTATION
};

static int getExifOrientation(ContentResolver contentResolver, Uri uri) {
    Cursor cursor = null;

    try {
        cursor = contentResolver.query(uri, CONTENT_ORIENTATION, null, null, null);
        if (cursor == null || !cursor.moveToFirst()) {
            return 0;
        }
        return cursor.getInt(0);
    } catch (RuntimeException ignored) {
        // If the orientation column doesn't exist, assume no rotation.
        return 0;
    } finally {
        if (cursor != null) {
            cursor.close();
        }
    }
}

semoga ini membantu :)

Cloud Chen
sumber
0

Coba ini di callback surfaceChanged:

Camera.Parameters parameters=mCamera.getParameters();
if(this.getResources().getConfiguration().orientation == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT){
    parameters.setRotation(90);
}else{
    parameters.setRotation(0);
}
mCamera.setParameters(parameters);
Manavendher
sumber
0

// klik tombol

btnCamera.setOnClickListener( new View.OnClickListener() {
        @Override
        public void onClick(View view) {

                try {
                    ContentValues values;
                    values = new ContentValues();
                    values.put(MediaStore.Images.Media.TITLE, "New Picture");
                    values.put(MediaStore.Images.Media.DESCRIPTION, "From your Camera");
                    imageUri = context.getContentResolver().insert(
                            MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values);
                    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                    intent.putExtra(MediaStore.EXTRA_OUTPUT, imageUri);
                    startActivityForResult(intent, CAMERA_REQUEST);
                }catch (Exception e){}

            });

// metode onActivityResult

   if (requestCode==CAMERA_REQUEST){
        try {
            if (imageUri!=null) {
                path = String.valueOf(new File(FilePath.getPath(context, imageUri)));
                   }  
        }catch (Exception e){
            toast("please try again "+e.getMessage());
            Log.e("image error",e.getMessage());
        }
    }

// buat jalur file kelas

public class FilePath {

public static String getPath(final Context context, final Uri uri) {

    // check here to KITKAT or new version
    final boolean isKitKat = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT;

    // DocumentProvider
    if (isKitKat && DocumentsContract.isDocumentUri(context, uri)) {

        // ExternalStorageProvider
        if (isExternalStorageDocument(uri)) {
            final String docId = DocumentsContract.getDocumentId(uri);
            final String[] split = docId.split(":");
            final String type = split[0];

            if ("primary".equalsIgnoreCase(type)) {
                return Environment.getExternalStorageDirectory() + "/"
                        + split[1];
            }
        }
        // DownloadsProvider
        else if (isDownloadsDocument(uri)) {

            final String id = DocumentsContract.getDocumentId(uri);
            final Uri contentUri = ContentUris.withAppendedId(
                    Uri.parse("content://downloads/public_downloads"),
                    Long.valueOf(id));

            return getDataColumn(context, contentUri, null, null);
        }
        // MediaProvider
        else if (isMediaDocument(uri)) {
            final String docId = DocumentsContract.getDocumentId(uri);
            final String[] split = docId.split(":");
            final String type = split[0];

            Uri contentUri = null;
            if ("image".equals(type)) {
                contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
            } else if ("video".equals(type)) {
                contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
            } else if ("audio".equals(type)) {
                contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
            }

            final String selection = "_id=?";
            final String[] selectionArgs = new String[] { split[1] };

            return getDataColumn(context, contentUri, selection,
                    selectionArgs);
        }
    }
    // MediaStore (and general)
    else if ("content".equalsIgnoreCase(uri.getScheme())) {

        // Return the remote address
        if (isGooglePhotosUri(uri))
            return uri.getLastPathSegment();

        return getDataColumn(context, uri, null, null);
    }
    // File
    else if ("file".equalsIgnoreCase(uri.getScheme())) {
        return uri.getPath();
    }

    return null;
}

/**
 * Get the value of the data column for this Uri. This is useful for
 * MediaStore Uris, and other file-based ContentProviders.
 *
 * @param context
 *            The context.
 * @param uri
 *            The Uri to query.
 * @param selection
 *            (Optional) Filter used in the query.
 * @param selectionArgs
 *            (Optional) Selection arguments used in the query.
 * @return The value of the _data column, which is typically a file path.
 */
public static String getDataColumn(Context context, Uri uri,
                                   String selection, String[] selectionArgs) {

    Cursor cursor = null;
    final String column = "_data";
    final String[] projection = { column };

    try {
        cursor = context.getContentResolver().query(uri, projection,
                selection, selectionArgs, null);
        if (cursor != null && cursor.moveToFirst()) {
            final int index = cursor.getColumnIndexOrThrow(column);
            return cursor.getString(index);
        }
    } finally {
        if (cursor != null)
            cursor.close();
    }
    return null;
}

/**
 * @param uri
 *            The Uri to check.
 * @return Whether the Uri authority is ExternalStorageProvider.
 */
public static boolean isExternalStorageDocument(Uri uri) {
    return "com.android.externalstorage.documents".equals(uri
            .getAuthority());
}

/**
 * @param uri
 *            The Uri to check.
 * @return Whether the Uri authority is DownloadsProvider.
 */
public static boolean isDownloadsDocument(Uri uri) {
    return "com.android.providers.downloads.documents".equals(uri
            .getAuthority());
}

/**
 * @param uri
 *            The Uri to check.
 * @return Whether the Uri authority is MediaProvider.
 */
public static boolean isMediaDocument(Uri uri) {
    return "com.android.providers.media.documents".equals(uri
            .getAuthority());
}

/**
 * @param uri
 *            The Uri to check.
 * @return Whether the Uri authority is Google Photos.
 */
public static boolean isGooglePhotosUri(Uri uri) {
    return "com.google.android.apps.photos.content".equals(uri
            .getAuthority());
}

}

Pramila Rawat
sumber
-1

Kode tersebut berfungsi untuk landscape dan portrait @frontCameraID = variabel mendapatkan metode klasik untuk show camera yang diinginkan

@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {

    if(holder.getSurface() == null) {
        return;
    }
    try{
        camera.stopPreview();
    } catch (Exception e){
    }

    try{

        int orientation = getDisplayOrientation(frontCameraID);

        Camera.Parameters parameters = camera.getParameters();
        parameters.setPreviewSize(mPreviewSize.width, mPreviewSize.height);
        if (parameters.getSupportedFocusModes().contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) {
            parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
        }

        parameters.setRotation(rotationPicture);
        camera.setParameters(parameters);
        camera.setDisplayOrientation(orientation);
        camera.startPreview();

    } catch (Exception e) {
        Log.i("ERROR", "Camera error changed: " + e.getMessage());
    }
}

Metode untuk mendapatkan orientasi y rotasi untuk menyimpan gambar dan tampilan orientasi @result = orientasi pada tampilan pratinjau kamera @rotationPicture = rotasi diperlukan untuk menyimpan gambar dengan benar

private int getDisplayOrientation(int cameraId) {

    android.hardware.Camera.CameraInfo info = new android.hardware.Camera.CameraInfo();
    android.hardware.Camera.getCameraInfo(cameraId, info);
    int rotation = ((Activity) context).getWindowManager().getDefaultDisplay().getRotation();
    int degrees = 0;
    switch (rotation) {
        case Surface.ROTATION_0: degrees = 0; break;
        case Surface.ROTATION_90: degrees = 90; break;
        case Surface.ROTATION_180: degrees = 180; break;
        case Surface.ROTATION_270: degrees = 270; break;
    }

    int result;
    if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
        result = (info.orientation + degrees) % 360;
        result = (360 - result) % 360;
        rotationPicture = (360 - result) % 360;
    } else {
        result = (info.orientation - degrees + 360) % 360;
        rotationPicture = result;
    }

    return result;
}

Seseorang bertanya tentang kode, tolong beritahu saya.

Alex Zaraos
sumber
-2

dua solusi satu baris menggunakan Picasso dan perpustakaan meluncur

Setelah menghabiskan banyak waktu dengan banyak solusi untuk masalah rotasi gambar, saya akhirnya menemukan dua solusi sederhana. Kami tidak perlu melakukan pekerjaan tambahan apa pun. Picasso dan Glide adalah perpustakaan yang sangat kuat untuk menangani gambar di aplikasi Anda. Ini akan membaca data EXIF ​​gambar dan memutar gambar secara otomatis.

Menggunakan glide library https://github.com/bumptech/glide

Glide.with(this).load("http url or sdcard url").into(imgageView);

Menggunakan perpustakaan Picasso https://github.com/square/picasso

Picasso.with(context).load("http url or sdcard url").into(imageView);
Vigneswaran A
sumber
Selamat datang di SO. Harap jangan meminta suara positif
JanS