Android 手机Camera Orientation问题的深入研究

      在Android 开发过程中经常跟Camera 打交道，对Camera Orientation 的理解由开始的迷糊到精通，着实走了不少弯路。本文将对Android 系统Camera 相关经验做一个总结。

      1. 手机的屏幕画面显示的自然方向：所谓自然方向就是人体手持手机时，视觉的习惯方向。例如，竖屏手机的自然方向一般都是垂直短边框向上，横屏手机的自然方向一般都是垂直长边框向上。这个自然方向是手机出厂时就定义好了的，相当于定义了一个坐标系，所有的旋转都要参照这个坐标系。

      2. 本文提及的所有角度都是顺时针方向旋转，即以参照物为起点，目标物为终点，顺时针走过的角度即为目标物与参照物之间的夹角。

      3. 当手机旋转时，display.getRotation() 返回的值为当前手机的空间位置与手机自然朝向之间的夹角。例如：将竖屛手机向右倾倒横放，display.getRotation() ＝ 90；将竖屛手机向左倾倒横放，display.getRotation() ＝ 270；将竖屛手机上下颠倒放置，display.getRotation() ＝ 180。

      4. 不管是横屏还是竖屛手机，Camera 的物理方向一般都是垂直于长边框向上。也就说对于竖屏手机，其Camera 物理方向与屏幕Display的自然方向的夹角为90度（顺时针）如下图一；对于横屏手机，其Camera 自然方向与屏幕Display的自然方向的夹角为0度，如下图二。

      5. Camera 拍照时，总是按照Camera 的物理方向取景，即相当于将人的脑袋朝着Camera 的物理方向所看到的视角。对于横屏手机，当手横持手机拍照时，拍出来的照片即为用户眼前所见视角。而对于竖屛手机，当手竖持手机拍照时，拍出的照片往往旋转了90度，这是因为在竖屛手机上，Camera 本身物理方向就与屏幕Display的自然方向有90度夹角，用手竖持手机时，Camera的方向是水平向右的，如下图一。因此要想没有90度旋转，需要设置 Camera.setDisplayOrientation(90) 来校正。

 

       

        6. 如何计算当前Camera 物理位置与屏幕Display自然方向间的夹角？

           算法的核心思想是：先假设手机为竖屛手机，然后按照竖屛手机的角度关系计算Camera 物理位置与屏幕Display自然方向间的夹角，最后根据长宽关系判断当前手机是否为竖屛，如果不是，补偿一个270度然后对360取模，非常巧妙。

    public static int getOrientation(Context context) {
        Display display = ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
        int rotation = display.getRotation();
        int orientation;
        boolean expectPortrait;
        switch (rotation) {
        case Surface.ROTATION_0:
        default:
            orientation = 90;
            expectPortrait = true;
            break;
        case Surface.ROTATION_90:
            orientation = 0;
            expectPortrait = false;
            break;
        case Surface.ROTATION_180:
            orientation = 270;
            expectPortrait = true;
            break;
        case Surface.ROTATION_270:
            orientation = 180;
            expectPortrait = false;
            break;
        }
        boolean isPortrait = display.getHeight() > display.getWidth();
        if (isPortrait != expectPortrait) {
            orientation = (orientation + 270) % 360; 
        }
        return orientation;
    }

        7.如何为Surface View 设置一个最佳的尺寸？

    private Size calculateBestPreviewSizeAndAdjustLayout(Camera camera, Rect surfaceSize, int orientation, int minHeight, int maxHeight) {
        SizeAndRatio optimalSizeAndRatio = null;  // output
        double targetRatio = (double)surfaceSize.right/surfaceSize.bottom;
        if (orientation % 180 == 90) {
            // We are in portrait
            targetRatio = 1/targetRatio;
            m_updatedCameraFrameLayoutSize = new Point(surfaceSize.bottom,surfaceSize.right);
        } else {
            m_updatedCameraFrameLayoutSize = new Point(surfaceSize.right,surfaceSize.bottom);
        }
        boolean allowedResize = android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.ICE_CREAM_SANDWICH && orientation != 270;
        List<Size> supportedPreviewSizes = camera.getParameters().getSupportedPreviewSizes();

        // Collect sub-list that meets height requirements
        List<SizeAndRatio> cameraSizesAndRatios = new ArrayList<SizeAndRatio>();
        for (Size s : supportedPreviewSizes) {
            if (s.height < minHeight || s.height > maxHeight) {
                continue;  // Filter out too small or too large sizes
            }
            double ratio = ((double) s.width) / s.height;
            SizeAndRatio sr = new SizeAndRatio(s, ratio);
            cameraSizesAndRatios.add(sr);
        }

        // Error, no available sizes
        if (cameraSizesAndRatios.isEmpty()) {
            return null;
        }

        // Sort the list by height descending
        Collections.sort(cameraSizesAndRatios, new Comparator<SizeAndRatio>() {
            @Override
            public int compare(SizeAndRatio a_lhs, SizeAndRatio a_rhs) {
                return (a_rhs.size.height) - (a_lhs.size.height);
            }
        });

        // First try to find an exact screen aspect ratio match
        for (SizeAndRatio sr : cameraSizesAndRatios) {
            if (Math.abs(sr.ratio - targetRatio) < EPSILON_TOLERANCE) {
                optimalSizeAndRatio = sr;
                break;
            }
        }
        if (optimalSizeAndRatio != null) {
            return optimalSizeAndRatio.size;
        }

        // If we allow layout resizing, try to find 16:9 or 4:3 ratio
        if (allowedResize) {
            // Try to find a 16:9 ratio
            for (SizeAndRatio sr : cameraSizesAndRatios) {
                if (Math.abs(sr.ratio - RATIO16_9) < EPSILON_TOLERANCE) {
                    optimalSizeAndRatio = sr;
                    break;
                }
            }
            if (optimalSizeAndRatio != null) {<p class="p1">                // Notify that the screen layout should change</p><p class="p2">                <span class="s1">m_updatedCameraFrameLayoutSize</span> = adjustSurfaceSize(<span class="s1">mActivity</span>, optimalSizeAndRatio.<span class="s1">ratio</span>, orientation);</p>                return optimalSizeAndRatio.size;
            }

            // Try to find a 4:3 ratio
            for (SizeAndRatio sr : cameraSizesAndRatios) {
                if (Math.abs(sr.ratio - RATIO4_3) < EPSILON_TOLERANCE) {
                    optimalSizeAndRatio = sr;
                    break;
                }
            }
            if (optimalSizeAndRatio != null) {<p class="p1"><span class="s1">                </span>// Notify that the screen layout should change</p><p class="p2">                <span class="s2">m_updatedCameraFrameLayoutSize</span> = adjustSurfaceSize(<span class="s2">mActivity</span>, optimalSizeAndRatio.<span class="s2">ratio</span>, orientation);</p>                return optimalSizeAndRatio.size;
            }
        }

        // Now just use preview size with smallest ratio difference
        double minRatioDifference = Double.MAX_VALUE;
        for (SizeAndRatio sr : cameraSizesAndRatios) {
            double ratioDifference = Math.abs(sr.ratio - targetRatio);
            if (ratioDifference < minRatioDifference) {
                minRatioDifference = ratioDifference;
                optimalSizeAndRatio = sr;
            }
        }<p class="p1">        </p><p class="p1"><span class="s1">        if</span> (allowedResize) {</p><p class="p1">            <span class="s2">m_updatedCameraFrameLayoutSize</span> = adjustSurfaceSize(<span class="s2">mActivity</span>, optimalSizeAndRatio.<span class="s2">ratio</span>, orientation);</p><p class="p1">        }</p>
        return optimalSizeAndRatio.size;
    }

    public Point adjustSurfaceSize(FSECameraActivity activity, double a_aspectRatio, int a_orientation) {
        boolean isPortrait = a_orientation % 180 == 90;
        // Collect the width, height, and ratio of the screen
        Display display = activity.getWindowManager().getDefaultDisplay();
        int windowWidth, windowHeight;
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.HONEYCOMB_MR2) {
            Point size = new Point();
            display.getSize(size);
            windowWidth = size.x;
            windowHeight = size.y;
        } else {
            // Old APIs
            windowWidth = display.getWidth();
            windowHeight = display.getHeight();   
        }
        int leftMargin = 0;  // This may need to be adjusted for increasing width in portrait
        double currentRatio = (double)windowWidth / (double)windowHeight;

        // Adjust the ratios
        if (currentRatio < 1 && a_aspectRatio > 1 || currentRatio > 1 && a_aspectRatio < 1) {
            a_aspectRatio = 1.0/a_aspectRatio;
        }

        // Adjust the necessary dimension
        if (currentRatio > a_aspectRatio) {
            // If current ratio is larger, we need to increase the smaller dimension (height)
            windowHeight = (int) (windowWidth / a_aspectRatio);
        } else if (currentRatio < a_aspectRatio) {
            // If current ratio is smaller, we need to increase the larger dimension (width)
            int oldWindowWidth = windowWidth;
            windowWidth = (int) (windowHeight * a_aspectRatio);
            if (isPortrait) {
                // We also need to fix the Left Margin if in portrait
                leftMargin = oldWindowWidth - windowWidth;
            }
        } else if (currentRatio == a_aspectRatio) {
            // No adjustment needed
        }

        // Update layout parameters
        final LayoutParams lp = (FrameLayout.LayoutParams) mPreviewLayout.getLayoutParams();
        lp.width = windowWidth;
        lp.height = windowHeight;
        lp.topMargin = 0;
        lp.leftMargin = leftMargin;
        mCameraScreenMarginLeft = leftMargin;
        mPreviewLayout.setLayoutParams(lp);

        // Return a point where X corresponds to Camera Width, and Y corresponds to Camera Height.
        return isPortrait ? new Point(windowHeight, windowWidth) : new Point(windowWidth, windowHeight);
    }

        8. 如何将Camera 捕景框上的点坐标转化为手机屏幕上的坐标？

    /**
     * Translate a point returned by <span style="font-family: Arial, Helvetica, sans-serif;">camera sensor </span>into a point on the camera surface preview
     * @param point input Point returned from <span style="font-family: Arial, Helvetica, sans-serif;">camera sensor</span>
     * @return PointF
     */
    public PointF translatePoint(PointF point) {
        switch (mOrientation) {
        case 0:  // landscape right
            return new PointF(point.x*m_updatedCameraFrameLayoutSize.x/mCameraPreviewSize.width,
                    point.y*m_updatedCameraFrameLayoutSize.y/mCameraPreviewSize.height);
        case 180:  // landscape left 
            return new PointF((mCameraPreviewSize.width-point.x)*m_updatedCameraFrameLayoutSize.x/mCameraPreviewSize.width,
                    (mCameraPreviewSize.height-point.y)*m_updatedCameraFrameLayoutSize.y/mCameraPreviewSize.height);
        case 270:  // upside down portrait
            return new PointF(point.y*m_updatedCameraFrameLayoutSize.y/mCameraPreviewSize.height,
                    (mCameraPreviewSize.width-point.x)*m_updatedCameraFrameLayoutSize.x/mCameraPreviewSize.width);
        default:  // 90, normal portrait
            return new PointF((mCameraPreviewSize.height-point.y)*m_updatedCameraFrameLayoutSize.y/mCameraPreviewSize.height,
                    point.x*m_updatedCameraFrameLayoutSize.x/mCameraPreviewSize.width);
        }
    }