Camera2使用surface支持

Camera2 API 是 Android 系统提供的相机 API，它支持将相机预览数据输出到 Surface 上。在使用 Camera2 进行相机预览时，需要创建一个 Surface 对象，并将其与相机设备关联，然后在预览过程中将相机输出数据渲染到这个 Surface 上。

在 Camera2 API 中，可以使用 SurfaceView、TextureView、SurfaceTexture 等不同的 Surface 类型作为相机预览的输出目标。其中，TextureView 是最常用的一种，因为它支持更多的特性，如旋转、缩放、裁剪等。使用 TextureView 时，需要在布局文件中定义一个 TextureView 控件，并在代码中获取它的 SurfaceTexture 对象，然后将其传递给 CameraDevice.createCaptureSession() 方法创建会话。在会话过程中，可以通过设置 CaptureRequest.Builder 的目标 Surface 为 TextureView 的 Surface，将相机预览数据输出到 TextureView 上。

相关问题

GLSurfaceView 支持与Camera2Api使用，请给出示例代码

以下是一个简单的示例代码，演示如何在GLSurfaceView中使用Camera2API预览摄像头数据：

public class CameraPreviewGLSurfaceView extends GLSurfaceView {
    private CameraDevice cameraDevice;
    private CameraCaptureSession cameraCaptureSession;
    private SurfaceTexture surfaceTexture;
    private Surface surface;
    private int textureId;

    public CameraPreviewGLSurfaceView(Context context, AttributeSet attrs) {
        super(context, attrs);
        setEGLContextClientVersion(2);
        setRenderer(new CameraPreviewRenderer());
        setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
    }

    private class CameraPreviewRenderer implements GLSurfaceView.Renderer, CameraDevice.StateCallback {
        @Override
        public void onSurfaceCreated(GL10 gl, EGLConfig config) {
            setupCamera();
            openCamera();
        }

        @Override
        public void onSurfaceChanged(GL10 gl, int width, int height) {
            configureTransform(width, height);
        }

        @Override
        public void onDrawFrame(GL10 gl) {
            if (surfaceTexture == null) {
                return;
            }
            surfaceTexture.updateTexImage();
            GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
            GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT);
            GLES20.glUseProgram(/* your shader program */);
            /* bind your vertex and texture coordinate buffers */
            GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
            GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, textureId);
            /* draw your geometry */
            GLES20.glDrawArrays(/* your draw mode */, 0, /* your vertex count */);
        }

        @Override
        public void onSurfaceDestroyed(GL10 gl) {
            closeCamera();
        }

        @Override
        public void onOpened(CameraDevice cameraDevice) {
            this.cameraDevice = cameraDevice;
            createCameraPreviewSession();
        }

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

        @Override
        public void onError(CameraDevice cameraDevice, int error) {
            cameraDevice.close();
            CameraPreviewGLSurfaceView.this.cameraDevice = null;
        }

        private void setupCamera() {
            CameraManager cameraManager = (CameraManager) getContext().getSystemService(Context.CAMERA_SERVICE);
            try {
                String cameraId = cameraManager.getCameraIdList()[0];
                CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId);
                StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
                Size[] outputSizes = map.getOutputSizes(SurfaceTexture.class);
                Size largest = Collections.max(Arrays.asList(outputSizes), new CompareSizesByArea());
                surfaceTexture = new SurfaceTexture(textureId);
                surfaceTexture.setDefaultBufferSize(largest.getWidth(), largest.getHeight());
                surface = new Surface(surfaceTexture);
            } catch (CameraAccessException e) {
                e.printStackTrace();
            }
        }

        private void openCamera() {
            CameraManager cameraManager = (CameraManager) getContext().getSystemService(Context.CAMERA_SERVICE);
            try {
                String cameraId = cameraManager.getCameraIdList()[0];
                cameraManager.openCamera(cameraId, this, null);
            } catch (CameraAccessException e) {
                e.printStackTrace();
            }
        }

        private void createCameraPreviewSession() {
            try {
                cameraDevice.createCaptureSession(Arrays.asList(surface), new CameraCaptureSession.StateCallback() {
                    @Override
                    public void onConfigured(CameraCaptureSession session) {
                        cameraCaptureSession = session;
                        try {
                            CaptureRequest.Builder builder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
                            builder.addTarget(surface);
                            CaptureRequest captureRequest = builder.build();
                            cameraCaptureSession.setRepeatingRequest(captureRequest, null, null);
                        } catch (CameraAccessException e) {
                            e.printStackTrace();
                        }
                    }

                    @Override
                    public void onConfigureFailed(CameraCaptureSession session) {
                        cameraCaptureSession = null;
                    }
                }, null);
            } catch (CameraAccessException e) {
                e.printStackTrace();
            }
        }

        private void closeCamera() {
            if (cameraCaptureSession != null) {
                cameraCaptureSession.close();
                cameraCaptureSession = null;
            }
            if (cameraDevice != null) {
                cameraDevice.close();
                cameraDevice = null;
            }
            if (surface != null) {
                surface.release();
                surface = null;
            }
            if (surfaceTexture != null) {
                surfaceTexture.release();
                surfaceTexture = null;
            }
        }

        private void configureTransform(int viewWidth, int viewHeight) {
            if (surfaceTexture == null) {
                return;
            }
            Matrix matrix = new Matrix();
            RectF viewRect = new RectF(0, 0, viewWidth, viewHeight);
            RectF bufferRect = new RectF(0, 0, surfaceTexture.getSurfaceTexture().getBufferSize().getWidth(), surfaceTexture.getSurfaceTexture().getBufferSize().getHeight());
            float centerX = viewRect.centerX();
            float centerY = viewRect.centerY();
            bufferRect.offset(centerX - bufferRect.centerX(), centerY - bufferRect.centerY());
            matrix.setRectToRect(viewRect, bufferRect, Matrix.ScaleToFit.FILL);
            matrix.postRotate(/* your rotation angle */, centerX, centerY);
            surfaceTexture.setTransform(matrix);
        }
    }
}

