Android Camera2 Api:LegacyCameraDevice\u nativeGetSurfaceId:无法从曲面检索本机曲面

我正在尝试Android的Camera2 API，前摄像头工作正常，但当它与后摄像头一起使用时，我认为会出现以下错误：

LegacyCameraDevice_nativeGetSurfaceId: Could not retrieve native Surface from surface.

这发生在我点击按钮拍照之后。捕获回调成功，但在onImageAvailable上没有图像

我遵循了《我不知道如何处理我现在面临的错误》的教程

下面是用于捕获图像的代码

private void takePicture() {
    if (mCameraDevice == null) {
        return;
    }
    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
        CameraManager mManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);

        try {
            CameraCharacteristics mCharacteristics = mManager.getCameraCharacteristics(mCameraDevice.getId());
            Size[] jpegSizes = null;

            if (mCharacteristics != null) {
                jpegSizes = mCharacteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP).getOutputSizes(ImageFormat.JPEG);
            }

            int width = 640;
            int height = 480;

            for(int x = 0; x < jpegSizes.length; x++) {
                Log.wtf("jpegSizes", String.valueOf(jpegSizes[x]));
            }

            if (jpegSizes != null && jpegSizes.length > 0) {
                width = jpegSizes[4].getWidth();
                height = jpegSizes[4].getHeight();
            }

            final ImageReader mReader = ImageReader.newInstance(width, height, ImageFormat.JPEG, 1);

            List<Surface> mOutputSurface = new ArrayList<>(2);
            mOutputSurface.add(mReader.getSurface());
            mOutputSurface.add(new Surface(mTextureView.getSurfaceTexture()));

            final CaptureRequest.Builder mCaptureBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
            mCaptureBuilder.addTarget(mReader.getSurface());
            mCaptureBuilder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);

            int mRotation = getWindowManager().getDefaultDisplay().getRotation();
            int jpegOrientation = (ORIENTATIONS.get(mRotation) + mSensorOrientation + 270) % 360;

            if(cameraId.equals("0")) {
                mCaptureBuilder.set(CaptureRequest.JPEG_ORIENTATION, ORIENTATIONS.get(mRotation));
            } else {
                if(extras.getString("orient").equals("landscape")) {
                    mCaptureBuilder.set(CaptureRequest.JPEG_ORIENTATION, ORIENTATIONS.get(mRotation));
                } else {
                    mCaptureBuilder.set(CaptureRequest.JPEG_ORIENTATION, jpegOrientation);
                }
            }

            final CameraCaptureSession.CaptureCallback captureListener = new CameraCaptureSession.CaptureCallback() {
                @Override
                public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
                    super.onCaptureCompleted(session, request, result);
                    if(mImage == null) {
                        Toast.makeText(StartCameraActivity.this, "Capturing Image Failed, Please Try Again", Toast.LENGTH_SHORT).show();
                        Log.wtf("onCaptureComplete", "Image not Available");
                    } else {
                        Log.wtf("onCaptureComplete", "Image Available");
                    }
                    //createCameraPreview();
                }

                @Override
                public void onCaptureFailed(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull CaptureFailure failure) {
                    super.onCaptureFailed(session, request, failure);
                    Log.wtf("FAILED", failure.toString());
                }
            };

            mCameraDevice.createCaptureSession(mOutputSurface, new CameraCaptureSession.StateCallback() {
                @Override
                public void onConfigured(@NonNull CameraCaptureSession session) {
                    Log.wtf("onConfigured", "succes");
                    try {
                        session.capture(mCaptureBuilder.build(), captureListener, mBackgroundHandler);
                    } catch (CameraAccessException e) {
                        e.printStackTrace();
                    }
                }

                @Override
                public void onConfigureFailed(@NonNull CameraCaptureSession session) {
                    Log.wtf("onConfigureFailed", "failed");
                }
            }, mBackgroundHandler);

            mReader.setOnImageAvailableListener(new ImageReader.OnImageAvailableListener() {
                @Override
                public void onImageAvailable(final ImageReader reader) {
                    mImage = reader.acquireLatestImage();
                    Log.wtf("imageAvail", "OnImageAvailable");

                    StartCameraActivity.this.runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            if (mImage == null) {
                                return;
                            }
                            final Image.Plane[] planes = mImage.getPlanes();
                            final ByteBuffer buffer = planes[0].getBuffer();
                            byte[] bytes = new byte[buffer.capacity()];
                            buffer.get(bytes);
                            Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);

                            mTextureView.setVisibility(View.INVISIBLE);
                            if(cameraId.equals("0")) {
                                screenshotHolder.setImageBitmap(bitmap);
                            } else {
                                screenshotHolder.setImageBitmap(flip(bitmap, mImage.getWidth(), mImage.getHeight()));
                            }
                            new RenderPicture(StartCameraActivity.this).execute();

                            if (mImage != null) {
                                mImage.close();
                            }
                            if(mReader != null) {
                                mReader.close();
                            }

                        }
                    });
                }
            }, mBackgroundHandler);


        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }
}

