blocks|key|936720|text|你看过图片的EXIF数据了吗？它可能知道拍摄照片时相机的方向。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|936721|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Have you looked at the EXIF data of the images? It may know the orientation of the camera when the picture was taken.

blocks|key|1151110|text|举个例子..。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1151111|首先，您需要创建一个ExifInterface：|1151112|ExifInterface+exif+=+new+ExifInterface(filename);|code-block|syntax|javascript|1151113|然后，您可以获取图像的方向：|1151114|orientation+=+exif.getAttributeInt(ExifInterface.TAG_ORIENTATION,+1);|1151115|方向值的含义如下：http://sylvana.net/jpegcrop/exif_orientation.html|offset|length|1151116|因此，最重要的值是3、6和8。例如，如果方向是ExifInterface.ORIENTATION_ROTATE_90+(即6)，则可以像这样旋转图像：|style|CODE|1151117|Matrix+matrix+=+new+Matrix();
matrix.postRotate(90);
rotatedBitmap+=+Bitmap.createBitmap(sourceBitmap,+0,+0,+sourceBitmap.getWidth(),+sourceBitmap.getHeight(),+matrix,+true);|1151118|不过，这只是一个简单的例子。我相信还有其他方法可以执行实际的旋转。但你也可以在StackOverflow上找到这些。|1151119|entityMap|0|LINK|mutability|MUTABLE|url|http://sylvana.net/jpegcrop/exif_orientation.html^0|0|0|0|0|0|9|1D|0|0|N|Z|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|19|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|1A|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|1B|8|@]|9|@$O|1C|P|1D|1|1E]]|A|$]]|$1|Q|3|R|5|6|7|1F|8|@$O|1G|P|1H|S|T]]|9|@]|A|$]]|$1|U|3|V|5|F|7|1I|8|@]|9|@]|A|$G|H]]|$1|W|3|X|5|6|7|1J|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]]]

So, as an example...

First you need to create an ExifInterface:

<pre><code>ExifInterface exif = new ExifInterface(filename);
</code></pre>

You can then grab the orientation of the image:

<pre><code>orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 1);
</code></pre>

Here's what the orientation values mean:
<a href="http://sylvana.net/jpegcrop/exif_orientation.html" rel="noreferrer">http://sylvana.net/jpegcrop/exif_orientation.html</a>

So, the most important values are 3, 6 and 8.
If the orientation is <code>ExifInterface.ORIENTATION_ROTATE_90</code> (which is 6), for example, you can rotate the image like this:

<pre><code>Matrix matrix = new Matrix();
matrix.postRotate(90);
rotatedBitmap = Bitmap.createBitmap(sourceBitmap, 0, 0, sourceBitmap.getWidth(), sourceBitmap.getHeight(), matrix, true);
</code></pre>

That's just a quick example, though. I'm sure there are other ways of performing the actual rotation. But you will find those on StackOverflow as well.

blocks|key|1151162|text|我用下面的解决方法解决了这个问题。请注意，我还对图像进行了缩放，这是避免OutOfMemoryExceptions所必需的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1151163|请注意，此解决方案将不能与肖像图像或倒置图像正常工作(感谢Timmmm的注意)。如果需要的话，Timmmm上面的解决方案可能是更好的选择，而且看起来也更优雅：https://stackoverflow.com/a/8914291/449918|offset|length|1151164|File+path+=+//+...+location+of+your+bitmap+file
int+w+=+512;+int+h+=+384;+//+size+that+does+not+lead+to+OutOfMemoryException+on+Nexus+One
Bitmap+b+=+BitmapFactory.decodeFile(path);


//+Hack+to+determine+whether+the+image+is+rotated
boolean+rotated+=+b.getWidth()+>+b.getHeight();

Bitmap+resultBmp+=+null;

//+If+not+rotated,+just+scale+it
if+(!rotated)+{
++++resultBmp+=+Bitmap.createScaledBitmap(b,+w,+h,+true);
++++b.recycle();
++++b+=+null;

//+If+rotated,+scale+it+by+switching+width+and+height+and+then+rotated+it
}+else+{
++++Bitmap+scaledBmp+=+Bitmap.createScaledBitmap(b,+h,+w,+true);
++++b.recycle();
++++b+=+null;

++++Matrix+mat+=+new+Matrix();
++++mat.postRotate(90);
++++resultBmp+=+Bitmap.createBitmap(scaledBmp,+0,+0,+h,+w,+mat,+true);

++++//+Release+image+resources
++++scaledBmp.recycle();
++++scaledBmp+=+null;
}

//+resultBmp+now+contains+the+scaled+and+rotated+image|code-block|syntax|javascript|1151165|干杯|1151166|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/8914291/449918^0|0|27|16|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@$D|W|E|X|1|Y]]|A|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

I solved the problem with the following workaround. Note that I am also scaling the image, which was necessary to avoid OutOfMemoryExceptions.

Beware that this solution will not work properly with portrait images or opside-down images (thank you Timmmm for noting). Timmmm's solution above might be the better choice if that is required and it looks more elegant, too: <a href="https://stackoverflow.com/a/8914291/449918">https://stackoverflow.com/a/8914291/449918</a>

<pre><code>File path = // ... location of your bitmap file
int w = 512; int h = 384; // size that does not lead to OutOfMemoryException on Nexus One
Bitmap b = BitmapFactory.decodeFile(path);


// Hack to determine whether the image is rotated
boolean rotated = b.getWidth() &gt; b.getHeight();

Bitmap resultBmp = null;

// If not rotated, just scale it
if (!rotated) {
 resultBmp = Bitmap.createScaledBitmap(b, w, h, true);
 b.recycle();
 b = null;

// If rotated, scale it by switching width and height and then rotated it
} else {
 Bitmap scaledBmp = Bitmap.createScaledBitmap(b, h, w, true);
 b.recycle();
 b = null;

 Matrix mat = new Matrix();
 mat.postRotate(90);
 resultBmp = Bitmap.createBitmap(scaledBmp, 0, 0, h, w, mat, true);

 // Release image resources
 scaledBmp.recycle();
 scaledBmp = null;
}

// resultBmp now contains the scaled and rotated image
</code></pre>

Cheers

blocks|key|936898|text|这是一个完整的解决方案(可以在Facebook+SDK的Hackbook示例中找到)。它的优点是不需要访问文件本身。如果你正在从内容解析器加载图片(例如，如果你的应用程序正在响应分享照片的意图)，这是非常有用的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|936899|public+static+int+getOrientation(Context+context,+Uri+photoUri)+{
++++/*+it's+on+the+external+media.+*/
++++Cursor+cursor+=+context.getContentResolver().query(photoUri,
++++++++++++new+String[]+{+MediaStore.Images.ImageColumns.ORIENTATION+},+null,+null,+null);

++++if+(cursor.getCount()+!=+1)+{
++++++++return+-1;
++++}

++++cursor.moveToFirst();
++++return+cursor.getInt(0);
}|code-block|syntax|javascript|936900|然后你可以得到一个旋转后的位图，如下所示。这段代码还将图像缩小(不幸的是)为MAX_IMAGE_DIMENSION。否则，您可能会耗尽内存。|936901|public+static+Bitmap+getCorrectlyOrientedImage(Context+context,+Uri+photoUri)+throws+IOException+{
++++InputStream+is+=+context.getContentResolver().openInputStream(photoUri);
++++BitmapFactory.Options+dbo+=+new+BitmapFactory.Options();
++++dbo.inJustDecodeBounds+=+true;
++++BitmapFactory.decodeStream(is,+null,+dbo);
++++is.close();

++++int+rotatedWidth,+rotatedHeight;
++++int+orientation+=+getOrientation(context,+photoUri);

++++if+(orientation+==+90+%7C%7C+orientation+==+270)+{
++++++++rotatedWidth+=+dbo.outHeight;
++++++++rotatedHeight+=+dbo.outWidth;
++++}+else+{
++++++++rotatedWidth+=+dbo.outWidth;
++++++++rotatedHeight+=+dbo.outHeight;
++++}

++++Bitmap+srcBitmap;
++++is+=+context.getContentResolver().openInputStream(photoUri);
++++if+(rotatedWidth+>+MAX_IMAGE_DIMENSION+%7C%7C+rotatedHeight+>+MAX_IMAGE_DIMENSION)+{
++++++++float+widthRatio+=+((float)+rotatedWidth)+/+((float)+MAX_IMAGE_DIMENSION);
++++++++float+heightRatio+=+((float)+rotatedHeight)+/+((float)+MAX_IMAGE_DIMENSION);
++++++++float+maxRatio+=+Math.max(widthRatio,+heightRatio);

++++++++//+Create+the+bitmap+from+file
++++++++BitmapFactory.Options+options+=+new+BitmapFactory.Options();
++++++++options.inSampleSize+=+(int)+maxRatio;
++++++++srcBitmap+=+BitmapFactory.decodeStream(is,+null,+options);
++++}+else+{
++++++++srcBitmap+=+BitmapFactory.decodeStream(is);
++++}
++++is.close();

++++/*
+++++*+if+the+orientation+is+not+0+(or+-1,+which+means+we+don't+know),+we
+++++*+have+to+do+a+rotation.
+++++*/
++++if+(orientation+>+0)+{
++++++++Matrix+matrix+=+new+Matrix();
++++++++matrix.postRotate(orientation);

++++++++srcBitmap+=+Bitmap.createBitmap(srcBitmap,+0,+0,+srcBitmap.getWidth(),
++++++++++++++++srcBitmap.getHeight(),+matrix,+true);
++++}

++++return+srcBitmap;
}|936902|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

