Problem mit der Kameraausrichtung in Android

100

Ich baue eine Anwendung, die Kamera verwendet, um Bilder aufzunehmen. Hier ist mein Quellcode, um dies zu tun:

        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);

Bei der onActivityResult()Methode verwende ich, BitmapFactory.decodeStream()um das Bild aufzunehmen.

Wenn ich meine Anwendung auf Nexus One ausführe, läuft sie gut. Wenn ich jedoch mit Samsung Galaxy S oder HTC Inspire 4G arbeite, ist die Bildrichtung nicht korrekt.

  • Bei der Aufnahme im Hochformat dreht sich das reale Bild (auf SD-Karte speichern) immer um 90 Grad.

Bildvorschau nach der Aufnahme echtes Bild auf SD-Karte

Bildvorschau nach der Aufnahme --------- Echtes Bild auf SD-Karte

  • Mit Querformat aufnehmen, alles ist gut.

Bildvorschau nach der Aufnahme Echtes Bild auf SD-Karte

Bildvorschau nach der Aufnahme --------- Echtes Bild auf SD-Karte

Nguyen Minh Binh
quelle
1
setRotation (90) funktionierte für mich in Samsung Galaxy Nexus, während es das Bild in Xperia S. nicht
drehte
kann mir jemand dabei helfen? Ich habe das gleiche Problem stackoverflow.com/questions/28379130/…
Antworte hier stackoverflow.com/questions/14066038/…
Shirish Herwade

Antworten:

50

Es gibt hier einige ähnliche Themen und Probleme. Da Sie keine eigene Kamera schreiben, läuft es meiner Meinung nach darauf hinaus:

Einige Geräte drehen das Bild vor dem Speichern, während andere einfach das Orientierungs-Tag in die Exif-Daten des Fotos einfügen.

Ich würde empfehlen, die Exif-Daten des Fotos zu überprüfen und besonders danach zu suchen

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

Da das Foto in Ihrer App korrekt angezeigt wird, bin ich mir nicht sicher, wo das Problem liegt, aber dies sollte Sie auf jeden Fall auf den richtigen Weg bringen!

ramz
quelle
33
Dies scheint auf einigen Geräten nicht zu funktionieren, es gibt 0 für alle Ausrichtungen zurück. Ich weiß, dass es auf Galaxy S Infuse, Sony Xperia Arc und S II passiert. Interessant ist hier, dass dieselben Bilder aus der Galerie ausgewählt werden hat der Inhaltsanbieter den richtigen Orientierungswert. Irgendwelche Ideen?
Tolga E
3
@Abhijit Ja, ich habe versucht, dieses Problem zu lösen (geöffnetes Ticket mit Android usw.). Und ich denke, ich habe eine vernünftige Lösung gefunden, um beide Telefone mit korrekten und fehlerhaften Orientierungsinformationen zu behandeln. Schauen Sie sich meine detaillierte Antwort an, die ich hier auf meine eigene Frage gepostet habe. stackoverflow.com/a/8864367/137404
Tolga E
1
@ramz Ich habe versucht, diese Lösung zu finden. Es wird jedoch für alle Ausrichtungen 0 zurückgegeben. Haben Sie eine Idee, warum für alle Orientierungen 0 zurückgegeben wird?
Dory
1
Der Grund dafür, dass diese Lösung nicht funktioniert, ist manchmal ein falscher "Pfad", der im ExifInterface-Konstruktor verwendet wird. Meistens auf KitKat. Sehen Sie hier, wie Sie den richtigen Weg finden: stackoverflow.com/a/20559175/690777
peter.bartos
1
Es gibt immer 0 (ExifInterface.ORIENTATION_UNDEFINED) auf meinem Samsung Galaxy S4 ...
valerybodak
28

Ich bin gerade auf dasselbe Problem gestoßen und habe dies verwendet, um die Ausrichtung zu korrigieren:

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);
    }
}

Wenn die Breite der Bitmap größer als die Höhe ist, befindet sich das zurückgegebene Bild im Querformat, sodass ich es um 90 Grad drehe.

Hoffe, es hilft anderen bei diesem Problem.


quelle
18
Was passiert , wenn das Bild tatsächlich aufgenommen in der Landschaft? Ihr Code wird es weiterhin drehen. Dies ist keine Antwort auf die Frage.
Wladimir Palant
1
Meine Anwendung erzwingt ein Porträt, das ist also kein Problem. Ich habe hier nur eine alternative Lösung für das Problem aufgenommen.
5
Aber wenn die Anwendung Hochformat erzwingt, können Sie immer noch ein Querformat (Breite> Höhe) aufnehmen und es wird gedreht ... Es ist zumindest das, was ich bekomme. ScreenOrientation = "Hochformat" für alles ... Kamera kann immer noch Querformat aufnehmen Bilder.
Ixx
vollständige und korrekte Antwort hier vorhanden stackoverflow.com/questions/6069122/…
Shirish Herwade
21

