Android 自定義相機(錄像) 解決預覽 照片方向問題

以下是自定義相機遇到的問題：
1. 相機預覽的方向
2. 相機預覽時圖像變形
3. 照片保存到本地的方向

最近剛好公司的業務需要開發遙控拍照的功能，最初想通過調用系統的相機來解決，不過最後始終沒找到讓系統相機自動拍照的方法， 故只能改用 自定義相機來開發。當然也就發現了相機開發中的坑。

1 解決相機預覽方向的問題：

 /**
     * 保證預覽方向正確
     *
     * @param activity
     * @param cameraId
     * @param camera
     */
    public static void setCameraDisplayOrientation(Activity activity, int cameraId, Camera camera) {
        android.hardware.Camera.CameraInfo info = new android.hardware.Camera.CameraInfo();
        android.hardware.Camera.getCameraInfo(cameraId, info);
        int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();

        int degrees = 0;
        switch (rotation) {
            case Surface.ROTATION_0:
                degrees = 0;
                break;
            case Surface.ROTATION_90:
                degrees = 90;
                break;
            case Surface.ROTATION_180:
                degrees = 180;
                break;
            case Surface.ROTATION_270:
                degrees = 270;
                break;
        }
        int result;
        if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
            result = (info.orientation + degrees) % 360;
            result = (360 - result) % 360;  // compensate the mirror
        } else {  // back-facing
            result = (info.orientation - degrees + 360) % 360;
        }
        camera.setDisplayOrientation(result);
    }

2 解決相機預覽變形的問題，相機在預覽變形時肯定是因爲 預覽的寬高的比例 和 surfaceview設置的不一致

/**
     * 設置Camera參數
     */
    private void setCameraParameters() {
        if (mCamera != null) {
            mParameters = mCamera.getParameters();
            List<Camera.Size> pictureSizeList = mParameters.getSupportedPictureSizes();
            /* 從列表中選取合適的分辨率 */
            Camera.Size picSize = CameraUtil.getProperSize4Ratio(pictureSizeList, (float) surfaceView.getHeight() / surfaceView.getWidth());
            mParameters.setPictureSize(picSize.width, picSize.height);
            Log.e("TAG","最終設置的picsize: picSize.width: " + picSize.width + " picSize.height: " + picSize.height);

            List<Camera.Size> videoSiezes = mParameters.getSupportedVideoSizes();
            int videoWidth = 0;
            int videoHeight = 0;
            if (videoSiezes != null && !videoSiezes.isEmpty()) {
//                Camera.Size videoSize = VideoUtil.getInstance().getPropVideoSize(videoSiezes,surfaceView.getWidth());
                  Camera.Size videoSize = CameraUtil.getMaxSize4Width(videoSiezes,surfaceView.getWidth());
                  Log.e("TAG", "獲取到的：video_width===" + videoSize.width + " video_height=== " +  videoSize.height);
                  videoWidth = videoSize.width;
                  videoHeight = videoSize.height;
            }
            List<Camera.Size> previewSizes = mParameters.getSupportedPreviewSizes();
//            Camera.Size previewSize = VideoUtil.getInstance().getPropPreviewSize(mParameters.getSupportedPreviewSizes(), videoWidth);
            Camera.Size previewSize = CameraUtil.getProperSize4Ratio(previewSizes,(float) videoWidth / videoHeight);
            mParameters.setPreviewSize(previewSize.width, previewSize.height);
            Log.e(TAG, "最終設置的預覽尺寸,previewSize.width: " + previewSize.width + " previewSize.height: " + previewSize.height);

            List<String> focusModes = mParameters.getSupportedFocusModes();
            if (focusModes != null && focusModes.size() > 0) {
                if (focusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) {
                    mParameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);  //設置自動對焦
                }
            }
            mCamera.setParameters(mParameters);
        }
    }

package com.beacool.beacoolcamera.utils;

import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import android.hardware.Camera.Size;
import android.util.Log;

public class CameraUtil {