This is a full solution (found in the Hackbook example from the Facebook SDK). It has the advantage of not needing access to the file itself. This is extremely useful if you are loading an image from the content resolver thingy (e.g. if your app is responding to a share-photo intent).

<pre><code>public static int getOrientation(Context context, Uri photoUri) {
 /* it's on the external media. */
 Cursor cursor = context.getContentResolver().query(photoUri,
 new String[] { MediaStore.Images.ImageColumns.ORIENTATION }, null, null, null);

 if (cursor.getCount() != 1) {
 return -1;
 }

 cursor.moveToFirst();
 return cursor.getInt(0);
}
</code></pre>

And then you can get a rotated Bitmap as follows. This code also scales down the image (badly unfortunately) to MAX_IMAGE_DIMENSION. Otherwise you may run out of memory.

<pre><code>public static Bitmap getCorrectlyOrientedImage(Context context, Uri photoUri) throws IOException {
 InputStream is = context.getContentResolver().openInputStream(photoUri);
 BitmapFactory.Options dbo = new BitmapFactory.Options();
 dbo.inJustDecodeBounds = true;
 BitmapFactory.decodeStream(is, null, dbo);
 is.close();

 int rotatedWidth, rotatedHeight;
 int orientation = getOrientation(context, photoUri);

 if (orientation == 90 || orientation == 270) {
 rotatedWidth = dbo.outHeight;
 rotatedHeight = dbo.outWidth;
 } else {
 rotatedWidth = dbo.outWidth;
 rotatedHeight = dbo.outHeight;
 }

 Bitmap srcBitmap;
 is = context.getContentResolver().openInputStream(photoUri);
 if (rotatedWidth &gt; MAX_IMAGE_DIMENSION || rotatedHeight &gt; MAX_IMAGE_DIMENSION) {
 float widthRatio = ((float) rotatedWidth) / ((float) MAX_IMAGE_DIMENSION);
 float heightRatio = ((float) rotatedHeight) / ((float) MAX_IMAGE_DIMENSION);
 float maxRatio = Math.max(widthRatio, heightRatio);

 // Create the bitmap from file
 BitmapFactory.Options options = new BitmapFactory.Options();
 options.inSampleSize = (int) maxRatio;
 srcBitmap = BitmapFactory.decodeStream(is, null, options);
 } else {
 srcBitmap = BitmapFactory.decodeStream(is);
 }
 is.close();

 /*
 * if the orientation is not 0 (or -1, which means we don't know), we
 * have to do a rotation.
 */
 if (orientation &gt; 0) {
 Matrix matrix = new Matrix();
 matrix.postRotate(orientation);

 srcBitmap = Bitmap.createBitmap(srcBitmap, 0, 0, srcBitmap.getWidth(),
 srcBitmap.getHeight(), matrix, true);
 }

 return srcBitmap;
}
</code></pre>

blocks|key|936954|text|Timmmm对上面的解决方案进行了改进，在最后添加了一些额外的缩放，以确保图像符合边界：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|936955|public+static+Bitmap+loadBitmap(String+path,+int+orientation,+final+int+targetWidth,+final+int+targetHeight)+{
++++Bitmap+bitmap+=+null;
++++try+{
++++++++//+First+decode+with+inJustDecodeBounds=true+to+check+dimensions
++++++++final+BitmapFactory.Options+options+=+new+BitmapFactory.Options();
++++++++options.inJustDecodeBounds+=+true;
++++++++BitmapFactory.decodeFile(path,+options);

++++++++//+Adjust+extents
++++++++int+sourceWidth,+sourceHeight;
++++++++if+(orientation+==+90+%7C%7C+orientation+==+270)+{
++++++++++++sourceWidth+=+options.outHeight;
++++++++++++sourceHeight+=+options.outWidth;
++++++++}+else+{
++++++++++++sourceWidth+=+options.outWidth;
++++++++++++sourceHeight+=+options.outHeight;
++++++++}

++++++++//+Calculate+the+maximum+required+scaling+ratio+if+required+and+load+the+bitmap
++++++++if+(sourceWidth+>+targetWidth+%7C%7C+sourceHeight+>+targetHeight)+{
++++++++++++float+widthRatio+=+(float)sourceWidth+/+(float)targetWidth;
++++++++++++float+heightRatio+=+(float)sourceHeight+/+(float)targetHeight;
++++++++++++float+maxRatio+=+Math.max(widthRatio,+heightRatio);
++++++++++++options.inJustDecodeBounds+=+false;
++++++++++++options.inSampleSize+=+(int)maxRatio;
++++++++++++bitmap+=+BitmapFactory.decodeFile(path,+options);
++++++++}+else+{
++++++++++++bitmap+=+BitmapFactory.decodeFile(path);
++++++++}

++++++++//+Rotate+the+bitmap+if+required
++++++++if+(orientation+>+0)+{
++++++++++++Matrix+matrix+=+new+Matrix();
++++++++++++matrix.postRotate(orientation);
++++++++++++bitmap+=+Bitmap.createBitmap(bitmap,+0,+0,+bitmap.getWidth(),+bitmap.getHeight(),+matrix,+true);
++++++++}

++++++++//+Re-scale+the+bitmap+if+necessary
++++++++sourceWidth+=+bitmap.getWidth();
++++++++sourceHeight+=+bitmap.getHeight();
++++++++if+(sourceWidth+!=+targetWidth+%7C%7C+sourceHeight+!=+targetHeight)+{
++++++++++++float+widthRatio+=+(float)sourceWidth+/+(float)targetWidth;
++++++++++++float+heightRatio+=+(float)sourceHeight+/+(float)targetHeight;
++++++++++++float+maxRatio+=+Math.max(widthRatio,+heightRatio);
++++++++++++sourceWidth+=+(int)((float)sourceWidth+/+maxRatio);
++++++++++++sourceHeight+=+(int)((float)sourceHeight+/+maxRatio);
++++++++++++bitmap+=+Bitmap.createScaledBitmap(bitmap,+sourceWidth,+sourceHeight,+true);
++++++++}
++++}+catch+(Exception+e)+{
++++}
++++return+bitmap;
}|code-block|syntax|javascript|936956|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Improving on the solution above by Timmmm to add some extra scaling at the end to ensure that the image fits within the bounds:

<pre><code>public static Bitmap loadBitmap(String path, int orientation, final int targetWidth, final int targetHeight) {
 Bitmap bitmap = null;
 try {
 // First decode with inJustDecodeBounds=true to check dimensions
 final BitmapFactory.Options options = new BitmapFactory.Options();
 options.inJustDecodeBounds = true;
 BitmapFactory.decodeFile(path, options);

 // Adjust extents
 int sourceWidth, sourceHeight;
 if (orientation == 90 || orientation == 270) {
 sourceWidth = options.outHeight;
 sourceHeight = options.outWidth;
 } else {
 sourceWidth = options.outWidth;
 sourceHeight = options.outHeight;
 }

 // Calculate the maximum required scaling ratio if required and load the bitmap
 if (sourceWidth &gt; targetWidth || sourceHeight &gt; targetHeight) {
 float widthRatio = (float)sourceWidth / (float)targetWidth;
 float heightRatio = (float)sourceHeight / (float)targetHeight;
 float maxRatio = Math.max(widthRatio, heightRatio);
 options.inJustDecodeBounds = false;
 options.inSampleSize = (int)maxRatio;
 bitmap = BitmapFactory.decodeFile(path, options);
 } else {
 bitmap = BitmapFactory.decodeFile(path);
 }

 // Rotate the bitmap if required
 if (orientation &gt; 0) {
 Matrix matrix = new Matrix();
 matrix.postRotate(orientation);
 bitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
 }

 // Re-scale the bitmap if necessary
 sourceWidth = bitmap.getWidth();
 sourceHeight = bitmap.getHeight();
 if (sourceWidth != targetWidth || sourceHeight != targetHeight) {
 float widthRatio = (float)sourceWidth / (float)targetWidth;
 float heightRatio = (float)sourceHeight / (float)targetHeight;
 float maxRatio = Math.max(widthRatio, heightRatio);
 sourceWidth = (int)((float)sourceWidth / maxRatio);
 sourceHeight = (int)((float)sourceHeight / maxRatio);
 bitmap = Bitmap.createScaledBitmap(bitmap, sourceWidth, sourceHeight, true);
 }
 } catch (Exception e) {
 }
 return bitmap;
}
</code></pre>

