9

以垂直格式拍摄的照片以横向格式保存，反之亦然。我正在使用此意图使用 Android 相机

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

onActivityResult() 我只是将图像 URL 保存到我的数据库并在列表视图中显示它。但有方向变化。如果我从图库中选择图像并保存它，也会发生同样的情况。

我想要拍摄照片的方向。我不想改变它。有没有人对此有解决方案。

4

2 回答 2

17

有些设备在拍摄后不会旋转图像，而只是将其方向信息写入 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);
    }

并在您的列表视图中使用这个新的位图。或者最好在拍摄照片后立即调用此方法并用新的旋转照片覆盖它。

如果您将位图数据作为 Uri 接收，则可以使用以下方法检索其文件路径：

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;
}
于 2012-05-10T08:51:07.940 回答
1

您也可以按照以下方式进行操作：

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);
}
于 2014-04-16T10:28:11.070 回答