private void takePicture（）{
if（mCameraDevice==null）{
返回；
}
if（android.os.Build.VERSION.SDK\u INT>=android.os.Build.VERSION\u code.LOLLIPOP）{
CameraManager mManager=（CameraManager）getSystemService（Context.CAMERA_服务）；
试一试{
CameraCharacteristics mCharacteristics=mManager.getCameraCharacteristics（mCameraDevice.getId（））；
Size[]jpegsize=null；
如果（mCharacteristics！=null）{
jpegSizes=mCharacteristics.get（CameraCharacteristics.SCALER\u STREAM\u CONFIGURATION\u MAP）.getOutputSizes（ImageFormat.JPEG）；
}
整数宽度=640；
内部高度=480；
对于（int x=0；x0）{
宽度=JPEG大小[4]。getWidth（）；
高度=JPEG大小[4]。getHeight（）；
}
最终ImageReader mReader=ImageReader.newInstance（宽度、高度、ImageFormat.JPEG，1）；
List mOutputSurface=新阵列列表（2）；
添加（mReader.getSurface（））；
添加（新曲面（mTextureView.getSurfaceTexture（））；
final CaptureRequest.Builder mCaptureBuilder=mCameraDevice.createCaptureRequest（CameraDevice.TEMPLATE\u STILL\u CAPTURE）；
mCaptureBuilder.addTarget（mReader.getSurface（））；
mCaptureBuilder.set（CaptureRequest.CONTROL_模式，CameraMetadata.CONTROL_模式自动）；
int mRotation=getWindowManager（）.getDefaultDisplay（）.getRotation（）；
int-jpegOrientation=（ORIENTATIONS.get（mRotation）+mSensorOrientation+270）%360；
if（cameraId.equals（“0”））{
mCaptureBuilder.set（CaptureRequest.JPEG_ORIENTATION，ORIENTATIONS.get（mRotation））；
}否则{
if（extras.getString（“orient”）.equals（“横向”））{
mCaptureBuilder.set（CaptureRequest.JPEG_ORIENTATION，ORIENTATIONS.get（mRotation））；
}否则{
mCaptureBuilder.set（CaptureRequest.JPEG\u-ORIENTATION，jpegOrientation）；
}
}
final CameraCaptureSession.CaptureCallback captureListener=新建CameraCaptureSession.CaptureCallback（）{
@凌驾
已完成捕获时公用void（@NonNull CameraCaptureSession会话、@NonNull CaptureRequest请求、@NonNull TotalCaptureResult）{
super.onCaptureCompleted（会话、请求、结果）；
if（mImage==null）{
Toast.makeText（StartCameraActivity.this，“捕获图像失败，请重试”，Toast.LENGTH_SHORT.show（）；
Log.wtf（“onCaptureComplete”，“图像不可用”）；
}否则{
Log.wtf（“onCaptureComplete”，“图像可用”）；
}
//createCameraPreview（）；
}
@凌驾
public void oncapturefiled（@NonNull CameraCaptureSession会话，@NonNull CaptureRequest请求，@NonNull CaptureFailure失败）{
super.onCaptureFailed（会话、请求、失败）；
Log.wtf（“FAILED”，failure.toString（））；
}
};
mCameraDevice.createCaptureSession（mOutputSurface，新的CameraCaptureSession.StateCallback（））{
@凌驾
未配置公共void（@NonNull CameraCaptureSession会话）{
Log.wtf（“未配置”、“成功”）；
试一试{
capture（mCaptureBuilder.build（），captureListener，mBackgroundHandler）；
}捕获（CameraAccessE异常）{
e、 printStackTrace（）；
}
}
@凌驾
已配置公用void onconfig（@NonNull CameraCaptureSession会话）{
Log.wtf（“onConfigureFailed”、“failed”）；
}
}，mBackgroundHandler）；
mReader.setOnImageAvailableListener（新的ImageReader.OnImageAvailableListener（）{
@凌驾
可用的公共图像（最终图像阅读器）{
mImage=reader.acquiredlatestimage（）；
Log.wtf（“imageAvail”、“OnImageAvailable”）；
StartCameraActivity.this.runOnUiThread（新的Runnable（））{
@凌驾
公开募捐{
if（mImage==null）{
返回；
}
final Image.Plane[]planes=mImage.getPlanes（）；
final ByteBuffer buffer=平面[0]。getBuffer（）；
字节[]字节=新字节[buffer.capacity（）]；
buffer.get（字节）；
位图位图=位图工厂.decodeByteArray（字节，0，字节.长度）；
mTextureView.setVisibility（View.INVISIBLE）；
if（cameraId.equals（“0”））{
screenshotHolder.setImageBitmap（位图）；
}否则{
screenshotHolder.setImageBitmap（翻转（位图，mImage.getWidth（），mImage.getHe