为什么通过相机意图捕获图像后图像会旋转？

Question

我已经被困在相机里6天了，但没有得到任何适当的解决方案。当我通过相机意图捕获图像时，图像正在旋转。我试图修复方向，但有时它没有在onActivityResult（）中给出位图值。当我尝试在ImageView中设置图像时，它会显示一个黑色屏幕。这是我的密码请帮帮我-

//call intent to capture image
captureBtn.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View arg0) {
                // TODO Auto-generated method stub
                try {
            Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
            if (takePictureIntent.resolveActivity(getActivity().getPackageManager()) != null) 
            {
                startActivityForResult(takePictureIntent,AlletConstants.CAPTURE_RECEIPT_IMAGE);
            }

        } catch (Exception e) {

            e.printStackTrace();
        }
            }
});


@Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        switch (requestCode) {
        case AlletConstants.CAPTURE_RECEIPT_IMAGE:
            if(data != null)
            {
                Uri qrcodeImageUri = data.getData();
                bitmapReceiptImage = handleQrBarCodeImage(qrcodeImageUri);
                mImageCaptureUri = AlletCommonUtility.bitmapToUri(getActivity(), bitmapReceiptImage);
                doCrop();
                AlletCommonUtility.showToast(getActivity(),"Uri = "+mImageCaptureUri);
            }

            break;

        case AlletConstants.CROP_RECEIPT_FROM_CAMERA:
            if(data != null)
            {
                Bundle qrcodeextras = data.getExtras();
                if (qrcodeextras != null) {
                    Bitmap cropBitmap = qrcodeextras.getParcelable("data");
                    receiptImageView.setImageBitmap(cropBitmap);
                    bitmapReceiptImage = cropBitmap;
                }

                File qrcodeFile = new File(mImageCaptureUri.getPath());
                if (qrcodeFile.exists())
                    qrcodeFile.delete();
            }

            break;      

        default:
            break;
        }

    }




// use to get bitmap from uri 
    private Bitmap handleReceiptImage(Uri selectedImageUri)
    {       
        String[] filePathColumn = {MediaStore.Images.Media.DATA };  

        Cursor cursor = getActivity().getContentResolver().query(selectedImageUri, filePathColumn, null, null, null);  
        cursor.moveToFirst();  

        int columnIndex = cursor.getColumnIndex(filePathColumn[0]);  
        picturePath = cursor.getString(columnIndex);  
        cursor.close(); 
        Bitmap bitmap = setCameraImageRotation(picturePath);
        return bitmap;
    }

    private Bitmap setCameraImageRotation(String picturePath)
    {
        Bitmap bitmapQrBarImage = null;
         try {
                File f = new File(picturePath);
                ExifInterface exif = new ExifInterface(f.getPath());
                int orientation =  exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);      
                AlletCommonUtility.showToast(getActivity(), "Orienattion = "+orientation);
                Matrix mat = new Matrix();
                mat.postRotate(getImageOrientation(orientation));
                BitmapFactory.Options options = new BitmapFactory.Options();
                options.inSampleSize= 4;
                Bitmap bmp = BitmapFactory.decodeStream(new FileInputStream(f), null, options);
                bitmapQrBarImage = Bitmap.createBitmap(bmp, 0, 0, bmp.getWidth(), bmp.getHeight(), mat, true);     

                if (bitmapQrBarImage != null) {
                     AlletCommonUtility.showToast(getActivity(), "CAMERA_PIC_SELECTION = "+bitmapQrBarImage);
                }
            }
            catch (IOException e) {
                Log.w("TAG", "-- Error in setting image");
            }   
            catch(OutOfMemoryError oom) {
                Log.w("TAG", "-- OOM Error in setting image");
            }

         return bitmapQrBarImage;

    }



// Use to crop image
    private void doCrop() {
        final ArrayList<CropOption> cropOptions = new ArrayList<CropOption>();
        Intent intent = new Intent("com.android.camera.action.CROP");
        intent.setType("image/*");

        List<ResolveInfo> list = getActivity().getPackageManager().queryIntentActivities( intent, 0 );

        int size = list.size();

        if (size == 0) {       
            AlletCommonUtility.showToast(getActivity(), AlletMessage.NOT_CROP_IMAGE);           
            return;
        } else {
            intent.setData(mImageCaptureUri);

            intent.putExtra("outputX", 200);
            intent.putExtra("outputY", 200);
            intent.putExtra("aspectX", 1);
            intent.putExtra("aspectY", 1);
            intent.putExtra("scale", true);
            intent.putExtra("return-data", true);

            if (size == 1) {
                Intent i        = new Intent(intent);
                ResolveInfo res = list.get(0);

                i.setComponent( new ComponentName(res.activityInfo.packageName, res.activityInfo.name));
                startActivityForResult(i, AlletConstants.CROP_RECEIPT_FROM_CAMERA);

            } else {
                for (ResolveInfo res : list) {
                    final CropOption co = new CropOption();

                    co.title    = getActivity().getPackageManager().getApplicationLabel(res.activityInfo.applicationInfo);
                    co.icon     = getActivity().getPackageManager().getApplicationIcon(res.activityInfo.applicationInfo);
                    co.appIntent= new Intent(intent);

                    co.appIntent.setComponent( new ComponentName(res.activityInfo.packageName, res.activityInfo.name));

                    cropOptions.add(co);
                }

                CropOptionAdapter adapter = new CropOptionAdapter(getActivity(), cropOptions);

                AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
                builder.setTitle("Choose Crop App");
                builder.setAdapter( adapter, new DialogInterface.OnClickListener() {
                    public void onClick( DialogInterface dialog, int item ) {
                        startActivityForResult( cropOptions.get(item).appIntent, AlletConstants.CROP_RECEIPT_FROM_CAMERA); 
                    }
                });

                builder.setOnCancelListener( new DialogInterface.OnCancelListener() {
                    @Override
                    public void onCancel( DialogInterface dialog ) {

                        if (mImageCaptureUri != null ) {
                            getActivity().getContentResolver().delete(mImageCaptureUri, null, null );
                            mImageCaptureUri = null;
                        }
                    }
                } );

                AlertDialog alert = builder.create();

                alert.show();
            }
        }
    }



