Java 在Android中定制CameraView

我打算在我的应用程序中使用beyondar框架，但我对cameraview有一个问题。Beyondar在横向模式下使用cameraview，但我只想在屏幕的一半以纵向模式使用此视图，如图所示

BeyondAR CameraView.java

public class CameraView extends SurfaceView implements SurfaceHolder.Callback,
    Camera.PictureCallback {

/**
 * 
 * @author Joan Puig Sanz (joanpuigsanz@gmail.com)
 * 
 */
public static interface IPictureCallback {
    /**
     * This method is called when the snapshot of the camera is ready. If
     * there is an error, the image will be null
     * 
     * @param picture
     */
    void onPictureTaken(Bitmap picture);
}

private SurfaceHolder mHolder;
private Camera mCamera;
private IPictureCallback mCameraCallback;
private BitmapFactory.Options mOptions;

private Size mPreviewSize;
private List<Size> mSupportedPreviewSizes;
private List<String> mSupportedFlashModes;

public CameraView(Context context) {
    super(context);
    init(context);
}

public CameraView(Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);
    init(context);
}

public CameraView(Context context, AttributeSet attrs) {
    super(context, attrs);
    init(context);
}

private void init(Context context) {
    mHolder = getHolder();
    mHolder.addCallback(this);

    try {
                    mCamera = Camera.open();
        //mCamera.setDisplayOrientation(90);
                     Method rotateMethod;
                        rotateMethod = android.hardware.Camera.class.getMethod("setDisplayOrientation", int.class);
                        rotateMethod.invoke(mCamera, 90);


        //Camera.Parameters params = mCamera.getParameters();
        //params.setPreviewSize(427, 1240); 
        //mCamera.setParameters(params);
        setCamera(mCamera);
    } catch (Exception e) {
        Log.e(Constants.TAG, "ERROR: Unable to open the camera", e);
    }

    if (android.os.Build.VERSION.SDK_INT <= 10) {// Android 2.3.x or lower
        mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
    }
}

public void setCamera(Camera camera) {
    mCamera = camera;
    if (mCamera != null) {
        mSupportedPreviewSizes = mCamera.getParameters().getSupportedPreviewSizes();
        mSupportedFlashModes = mCamera.getParameters().getSupportedFlashModes();
        // Set the camera to Auto Flash mode.
        if (mSupportedFlashModes != null
                && mSupportedFlashModes.contains(Camera.Parameters.FLASH_MODE_AUTO)) {
            Camera.Parameters parameters = mCamera.getParameters();
            parameters.setFlashMode(Camera.Parameters.FLASH_MODE_AUTO);
            //parameters.setPreviewSize(300, 200);

            mCamera.setParameters(parameters);
        }
    }
}

public void setSupportedPreviewSizes(List<Size> supportedPreviewSizes) {
    mSupportedPreviewSizes = supportedPreviewSizes;
}

public Size getPreviewSize() {
    return mPreviewSize;
}

public void surfaceCreated(SurfaceHolder holder) {
    // The Surface has been created, acquire the camera and tell it where
    // to draw.
    try {

        if (mCamera == null) {
            init(getContext());
            if (mCamera == null) {
                return;
            }
        }

        mCamera.setPreviewDisplay(holder);
    } catch (IOException exception) {
        if (mCamera != null) {
            mCamera.release();
        }
        mCamera = null;
        Log.e(Constants.TAG, "CameraView -- ERROR en SurfaceCreated", exception);
    }
}

public void surfaceDestroyed(SurfaceHolder holder) {
    // Surface will be destroyed when we return, so stop the preview.
    // Because the CameraDevice object is not a shared resource, it's very
    // important to release it when the activity is paused.
    if (mCamera == null) {
        return;
    }
    mCamera.stopPreview();
    mCamera.release();
    mCamera = null;
}

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    final int width = resolveSize(getSuggestedMinimumWidth(), widthMeasureSpec);
    final int height = resolveSize(getSuggestedMinimumHeight(), heightMeasureSpec);
    setMeasuredDimension(width, height);

    if (mSupportedPreviewSizes != null) {
        mPreviewSize = getOptimalPreviewSize(mSupportedPreviewSizes, width, height);
    }

    super.onMeasure(widthMeasureSpec, heightMeasureSpec);
}