blocks|key|937021|text|你只需从SD卡中读取路径并执行以下代码...它将在旋转后替换现有的照片。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937022|不:+Exif不能在大多数设备上工作，它给出了错误的数据，所以在保存到你想要的任何程度之前硬编码旋转是很好的，你只需要在postRotate中将角度值更改为你想要的任何值。|937023|++++String+photopath+=+tempphoto.getPath().toString();
++++Bitmap+bmp+=+BitmapFactory.decodeFile(photopath);

++++Matrix+matrix+=+new+Matrix();
++++matrix.postRotate(90);
++++bmp+=+Bitmap.createBitmap(bmp,+0,+0,+bmp.getWidth(),+bmp.getHeight(),+matrix,+true);

++++FileOutputStream+fOut;
++++try+{
++++++++fOut+=+new+FileOutputStream(tempphoto);
++++++++bmp.compress(Bitmap.CompressFormat.JPEG,+85,+fOut);
++++++++fOut.flush();
++++++++fOut.close();

++++}+catch+(FileNotFoundException+e1)+{
++++++++//+TODO+Auto-generated+catch+block
++++++++e1.printStackTrace();
++++}+catch+(IOException+e)+{
++++++++//+TODO+Auto-generated+catch+block
++++++++e.printStackTrace();
++++}

}|code-block|syntax|javascript|937024|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You can just read the path from sd card and do the following code...it'll Replace the existing photo after rotating it..

Not: Exif doesnt work on most of the devices, it gives the wrong data so it's good to hard code the rotating before saving to any degree you want to,You just have to change the angle value in postRotate to any you want to.

<pre><code> String photopath = tempphoto.getPath().toString();
 Bitmap bmp = BitmapFactory.decodeFile(photopath);

 Matrix matrix = new Matrix();
 matrix.postRotate(90);
 bmp = Bitmap.createBitmap(bmp, 0, 0, bmp.getWidth(), bmp.getHeight(), matrix, true);

 FileOutputStream fOut;
 try {
 fOut = new FileOutputStream(tempphoto);
 bmp.compress(Bitmap.CompressFormat.JPEG, 85, fOut);
 fOut.flush();
 fOut.close();

 } catch (FileNotFoundException e1) {
 // TODO Auto-generated catch block
 e1.printStackTrace();
 } catch (IOException e) {
 // TODO Auto-generated catch block
 e.printStackTrace();
 }

}
</code></pre>

blocks|key|1151403|text|在我的例子中，通过这篇文章的帮助，用下面的代码解决了这个问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1151404|++++++++++++Bitmap+myBitmap+=+getBitmap(imgFile.getAbsolutePath());

++++++++++++try+{
++++++++++++++++ExifInterface+exif+=+new+ExifInterface(imgFile.getAbsolutePath());
++++++++++++++++int+orientation+=+exif.getAttributeInt(ExifInterface.TAG_ORIENTATION,+1);
++++++++++++++++Log.d("EXIF",+"Exif:+"+%2B+orientation);
++++++++++++++++Matrix+matrix+=+new+Matrix();
++++++++++++++++if+(orientation+==+6)+{
++++++++++++++++++++matrix.postRotate(90);
++++++++++++++++}
++++++++++++++++else+if+(orientation+==+3)+{
++++++++++++++++++++matrix.postRotate(180);
++++++++++++++++}
++++++++++++++++else+if+(orientation+==+8)+{
++++++++++++++++++++matrix.postRotate(270);
++++++++++++++++}
++++++++++++++++myBitmap+=+Bitmap.createBitmap(myBitmap,+0,+0,+myBitmap.getWidth(),+myBitmap.getHeight(),+matrix,+true);+//+rotating+bitmap
++++++++++++}
++++++++++++catch+(Exception+e)+{

++++++++++++}
++++++++++++ImageView+img+=+(ImageView)+findViewById(R.id.imgTakingPic);
++++++++++++img.setImageBitmap(myBitmap);|code-block|syntax|javascript|1151405|希望它能节省一些人的时间！|1151406|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Solved it in my case with this code using help of this post:

<pre><code> Bitmap myBitmap = getBitmap(imgFile.getAbsolutePath());

 try {
 ExifInterface exif = new ExifInterface(imgFile.getAbsolutePath());
 int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 1);
 Log.d("EXIF", "Exif: " + orientation);
 Matrix matrix = new Matrix();
 if (orientation == 6) {
 matrix.postRotate(90);
 }
 else if (orientation == 3) {
 matrix.postRotate(180);
 }
 else if (orientation == 8) {
 matrix.postRotate(270);
 }
 myBitmap = Bitmap.createBitmap(myBitmap, 0, 0, myBitmap.getWidth(), myBitmap.getHeight(), matrix, true); // rotating bitmap
 }
 catch (Exception e) {

 }
 ImageView img = (ImageView) findViewById(R.id.imgTakingPic);
 img.setImageBitmap(myBitmap);
</code></pre>

Hope it saves someone's time!

blocks|key|937171|text|这是可行的，但可能不是最好的方式，但它可能会帮助某些人。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937172|String+imagepath+=+someUri.getAbsolutePath();
imageview+=+(ImageView)findViewById(R.id.imageview);
imageview.setImageBitmap(setImage(imagepath,+120,+120));++++

public+Bitmap+setImage(String+path,+final+int+targetWidth,+final+int+targetHeight)+{
++++Bitmap+bitmap+=+null;
//+Get+exif+orientation+++++
++++try+{
++++++++ExifInterface+exif+=+new+ExifInterface(path);
++++++++int+orientation+=+exif.getAttributeInt(ExifInterface.TAG_ORIENTATION,+1);
++++++++if+(orientation+==+6)+{
++++++++++++orientation_val+=+90;
++++++++}
++++++++else+if+(orientation+==+3)+{
++++++++++++orientation_val+=+180;
++++++++}
++++++++else+if+(orientation+==+8)+{
++++++++++++orientation_val+=+270;
++++++++}
++++}
++++++++catch+(Exception+e)+{
++++++++}

++++++++try+{
//+First+decode+with+inJustDecodeBounds=true+to+check+dimensions
++++++++++++final+BitmapFactory.Options+options+=+new+BitmapFactory.Options();
++++++++++++options.inJustDecodeBounds+=+true;
++++++++++++BitmapFactory.decodeFile(path,+options);

//+Adjust+extents
++++++++++++int+sourceWidth,+sourceHeight;
++++++++++++if+(orientation_val+==+90+%7C%7C+orientation_val+==+270)+{
++++++++++++++++sourceWidth+=+options.outHeight;
++++++++++++++++sourceHeight+=+options.outWidth;
++++++++++++}+else+{
++++++++++++++++sourceWidth+=+options.outWidth;
++++++++++++++++sourceHeight+=+options.outHeight;
++++++++++++}

//+Calculate+the+maximum+required+scaling+ratio+if+required+and+load+the+bitmap
++++++++++++if+(sourceWidth+>+targetWidth+%7C%7C+sourceHeight+>+targetHeight)+{
++++++++++++++++float+widthRatio+=+(float)sourceWidth+/+(float)targetWidth;
++++++++++++++++float+heightRatio+=+(float)sourceHeight+/+(float)targetHeight;
++++++++++++++++float+maxRatio+=+Math.max(widthRatio,+heightRatio);
++++++++++++++++options.inJustDecodeBounds+=+false;
++++++++++++++++options.inSampleSize+=+(int)maxRatio;
++++++++++++++++bitmap+=+BitmapFactory.decodeFile(path,+options);
++++++++++++}+else+{
++++++++++++++++bitmap+=+BitmapFactory.decodeFile(path);
++++++++++++}

//+Rotate+the+bitmap+if+required
++++++++++++if+(orientation_val+>+0)+{
++++++++++++++++Matrix+matrix+=+new+Matrix();
++++++++++++++++matrix.postRotate(orientation_val);
++++++++++++++++bitmap+=+Bitmap.createBitmap(bitmap,+0,+0,+bitmap.getWidth(),+bitmap.getHeight(),+matrix,+true);
++++++++++++}

//+Re-scale+the+bitmap+if+necessary
++++++++++++sourceWidth+=+bitmap.getWidth();
++++++++++++sourceHeight+=+bitmap.getHeight();
++++++++++++if+(sourceWidth+!=+targetWidth+%7C%7C+sourceHeight+!=+targetHeight)+{
++++++++++++++++float+widthRatio+=+(float)sourceWidth+/+(float)targetWidth;
++++++++++++++++float+heightRatio+=+(float)sourceHeight+/+(float)targetHeight;
++++++++++++++++float+maxRatio+=+Math.max(widthRatio,+heightRatio);
++++++++++++++++sourceWidth+=+(int)((float)sourceWidth+/+maxRatio);
++++++++++++++++sourceHeight+=+(int)((float)sourceHeight+/+maxRatio);
++++++++++++++++bitmap+=+Bitmap.createScaledBitmap(bitmap,+sourceWidth,+++++sourceHeight,+true);
++++++++++++}
++++++++}+catch+(Exception+e)+{
++++++++}
++++++++return+bitmap;
++++}|code-block|syntax|javascript|937173|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This works, but probably not the best way to do it, but it might help someone.