这个示例代码演示了如何使用Camera2API在GLSurfaceView中预览摄像头数据。其中，setupCamera()方法用于设置摄像头的参数，openCamera()方法用于打开摄像头，createCameraPreviewSession()方法用于创建摄像头预览会话，configureTransform()方法用于配置变换矩阵以适应屏幕旋转。注意，这个示例代码没有包括如何处理摄像头权限请求等必要的步骤，需要在实际应用中加以处理。

使用Camera2编写一个支持预览、录音、录像的完整Demo。

好的，下面我给你提供一些关于使用Camera2 API编写支持预览、录音、录像的Demo的指导：

1. 创建CameraDevice和CaptureSession

首先，你需要创建一个CameraDevice对象，这个对象用于管理你的相机硬件设备。你可以使用CameraManager类来获取相机设备的列表，并打开相应的相机设备。

接下来，你需要创建一个CaptureSession对象，这个对象用于管理相机的预览和录像操作。你可以使用CameraDevice的createCaptureSession()方法来创建一个CaptureSession对象。在创建CaptureSession的过程中，你需要指定预览和录像的Surface。

2. 配置预览

在创建CaptureSession之后，你需要配置预览。首先，你需要创建一个SurfaceView或TextureView，用于显示相机预览。然后，你需要将SurfaceView或TextureView的Surface与CaptureSession绑定。

接下来，你需要创建一个CaptureRequest对象，用于控制预览的参数。你可以使用CaptureRequest.Builder类来创建CaptureRequest对象，并设置需要的参数，例如预览大小、帧率、曝光时间等。

最后，你需要使用CaptureSession的setRepeatingRequest()方法，将CaptureRequest发送给相机设备，从而实现预览功能。

3. 配置录像

在配置完预览之后，你需要配置录像。首先，你需要创建一个MediaRecorder对象，用于录制音频和视频。然后，你需要将MediaRecorder的输出Surface与CaptureSession绑定。

接下来，你需要以类似于预览的方式，创建一个CaptureRequest对象，用于控制录像的参数。你可以设置需要的参数，例如视频大小、帧率、视频编码格式、音频编码格式等。

最后，你需要使用MediaRecorder的start()方法开始录制，并使用CaptureSession的setRepeatingRequest()方法，将CaptureRequest发送给相机设备，从而实现录像功能。

这些就是使用Camera2 API编写支持预览、录音、录像的Demo的基本步骤。当然，具体的实现细节还需要根据你的具体需求进行调整。希望这些信息能对你有所帮助！