camera2 可不可以多个createCaptureSession

是的，Camera2 API 支持同时创建多个 CaptureSession。每个 CaptureSession 可以与不同的 Surface 关联，用于实现不同的相机应用场景。例如，你可以创建多个 CaptureSession 实例，一个用于预览，一个用于拍照，一个用于录制视频等。但要注意，当你创建多个 CaptureSession 时，需要及时释放资源以避免内存泄漏。

相关问题

camera2多个createCaptureSession demo

以下是一个简单的 Camera2 API 创建多个 CaptureSession 的示例代码：

public class CameraFragment extends Fragment {

    private CameraDevice mCameraDevice;
    private CameraCaptureSession mPreviewSession;
    private CameraCaptureSession mImageSession;
    private Size mPreviewSize;
    private Size mImageSize;
    private ImageReader mImageReader;

    private final CameraDevice.StateCallback mStateCallback = new CameraDevice.StateCallback() {

        @Override
        public void onOpened(@NonNull CameraDevice cameraDevice) {
            mCameraDevice = cameraDevice;
            createPreviewSession();
            createImageSession();
        }

        @Override
        public void onDisconnected(@NonNull CameraDevice cameraDevice) {
            cameraDevice.close();
            mCameraDevice = null;
        }

        @Override
        public void onError(@NonNull CameraDevice cameraDevice, int error) {
            cameraDevice.close();
            mCameraDevice = null;
            Activity activity = getActivity();
            if (null != activity) {
                activity.finish();
            }
        }

    };

    private final CameraCaptureSession.StateCallback mPreviewSessionCallback =
            new CameraCaptureSession.StateCallback() {

        @Override
        public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
            mPreviewSession = cameraCaptureSession;
            updatePreview();
        }