<pre><code>String imagepath = someUri.getAbsolutePath();
imageview = (ImageView)findViewById(R.id.imageview);
imageview.setImageBitmap(setImage(imagepath, 120, 120)); 

public Bitmap setImage(String path, final int targetWidth, final int targetHeight) {
 Bitmap bitmap = null;
// Get exif orientation 
 try {
 ExifInterface exif = new ExifInterface(path);
 int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 1);
 if (orientation == 6) {
 orientation_val = 90;
 }
 else if (orientation == 3) {
 orientation_val = 180;
 }
 else if (orientation == 8) {
 orientation_val = 270;
 }
 }
 catch (Exception e) {
 }

 try {
// First decode with inJustDecodeBounds=true to check dimensions
 final BitmapFactory.Options options = new BitmapFactory.Options();
 options.inJustDecodeBounds = true;
 BitmapFactory.decodeFile(path, options);

// Adjust extents
 int sourceWidth, sourceHeight;
 if (orientation_val == 90 || orientation_val == 270) {
 sourceWidth = options.outHeight;
 sourceHeight = options.outWidth;
 } else {
 sourceWidth = options.outWidth;
 sourceHeight = options.outHeight;
 }

// Calculate the maximum required scaling ratio if required and load the bitmap
 if (sourceWidth &gt; targetWidth || sourceHeight &gt; targetHeight) {
 float widthRatio = (float)sourceWidth / (float)targetWidth;
 float heightRatio = (float)sourceHeight / (float)targetHeight;
 float maxRatio = Math.max(widthRatio, heightRatio);
 options.inJustDecodeBounds = false;
 options.inSampleSize = (int)maxRatio;
 bitmap = BitmapFactory.decodeFile(path, options);
 } else {
 bitmap = BitmapFactory.decodeFile(path);
 }

// Rotate the bitmap if required
 if (orientation_val &gt; 0) {
 Matrix matrix = new Matrix();
 matrix.postRotate(orientation_val);
 bitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
 }

// Re-scale the bitmap if necessary
 sourceWidth = bitmap.getWidth();
 sourceHeight = bitmap.getHeight();
 if (sourceWidth != targetWidth || sourceHeight != targetHeight) {
 float widthRatio = (float)sourceWidth / (float)targetWidth;
 float heightRatio = (float)sourceHeight / (float)targetHeight;
 float maxRatio = Math.max(widthRatio, heightRatio);
 sourceWidth = (int)((float)sourceWidth / maxRatio);
 sourceHeight = (int)((float)sourceHeight / maxRatio);
 bitmap = Bitmap.createScaledBitmap(bitmap, sourceWidth, sourceHeight, true);
 }
 } catch (Exception e) {
 }
 return bitmap;
 }
</code></pre>

blocks|key|937227|text|使用以下代码正确旋转图像：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937228|private+Bitmap+rotateImage(Bitmap+bitmap,+String+filePath)
{
++++Bitmap+resultBitmap+=+bitmap;

++++try
++++{
++++++++ExifInterface+exifInterface+=+new+ExifInterface(filePath);
++++++++int+orientation+=+exifInterface.getAttributeInt(ExifInterface.TAG_ORIENTATION,+1);

++++++++Matrix+matrix+=+new+Matrix();

++++++++if+(orientation+==+ExifInterface.ORIENTATION_ROTATE_90)
++++++++{
++++++++++++matrix.postRotate(ExifInterface.ORIENTATION_ROTATE_90);
++++++++}
++++++++else+if+(orientation+==+ExifInterface.ORIENTATION_ROTATE_180)
++++++++{
++++++++++++matrix.postRotate(ExifInterface.ORIENTATION_ROTATE_180);
++++++++}
++++++++else+if+(orientation+==+ExifInterface.ORIENTATION_ROTATE_270)
++++++++{
++++++++++++matrix.postRotate(ExifInterface.ORIENTATION_ROTATE_270);
++++++++}

++++++++//+Rotate+the+bitmap
++++++++resultBitmap+=+Bitmap.createBitmap(bitmap,+0,+0,+bitmap.getWidth(),+bitmap.getHeight(),+matrix,+true);
++++}
++++catch+(Exception+exception)
++++{
++++++++Logger.d("Could+not+rotate+the+image");
++++}
++++return+resultBitmap;
}|code-block|syntax|javascript|937229|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Use the following code to rotate an image correctly:

<pre><code>private Bitmap rotateImage(Bitmap bitmap, String filePath)
{
 Bitmap resultBitmap = bitmap;

 try
 {
 ExifInterface exifInterface = new ExifInterface(filePath);
 int orientation = exifInterface.getAttributeInt(ExifInterface.TAG_ORIENTATION, 1);

 Matrix matrix = new Matrix();

 if (orientation == ExifInterface.ORIENTATION_ROTATE_90)
 {
 matrix.postRotate(ExifInterface.ORIENTATION_ROTATE_90);
 }
 else if (orientation == ExifInterface.ORIENTATION_ROTATE_180)
 {
 matrix.postRotate(ExifInterface.ORIENTATION_ROTATE_180);
 }
 else if (orientation == ExifInterface.ORIENTATION_ROTATE_270)
 {
 matrix.postRotate(ExifInterface.ORIENTATION_ROTATE_270);
 }

 // Rotate the bitmap
 resultBitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
 }
 catch (Exception exception)
 {
 Logger.d("Could not rotate the image");
 }
 return resultBitmap;
}
</code></pre>

blocks|key|1151570|text|下面的方法根据方向缩放和旋转位图：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1151571|public+Bitmap+scaleAndRotateImage(String+path,+int+orientation,+final+int+targetWidth,+final+int+targetHeight)
{
++++Bitmap+bitmap+=+null;

++++try
++++{
++++++++//+Check+the+dimensions+of+the+Image
++++++++final+BitmapFactory.Options+options+=+new+BitmapFactory.Options();
++++++++options.inJustDecodeBounds+=+true;
++++++++BitmapFactory.decodeFile(path,+options);

++++++++//+Adjust+the+Width+and+Height
++++++++int+sourceWidth,+sourceHeight;
++++++++if+(orientation+==+90+%7C%7C+orientation+==+270)
++++++++{
++++++++++++sourceWidth+=+options.outHeight;
++++++++++++sourceHeight+=+options.outWidth;
++++++++}
++++++++else
++++++++{
++++++++++++sourceWidth+=+options.outWidth;
++++++++++++sourceHeight+=+options.outHeight;
++++++++}

++++++++//+Calculate+the+maximum+required+scaling+ratio+if+required+and+load+the+bitmap
++++++++if+(sourceWidth+>+targetWidth+%7C%7C+sourceHeight+>+targetHeight)
++++++++{
++++++++++++float+widthRatio+=+(float)sourceWidth+/+(float)targetWidth;
++++++++++++float+heightRatio+=+(float)sourceHeight+/+(float)targetHeight;
++++++++++++float+maxRatio+=+Math.max(widthRatio,+heightRatio);
++++++++++++options.inJustDecodeBounds+=+false;
++++++++++++options.inSampleSize+=+(int)maxRatio;
++++++++++++bitmap+=+BitmapFactory.decodeFile(path,+options);
++++++++}
++++++++else
++++++++{
++++++++++++bitmap+=+BitmapFactory.decodeFile(path);
++++++++}

++++++++//+We+need+to+rotate+the+bitmap+(if+required)
++++++++int+orientationInDegrees+=+exifToDegrees(orientation);
++++++++if+(orientation+>+0)
++++++++{
++++++++++++Matrix+matrix+=+new+Matrix();
++++++++++++if+(orientation+!=+0f)
++++++++++++{
++++++++++++++++matrix.preRotate(orientationInDegrees);
++++++++++++};

++++++++++++bitmap+=+Bitmap.createBitmap(bitmap,+0,+0,+bitmap.getWidth(),+bitmap.getHeight(),+matrix,+true);
++++++++}

++++++++//+Re-scale+the+bitmap+if+necessary
++++++++sourceWidth+=+bitmap.getWidth();
++++++++sourceHeight+=+bitmap.getHeight();

++++++++if+(sourceWidth+!=+targetWidth+%7C%7C+sourceHeight+!=+targetHeight)
++++++++{
++++++++++++float+widthRatio+=+(float)sourceWidth+/+(float)targetWidth;
++++++++++++float+heightRatio+=+(float)sourceHeight+/+(float)targetHeight;
++++++++++++float+maxRatio+=+Math.max(widthRatio,+heightRatio);
++++++++++++sourceWidth+=+(int)((float)sourceWidth+/+maxRatio);
++++++++++++sourceHeight+=+(int)((float)sourceHeight+/+maxRatio);
++++++++++++bitmap+=+Bitmap.createScaledBitmap(bitmap,+sourceWidth,+sourceHeight,+true);
++++++++}
++++}
++++catch+(Exception+e)
++++{
++++++++Logger.d("Could+not+rotate+the+image");
++++++++Logger.d(e.getMessage());
++++}
++++return+bitmap;
}|code-block|syntax|javascript|1151572|示例：|1151573|public+void+getPictureFromDevice(Uri+Uri,ImageView+imageView)
{
++++try
++++{
++++++++ExifInterface+exifInterface+=+new+ExifInterface(Uri.getPath());
++++++++int+orientation+=+exifInterface.getAttributeInt(ExifInterface.TAG_ORIENTATION,+ExifInterface.ORIENTATION_NORMAL);

++++++++Bitmap+bitmap+=+scaleAndRotateImage(Uri.getPath(),+orientation,+imageView.getWidth(),+imageView.getHeight());
++++++++imageView.setImageBitmap(bitmap);
++++}
++++catch+(OutOfMemoryError+outOfMemoryError)
++++{
++++++++Logger.d(outOfMemoryError.getLocalizedMessage());
++++++++Logger.d("Failed+to+load+image+from+filePath+(out+of+memory)");
++++++++Logger.d(Uri.toString());
++++}
++++catch+(Exception+e)
++++{
++++++++Logger.d("Failed+to+load+image+from+filePath");
++++++++Logger.d(Uri.toString());
++++}
}|1151574|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

