Android解决三星手机拍照图片调用时逆时针旋转90度问题

Uri uri = getIntent().getData();
System.out.println("图片URI地址" + uri.toString());
Point point = DisplayUtil.getScreenPoint(this);
Bitmap bitmap = ImageUtils.decodeBitmapWithOrientationMax(ImageUtils.getFilePathByFileUri(this, uri), point.x, point.y, isPortrait);
//得到图片旋转角度 设置旋转角度
String path= ImageUtils.getFilePathByFileUri(this,uri);
int degrees=ImageUtils.getImageDegrees(path);
Bitmap bitmap1=ImageUtils.getRotateBitmap(bitmap,degrees);
System.out.println("图片path地址" + path);
System.out.println("图片角度" + degrees);
imageView.setImageBitmap(bitmap1);

/**
* 图片简单处理工具类
*/
public class ImageUtils {

/**
* 屏幕宽
*
* @param context
* @return
*/
public static int getWidth(Context context) {
DisplayMetrics dm = context.getResources().getDisplayMetrics();
return dm.widthPixels;
}

/**
* 屏幕高
*
* @param context
* @return
*/
public static int getHeight(Context context) {
DisplayMetrics dm = context.getResources().getDisplayMetrics();
return dm.heightPixels;
}

/**
* 根据文件Uri获取路径
*
* @param context
* @param uri
* @return
*/
public static String getFilePathByFileUri(Context context, Uri uri) {
String filePath = null;
Cursor cursor = context.getContentResolver().query(uri, null, null,
null, null);
if (cursor!=null && cursor.moveToFirst()) {
//如果从相册中获取的,
filePath = cursor.getString(cursor
.getColumnIndex(MediaStore.Images.Media.DATA));
cursor.close();
}else{
//如果从本地文件中获取的
filePath=uri.getPath();
}
return filePath;
}

/**
* 根据图片原始路径获取图片缩略图
*
* @param imagePath 图片原始路径
* @param width     缩略图宽度
* @param height    缩略图高度
* @return
*/
public static Bitmap getImageThumbnail(String imagePath, int width,
int height) {
Bitmap bitmap = null;
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;//不加载直接获取Bitmap宽高
// 获取这个图片的宽和高，注意此处的bitmap为null
bitmap = BitmapFactory.decodeFile(imagePath, options);
if(bitmap == null){
// 计算缩放比
int h = options.outHeight;
int w = options.outWidth;
int beWidth = w / width;
int beHeight = h / height;
int rate = 1;
if (beWidth < beHeight) {
rate = beWidth;
} else {
rate = beHeight;
}
if (rate <= 0) {//图片实际大小小于缩略图,不缩放
rate = 1;
}
options.inSampleSize = rate;
options.inJustDecodeBounds = false;
// 重新读入图片，读取缩放后的bitmap，注意这次要把options.inJustDecodeBounds 设为 false
bitmap = BitmapFactory.decodeFile(imagePath, options);
// 利用ThumbnailUtils来创建缩略图，这里要指定要缩放哪个Bitmap对象
bitmap = ThumbnailUtils.extractThumbnail(bitmap, width, height,
ThumbnailUtils.OPTIONS_RECYCLE_INPUT);
}
return bitmap;
}

/**
* ��תBitmap
* @param b
* @param rotateDegree
* @return
*/
public static Bitmap getRotateBitmap(Bitmap b, float rotateDegree){
Matrix matrix = new Matrix();
matrix.postRotate((float)rotateDegree);
Bitmap rotaBitmap = Bitmap.createBitmap(b, 0, 0, b.getWidth(), b.getHeight(), matrix, false);
return rotaBitmap;
}

public static Bitmap decodeBitmapWithOrientationMax(String pathName, int width, int height, boolean isPortrait) {
return decodeBitmapWithSize(pathName, width, height, true,isPortrait);
}

private static Bitmap decodeBitmapWithSize(String pathName, int width, int height,
boolean useBigger, boolean isPortrait) {
final BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
options.inInputShareable = true;
options.inPurgeable = true;
BitmapFactory.decodeFile(pathName, options);

//      int decodeWidth = width, decodeHeight = height;
//      final int degrees = getImageDegrees(pathName);
//      if (degrees == 90 || degrees == 270) {
//          decodeWidth = height;
//          decodeHeight = width;
//      }
//
//      if (useBigger) {
//          options.inSampleSize = (int) Math.min(((float) options.outWidth / decodeWidth),
//                  ((float) options.outHeight / decodeHeight));
//      } else {
//          options.inSampleSize = (int) Math.max(((float) options.outWidth / decodeWidth),
//                  ((float) options.outHeight / decodeHeight));
//      }
//
//      options.inJustDecodeBounds = false;
//      Bitmap sourceBm = BitmapFactory.decodeFile(pathName, options);
//      return imageWithFixedRotation(sourceBm, degrees);
int targetDensity = UiUtils.getInstance().getContext().getResources().getDisplayMetrics().densityDpi;
DisplayMetrics dm = new DisplayMetrics();
WindowManager windowManager=(WindowManager)UiUtils.getInstance().//
getContext().getSystemService(Context.WINDOW_SERVICE);
windowManager.getDefaultDisplay().getMetrics(dm);
//      int x = dm.widthPixels;
//      int y = dm.heightPixels;

int x=600;
int y=800;
options.inSampleSize = calculateInSampleSize(options, x, y);
double xSScale = ((double)options.outWidth) / ((double)x);
double ySScale = ((double)options.outHeight) / ((double)y);
double startScale = xSScale > ySScale ? xSScale : ySScale;

Log.d("MainActivity", "startScale:" + startScale);
options.inScaled = true;
//      options.inDensity = (int) (targetDensity*startScale);
//防止分辨率过小
if(options.outHeight*options.outWidth<x*y){
options.inDensity = (int) (targetDensity);//乘以一个固定值
}else{
if(isPortrait){
//进行判断范围 像素
options.inDensity = (int) (targetDensity*2);//乘以一个固定值
}else{
options.inDensity = (int) (targetDensity*1.5);//乘以一个固定值
}

}
options.inTargetDensity = targetDensity;
options.inJustDecodeBounds = false;
return  BitmapFactory.decodeFile(pathName, options);
}

/**
* 计算采样率的大小
* @param options
* @param reqWidth
* @param reqHeight
* @return
*/
private static  int calculateInSampleSize(BitmapFactory.Options options,
int reqWidth, int reqHeight) {
// Raw height and width of image
//      final int height = options.outHeight;
//      final int width = options.outWidth;
int height;
int width;
if(options.outWidth>options.outHeight){
height = options.outWidth;
width = options.outHeight;
}else{
height = options.outHeight;
width = options.outWidth;
}
int inSampleSize = 1;

System.out.println("ImageUtils calculateInSampleSize height:"+height+"..width:"+width+"...reqHeight:"+reqHeight+"..reqWidth:"+reqWidth);
if (height > reqHeight || width > reqWidth) {

final int halfHeight = height / 2;
final int halfWidth = width / 2;

// Calculate the largest inSampleSize value that is a power of 2 and
// keeps both
// height and width larger than the requested height and width.
while ((halfHeight / inSampleSize) > reqHeight
&& (halfWidth / inSampleSize) > reqWidth) {
inSampleSize *= 2;
}

if(inSampleSize==1){
inSampleSize=2;
}
}

Log.d("MainActivity", "inSampleSize:" + inSampleSize);
return inSampleSize;
}

public static int getImageDegrees(String pathName) {
int degrees = 0;
try {
ExifInterface exifInterface = new ExifInterface(pathName);
int orientation = exifInterface.getAttributeInt(ExifInterface.TAG_ORIENTATION,
ExifInterface.ORIENTATION_NORMAL);
switch (orientation) {
case ExifInterface.ORIENTATION_ROTATE_90:
degrees = 90;
break;
case ExifInterface.ORIENTATION_ROTATE_180:
degrees = 180;
break;
case ExifInterface.ORIENTATION_ROTATE_270:
degrees = 270;
break;
}
} catch (Exception e) {
e.printStackTrace();
}
return degrees;
}

public static Bitmap imageWithFixedRotation(Bitmap bm, int degrees) {
if (bm == null || bm.isRecycled())
return null;

if (degrees == 0)
return bm;

final Matrix matrix = new Matrix();
matrix.postRotate(degrees);
Bitmap result = Bitmap.createBitmap(bm, 0, 0, bm.getWidth(), bm.getHeight(), matrix, true);
if (result != bm)
bm.recycle();
return result;

}

}