Android कैमरा अभिविन्यास मुद्दा

Question

ऊर्ध्वाधर प्रारूप में लिए गए चित्रों परिदृश्य प्रारूप और उपाध्यक्ष प्रतिकूल में सहेजे जाते हैं। मैं इस आशय

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

onActivityResult() मैं बस अपना डेटाबेस के लिए चित्र URL की बचत कर रहा हूँ और सूचीदृश्य में यह प्रदर्शित करने का उपयोग करके एंड्रॉयड कैमरे का उपयोग कर रहा हूँ। लेकिन उन्मुखता परिवर्तन बदलता है। अगर मैं गैलरी से छवि चुनता हूं और इसे सहेजता हूं तो वही होगा।

मैं उन्मुखीकरण जिसमें फोटो लिया गया है चाहता हूँ। मैं इसे बदलना नहीं चाहता। क्या किसी के पास इस पर एक समाधान है।

Answer 1

कुछ उपकरणों छवि को घुमाने नहीं करता है के बाद यह लिया गया था लेकिन सिर्फ Exif डेटा में अपने उन्मुखीकरण जानकारी लिखें। इसलिए ली गई तस्वीर का उपयोग करने से पहले आपको

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

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

इसकी ओरिएंटेशन की जांच करने के लिए कॉल करना चाहिए। फिर लागू करें:

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

और अपनी सूचीदृश्य में इस नए बिटमैप का उपयोग करें। या आपकी तस्वीरों को लेने के बाद और इसे नए घुमावदार के साथ ओवरराइड करने के बाद भी इस विधियों को कॉल करना बेहतर है।

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

आप भी इस माध्यम से पालन कर सकते हैं:

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