Orientamento videocamera Android ISsue

Question

Le foto scattate in formato verticale vengono salvate in formato orizzontale e viceversa. Sto usando fotocamera Android utilizzando questo intento

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

onActivityResult() sto solo risparmiando URL dell'immagine al mio database e la visualizzazione in un controllo ListView. ma non ci sono modifiche orientative. Lo stesso accadrà se scelgo l'immagine dalla galleria e la salvo.

Desidero l'orientamento in cui è stata scattata la foto. Non voglio cambiarlo. Qualcuno ha una soluzione su questo.

Answer 1

Alcuni dispositivi non ruotano l'immagine dopo che è stata presa, ma semplicemente scrivono le informazioni di orientamento in dati Exif. Quindi, prima di utilizzare la foto scattata, devi chiamare il metodo:

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

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

per verificare l'orientamento. Quindi applicare:

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

e utilizzare questa nuova bitmap nella lista. Oppure è ancora meglio chiamare questo metodo subito dopo aver scattato la foto e sostituirla con una nuova.

Nel caso in cui se si ricevono i dati bitmap come Uri il seguente metodo può essere utilizzato per recuperare il suo percorso file:

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

Potete anche seguire in questo modo:

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