// use to rotate captured image from device camera 
public static int getImageOrientation(int rotation)
    {
         int angle = 0;

            switch (rotation) {
            case 0:
                angle = 90;
                break;

            case ExifInterface.ORIENTATION_ROTATE_90:
                angle = 90;
                break;

            case ExifInterface.ORIENTATION_ROTATE_180:
                angle = 180;
                break;

            case ExifInterface.ORIENTATION_ROTATE_270:
                angle = 270;
                break;
            default:
                break;
            }

            return angle;

    }

我得到的图像在横向模式，但不是在potrait模式。相机预览在拍摄图像后自动旋转90度。

Answer 1

根据您的内置摄像头方向和设备方向，图片将有不同的旋转。您可以通过ExifInterface检查特定图像的旋转。

/**
 * @param filename      Path to image file
 * @param captureTime   Time when image file was created
 */
public static int extractExifOrientationTagFromImageFile(String filename, long creationTime) {
    /* The issue is on some devices, there's a bug that makes the picture taken saved in your app folder without proper 
       exif tags while a properly rotated image is saved in the android default folder (even though it shouldn't be).
       Now what we do is recording the time when we're starting the camera app. Then we query
       the Media Provider to see if any pictures were saved after this timestamp we've saved. That means most likely Android OS 
       saved the properly rotated picture in the default folder and of course put an entry in the media store and we can use the 
       rotation information from this row.  */
    int imageRotation = -1;
    long imageFileSize = new File(filename).length();

    Cursor mediaFileCursor = getContext().getContentResolver().query(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, 
            new String[] { MediaStore.Images.ImageColumns.ORIENTATION, MediaStore.MediaColumns.SIZE }, 
            MediaStore.MediaColumns.DATE_ADDED + " >= ?", new String[] { String.valueOf(creationTime / 1000 - 1) }, 
            MediaStore.MediaColumns.DATE_ADDED + " DESC");
    if((mediaFileCursor != null) && (mediaFileCursor.getCount() != 0)) {
        while(mediaFileCursor.moveToNext()) {
            long mediaFileSize = getLongFromCursor(mediaFileCursor, MediaStore.MediaColumns.SIZE);
            // Extra check to make sure that we are getting the orientation from the proper file
            if(mediaFileSize == imageFileSize) {
                imageRotation = getIntFromCursor(mediaFileCursor, MediaStore.Images.ImageColumns.ORIENTATION);
                break;
            }
        }
    }

    /* Now if the rotation at this point is still -1, then that means this is one of the devices with proper rotation information. */
    if(imageRotation == -1) {
        ExifInterface exif = null;
        try {
            exif = new ExifInterface(filename);
        } 
        catch (IOException e) {
            e.printStackTrace();
        }
        imageRotation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, -1);
    }

    return imageRotation;
}

private static final int COLUMN_NOT_EXISTS = -1;

public static Long getLongFromCursor(Cursor cursor, String columnName) {
    int columnIndex;
    if((columnIndex = cursor.getColumnIndex(columnName)) != COLUMN_NOT_EXISTS) {
        return cursor.getLong(columnIndex);
    }
    else {
        return null;
    }
}

public static Integer getIntFromCursor(Cursor cursor, String columnName) {
    int columnIndex;
    if((columnIndex = cursor.getColumnIndex(columnName)) != COLUMN_NOT_EXISTS) {
        return cursor.getInt(columnIndex);
    }
    else {
        return null;
    }
}

现在，当您进行图像旋转时，可以正确旋转其位图：

int imageRotation = extractExifOrientationTagFromImageFile(lastCapturedMediaUriPath, cameraAppInvokeTime);
Matrix matrix = new Matrix();
switch(imageRotation) {
    case ExifInterface.ORIENTATION_ROTATE_90:
        matrix.postRotate(90);
        break;
    case ExifInterface.ORIENTATION_ROTATE_180:
        matrix.postRotate(180);
        break;
    case ExifInterface.ORIENTATION_ROTATE_270:
        matrix.postRotate(270);
        break;
    default:
        break;
}
final Bitmap loadedBitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);

Answer 2

这是因为图像的EXIF数据。您需要使用旋转方法。