如何在android中打开前置摄像头预览？

现在我正在开发摄像头应用程序，因为我需要同时使用前后摄像头。我的要求是，当我首先打开应用程序时，它将显示后表面视图，而且我有一个按钮，当我按下一个按钮时，它将切换到前摄像头表面视图，并且当我第二次按下按钮时，它将再次切换到后摄像头，以便我写入这个代码

        import android.app.Activity;
        import android.app.AlertDialog;
        import android.content.Context;
        import android.hardware.Camera;
        import android.hardware.Camera.CameraInfo;
        import android.hardware.Camera.Size;
        import android.os.Bundle;
        import android.util.Log;
        import android.view.Menu;
        import android.view.MenuInflater;
        import android.view.MenuItem;
        import android.view.SurfaceHolder;
        import android.view.SurfaceView;
        import android.view.View;
        import android.view.ViewGroup;
        import android.view.Window;
        import android.view.WindowManager;

        import java.io.IOException;
        import java.util.List;

        import com.example.R;

        public class MainActivity extends Activity {
             private Preview mPreview;
                Camera mCamera;
                int numberOfCameras;
                int cameraCurrentlyLocked;

                // The first rear facing camera
                int defaultCameraId;

            protected void onCreate(Bundle savedInstanceState) 
              {
                super.onCreate(savedInstanceState);
                // Hide the window title.
                requestWindowFeature(Window.FEATURE_NO_TITLE);
                getWindow().addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);

                // Create a RelativeLayout container that will hold a SurfaceView,
                // and set it as the content of our activity.
                mPreview = new Preview(this);
                setContentView(mPreview);

                // Find the total number of cameras available
                numberOfCameras = Camera.getNumberOfCameras();

                // Find the ID of the default camera
                CameraInfo cameraInfo = new CameraInfo();
                    for (int i = 0; i < numberOfCameras; i++)
                   {
                        Camera.getCameraInfo(i, cameraInfo);
                        if (cameraInfo.facing == CameraInfo.CAMERA_FACING_BACK)
                        {
                            defaultCameraId = i;
                        }
                    }
            }

            @Override
            protected void onResume() {
                super.onResume();

                // Open the default i.e. the first rear facing camera.
                mCamera = Camera.open();
                cameraCurrentlyLocked = defaultCameraId;
                mPreview.setCamera(mCamera);
            }

            @Override
            protected void onPause() {
                super.onPause();

                // Because the Camera object is a shared resource, it's very
                // important to release it when the activity is paused.
                if (mCamera != null) {
                    mPreview.setCamera(null);
                    mCamera.release();
                    mCamera = null;
                }
            }

            @Override
            public boolean onCreateOptionsMenu(Menu menu) {

                // Inflate our menu which can gather user input for switching camera
                MenuInflater inflater = getMenuInflater();
                inflater.inflate(R.menu.camera_menu, menu);
                return true;
            }

            @Override
            public boolean onOptionsItemSelected(MenuItem item) {
                // Handle item selection
                switch (item.getItemId()) {
                case R.id.switch_cam:
                    // check for availability of multiple cameras
                    if (numberOfCameras == 1) {
                        AlertDialog.Builder builder = new AlertDialog.Builder(this);
                        builder.setMessage("camera_alert")
                               .setNeutralButton("Close", null);
                        AlertDialog alert = builder.create();
                        alert.show();
                        return true;
                    }

                    // OK, we have multiple cameras.
                    // Release this camera -> cameraCurrentlyLocked
                    if (mCamera != null) {
                        mCamera.stopPreview();
                        mPreview.setCamera(null);
                        mCamera.release();
                        mCamera = null;
                    }

                    // Acquire the next camera and request Preview to reconfigure
                    // parameters.
                    mCamera = Camera
                            .open((cameraCurrentlyLocked + 1) % numberOfCameras);
                    cameraCurrentlyLocked = (cameraCurrentlyLocked + 1)
                            % numberOfCameras;
                    mPreview.switchCamera(mCamera);

                    // Start the preview
                    mCamera.startPreview();
                    return true;
                default:
                    return super.onOptionsItemSelected(item);
                }
            }

            class Preview extends ViewGroup implements SurfaceHolder.Callback {
                private final String TAG = "Preview";

                SurfaceView mSurfaceView;
                SurfaceHolder mHolder;
                Size mPreviewSize;
                List<Size> mSupportedPreviewSizes;
                Camera mCamera;

                Preview(Context context) {
                    super(context);

                    mSurfaceView = new SurfaceView(context);
                    addView(mSurfaceView);

                    // Install a SurfaceHolder.Callback so we get notified when the
                    // underlying surface is created and destroyed.
                    mHolder = mSurfaceView.getHolder();
                    mHolder.addCallback(this);
                    mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
                }

                public void setCamera(Camera camera) {
                    mCamera = camera;
                    if (mCamera != null) {
                        mSupportedPreviewSizes = mCamera.getParameters().getSupportedPreviewSizes();
                        requestLayout();
                    }
                }

                public void switchCamera(Camera camera) {
                   setCamera(camera);
                   try {
                       camera.setPreviewDisplay(mHolder);
                   } catch (IOException exception) {
                       Log.e(TAG, "IOException caused by setPreviewDisplay()", exception);
                   }
                   Camera.Parameters parameters = camera.getParameters();
                   parameters.setPreviewSize(mPreviewSize.width, mPreviewSize.height);
                   requestLayout();

                   camera.setParameters(parameters);
                }

                @Override
                protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
                    // We purposely disregard child measurements because act as a
                    // wrapper to a SurfaceView that centers the camera preview instead
                    // of stretching it.
                    final int width = resolveSize(getSuggestedMinimumWidth(), widthMeasureSpec);
                    final int height = resolveSize(getSuggestedMinimumHeight(), heightMeasureSpec);
                    setMeasuredDimension(width, height);

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

                @Override
                protected void onLayout(boolean changed, int l, int t, int r, int b) {
                    if (changed && getChildCount() > 0) {
                        final View child = getChildAt(0);

                        final int width = r - l;
                        final int height = b - t;

                        int previewWidth = width;
                        int previewHeight = height;
                        if (mPreviewSize != null) {
                            previewWidth = mPreviewSize.width;
                            previewHeight = mPreviewSize.height;
                        }

                        // Center the child SurfaceView within the parent.
                        if (width * previewHeight > height * previewWidth) {
                            final int scaledChildWidth = previewWidth * height / previewHeight;
                            child.layout((width - scaledChildWidth) / 2, 0,
                                    (width + scaledChildWidth) / 2, height);
                        } else {
                            final int scaledChildHeight = previewHeight * width / previewWidth;
                            child.layout(0, (height - scaledChildHeight) / 2,
                                    width, (height + scaledChildHeight) / 2);
                        }
                    }
                }

                public void surfaceCreated(SurfaceHolder holder) {
                    // The Surface has been created, acquire the camera and tell it where
                    // to draw.
                    try {
                        if (mCamera != null) {
                            mCamera.setPreviewDisplay(holder);
                        }
                    } catch (IOException exception) {
                        Log.e(TAG, "IOException caused by setPreviewDisplay()", exception);
                    }
                }

                public void surfaceDestroyed(SurfaceHolder holder) {
                    // Surface will be destroyed when we return, so stop the preview.
                    if (mCamera != null) {
                        mCamera.stopPreview();
                    }
                }


                private Size getOptimalPreviewSize(List<Size> sizes, int w, int h) {
                    final double ASPECT_TOLERANCE = 0.1;
                    double targetRatio = (double) w / h;
                    if (sizes == null) return null;

                    Size optimalSize = null;
                    double minDiff = Double.MAX_VALUE;

                    int targetHeight = h;

                    // Try to find an size match aspect ratio and size
                    for (Size size : sizes) {
                        double ratio = (double) size.width / size.height;
                        if (Math.abs(ratio - targetRatio) > ASPECT_TOLERANCE) continue;
                        if (Math.abs(size.height - targetHeight) < minDiff) {
                            optimalSize = size;
                            minDiff = Math.abs(size.height - targetHeight);
                        }
                    }

                    // Cannot find the one match the aspect ratio, ignore the requirement
                    if (optimalSize == null) {
                        minDiff = Double.MAX_VALUE;
                        for (Size size : sizes) {
                            if (Math.abs(size.height - targetHeight) < minDiff) {
                                optimalSize = size;
                                minDiff = Math.abs(size.height - targetHeight);
                            }
                        }
                    }
                    return optimalSize;
                }

                public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
                    // Now that the size is known, set up the camera parameters and begin
                    // the preview.
                    Camera.Parameters parameters = mCamera.getParameters();
                    parameters.setPreviewSize(mPreviewSize.width, mPreviewSize.height);
                    requestLayout();

                    mCamera.setParameters(parameters);
                    mCamera.startPreview();
                }

            }
        }

        and my menu.xml
        <?xml version="1.0" encoding="utf-8"?>
        <menu xmlns:android="http://schemas.android.com/apk/res/android">
            <item android:id="@+id/switch_cam"
                  android:title="@string/switch_cam" />
        </menu>

        when i write this code i get error

        menu cannot be resolved or is not a field and 
        switch_cam cannot be resolved or is not a field
        pleae help me

