android.hardware.camera2.CameraAccessException:CAMERA_已断开连接（2）：取消请求：473:相机设备不再活动

运行我的应用程序，我可以看到完美的摄像头视图，现在我打开内置摄像头应用程序，然后再次切换到我自己的应用程序（在这里，我只能看到黑屏）

日志

XML

---

当您将应用程序放在后台，然后将摄像头与此应用程序分离时，您可以在

onPause（）

方法中执行此操作，并在再次打开应用程序时在

onResume（）

方法中重新连接此操作。

在您的摄像头

活动中执行此操作

@Override
protected void onResume() {
    super.onResume();
    try {
        if (AppConstants.isActivityPaused) {//isActivityPaused is boolean var in AppConstant class
            startCamera();
            mBinding.frmCameraPreview.startPreview();
            AppConstants.isActivityPaused = false;
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

@Override
protected void onPause() {
    AppConstants.isActivityPaused = true;
    try {
        if (mCamera != null) {//mCamera is Camera object
            mCamera.stopPreview();
            mCamera.lock();
            mCamera.release();
            mCamera = null;
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    super.onPause();
}

private void startCamera() {
    mBinding.frmCameraPreview.requestLayout();
    try {
        if (mCamera == null)
            mCamera = getCameraInstance();
        if (mCamera != null) {
            //setup camera
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

/**
 * Helper method to access the camera returns null if it cannot get the
 * camera or does not exist
 *
 * @return camera
 */
private Camera getCameraInstance() {
    Camera camera = null;
    try {
        camera = Camera.open();
        if (camera == null) {
            camera = getFrontFacingCamera();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return camera;
}


/**
 * if there is no back camera we will get front camera instance
 *
 * @return front camera
 */
private Camera getFrontFacingCamera() {
    int cameraCount;
    Camera cam = null;
    Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
    cameraCount = Camera.getNumberOfCameras();
    for (int camIdx = 0; camIdx < cameraCount; camIdx++) {
        Camera.getCameraInfo(camIdx, cameraInfo);
        if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
            cam = Camera.open(camIdx);
        }
    }
    if (cam == null)
        cam = Camera.open();
    return cam;
}

@覆盖
受保护的void onResume（）{
super.onResume（）；
试一试{
如果（AppConstants.isActivityPaused）{//isActivityPaused是AppConstant类中的布尔变量
startCamera（）；
mBinding.frmCameraPreview.startPreview（）；
AppConstants.isActivityPaused=false；
}
}捕获（例外e）{
e、 printStackTrace（）；
}
}
@凌驾
受保护的void onPause（）{
AppConstants.isActivityPaused=true；
试一试{
如果（mCamera！=null）{//mCamera是摄影机对象
mCamera.stopPreview（）；
mCamera.lock（）；
mCamera.release（）；
mCamera=null；
}
}捕获（例外e）{
e、 printStackTrace（）；
}
super.onPause（）；
}
私有void startCamera（）{
mBinding.frmCameraPreview.requestLayout（）；
试一试{
if（mCamera==null）
mCamera=getCameraInstance（）；
if（mCamera！=null）{
//设置摄像机
}
}捕获（例外e）{
e、 printStackTrace（）；
}
}
/**
*如果无法获取该值，则访问摄影机的Helper方法将返回null
*摄像机或摄像机不存在
*
*@返回照相机
*/
私人摄像机getCameraInstance（）{
摄像头=空；
试一试{
camera=camera.open（）；
如果（摄像机==null）{
摄像头=getFrontFacingCamera（）；
}
}捕获（例外e）{
e、 printStackTrace（）；
}
返回摄像机；
}
/**
*如果没有后摄像头，我们将获得前摄像头实例
*
*@返回前摄像头
*/
私人摄像机getFrontFacingCamera（）{
国际照相机计数；
摄像机摄像机=null；
Camera.CameraInfo CameraInfo=新的Camera.CameraInfo（）；
cameraCount=Camera.getNumberOfCameras（）；
对于（int-camIdx=0；camIdx

恢复应用程序时，您必须在

onResume（）中重新初始化相机。

@HB。下面是我在onCreate（）中使用的代码，现在让我知道在onResume（）中必须使用什么

<com.src.webrtc.android.VideoView
     android:id="@+id/main_view"
     android:layout_width="wrap_content"
     android:layout_height="wrap_content" />

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)

    viewModel = ViewModelProvider(
        this,
        ViewModelFactory.getInstance(application)
    ).get(MainViewModel::class.java)

    binding = DataBindingUtil.setContentView(this, R.layout.activity_main)
    binding.viewModel = this.viewModel
    binding.lifecycleOwner = this

    binding.apply {
        peerViews.add(mainView)
        peerViews.add(subView1)
        for (i in viewRenderers.indices) {
            viewRenderers[i].setTarget(peerViews[i])
        }
    }

    viewModel.room.observe(this, Observer {
        Log.d(TAG, "observe room $it")
        if (it != null) {
            binding.mainView.apply {
                init(null)
                setScalingType(RendererCommon.ScalingType.SCALE_ASPECT_FIT)
                setEnableHardwareScaler(false)
            }
            initSubView(it, binding.subView1)
        } else {
            binding.mainView.clearImage()
            binding.subView1.clearImage()
            Handler().postDelayed({
                binding.mainView.release()
                binding.subView1.release()
            }, 100)
        }
    })

}

@Override
protected void onResume() {
    super.onResume();
    try {
        if (AppConstants.isActivityPaused) {//isActivityPaused is boolean var in AppConstant class
            startCamera();
            mBinding.frmCameraPreview.startPreview();
            AppConstants.isActivityPaused = false;
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

@Override
protected void onPause() {
    AppConstants.isActivityPaused = true;
    try {
        if (mCamera != null) {//mCamera is Camera object
            mCamera.stopPreview();
            mCamera.lock();
            mCamera.release();
            mCamera = null;
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    super.onPause();
}

private void startCamera() {
    mBinding.frmCameraPreview.requestLayout();
    try {
        if (mCamera == null)
            mCamera = getCameraInstance();
        if (mCamera != null) {
            //setup camera
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

/**
 * Helper method to access the camera returns null if it cannot get the
 * camera or does not exist
 *
 * @return camera
 */
private Camera getCameraInstance() {
    Camera camera = null;
    try {
        camera = Camera.open();
        if (camera == null) {
            camera = getFrontFacingCamera();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return camera;
}


/**
 * if there is no back camera we will get front camera instance
 *
 * @return front camera
 */
private Camera getFrontFacingCamera() {
    int cameraCount;
    Camera cam = null;
    Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
    cameraCount = Camera.getNumberOfCameras();
    for (int camIdx = 0; camIdx < cameraCount; camIdx++) {
        Camera.getCameraInfo(camIdx, cameraInfo);
        if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
            cam = Camera.open(camIdx);
        }
    }
    if (cam == null)
        cam = Camera.open();
    return cam;
}