Android Camera Orientation ISsue

Question

las imágenes tomadas en formato vertical se guardan en formato apaisado y viceversa. Estoy usando la cámara de Android mediante el uso de esta intención

Intent captureImage = new Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE); 
captureImage.putExtra(MediaStore.EXTRA_OUTPUT, imageFileUri);    
startActivityForResult(captureImage, CAMERA_PIC_REQUEST); 

onActivityResult() Estoy ahorrando URL de la imagen a mi base de datos y mostrarlo en una vista de lista. pero hay cambios de orientación. Lo mismo sucederá si selecciono la imagen de la galería y la guardo.

Quiero la orientación en la que se tomó la foto. No quiero cambiarlo. ¿Alguien tiene una solución en esto?

Answer 1

Algunos dispositivos no rotan la imagen después de que se tomó, sino que simplemente escriben su información de orientación en datos Exif. Por lo tanto, antes de usar la foto tomada debe llamar al método como:

private int resolveBitmapOrientation(File bitmapFile) throws IOException { 
     ExifInterface exif = null; 
     exif = new ExifInterface(bitmapFile.getAbsolutePath()); 

     return exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL); 
    } 

para verificar su orientación. A continuación, aplique:

private Bitmap applyOrientation(Bitmap bitmap, int orientation) { 
     int rotate = 0; 
     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; 
      default: 
       return bitmap; 
     } 

     int w = bitmap.getWidth(); 
     int h = bitmap.getHeight(); 
     Matrix mtx = new Matrix(); 
     mtx.postRotate(rotate); 
     return Bitmap.createBitmap(bitmap, 0, 0, w, h, mtx, true); 
    } 

y utilice este nuevo mapa de bits en su lista de lista. O incluso es mejor llamar a este método justo después de tomar la foto y anularla con una nueva girada.

En caso si usted está recibiendo datos de mapa de bits como Uri el siguiente método se puede utilizar para recuperar su ruta de archivo:

public static String getPathFromURI(Context context, Uri contentUri) { 
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT && 
      DocumentsContract.isDocumentUri(context, contentUri)) { 
     return getPathForV19AndUp(context, contentUri); 
    } else { 
     return getPathForPreV19(context, contentUri); 
    } 
} 

private static String getPathForPreV19(Context context, Uri contentUri) { 
    String[] projection = { MediaStore.Images.Media.DATA }; 
    Cursor cursor = context.getContentResolver().query(contentUri, projection, null, null, null); 
    if (cursor != null && cursor.moveToFirst()) { 
     try { 
      int columnIndex = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA); 
      return cursor.getString(columnIndex); 
     } finally { 
      cursor.close(); 
     } 
    } 

    return null; 
} 

@TargetApi(Build.VERSION_CODES.KITKAT) 
private static String getPathForV19AndUp(Context context, Uri contentUri) { 
    String documentId = DocumentsContract.getDocumentId(contentUri); 
    String id = documentId.split(":")[1]; 

    String[] column = { MediaStore.Images.Media.DATA }; 
    String sel = MediaStore.Images.Media._ID + "=?"; 
    Cursor cursor = context.getContentResolver(). 
      query(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, 
        column, sel, new String[]{ id }, null); 

    if (cursor != null) { 
     try { 
      int columnIndex = cursor.getColumnIndex(column[0]); 
      if (cursor.moveToFirst()) { 
       return cursor.getString(columnIndex); 
      } 
     } finally { 
      cursor.close(); 
     } 
    } 

    return null; 
} 

Answer 2

También puede seguir de esta manera:

static Uri image_uri; 
static Bitmap taken_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()); 
//Since API Level 5 
       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); 
}