导入android.app.Activity；
导入android.app.AlertDialog；
导入android.content.Context；
导入android.hardware.Camera；
导入android.hardware.Camera.CameraInfo；
导入android.hardware.Camera.Size；
导入android.os.Bundle；
导入android.util.Log；
导入android.view.Menu；
导入android.view.MenuInflater；
导入android.view.MenuItem；
导入android.view.SurfaceHolder；
导入android.view.SurfaceView；
导入android.view.view；
导入android.view.ViewGroup；
导入android.view.Window；
导入android.view.WindowManager；
导入java.io.IOException；
导入java.util.List；
导入com.example.R；
公共类MainActivity扩展了活动{
私人审查；
麦克默拉照相机；
国际数码相机；
int CameracCurrentlyLocked；
//第一个后向摄像头
int-defaultCameraId；
创建时受保护的void（Bundle savedInstanceState）
{
super.onCreate（savedInstanceState）；
//隐藏窗口标题。
requestWindowFeature（窗口。功能\u无\u标题）；
getWindow（）.addFlags（WindowManager.LayoutParams.FLAG_全屏）；
//创建一个RelativeLayout容器，用于保存SurfaceView，
//并将其作为我们活动的内容。
mPreview=新预览（本）；
setContentView（mPreview）；
//查找可用相机的总数
numberOfCameras=Camera.getNumberOfCameras（）；
//查找默认摄影机的ID
camerRainfo camerRainfo=新的camerRainfo（）；
对于（int i=0；i相机当前锁定
if（mCamera！=null）{
mCamera.stopPreview（）；
mPreview.setCamera（空）；
mCamera.release（）；
mCamera=null；
}
//获取下一个摄像头并请求预览以重新配置
//参数。
mCamera=照相机
.打开（（摄像机当前锁定+1）%numberofcamera）；
cameraCurrentlyLocked=（cameraCurrentlyLocked+1）
%摄像机数量；
mPreview.switchCamera（mCamera）；
//开始预览
mCamera.startPreview（）；
返回true；
违约：
返回super.onOptionsItemSelected（项目）；
}
}
类预览扩展视图组实现SurfaceHolder.Callback{
私有最终字符串标记=“预览”；
SurfaceView mSurfaceView；
表面粗糙度；
大小mPreviewSize；
列出MSSupportedPreviewsizes；
麦克默拉照相机；
预览（上下文）{
超级（上下文）；
mSurfaceView=新的SurfaceView（上下文）；
addView（mSurfaceView）；
//安装SurfaceHolder.Callback，以便在
if(valueofcam.equalsIgnoreCase("front")){
            // Find the ID of the default camera
            CameraInfo cameraInfo = new CameraInfo();
                for (int i = 0; i < numberOfCameras; i++) {
                    Camera.getCameraInfo(i, cameraInfo);
                    if (cameraInfo.facing == CameraInfo.CAMERA_FACING_FRONT) {
                        defaultCameraId = i;
//                      Toast.makeText(getApplicationContext(), "front", Toast.LENGTH_LONG).show();
                    }
                    else if (cameraInfo.facing == CameraInfo.CAMERA_FACING_BACK) {
                        defaultCameraId = i;
//                      Toast.makeText(getApplicationContext(), ""+defaultCameraId, Toast.LENGTH_LONG).show();
                    }
                }
    }

    camera = Camera.open(defaultCameraId);

        <com.google.android.cameraview.CameraView
            android:id="@+id/camera"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:adjustViewBounds="true"
            app:autoFocus="true"
            app:aspectRatio="4:3"
            app:facing="front"
            app:flash="off"
            android:background="@android:color/black" />