The methods below scales AND rotates the bitmap according to the orientation:

<pre><code>public Bitmap scaleAndRotateImage(String path, int orientation, final int targetWidth, final int targetHeight)
{
 Bitmap bitmap = null;

 try
 {
 // Check the dimensions of the Image
 final BitmapFactory.Options options = new BitmapFactory.Options();
 options.inJustDecodeBounds = true;
 BitmapFactory.decodeFile(path, options);

 // Adjust the Width and Height
 int sourceWidth, sourceHeight;
 if (orientation == 90 || orientation == 270)
 {
 sourceWidth = options.outHeight;
 sourceHeight = options.outWidth;
 }
 else
 {
 sourceWidth = options.outWidth;
 sourceHeight = options.outHeight;
 }

 // Calculate the maximum required scaling ratio if required and load the bitmap
 if (sourceWidth &gt; targetWidth || sourceHeight &gt; targetHeight)
 {
 float widthRatio = (float)sourceWidth / (float)targetWidth;
 float heightRatio = (float)sourceHeight / (float)targetHeight;
 float maxRatio = Math.max(widthRatio, heightRatio);
 options.inJustDecodeBounds = false;
 options.inSampleSize = (int)maxRatio;
 bitmap = BitmapFactory.decodeFile(path, options);
 }
 else
 {
 bitmap = BitmapFactory.decodeFile(path);
 }

 // We need to rotate the bitmap (if required)
 int orientationInDegrees = exifToDegrees(orientation);
 if (orientation &gt; 0)
 {
 Matrix matrix = new Matrix();
 if (orientation != 0f)
 {
 matrix.preRotate(orientationInDegrees);
 };

 bitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
 }

 // Re-scale the bitmap if necessary
 sourceWidth = bitmap.getWidth();
 sourceHeight = bitmap.getHeight();

 if (sourceWidth != targetWidth || sourceHeight != targetHeight)
 {
 float widthRatio = (float)sourceWidth / (float)targetWidth;
 float heightRatio = (float)sourceHeight / (float)targetHeight;
 float maxRatio = Math.max(widthRatio, heightRatio);
 sourceWidth = (int)((float)sourceWidth / maxRatio);
 sourceHeight = (int)((float)sourceHeight / maxRatio);
 bitmap = Bitmap.createScaledBitmap(bitmap, sourceWidth, sourceHeight, true);
 }
 }
 catch (Exception e)
 {
 Logger.d("Could not rotate the image");
 Logger.d(e.getMessage());
 }
 return bitmap;
}
</code></pre>

Example:

<pre><code>public void getPictureFromDevice(Uri Uri,ImageView imageView)
{
 try
 {
 ExifInterface exifInterface = new ExifInterface(Uri.getPath());
 int orientation = exifInterface.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);

 Bitmap bitmap = scaleAndRotateImage(Uri.getPath(), orientation, imageView.getWidth(), imageView.getHeight());
 imageView.setImageBitmap(bitmap);
 }
 catch (OutOfMemoryError outOfMemoryError)
 {
 Logger.d(outOfMemoryError.getLocalizedMessage());
 Logger.d("Failed to load image from filePath (out of memory)");
 Logger.d(Uri.toString());
 }
 catch (Exception e)
 {
 Logger.d("Failed to load image from filePath");
 Logger.d(Uri.toString());
 }
}
</code></pre>

blocks|key|1151635|text|也许这会有帮助(旋转90度)(这对我很有效)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1151636|private+Bitmap+rotateBitmap(Bitmap+image){
++++++++int+width=image.getHeight();
++++++++int+height=image.getWidth();

++++++++Bitmap+srcBitmap=Bitmap.createBitmap(width,+height,+image.getConfig());

++++++++for+(int+y=width-1;y>=0;y--)
++++++++++++for(int+x=0;x<height;x%2B%2B)
++++++++++++++++srcBitmap.setPixel(width-y-1,+x,image.getPixel(x,+y));
++++++++return+srcBitmap;

++++}|code-block|syntax|javascript|1151637|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

maybe this will help (rotate 90 degree)(this worked for me)

<pre><code>private Bitmap rotateBitmap(Bitmap image){
 int width=image.getHeight();
 int height=image.getWidth();

 Bitmap srcBitmap=Bitmap.createBitmap(width, height, image.getConfig());

 for (int y=width-1;y&gt;=0;y--)
 for(int x=0;x&lt;height;x++)
 srcBitmap.setPixel(width-y-1, x,image.getPixel(x, y));
 return srcBitmap;

 }
</code></pre>

blocks|key|937440|text|我改进了Teo+Inke的回答。它不再旋转图像，除非确实有必要。它也更容易阅读，而且应该运行得更快。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937441|//+Load+Image
Bitmap+bitmap+=+BitmapFactory.decodeFile(filePath);

//+Rotate+Image+if+Needed
try
{
++++//+Determine+Orientation
++++ExifInterface+exif+=+new+ExifInterface(filePath);
++++int+orientation+=+exif.getAttributeInt(ExifInterface.TAG_ORIENTATION,+1);

++++//+Determine+Rotation
++++int+rotation+=+0;
++++if++++++(orientation+==+6)++++++rotation+=+90;
++++else+if+(orientation+==+3)++++++rotation+=+180;
++++else+if+(orientation+==+8)++++++rotation+=+270;

++++//+Rotate+Image+if+Necessary
++++if+(rotation+!=+0)
++++{
++++++++//+Create+Matrix
++++++++Matrix+matrix+=+new+Matrix();
++++++++matrix.postRotate(rotation);

++++++++//+Rotate+Bitmap
++++++++Bitmap+rotated+=+Bitmap.createBitmap(bitmap,+0,+0,+bitmap.getWidth(),+bitmap.getHeight(),+matrix,+true);+

++++++++//+Pretend+none+of+this+ever+happened!
++++++++bitmap.recycle();
++++++++bitmap+=+rotated;
++++++++rotated+=+null;
+++++}
}
catch+(Exception+e)
{
++++//+TODO:+Log+Error+Messages+Here
}

//+TODO:+Use+Result+Here
xxx.setBitmap(bitmap);|code-block|syntax|javascript|937442|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I improved upon the answer by Teo Inke. It no longer rotates the image unless it is actually necessary. It is also easier to read, and should run faster.

<pre><code>// Load Image
Bitmap bitmap = BitmapFactory.decodeFile(filePath);

// Rotate Image if Needed
try
{
 // Determine Orientation
 ExifInterface exif = new ExifInterface(filePath);
 int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 1);

 // Determine Rotation
 int rotation = 0;
 if (orientation == 6) rotation = 90;
 else if (orientation == 3) rotation = 180;
 else if (orientation == 8) rotation = 270;

 // Rotate Image if Necessary
 if (rotation != 0)
 {
 // Create Matrix
 Matrix matrix = new Matrix();
 matrix.postRotate(rotation);

 // Rotate Bitmap
 Bitmap rotated = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true); 

 // Pretend none of this ever happened!
 bitmap.recycle();
 bitmap = rotated;
 rotated = null;
 }
}
catch (Exception e)
{
 // TODO: Log Error Messages Here
}

