Kamera-Orientierung Problem in Android

Ich baue eine Anwendung, die Kamera verwendet, um Bilder zu machen. Hier ist mein Quellcode dazu:

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

Auf onActivityResult() -Methode verwende ich BitmapFactory.decodeStream() um das Bild aufzunehmen.

  • Änderungsstring-Datumsformat und in TextView in Android einfügen?
  • RawQuery (Abfrage, AuswahlArgs)
  • Wie kann ich wissen, welche Marker auf Google Maps v2 für Android geklickt wurde?
  • Android-Galerie View Scrolling Problem, wenn onClickListener für Artikel gegeben
  • Android Bild Schaltfläche
  • Crashlytics / Fabric berichtet nicht auf Android
  • Wenn ich meine Anwendung auf Nexus eins laufe, läuft es gut. Aber wenn ich auf Samsung Galaxy S oder HTC Inspire 4G laufen, ist die Richtung des Bildes nicht korrekt.

    • Capture mit Portrait-Modus, das echte Bild (auf SD-Karte speichern) dreht sich immer um 90 Grad.

    Bildvorschau nach dem SchussEchtes Bild auf SD-Karte

    Bild Vorschau nach Schuss ——— Echtes Bild auf SD-Karte

    • Capture mit Landschaftsmodus, alles ist gut

    Bildvorschau nach SchussEchtes Bild auf SD-Karte

    Bild Vorschau nach Schuss ——— Echtes Bild auf SD-Karte

  • Zu wissen, wann die Karte gestoppt hat zu scrollen (wie "moveend" in Javascript API)
  • Ist es Pflicht, Gradle mit Android Studio zu verwenden?
  • Fehler beim Start von AVD - Das Dateisystem ist bereits 140800 (4k) Blöcke lang - Nichts zu tun
  • Android 3.x + Java ZipFile Klasse - Kann nicht lesen ZipEntries aus großen Dateien
  • Ansicht Pager Indikator Jake Wharton
  • Alarmmanager's Wake Lock beim Starten eines Service
  • 13 Solutions collect form web for “Kamera-Orientierung Problem in Android”

    Es gibt noch einige ähnliche Themen und Themen hier. Da du deine eigene Kamera nicht schreibst, denke ich, dass es hierher kommt:

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

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

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

    Da das Foto korrekt in deiner App angezeigt wird, bin ich mir nicht sicher, wo das Problem ist, aber das sollte dich definitiv auf den richtigen Weg stellen!

    Ich habe gerade das gleiche Problem, und verwendet, um die Orientierung 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, ist das zurückgegebene Bild in der Landschaft, also drehe ich es um 90 Grad.

    Hoffe, es hilft jedem anderen mit diesem Problem.

    Es gibt zwei Dinge:

    1. Kamera-Vorschau muss das gleiche wie Ihre Rotation. Setzen Sie dies durch camera.setDisplayOrientation(result);

    2. Speichern Sie das aufgenommene Bild als Kamera-Vorschau. 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); 

    Ich hoffe, das hilft.

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

    Eine weitere Möglichkeit besteht darin, die Bitmap im Ergebnisbild so 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); 

    Ich habe auch diese Art von gleichen Problem für ein Gerät:

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

    Nicht mehr die exif Daten des Fotos überprüfen. Geh einfach mit gleiten

    Google hat uns eine Image Loader Library für Android entwickelt, die von bumptech namens Glide als Bibliothek entwickelt wurde, die von Google empfohlen wurde. Es wurde in vielen Google Open-Source-Projekte bis jetzt einschließlich Google I / O 2014 offizielle Anwendung verwendet.

    Ex: Glide.with (Kontext) .load (uri) .into (imageview);

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

    Versuche es so: statisch 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); 

    }

     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

      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!

    Nur das gleiche Problem hier, das Code-Snippet unten 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 🙂

    Probieren Sie dies in surfaceChanged callback:

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

    Der Code ist funktional für Landschaft und Portrait @frontCameraID = Variable hat es die Methode klassisch 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 für die Orientierung y Rotation, um Bild- und Display-Orientierung zu speichern @result = Orientierung auf der Vorschau-Ansicht der Kamera @rotationPicture = Rotation notwendig, 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 Frage über Code, bitte sagen Sie mir.

    Das Android ist ein Google Android Fan-Website, Alles über Android Phones, Android Wear, Android Dev und Android Spiele Apps und so weiter.