Java 删除Android studio上打开的摄像头界面

我真的需要帮助。我有一个叫做MyHeartRate的项目，我在Github下载了心率项目的源代码。因此，我尝试运行该源代码，并且没有错误。在界面布局中，显示“摄像头”。例如，当你打开相机时，你会看到屏幕焦点在你想要拍照的区域。所以我的问题是，我想删除布局中的“摄像头”。我需要知道哪些代码需要删除，然后“相机”不在我的布局

这是我的密码

xml文件

java文件（HeartRateMonitor）

公共类HeartRateMonitor扩展活动{
私有静态最终字符串TAG=“HeartRateMonitor”；
私有静态最终AtomicBoolean处理=新AtomicBoolean（false）；
私有静态SurfaceView预览=null；
私有静态SurfaceHolder previewHolder=null；
专用静态摄像机=空；
私有静态视图图像=null；
私有静态TextView text=null；
私有静态WakeLock WakeLock=null；
私有静态int averageIndex=0；
私有静态final int averageArraySize=4；
私有静态final int[]averageArray=new int[averageArraySize]；
公共静态枚举类型{
绿色，红色
};
私有静态类型currentType=TYPE.GREEN；
公共静态类型getCurrent（）{
返回电流类型；
}
私有静态int-beatsIndex=0；
私有静态最终整数beatsArraySize=3；
私有静态最终整数[]beatsArray=新整数[beatsArraySize]；
私人静态双拍=0；
私有静态长起始时间=0；
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.main）；
预览=（SurfaceView）findViewById（R.id.preview）；
previewHolder=preview.getHolder（）；
previewHolder.addCallback（surfaceCallback）；
previewHolder.setType（SurfaceHolder.SURFACE类型推送缓冲区）；
image=findviewbyd（R.id.image）；
text=（TextView）findViewById（R.id.text）；
PowerManager pm=（PowerManager）getSystemService（Context.POWER\u服务）；
wakeLock=pm.newWakeLock（PowerManager.FULL_WAKE_LOCK，“DoNotDimScreen”）；
}
@凌驾
公共无效OnConfiguration已更改（配置newConfig）{
super.onConfigurationChanged（newConfig）；
}
@凌驾
恢复时公开作废（）{
super.onResume（）；
wakeLock.acquire（）；
camera=camera.open（）；
startTime=System.currentTimeMillis（）；
}
@凌驾
公共无效暂停（）{
super.onPause（）；
wakeLock.release（）；
camera.setPreviewCallback（空）；
camera.stopPreview（）；
相机。释放（）；
摄像机=零；
}
私有静态PreviewCallback PreviewCallback=新建PreviewCallback（）{
@凌驾
预览帧上的公共无效（字节[]数据，摄像头）{
如果（data==null）抛出新的NullPointerException（）；
Camera.Size Size=cam.getParameters（）.getPreviewSize（）；
如果（size==null）抛出新的NullPointerException（）；
if（！processing.compareAndSet（false，true））返回；
int width=size.width；
int height=size.height；
int imgAvg=ImageProcessing.decodeyuv420sptorederavg（data.clone（），高度，宽度）；
//Log.i（标签，“imgAvg=“+imgAvg”）；
如果（imgAvg==0 | | imgAvg==255）{
处理。设置（假）；
回来
}
int averageArrayAvg=0；
int averageArrayCnt=0；
for（int i=0；i0）{
averageArrayAvg+=averageArray[i]；
averageArrayCnt++；
}
}
int rollingAverage=（averageArrayCnt>0）？（averageArrayAvg/averageArrayCnt）：0；
类型newType=currentType；
if（imgAvg<滚动平均值）{
newType=TYPE.RED；
if（newType！=currentType）{
beats++；
//Log.d（标记“BEAT！！beats=“+beats”）；
}
}否则如果（imgAvg>滚动平均值）{
newType=TYPE.GREEN；
}
如果（averageIndex==averageArraySize）averageIndex=0；
averageArray[averageIndex]=imgAvg；
平均指数++；
//从一个州过渡到另一个州
if（newType！=currentType）{
currentType=newType；
image.postInvalidate（）；
}
long-endTime=System.currentTimeMillis（）；
双总时间=（结束时间-开始时间）/1000d；
如果（总时间>=10）{
双bps=（节拍/总时间）；
int dpm=（int）（bps*60d）；
如果（dpm<30 | | dpm>180）{
startTime=System.currentTimeMillis（）；
节拍=0；
处理。设置（假）；
回来
}
//Log.d（标签，
//“totalTimeInSecs=“+totalTimeInSecs+”beats=“+beats”）；
如果（beatsIndex==beatsArraySize）beatsIndex=0；
beatsArray[beatsIndex]=dpm；
beatsIndex++；
int-beatsArrayAvg=0；
int-beatsArrayCnt=0；
for（int i=0；i0）{
beatsArrayAvg+=beatsArray[i]；
beatsArrayCnt++；
}
}
int beatsAvg=（beatsArrayAvg/beatsArrayCnt）；
text.setText（String.valueOf（beatsAvg））；
startTime=System.currentTimeMillis（）；
节拍=0；
}
处理。设置（假）；
}
};
私有静态SurfaceHolder.Callback surfaceCallback=new SurfaceHolder.Callback（）{
@凌驾
已创建的公共空白表面（表面持有人）{
试一试{
照相机。设置预览显示（预览文件夹）；
camera.setPreviewCallback（previewCallback）；
}捕获（可丢弃的t）{
Log.e（“PreviewDemo surfaceCallback”，“setPreviewDisplay（）中的异常”，t）；
}
}
@结束
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical" 
android:layout_width="fill_parent"
android:layout_height="fill_parent" 
android:id="@+id/layout">
<LinearLayout android:id="@+id/top"
    android:paddingLeft="10dp"
    android:paddingRight="10dp"
    android:orientation="horizontal" 
    android:layout_width="fill_parent"
    android:layout_height="50dp">
    <TextView android:id="@+id/text"
        android:text="@string/default_text"
        android:textSize="32dp"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content">        
    </TextView>
    <RelativeLayout
        android:orientation="horizontal" 
        android:layout_width="fill_parent"
        android:layout_height="fill_parent">
        <com.jwetherell.heart_rate_monitor.HeartbeatView android:id="@+id/image"
            android:layout_centerInParent="true"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content">
        </com.jwetherell.heart_rate_monitor.HeartbeatView>
    </RelativeLayout>
</LinearLayout>
<SurfaceView android:id="@+id/preview"
    android:layout_weight="1" 
    android:layout_width="fill_parent"
    android:layout_height="0dp">
</SurfaceView>

public class HeartRateMonitor extends Activity {

private static final String TAG = "HeartRateMonitor";
private static final AtomicBoolean processing = new AtomicBoolean(false);

private static SurfaceView preview = null;
private static SurfaceHolder previewHolder = null;
private static Camera camera = null;
private static View image = null;
private static TextView text = null;

private static WakeLock wakeLock = null;

private static int averageIndex = 0;
private static final int averageArraySize = 4;
private static final int[] averageArray = new int[averageArraySize];

public static enum TYPE {
    GREEN, RED
};

private static TYPE currentType = TYPE.GREEN;

public static TYPE getCurrent() {
    return currentType;
}

private static int beatsIndex = 0;
private static final int beatsArraySize = 3;
private static final int[] beatsArray = new int[beatsArraySize];
private static double beats = 0;
private static long startTime = 0;

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

    preview = (SurfaceView) findViewById(R.id.preview);
    previewHolder = preview.getHolder();
    previewHolder.addCallback(surfaceCallback);
    previewHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);

    image = findViewById(R.id.image);
    text = (TextView) findViewById(R.id.text);

    PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
    wakeLock = pm.newWakeLock(PowerManager.FULL_WAKE_LOCK, "DoNotDimScreen");
}