// TODO: Use Result Here
xxx.setBitmap(bitmap);
</code></pre>

blocks|key|937522|text|这是因为图库正确地显示了旋转的图像，而不是ImageView，请看这里：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937523|++++++++++++++++++++myBitmap+=+BitmapFactory.decodeFile(imgFile.getAbsolutePath(),optionss);
++++++++++++++++++++ExifInterface+exif+=+new+ExifInterface(selectedImagePath);
++++++++++++++++++++int+rotation+=+exif.getAttributeInt(ExifInterface.TAG_ORIENTATION,+ExifInterface.ORIENTATION_NORMAL);
++++++++++++++++++++int+rotationInDegrees+=+exifToDegrees(rotation);
++++++++++++++++++++deg+=+rotationInDegrees;
++++++++++++++++++++Matrix+matrix+=+new+Matrix();
++++++++++++++++++++if+(rotation+!=+0f)+{
++++++++++++++++++++++++matrix.preRotate(rotationInDegrees);
++++++++++++++++++++++++myBitmap+=+Bitmap.createBitmap(myBitmap,+0,+0,+myBitmap.getWidth(),+myBitmap.getHeight(),+matrix,+true);
++++++++++++++++++++}|code-block|syntax|javascript|937524|你需要这样做：|937525|private+static+int+exifToDegrees(int+exifOrientation)+{++++++++
++++if+(exifOrientation+==+ExifInterface.ORIENTATION_ROTATE_90)+{+return+90;+}+
++++else+if+(exifOrientation+==+ExifInterface.ORIENTATION_ROTATE_180)+{++return+180;+}+
++++else+if+(exifOrientation+==+ExifInterface.ORIENTATION_ROTATE_270)+{++return+270;+}++++++++++++
++++return+0;++++
}+|937526|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

its because gallery correct displaying rotated images but not ImageView
look at here:

<pre><code> myBitmap = BitmapFactory.decodeFile(imgFile.getAbsolutePath(),optionss);
 ExifInterface exif = new ExifInterface(selectedImagePath);
 int rotation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
 int rotationInDegrees = exifToDegrees(rotation);
 deg = rotationInDegrees;
 Matrix matrix = new Matrix();
 if (rotation != 0f) {
 matrix.preRotate(rotationInDegrees);
 myBitmap = Bitmap.createBitmap(myBitmap, 0, 0, myBitmap.getWidth(), myBitmap.getHeight(), matrix, true);
 }
</code></pre>

and you need this:

<pre><code>private static int exifToDegrees(int exifOrientation) { 
 if (exifOrientation == ExifInterface.ORIENTATION_ROTATE_90) { return 90; } 
 else if (exifOrientation == ExifInterface.ORIENTATION_ROTATE_180) { return 180; } 
 else if (exifOrientation == ExifInterface.ORIENTATION_ROTATE_270) { return 270; } 
 return 0; 
} 
</code></pre>

blocks|key|1151860|text|打开光标后应将其关闭。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1151861|下面是一个例子。|1151862|+public+static+int+getOrientation(Context+context,+Uri+selectedImage)
{
++++int+orientation+=+-1;
++++Cursor+cursor+=+context.getContentResolver().query(selectedImage,
++++++++++++new+String[]+{+MediaStore.Images.ImageColumns.ORIENTATION+},+null,+null,+null);
++++if+(cursor.getCount()+!=+1)
+++++++return+orientation;

++++cursor.moveToFirst();
++++orientation+=+cursor.getInt(0);
++++cursor.close();+//+ADD+THIS+LINE
+++return+orientation;
}|code-block|syntax|javascript|1151863|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

The cursor should be closed after opening it.

Here is an example.

<pre><code> public static int getOrientation(Context context, Uri selectedImage)
{
 int orientation = -1;
 Cursor cursor = context.getContentResolver().query(selectedImage,
 new String[] { MediaStore.Images.ImageColumns.ORIENTATION }, null, null, null);
 if (cursor.getCount() != 1)
 return orientation;

 cursor.moveToFirst();
 orientation = cursor.getInt(0);
 cursor.close(); // ADD THIS LINE
 return orientation;
}
</code></pre>

blocks|key|937679|text|你需要的第一件事是真实的文件路径，如果你有它，如果你正在使用URI，那么使用这个方法来获得真实的路径：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937680|+public+static+String+getRealPathFromURI(Uri+contentURI,Context+context)+{
++++String+path=+contentURI.getPath();
++++try+{
++++++++Cursor+cursor+=+context.getContentResolver().query(contentURI,+null,+null,+null,+null);
++++++++cursor.moveToFirst();
++++++++String+document_id+=+cursor.getString(0);
++++++++document_id+=+document_id.substring(document_id.lastIndexOf(":")+%2B+1);
++++++++cursor.close();

++++++++cursor+=+context.getContentResolver().query(
++++++++++++++++android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
++++++++++++++++null,+MediaStore.Images.Media._ID+%2B+"+=+?+",+new+String[]{document_id},+null);
++++++++cursor.moveToFirst();
++++++++path+=+cursor.getString(cursor.getColumnIndex(MediaStore.Images.Media.DATA));
++++++++cursor.close();
++++}
++++catch(Exception+e)
++++{
++++++++return+path;
++++}
++++return+path;
}|code-block|syntax|javascript|937681|提取位图，例如：|937682|++try+{
++++++++++++++++++++++++++++Bitmap+bitmap+=+MediaStore.Images.Media.getBitmap(this.getContentResolver(),+selectedImage);

++++++++++++++++++++++++}
++++++++++++++++++++++++catch+(IOException+e)
++++++++++++++++++++++++{
++++++++++++++++++++++++++++Log.e("IOException",e.toString());
++++++++++++++++++++++++}|937683|如果您愿意，也可以使用decodeFile()。|937684|现在你已经有了位图和真实的路径，得到图像的方向：|937685|+private+static+int+getExifOrientation(String+src)+throws+IOException+{
++++++++int+orientation+=+1;

++++++++ExifInterface+exif+=+new+ExifInterface(src);
++++++++String+orientationString=exif.getAttribute(ExifInterface.TAG_ORIENTATION);
++++++++try+{
++++++++++++orientation+=+Integer.parseInt(orientationString);
++++++++}
++++++++catch(NumberFormatException+e){}

++++++++return+orientation;
++++}|937686|最后将它旋转到正确的位置，如下所示：|937687|public+static+Bitmap+rotateBitmap(String+src,+Bitmap+bitmap)+{
++++++++try+{
++++++++++++int+orientation+=+getExifOrientation(src);

++++++++++++if+(orientation+==+1)+{
++++++++++++++++return+bitmap;
++++++++++++}

++++++++++++Matrix+matrix+=+new+Matrix();
++++++++++++switch+(orientation)+{
++++++++++++++++case+2:
++++++++++++++++++++matrix.setScale(-1,+1);
++++++++++++++++++++break;
++++++++++++++++case+3:
++++++++++++++++++++matrix.setRotate(180);
++++++++++++++++++++break;
++++++++++++++++case+4:
++++++++++++++++++++matrix.setRotate(180);
++++++++++++++++++++matrix.postScale(-1,+1);
++++++++++++++++++++break;
++++++++++++++++case+5:
++++++++++++++++++++matrix.setRotate(90);
++++++++++++++++++++matrix.postScale(-1,+1);
++++++++++++++++++++break;
++++++++++++++++case+6:
++++++++++++++++++++matrix.setRotate(90);
++++++++++++++++++++break;
++++++++++++++++case+7:
++++++++++++++++++++matrix.setRotate(-90);
++++++++++++++++++++matrix.postScale(-1,+1);
++++++++++++++++++++break;
++++++++++++++++case+8:
++++++++++++++++++++matrix.setRotate(-90);
++++++++++++++++++++break;
++++++++++++++++default:
++++++++++++++++++++return+bitmap;
++++++++++++}

++++++++++++try+{
++++++++++++++++Bitmap+oriented+=+Bitmap.createBitmap(bitmap,+0,+0,+bitmap.getWidth(),+bitmap.getHeight(),+matrix,+true);
++++++++++++++++bitmap.recycle();
++++++++++++++++return+oriented;
++++++++++++}+catch+(OutOfMemoryError+e)+{
++++++++++++++++e.printStackTrace();
++++++++++++++++return+bitmap;
++++++++++++}
++++++++}+catch+(IOException+e)+{
++++++++++++e.printStackTrace();
++++++++}

++++++++return+bitmap;
++++}|937688|就是这样，您现在已经将位图旋转到了正确的位置。|937689|干杯。|937690|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|17|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|18|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|19|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