Es sind zwei Dinge erforderlich:

  1. Die Kameravorschau muss der Rotation entsprechen. Stellen Sie dies ein durchcamera.setDisplayOrientation(result);

  2. Speichern Sie das aufgenommene Bild als Kameravorschau. Tun Sie dies über 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);

Hoffentlich hilft das.

Tran Khanh Tung
quelle
Das ist es! Camera.parameters ist sehr praktisch, um Schnappschüsse zu speichern, ohne auf einer Zwischen-Bitmap zu
rendern
Bitte markieren Sie dies als die einfachste Antwort! Das macht den Job! Sehr glücklich über diese einfache Lösung
Kai Burghardt
Wenn dieses Snippet so genommen wird, wie es ist, könnten wir einfach sagen parameters.setRotation(result), nein?
Matt Logan
10
Dies setzt voraus, dass Sie die Camera-Klasse direkt verwenden. Sie können nicht dieselben Optionen angeben, wenn Sie die Absicht ACTION_IMAGE_CAPTURE verwenden.
Dach
1
Was ist Ergebnis und 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);
Weinkumpel
quelle
Es wäre hilfreich, eine Erklärung zu haben, was Ihr Code tut und wie er die Dinge anders macht als andere Antworten (die Frage ist schließlich schon ziemlich alt, und die anderen Antworten sind daher wahrscheinlich ziemlich ausgereift).
Codelling
7

Eine andere Möglichkeit besteht darin, die Bitmap im Ergebnisbildschirm wie folgt zu drehen:

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
quelle
30
Dieser Ansatz funktioniert nicht, da auch Bilder von Geräten gedreht werden, die die Ausrichtung richtig handhaben.
Hanspeide
vollständige und korrekte Antwort hier vorhanden stackoverflow.com/questions/6069122/…
Shirish Herwade
3

Ich habe auch diese Art von Problem für einige Geräte:

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
quelle
1

Versuchen Sie es folgendermaßen: static Uri image_uri; statische Bitmap take_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
quelle
1

Keine Überprüfung der Exif-Daten des Fotos mehr. Gehen Sie einfach mit Glide .

Google hat uns eine von Bumptech entwickelte Image Loader Library für Android namens Glide als von Google empfohlene Bibliothek vorgestellt. Es wurde bisher in vielen Open Source-Projekten von Google verwendet, einschließlich der offiziellen Anwendung von Google I / O 2014.

Beispiel: Glide.with (Kontext) .load (uri) .into (Bildansicht);

Für mehr: https://github.com/bumptech/glide

S.Prapagorn
quelle
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);
    }

Hoffe das wird helfen !! Vielen Dank

Lieber S
quelle
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;
    }

}

Ich hoffe das wird helfen. Danke!

jagdisch
quelle
0

Stoßen Sie hier auf dasselbe Problem, das folgende Codefragment funktioniert für mich:

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();
        }
    }
}

hoffe das hilft :)

Wolke Chen
quelle
0

Versuchen Sie dies im Rückruf von 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
quelle
0

// Schaltfläche klicken

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){}

            });

// onActivityResult-Methode

   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());
        }
    }

// einen Klassendateipfad erstellen

öffentliche Klasse 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
quelle
-1

Der Code ist funktional für Quer- und Hochformat @frontCameraID = Variable hat es die klassische Methode für Showkamera gesucht

@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());
    }
}

Methode zum Abrufen der Ausrichtung und Drehung zum Speichern des Bilds und Anzeigen der Ausrichtung @result = Ausrichtung in der Vorschau der Kamera @rotationPicture = Drehung erforderlich, um das Bild korrekt zu speichern

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;
}

Jemand fragt nach Code, bitte sag es mir.

Alex Zaraos
quelle
-2

zwei Einzeilige Lösungen mit Picasso und Gleitbibliothek

Nachdem ich viel Zeit mit vielen Lösungen für das Problem der Bildrotation verbracht hatte, fand ich endlich zwei einfache Lösungen. Wir müssen keine zusätzlichen Arbeiten durchführen. Picasso und Glide sind eine sehr leistungsstarke Bibliothek für die Verarbeitung von Bildern in Ihrer App. Es liest EXIF-Bilddaten und dreht die Bilder automatisch.

Verwenden der Gleitbibliothek https://github.com/bumptech/glide

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

Verwenden der Picasso-Bibliothek https://github.com/square/picasso

Picasso.with(context).load("http url or sdcard url").into(imageView);
Vigneswaran A.
quelle
Willkommen bei SO. Bitte unterlassen Sie fordern upvotes: meta.stackexchange.com/questions/194061/...
JanS