    /**
     * 根據比例得到合適的尺寸的最大尺寸
     */
    public static Size getProperSize4Ratio(List<Size> sizeList, float displayRatio) {
        Collections.sort(sizeList, new SizeL2hComparator());
        Size result = null;
        for (Size size : sizeList) {
            float curRatio = ((float) size.width) / size.height;
            if (curRatio == displayRatio) {
                result = size;
            }
        }

        if (null == result) {
            for (Size size : sizeList) {
                float curRatio = ((float) size.width) / size.height;
                if (curRatio == 3f / 4) {
                    result = size;
                }
            }
        }
        return result;
    }

    /**
     * 根據寬度得到最大合適的尺寸
     * @param sizeList
     * @param Width
     * @return
     */
    public static Size getMaxSize4Width(List<Size> sizeList, int Width) {
        // 先對傳進來的size列表進行排序
        Collections.sort(sizeList, new SizeL2hComparator());
        Size result = null;
        for (Size size : sizeList) {
            if (size.height == Width) {
                result = size;
            }
        }
        return result;
    }

    /**
     * 獲取支持的最大尺寸
     */
    public static Size getMaxSize(List<Size> sizeList) {
        // 先對傳進來的size列表進行排序
        Collections.sort(sizeList, new SizeL2hComparator());
        Size result = null;
        if(sizeList != null && !sizeList.isEmpty()){
            result = sizeList.get(sizeList.size() - 1);
        }
        return result;
    }

    /**
     * 從小到大排序
     */
    private static class SizeL2hComparator implements Comparator<Size> {
        @Override
        public int compare(Size size1, Size size2) {
            if (size1.width < size2.width) {
                return -1;
            }else if (size1.width > size2.width) {
                return 1;
            }
            return 0;
        }
    }

    public static int getRecorderRotation(int cameraId){
        android.hardware.Camera.CameraInfo info = new                 android.hardware.Camera.CameraInfo();
        android.hardware.Camera.getCameraInfo(cameraId, info);
        return info.orientation;
    }
}

3 照片的保存方向，關於這個問題解決的方案很多，有把拍照的Bitmap進行旋轉的再進行保存，但是這種比較耗時 特別是拍的照片比較大，則在旋轉和保存都比較耗時；還有的是通過 ExifInterface 一下也給出代碼：

    /**
     * 將圖片的旋轉角度置爲0
     *
     * @param path
     * @return void
     * @Title: setPictureDegreeZero
     * @date 2012-12-10 上午10:54:46
     */
    public static void setPictureDegreeZero(String path) {
        try {
            ExifInterface exifInterface = new ExifInterface(path);
            // 修正圖片的旋轉角度，設置其不旋轉。這裏也可以設置其旋轉的角度，可以傳值過去，
            // 例如旋轉90度，傳值ExifInterface.ORIENTATION_ROTATE_90，需要將這個值轉換爲String類型的
            exifInterface.setAttribute(ExifInterface.TAG_ORIENTATION, "" + ExifInterface.ORIENTATION_ROTATE_90);
            exifInterface.saveAttributes();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

我覺得還是通過方向的監聽 IOrientationEventListener 來改變比較好 代碼如下：

 public class IOrientationEventListener extends OrientationEventListener {

        public IOrientationEventListener(Context context) {
            super(context);
        }

        @Override
        public void onOrientationChanged(int orientation) {
            if (ORIENTATION_UNKNOWN == orientation) {
                return;
            }
            Camera.CameraInfo info = new Camera.CameraInfo();
            Camera.getCameraInfo(mCameraId, info);
            orientation = (orientation + 45) / 90 * 90;
            int rotation = 0;
            if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
                rotation = (info.orientation - orientation + 360) % 360;
            } else {
                rotation = (info.orientation + orientation) % 360;
            }
//            Log.e("TAG","orientation: " + orientation);
            if (null != mCamera) {
                Camera.Parameters parameters = mCamera.getParameters();
                parameters.setRotation(rotation);
                mCamera.setParameters(parameters);
            }
        }
    }

只需要在 surfaceholder,callback 中的如下調用：

@Override
    public void surfaceCreated(SurfaceHolder holder) {
        startPreview();
        orienListener.enable();
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {

    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
         releaseCamera();
         orienListener.disable();
    }

以上便解決了拍照中常見的三個問題