The first thing you need is the real File path
If you have it great, if you are using URI then use this method to
get the real Path:

<pre><code> public static String getRealPathFromURI(Uri contentURI,Context context) {
 String path= contentURI.getPath();
 try {
 Cursor cursor = context.getContentResolver().query(contentURI, null, null, null, null);
 cursor.moveToFirst();
 String document_id = cursor.getString(0);
 document_id = document_id.substring(document_id.lastIndexOf(":") + 1);
 cursor.close();

 cursor = context.getContentResolver().query(
 android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
 null, MediaStore.Images.Media._ID + " = ? ", new String[]{document_id}, null);
 cursor.moveToFirst();
 path = cursor.getString(cursor.getColumnIndex(MediaStore.Images.Media.DATA));
 cursor.close();
 }
 catch(Exception e)
 {
 return path;
 }
 return path;
}
</code></pre>

extract your Bitmap for example:

<pre><code> try {
 Bitmap bitmap = MediaStore.Images.Media.getBitmap(this.getContentResolver(), selectedImage);

 }
 catch (IOException e)
 {
 Log.e("IOException",e.toString());
 }
</code></pre>

you can use decodeFile() instead if you wish.

Now that you have the Bitmap and the real Path get the Orientation of the Image:

<pre><code> private static int getExifOrientation(String src) throws IOException {
 int orientation = 1;

 ExifInterface exif = new ExifInterface(src);
 String orientationString=exif.getAttribute(ExifInterface.TAG_ORIENTATION);
 try {
 orientation = Integer.parseInt(orientationString);
 }
 catch(NumberFormatException e){}

 return orientation;
 }
</code></pre>

and finally rotate it to the right position like so:

<pre><code>public static Bitmap rotateBitmap(String src, Bitmap bitmap) {
 try {
 int orientation = getExifOrientation(src);

 if (orientation == 1) {
 return bitmap;
 }

 Matrix matrix = new Matrix();
 switch (orientation) {
 case 2:
 matrix.setScale(-1, 1);
 break;
 case 3:
 matrix.setRotate(180);
 break;
 case 4:
 matrix.setRotate(180);
 matrix.postScale(-1, 1);
 break;
 case 5:
 matrix.setRotate(90);
 matrix.postScale(-1, 1);
 break;
 case 6:
 matrix.setRotate(90);
 break;
 case 7:
 matrix.setRotate(-90);
 matrix.postScale(-1, 1);
 break;
 case 8:
 matrix.setRotate(-90);
 break;
 default:
 return bitmap;
 }

 try {
 Bitmap oriented = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
 bitmap.recycle();
 return oriented;
 } catch (OutOfMemoryError e) {
 e.printStackTrace();
 return bitmap;
 }
 } catch (IOException e) {
 e.printStackTrace();
 }

 return bitmap;
 }
</code></pre>

That's it , you now have the bitmap rotated to the right position.

cheers.

blocks|key|937755|text|我已经将@Timmmm+answer和@Manuel融为一体。如果执行此解决方案，则不会出现内存不足异常。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937756|此方法检索图像方向：|937757|private+static+final+int+ROTATION_DEGREES+=+90;
//+This+means+512+px
private+static+final+Integer+MAX_IMAGE_DIMENSION+=+512;

public+static+int+getOrientation(Uri+photoUri)+throws+IOException+{

++++ExifInterface+exif+=+new+ExifInterface(photoUri.getPath());
++++int+orientation+=+exif.getAttributeInt(ExifInterface.TAG_ORIENTATION,+1);

++++switch+(orientation)+{
++++++++case+ExifInterface.ORIENTATION_ROTATE_90:
++++++++++++orientation+=+ROTATION_DEGREES;
++++++++++++break;
++++++++case+ExifInterface.ORIENTATION_ROTATE_180:
++++++++++++orientation+=+ROTATION_DEGREES+*+2;
++++++++++++break;
++++++++case+ExifInterface.ORIENTATION_ROTATE_270:
++++++++++++orientation+=+ROTATION_DEGREES+*+3;
++++++++++++break;
++++++++default:
++++++++++++//+Default+case,+image+is+not+rotated
++++++++++++orientation+=+0;
++++}

++++return+orientation;
}|code-block|syntax|javascript|937758|因此，在将图像加载到内存之前，可以使用此方法调整图像的大小。这样，您就不会得到内存异常。|937759|public+static+Bitmap+getCorrectlyOrientedImage(Context+context,+Uri+photoUri)+throws+IOException+{
++++InputStream+is+=+context.getContentResolver().openInputStream(photoUri);
++++BitmapFactory.Options+dbo+=+new+BitmapFactory.Options();
++++dbo.inJustDecodeBounds+=+true;
++++BitmapFactory.decodeStream(is,+null,+dbo);
++++is.close();

++++int+rotatedWidth,+rotatedHeight;
++++int+orientation+=+getOrientation(photoUri);

++++if+(orientation+==+90+%7C%7C+orientation+==+270)+{
++++++++rotatedWidth+=+dbo.outHeight;
++++++++rotatedHeight+=+dbo.outWidth;
++++}+else+{
++++++++rotatedWidth+=+dbo.outWidth;
++++++++rotatedHeight+=+dbo.outHeight;
++++}

++++Bitmap+srcBitmap;
++++is+=+context.getContentResolver().openInputStream(photoUri);
++++if+(rotatedWidth+>+MAX_IMAGE_DIMENSION+%7C%7C+rotatedHeight+>+MAX_IMAGE_DIMENSION)+{
++++++++float+widthRatio+=+((float)+rotatedWidth)+/+((float)+MAX_IMAGE_DIMENSION);
++++++++float+heightRatio+=+((float)+rotatedHeight)+/+((float)+MAX_IMAGE_DIMENSION);
++++++++float+maxRatio+=+Math.max(widthRatio,+heightRatio);

++++++++//+Create+the+bitmap+from+file
++++++++BitmapFactory.Options+options+=+new+BitmapFactory.Options();
++++++++options.inSampleSize+=+(int)+maxRatio;
++++++++srcBitmap+=+BitmapFactory.decodeStream(is,+null,+options);
++++}+else+{
++++++++srcBitmap+=+BitmapFactory.decodeStream(is);
++++}
++++is.close();

++++//+if+the+orientation+is+not+0,+we+have+to+do+a+rotation.
++++if+(orientation+>+0)+{
++++++++Matrix+matrix+=+new+Matrix();
++++++++matrix.postRotate(orientation);

++++++++srcBitmap+=+Bitmap.createBitmap(srcBitmap,+0,+0,+srcBitmap.getWidth(),
++++++++++++++++srcBitmap.getHeight(),+matrix,+true);
++++}

++++return+srcBitmap;
}|937760|这对我来说非常有效。我希望这对其他人有帮助|937761|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I have melted @Timmmm answer and @Manuel. If you do this solution, you will not get a Run Out Of Memory Exception.

This method retrieves the image orientation:

<pre><code>private static final int ROTATION_DEGREES = 90;
// This means 512 px
private static final Integer MAX_IMAGE_DIMENSION = 512;

public static int getOrientation(Uri photoUri) throws IOException {

 ExifInterface exif = new ExifInterface(photoUri.getPath());
 int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 1);

 switch (orientation) {
 case ExifInterface.ORIENTATION_ROTATE_90:
 orientation = ROTATION_DEGREES;
 break;
 case ExifInterface.ORIENTATION_ROTATE_180:
 orientation = ROTATION_DEGREES * 2;
 break;
 case ExifInterface.ORIENTATION_ROTATE_270:
 orientation = ROTATION_DEGREES * 3;
 break;
 default:
 // Default case, image is not rotated
 orientation = 0;
 }

 return orientation;
}
</code></pre>

Therefore, you would use this method to resize image before load it on memory. In that way, you will not get a Memory Exception.