@Override
public void onConfigurationChanged(Configuration newConfig) {
    super.onConfigurationChanged(newConfig);
}

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

    wakeLock.acquire();

    camera = Camera.open();

    startTime = System.currentTimeMillis();
}

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

    wakeLock.release();

    camera.setPreviewCallback(null);
    camera.stopPreview();
    camera.release();
    camera = null;
}

private static PreviewCallback previewCallback = new PreviewCallback() {

    @Override
    public void onPreviewFrame(byte[] data, Camera cam) {
        if (data == null) throw new NullPointerException();
        Camera.Size size = cam.getParameters().getPreviewSize();
        if (size == null) throw new NullPointerException();

        if (!processing.compareAndSet(false, true)) return;

        int width = size.width;
        int height = size.height;

        int imgAvg = ImageProcessing.decodeYUV420SPtoRedAvg(data.clone(), height, width);
        // Log.i(TAG, "imgAvg="+imgAvg);
        if (imgAvg == 0 || imgAvg == 255) {
            processing.set(false);
            return;
        }

        int averageArrayAvg = 0;
        int averageArrayCnt = 0;
        for (int i = 0; i < averageArray.length; i++) {
            if (averageArray[i] > 0) {
                averageArrayAvg += averageArray[i];
                averageArrayCnt++;
            }
        }

        int rollingAverage = (averageArrayCnt > 0) ? (averageArrayAvg / averageArrayCnt) : 0;
        TYPE newType = currentType;
        if (imgAvg < rollingAverage) {
            newType = TYPE.RED;
            if (newType != currentType) {
                beats++;
                // Log.d(TAG, "BEAT!! beats="+beats);
            }
        } else if (imgAvg > rollingAverage) {
            newType = TYPE.GREEN;
        }

        if (averageIndex == averageArraySize) averageIndex = 0;
        averageArray[averageIndex] = imgAvg;
        averageIndex++;

        // Transitioned from one state to another to the same
        if (newType != currentType) {
            currentType = newType;
            image.postInvalidate();
        }

        long endTime = System.currentTimeMillis();
        double totalTimeInSecs = (endTime - startTime) / 1000d;
        if (totalTimeInSecs >= 10) {
            double bps = (beats / totalTimeInSecs);
            int dpm = (int) (bps * 60d);
            if (dpm < 30 || dpm > 180) {
                startTime = System.currentTimeMillis();
                beats = 0;
                processing.set(false);
                return;
            }

            // Log.d(TAG,
            // "totalTimeInSecs="+totalTimeInSecs+" beats="+beats);

            if (beatsIndex == beatsArraySize) beatsIndex = 0;
            beatsArray[beatsIndex] = dpm;
            beatsIndex++;

            int beatsArrayAvg = 0;
            int beatsArrayCnt = 0;
            for (int i = 0; i < beatsArray.length; i++) {
                if (beatsArray[i] > 0) {
                    beatsArrayAvg += beatsArray[i];
                    beatsArrayCnt++;
                }
            }
            int beatsAvg = (beatsArrayAvg / beatsArrayCnt);
            text.setText(String.valueOf(beatsAvg));
            startTime = System.currentTimeMillis();
            beats = 0;
        }
        processing.set(false);
    }
};

private static SurfaceHolder.Callback surfaceCallback = new SurfaceHolder.Callback() {

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        try {
            camera.setPreviewDisplay(previewHolder);
            camera.setPreviewCallback(previewCallback);
        } catch (Throwable t) {
            Log.e("PreviewDemo-surfaceCallback", "Exception in setPreviewDisplay()", t);
        }
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        Camera.Parameters parameters = camera.getParameters();
        parameters.setFlashMode(Camera.Parameters.FLASH_MODE_TORCH);
        Camera.Size size = getSmallestPreviewSize(width, height, parameters);
        if (size != null) {
            parameters.setPreviewSize(size.width, size.height);
            Log.d(TAG, "Using width=" + size.width + " height=" + size.height);
        }
        camera.setParameters(parameters);
        camera.startPreview();
    }

   @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        // Ignore
    }
};

private static Camera.Size getSmallestPreviewSize(int width, int height, Camera.Parameters parameters) {
    Camera.Size result = null;

    for (Camera.Size size : parameters.getSupportedPreviewSizes()) {
        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;
}

//preview = (SurfaceView) findViewById(R.id.preview);
//previewHolder = preview.getHolder();
//previewHolder.addCallback(surfaceCallback);
//previewHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);