Camera API拍照方向异常：通用方案失效后的适配方案咨询

Great question! The inconsistency you're seeing with the standard rotation fix is super common—different device manufacturers tend to implement the Camera API's rotation methods in slightly different ways, which is why that "one-size-fits-all" code fails on some devices. Let's break down your approach and a more robust solution:

你的思路完全可行！ #

Moving the rotation correction to after the photo is taken is a reliable compatibility fallback that avoids relying on inconsistent manufacturer implementations of parameters.setRotation(). Here's how to implement it properly:

拍照后旋转Bitmap的示例代码 #

In your onPictureTaken callback, you can decode the raw image data and apply the rotation using a Matrix:

@Override
public void onPictureTaken(byte[] data, Camera camera) {
    // Decode the original bitmap from the photo data
    Bitmap originalBitmap = BitmapFactory.decodeByteArray(data, 0, data.length);
    
    // Create a matrix to apply the rotation
    Matrix rotationMatrix = new Matrix();
    rotationMatrix.postRotate(mRotation); // Use the rotation value you calculated earlier
    
    // Generate the rotated bitmap (true = filter for smooth edges)
    Bitmap correctedBitmap = Bitmap.createBitmap(
        originalBitmap, 
        0, 0, 
        originalBitmap.getWidth(), originalBitmap.getHeight(), 
        rotationMatrix, 
        true
    );
    
    // Now use correctedBitmap for display, saving, etc.
    // Don't forget to recycle the original bitmap to save memory!
    originalBitmap.recycle();
}

Pros of this approach:

• Works across almost all devices: You're bypassing any manufacturer-specific quirks in the Camera API's rotation handling.
• Full control: You can adjust the rotation logic precisely for front vs. rear cameras (more on that later).

Minor caveat:

• For very high-resolution photos, rotating the bitmap uses a small amount of processing power, but modern devices handle this easily without noticeable lag.

更完善的适配方案（覆盖所有场景） #

To combine the best of both worlds (smooth preview + reliable photo orientation), use this multi-step approach:

1. Calculate the correct rotation angle (critical for front cameras!) #

The standard getRotation() method often misses the mirroring needed for front-facing cameras. Use this method to get the accurate rotation for both camera types:

private int getCameraRotation(Camera.CameraInfo cameraInfo) {
    // Get the device's current display rotation
    int displayRotation = getWindowManager().getDefaultDisplay().getRotation();
    int displayDegrees = 0;
    
    switch (displayRotation) {
        case Surface.ROTATION_0: displayDegrees = 0; break;
        case Surface.ROTATION_90: displayDegrees = 90; break;
        case Surface.ROTATION_180: displayDegrees = 180; break;
        case Surface.ROTATION_270: displayDegrees = 270; break;
    }

    int finalRotation;
    if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
        // Front cameras need mirror rotation to look natural
        finalRotation = (cameraInfo.orientation + displayDegrees) % 360;
        finalRotation = (360 - finalRotation) % 360;
    } else {
        // Rear cameras use direct rotation relative to display
        finalRotation = (cameraInfo.orientation - displayDegrees + 360) % 360;
    }
    return finalRotation;
}

2. Handle preview and photo rotation separately #

• For preview: Always use mCamera.setDisplayOrientation(mRotation)—this ensures the live preview looks correct to the user, and it works consistently across devices.
• For photo capture:
  1. First try the standard parameters.setRotation(mRotation) method (it works on most devices and avoids post-processing).
  2. If that fails (you'll notice the photo is still misoriented), fall back to the post-capture bitmap rotation method we covered earlier.

3. Check Exif metadata (avoid double rotation) #

Some devices save the rotation angle in the photo's Exif metadata instead of applying it directly to the pixel data. When loading saved photos, always check the Exif orientation to avoid rotating an already corrected image:

private int getExifOrientation(String imageFilePath) {
    try {
        ExifInterface exif = new ExifInterface(imageFilePath);
        int orientation = exif.getAttributeInt(
            ExifInterface.TAG_ORIENTATION,
            ExifInterface.ORIENTATION_NORMAL
        );
        
        switch (orientation) {
            case ExifInterface.ORIENTATION_ROTATE_90: return 90;
            case ExifInterface.ORIENTATION_ROTATE_180: return 180;
            case ExifInterface.ORIENTATION_ROTATE_270: return 270;
            default: return 0;
        }
    } catch (IOException e) {
        e.printStackTrace();
        return 0;
    }
}

Final Takeaway #

Your idea to move rotation correction to post-capture is absolutely valid and should be part of your compatibility strategy. Pair it with the accurate rotation calculation and Exif check, and you'll cover nearly every device out there.

内容的提问来源于stack exchange，提问作者h_coder