<pre><code>public static Bitmap getCorrectlyOrientedImage(Context context, Uri photoUri) throws IOException {
 InputStream is = context.getContentResolver().openInputStream(photoUri);
 BitmapFactory.Options dbo = new BitmapFactory.Options();
 dbo.inJustDecodeBounds = true;
 BitmapFactory.decodeStream(is, null, dbo);
 is.close();

 int rotatedWidth, rotatedHeight;
 int orientation = getOrientation(photoUri);

 if (orientation == 90 || orientation == 270) {
 rotatedWidth = dbo.outHeight;
 rotatedHeight = dbo.outWidth;
 } else {
 rotatedWidth = dbo.outWidth;
 rotatedHeight = dbo.outHeight;
 }

 Bitmap srcBitmap;
 is = context.getContentResolver().openInputStream(photoUri);
 if (rotatedWidth &gt; MAX_IMAGE_DIMENSION || rotatedHeight &gt; MAX_IMAGE_DIMENSION) {
 float widthRatio = ((float) rotatedWidth) / ((float) MAX_IMAGE_DIMENSION);
 float heightRatio = ((float) rotatedHeight) / ((float) MAX_IMAGE_DIMENSION);
 float maxRatio = Math.max(widthRatio, heightRatio);

 // Create the bitmap from file
 BitmapFactory.Options options = new BitmapFactory.Options();
 options.inSampleSize = (int) maxRatio;
 srcBitmap = BitmapFactory.decodeStream(is, null, options);
 } else {
 srcBitmap = BitmapFactory.decodeStream(is);
 }
 is.close();

 // if the orientation is not 0, we have to do a rotation.
 if (orientation &gt; 0) {
 Matrix matrix = new Matrix();
 matrix.postRotate(orientation);

 srcBitmap = Bitmap.createBitmap(srcBitmap, 0, 0, srcBitmap.getWidth(),
 srcBitmap.getHeight(), matrix, true);
 }

 return srcBitmap;
}
</code></pre>

This works perfectly for me. I hope this helps somebody else

blocks|key|937855|text|经过多次尝试后，我终于可以工作了，这要归功于一个我再也找不到的帖子:-(|type|unstyled|depth|inlineStyleRanges|entityRanges|data|937856|Exif似乎总是有效的，困难的是获取文件路径。我发现的代码使得4.4之前的API和4.4之后的API有所不同。基本上，4.4%2B的图片URI包含"com.android.providers“。对于这种类型的URI，代码使用DocumentsContract获取图片id，然后使用ContentResolver运行查询，而对于较旧的SDK，代码直接使用ContentResolver查询URI。|937857|下面是代码(对不起，我不知道是谁发的)：|937858|/**
+*+Handles+pre+V19+uri's
+*+@param+context
+*+@param+contentUri
+*+@return
+*/
public+static+String+getPathForPreV19(Context+context,+Uri+contentUri)+{
++++String+res+=+null;

++++String[]+proj+=+{+MediaStore.Images.Media.DATA+};
++++Cursor+cursor+=+context.getContentResolver().query(contentUri,+proj,+null,+null,+null);
++++if(cursor.moveToFirst()){;
++++++++int+column_index+=+cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
++++++++res+=+cursor.getString(column_index);
++++}
++++cursor.close();

++++return+res;
}

/**
+*+Handles+V19+and+up+uri's
+*+@param+context
+*+@param+contentUri
+*+@return+path
+*/
@TargetApi(Build.VERSION_CODES.KITKAT)
public+static+String+getPathForV19AndUp(Context+context,+Uri+contentUri)+{
++++String+wholeID+=+DocumentsContract.getDocumentId(contentUri);

++++//+Split+at+colon,+use+second+item+in+the+array
++++String+id+=+wholeID.split(":")[1];
++++String[]+column+=+{+MediaStore.Images.Media.DATA+};

++++//+where+id+is+equal+to
++++String+sel+=+MediaStore.Images.Media._ID+%2B+"=?";
++++Cursor+cursor+=+context.getContentResolver().
++++++++++++query(MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
++++++++++++++++++++column,+sel,+new+String[]{+id+},+null);

++++String+filePath+=+"";
++++int+columnIndex+=+cursor.getColumnIndex(column[0]);
++++if+(cursor.moveToFirst())+{
++++++++filePath+=+cursor.getString(columnIndex);
++++}

++++cursor.close();
++++return+filePath;
}

public+static+String+getRealPathFromURI(Context+context,
++++++++Uri+contentUri)+{
++++String+uriString+=+String.valueOf(contentUri);
++++boolean+goForKitKat=+uriString.contains("com.android.providers");

+++++if+(Build.VERSION.SDK_INT+>=+Build.VERSION_CODES.KITKAT+&&+goForKitKat)+{
++++++++++++Log.i("KIKAT","YES");
++++++++++++return+getPathForV19AndUp(context,+contentUri);
++++++++}+else+{

++++++++++++return+getPathForPreV19(context,+contentUri);
++++++++}
}|code-block|syntax|javascript|937859|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Got it to work after many attempts thanks to a post I can no longer find :-(

Exif seems to work always, the difficulty was to get the filepath. The code I found makes a different between API older than 4.4 and after 4.4. Basically the picture URI for 4.4+ contains "com.android.providers". For this type of URI, the code uses DocumentsContract to get the picture id and then runs a query using the ContentResolver, while for older SDK, the code goes straight to query the URI with the ContentResolver.

Here is the code (sorry I cannot credit who posted it):

<pre><code>/**
 * Handles pre V19 uri's
 * @param context
 * @param contentUri
 * @return
 */
public static String getPathForPreV19(Context context, Uri contentUri) {
 String res = null;

 String[] proj = { MediaStore.Images.Media.DATA };
 Cursor cursor = context.getContentResolver().query(contentUri, proj, null, null, null);
 if(cursor.moveToFirst()){;
 int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
 res = cursor.getString(column_index);
 }
 cursor.close();

 return res;
}

/**
 * Handles V19 and up uri's
 * @param context
 * @param contentUri
 * @return path
 */
@TargetApi(Build.VERSION_CODES.KITKAT)
public static String getPathForV19AndUp(Context context, Uri contentUri) {
 String wholeID = DocumentsContract.getDocumentId(contentUri);

 // Split at colon, use second item in the array
 String id = wholeID.split(":")[1];
 String[] column = { MediaStore.Images.Media.DATA };

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

 String filePath = "";
 int columnIndex = cursor.getColumnIndex(column[0]);
 if (cursor.moveToFirst()) {
 filePath = cursor.getString(columnIndex);
 }

 cursor.close();
 return filePath;
}

public static String getRealPathFromURI(Context context,
 Uri contentUri) {
 String uriString = String.valueOf(contentUri);
 boolean goForKitKat= uriString.contains("com.android.providers");

 if (Build.VERSION.SDK_INT &gt;= Build.VERSION_CODES.KITKAT &amp;&amp; goForKitKat) {
 Log.i("KIKAT","YES");
 return getPathForV19AndUp(context, contentUri);
 } else {

 return getPathForPreV19(context, contentUri);
 }
}
</code></pre>

blocks|key|1152158|text|Kotlin代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1152159|if+(file.exists()){
++++val+bitmap+=+BitmapFactory.decodeFile(file.absolutePath)

++++val+exif+=+ExifInterface(file.absoluteFile.toString())
++++val+orientation+=+exif.getAttributeInt(ExifInterface.TAG_ORIENTATION,+ExifInterface.ORIENTATION_NORMAL)
++++val+matrix+=+Matrix()

++++when(orientation){
++++++++ExifInterface.ORIENTATION_ROTATE_90+->+matrix.postRotate(90F)
++++++++ExifInterface.ORIENTATION_ROTATE_180+->+matrix.postRotate(180F)
++++++++ExifInterface.ORIENTATION_ROTATE_270+->+matrix.postRotate(270F)
++++}

++++val+rotatedBitmap+=+Bitmap.createBitmap(bitmap,+0,0+,+bitmap.width,+bitmap.height,+matrix,+true)
++++bitmap.recycle()
++++iv_capture.setImageBitmap(rotatedBitmap)
}|code-block|syntax|javascript|1152160|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Kotlin code:

<pre><code>if (file.exists()){
 val bitmap = BitmapFactory.decodeFile(file.absolutePath)

 val exif = ExifInterface(file.absoluteFile.toString())
 val orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL)
 val matrix = Matrix()

 when(orientation){
 ExifInterface.ORIENTATION_ROTATE_90 -&gt; matrix.postRotate(90F)
 ExifInterface.ORIENTATION_ROTATE_180 -&gt; matrix.postRotate(180F)
 ExifInterface.ORIENTATION_ROTATE_270 -&gt; matrix.postRotate(270F)
 }

 val rotatedBitmap = Bitmap.createBitmap(bitmap, 0,0 , bitmap.width, bitmap.height, matrix, true)
 bitmap.recycle()
 iv_capture.setImageBitmap(rotatedBitmap)
}
</code></pre>

When I load an image from the media gallery into a Bitmap, everything is working fine, except that pictures that were shot with the camera while holding the phone vertically, are rotated so that I always get a horizontal picture even though it appears vertical in the gallery.
Why is that and how can I load it correctly?

Android: Bitmaps loaded from gallery are rotated in ImageView

Kotlin

当我将媒体库中的图像加载到位图中时，一切正常，除了垂直握住手机时用相机拍摄的图片被旋转，以便我始终获得水平图片，即使它在库中显示为垂直。为什么会这样?我怎样才能正确加载它？

问Android:从图库加载的位图在ImageView中旋转
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Android:从图库加载的位图在ImageView中旋转EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Android:从图库加载的位图在ImageView中旋转
EN