        @Override
        public void onConfigureFailed(@NonNull CameraCaptureSession cameraCaptureSession) {
            Activity activity = getActivity();
            if (null != activity) {
                Toast.makeText(activity, "Failed", Toast.LENGTH_SHORT).show();
            }
        }

    };

    private final CameraCaptureSession.StateCallback mImageSessionCallback =
            new CameraCaptureSession.StateCallback() {

        @Override
        public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
            mImageSession = cameraCaptureSession;
        }

        @Override
        public void onConfigureFailed(@NonNull CameraCaptureSession cameraCaptureSession) {
            Activity activity = getActivity();
            if (null != activity) {
                Toast.makeText(activity, "Failed", Toast.LENGTH_SHORT).show();
            }
        }

    };

    private final ImageReader.OnImageAvailableListener mOnImageAvailableListener =
            new ImageReader.OnImageAvailableListener() {

        @Override
        public void onImageAvailable(ImageReader reader) {
            Image image = reader.acquireLatestImage();
            // Process the captured image
            image.close();
        }

    };

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container,
                             @Nullable Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_camera, container, false);
        return view;
    }

    @Override
    public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        // Initialize the camera
        openCamera();
    }

    @Override
    public void onResume() {
        super.onResume();
        // Start the preview session
        if (null != mCameraDevice) {
            createPreviewSession();
        }
    }

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

    private void openCamera() {
        Activity activity = getActivity();
        if (null == activity || activity.isFinishing()) {
            return;
        }
        CameraManager manager = (CameraManager) activity.getSystemService(Context.CAMERA_SERVICE);
        try {
            String cameraId = manager.getCameraIdList()[0];
            CameraCharacteristics characteristics = manager.getCameraCharacteristics(cameraId);
            StreamConfigurationMap map = characteristics.get(
                    CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
            mPreviewSize = map.getOutputSizes(SurfaceTexture.class)[0];
            mImageSize = map.getOutputSizes(ImageFormat.JPEG)[0];
            mImageReader = ImageReader.newInstance(mImageSize.getWidth(), mImageSize.getHeight(),
                    ImageFormat.JPEG, /*maxImages*/2);
            mImageReader.setOnImageAvailableListener(mOnImageAvailableListener, null);
            manager.openCamera(cameraId, mStateCallback, null);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    private void closeCamera() {
        if (null != mPreviewSession) {
            mPreviewSession.close();
            mPreviewSession = null;
        }
        if (null != mImageSession) {
            mImageSession.close();
            mImageSession = null;
        }
        if (null != mCameraDevice) {
            mCameraDevice.close();
            mCameraDevice = null;
        }
        if (null != mImageReader) {
            mImageReader.close();
            mImageReader = null;
        }
    }

    private void createPreviewSession() {
        try {
            SurfaceTexture texture = getSurfaceTexture();
            texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight());
            Surface surface = new Surface(texture);
            CaptureRequest.Builder builder =
                    mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
            builder.addTarget(surface);
            mCameraDevice.createCaptureSession(Arrays.asList(surface), mPreviewSessionCallback,
                    null);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    private void createImageSession() {
        try {
            Surface surface = mImageReader.getSurface();
            CaptureRequest.Builder builder =
                    mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
            builder.addTarget(surface);
            mCameraDevice.createCaptureSession(Arrays.asList(surface), mImageSessionCallback,
                    null);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    private void updatePreview() {
        if (null == mCameraDevice) {
            return;
        }
        try {
            CaptureRequest.Builder builder =
                    mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
            SurfaceTexture texture = getSurfaceTexture();
            texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight());
            Surface surface = new Surface(texture);
            builder.addTarget(surface);
            mPreviewSession.setRepeatingRequest(builder.build(), null, null);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    private SurfaceTexture getSurfaceTexture() {
        Activity activity = getActivity();
        if (null == activity) {
            return null;
        }
        TextureView textureView = activity.findViewById(R.id.texture_view);
        return textureView.getSurfaceTexture();
    }

}

在此示例中，我们创建了两个 CaptureSession：一个用于预览，一个用于捕获图像。我们使用 ImageReader 来捕获 JPEG 图像，然后在 mOnImageAvailableListener 中处理捕获的图像。在 openCamera() 方法中，我们初始化了 ImageReader 并调用了 manager.openCamera() 来打开相机。在 mStateCallback 的 onOpened() 方法中，我们创建了两个 CaptureSession：一个用于预览，一个用于捕获图像。在 createPreviewSession() 方法中，我们首先获取 SurfaceTexture，然后创建一个 Surface 并将其添加到 CaptureRequest.Builder 中。然后，我们调用 mCameraDevice.createCaptureSession() 来创建预览 CaptureSession。在 createImageSession() 方法中，我们创建了一个与 ImageReader 相关联的 Surface，并将其添加到 CaptureRequest.Builder 中。然后，我们调用 mCameraDevice.createCaptureSession() 来创建捕获图像的 CaptureSession。在 updatePreview() 方法中，我们首先获取 SurfaceTexture，然后创建一个 Surface 并将其添加到 CaptureRequest.Builder 中。然后，我们调用 mPreviewSession.setRepeatingRequest() 来更新预览。

Android多个camera默认camera

在 Android 中，默认情况下，系统会将背面的摄像头（通常是主摄像头）设置为默认的摄像头。这是因为背面摄像头通常具有较高的像素和更好的图像质量，适合用于大多数摄像和拍照应用。

要访问默认的摄像头，您可以使用 Camera.open() 方法，而不指定具体的摄像头ID。这将打开默认的摄像头并返回一个 Camera 对象，您可以使用它来进行摄像和拍照操作。

以下是一个简单的示例代码，演示如何打开默认的摄像头：

Camera camera = Camera.open();

请注意，Camera 类是在 Android API level 21 中被弃用的。从 Android 5.0（API level 21）开始，Google 推荐使用 Camera2 API 来访问摄像头。使用 Camera2 API，您可以通过设置适当的参数来选择要使用的摄像头。

希望这个回答能对您有所帮助！如果您有任何其他问题，请随时提问。