private Size getOptimalPreviewSize(List<Size> sizes, int width, int height) {

    Size result = null;

    for (Camera.Size size : sizes) {
        if (size.width <= width && size.height <= height) {
            if (result == null) {
                result = size;
            } else {
                int resultArea = result.width * result.height;
                int newArea = size.width * size.height;

                if (newArea > resultArea) {
                    result = size;
                }
            }
        }
    }

    return result;
}

public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
    if (mCamera == null || getPreviewSize() == null) {
        return;
    }

    Camera.Parameters parameters = mCamera.getParameters();
    Size previewSize = getPreviewSize();
    parameters.setPreviewSize(previewSize.width, previewSize.height);

    mCamera.setParameters(parameters);
    previewCamera();

}

@Override
public void onPictureTaken(byte[] imageData, Camera camera) {
    if (imageData != null && mCameraCallback != null) {
        mCameraCallback.onPictureTaken(StoreByteImage(imageData));
    }
    previewCamera();
}

public void previewCamera() {
    if (mCamera == null){
        return;
    }
    try {
        mCamera.setPreviewDisplay(mHolder);
        mCamera.startPreview();
    } catch (Exception e) {
        Log.d(Constants.TAG, "Cannot start preview.", e);
    }
}

private Bitmap StoreByteImage(byte[] imageData) {

    Bitmap myImage = DebugBitmap.decodeByteArray(imageData, 0, imageData.length, mOptions);

    imageData = null;
    System.gc();

    return myImage;
}

public void tackePicture(IPictureCallback cameraCallback) {
    BitmapFactory.Options options = new BitmapFactory.Options();
    options.inSampleSize = 4;
    tackePicture(cameraCallback, options);
}

public void tackePicture(IPictureCallback cameraCallback, BitmapFactory.Options options) {
    if (mCamera == null) {
        return;
    }
    mCameraCallback = cameraCallback;
    mCamera.takePicture(null, this, this);
    mOptions = options;
}


}

公共类CameraView扩展了SurfaceView实现了SurfaceHolder.Callback， 摄像机，图像调回{ /** * *@作者琼·普伊格·桑兹(joanpuigsanz@gmail.com) * */ 公共静态接口IPactureCallback{ /** *当相机快照准备就绪时调用此方法。如果 *出现错误，图像将为空 * *@param图片 */ void onPictureTaken（位图图片）； } 私人地勤人员； 私人摄像机麦卡梅拉； 私人IPictureCallback mCameraCallback； 私有位图工厂； 私人规模的mPreviewSize； 私有列表msupportedpreviews； 私有列表MSSupportedFlashModes； 公共摄像师（背景）{ 超级（上下文）； init（上下文）； } 公共摄影机视图（上下文、属性集属性、int-defStyle）{ 超级（上下文、属性、定义样式）； init（上下文）； } 公共摄影机视图（上下文、属性集属性）{ 超级（上下文，attrs）； init（上下文）； } 私有void init（上下文）{ mHolder=getHolder（）； mHolder.addCallback（this）； 试一试{ mCamera=Camera.open（）； //mCamera.setDisplayOrientation（90）； 方法旋转法； rotateMethod=android.hardware.Camera.class.getMethod（“setDisplayOrientation”，int.class）； rotateMethod.invoke（mCamera，90）； //Camera.Parameters params=mCamera.getParameters（）； //参数setPreviewSize（4271240）； //mCamera.setParameters（参数）； setCamera（mCamera）； }捕获（例外e）{ Log.e（Constants.TAG，“错误：无法打开摄像头”，e）； }

---

如果（android.os.Build.VERSION.SDK_INT查看库的最后一个版本，那么这个问题已经解决，框架的使用会更好