private void openCamera(String cameraId) { try { //创建 CameraManager 对象 CameraManager cameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE); //获取可用摄像头列表 String[] cameraIds = cameraManager.getCameraIdList(); if (ActivityCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) { // TODO: Consider calling // ActivityCompat#requestPermissions // here to request the missing permissions, and then overriding // public void onRequestPermissionsResult(int requestCode, String[] permissions, // int[] grantResults) // to handle the case where the user grants the permission. See the documentation // for ActivityCompat#requestPermissions for more details. return; } cameraManager.openCamera(cameraId, new CameraDevice.StateCallback() { @Override public void onOpened(@NonNull CameraDevice camera) { //相机已经打开，可以进行拍照等操作 } @Override public void onDisconnected(@NonNull CameraDevice camera) { //相机断开连接，释放资源 cameraDevice.close(); } @Override public void onError(@NonNull CameraDevice camera, int error) { //相机发生错误，释放资源 cameraDevice.close(); } }, null); }catch (CameraAccessException e) { e.printStackTrace(); } }

这段代码是用于打开相机的方法，具体实现流程如下：

1. 创建 CameraManager 对象，它是用于访问摄像头的管理器。
2. 获取当前设备上可用的摄像头列表。
3. 检查是否已经授权使用摄像头权限，如果没有则返回。
4. 通过 cameraManager.openCamera() 方法打开指定 ID 的摄像头。
5. 在 CameraDevice.StateCallback 回调中处理相机的状态变化，包括相机已经打开、断开连接、发生错误等。

需要注意的是，该方法需要在 Android 5.0 及以上版本才能正常使用，并且需要在 AndroidManifest.xml 文件中声明相应的权限。

相关问题

android camera2点击监听,使用Android camera2 API打开/关闭闪光灯不起作用

要使用 Android camera2 API 打开/关闭闪光灯，需要先进行如下步骤：

1. 获取 CameraManager 实例
2. 获取可用的相机列表
3. 选择需要使用的相机
4. 创建一个 CameraDevice.StateCallback 实例
5. 打开相机
6. 获取 CameraCharacteristics 实例
7. 获取闪光灯是否可用的信息
8. 创建一个 CaptureRequest.Builder 实例
9. 设置闪光灯状态
10. 构建 CaptureRequest 实例
11. 创建一个 CameraCaptureSession.StateCallback 实例
12. 开始预览

下面是一个简单的示例代码，可以在点击按钮时打开/关闭闪光灯：

private CameraManager mCameraManager;
private String mCameraId;
private CameraDevice mCameraDevice;
private CameraCaptureSession mCaptureSession;
private CaptureRequest.Builder mPreviewRequestBuilder;
private SurfaceTexture mSurfaceTexture;
private Surface mPreviewSurface;

private boolean mIsFlashOn = false;

// 点击按钮时调用
public void toggleFlash() {
    if (mCameraDevice == null) {
        return;
    }

    // 切换闪光灯状态
    mIsFlashOn = !mIsFlashOn;

    try {
        // 创建一个新的 CaptureRequest.Builder 实例
        mPreviewRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);

        // 设置闪光灯状态
        mPreviewRequestBuilder.set(CaptureRequest.FLASH_MODE, mIsFlashOn ? CaptureRequest.FLASH_MODE_TORCH : CaptureRequest.FLASH_MODE_OFF);

        // 构建 CaptureRequest 实例
        CaptureRequest previewRequest = mPreviewRequestBuilder.build();

        // 发送请求
        mCaptureSession.setRepeatingRequest(previewRequest, null, null);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

// 在 onCreate() 方法中调用
private void setupCamera() {
    mCameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);

    try {
        // 获取可用的相机列表
        String[] cameraIds = mCameraManager.getCameraIdList();

        // 选择需要使用的相机
        for (String cameraId : cameraIds) {
            CameraCharacteristics characteristics = mCameraManager.getCameraCharacteristics(cameraId);
            Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING);
            if (facing != null && facing == CameraCharacteristics.LENS_FACING_BACK) {
                mCameraId = cameraId;
                break;
            }
        }

        // 创建一个 CameraDevice.StateCallback 实例
        CameraDevice.StateCallback stateCallback = new CameraDevice.StateCallback() {
            @Override
            public void onOpened(CameraDevice camera) {
                mCameraDevice = camera;
                startPreview();
            }

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

            @Override
            public void onError(CameraDevice camera, int error) {
                camera.close();
                mCameraDevice = null;
            }
        };

        // 打开相机
        mCameraManager.openCamera(mCameraId, stateCallback, null);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

// 开始预览
private void startPreview() {
    try {
        // 获取 CameraCharacteristics 实例
        CameraCharacteristics characteristics = mCameraManager.getCameraCharacteristics(mCameraId);

        // 获取闪光灯是否可用的信息
        Boolean flashAvailable = characteristics.get(CameraCharacteristics.FLASH_INFO_AVAILABLE);

        // 创建一个 CaptureRequest.Builder 实例
        mPreviewRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);

        // 设置闪光灯状态
        mPreviewRequestBuilder.set(CaptureRequest.FLASH_MODE, CaptureRequest.FLASH_MODE_OFF);

        // 获取 SurfaceTexture 实例
        mSurfaceTexture = new SurfaceTexture(0);

        // 获取 Surface 实例
        mPreviewSurface = new Surface(mSurfaceTexture);

        // 添加 Surface 到 CaptureRequest.Builder 实例中
        mPreviewRequestBuilder.addTarget(mPreviewSurface);

        // 创建一个 CameraCaptureSession.StateCallback 实例
        CameraCaptureSession.StateCallback callback = new CameraCaptureSession.StateCallback() {
            @Override
            public void onConfigured(CameraCaptureSession session) {
                mCaptureSession = session;

                try {
                    // 构建 CaptureRequest 实例
                    CaptureRequest previewRequest = mPreviewRequestBuilder.build();

                    // 发送请求
                    mCaptureSession.setRepeatingRequest(previewRequest, null, null);
                } catch (CameraAccessException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void onConfigureFailed(CameraCaptureSession session) {
                session.close();
                mCaptureSession = null;
            }
        };

        // 创建一个 CameraCaptureSession 实例
        mCameraDevice.createCaptureSession(Collections.singletonList(mPreviewSurface), callback, null);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

值得注意的是，闪光灯是否可用的信息可以通过 CameraCharacteristics.FLASH_INFO_AVAILABLE 获取。如果该值为 false，则说明该相机不支持闪光灯。

CameraManager 拍照代码

以下是使用 CameraManager 进行拍照的代码示例：

首先，在 AndroidManifest.xml 文件中添加相机权限：

<uses-permission android:name="android.permission.CAMERA" />

然后，在需要拍照的 Activity 中，定义 CameraManager 对象和相机预览视图：

private CameraManager cameraManager;
private CameraPreview cameraPreview;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    // 获取 CameraManager 实例
    cameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);

    // 初始化相机预览视图
    cameraPreview = findViewById(R.id.camera_preview);
    cameraPreview.setCameraManager(cameraManager);
}

在布局文件中添加相机预览视图：

<com.example.camera.CameraPreview
    android:id="@+id/camera_preview"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

接下来，实现拍照功能。在拍照之前，需要先打开相机并启动预览：

private void startCamera() {
    try {
        // 获取相机列表中的第一个相机
        String cameraId = cameraManager.getCameraIdList()[0];

        // 打开相机并设置预览视图
        cameraManager.openCamera(cameraId, new CameraDevice.StateCallback() {
            @Override
            public void onOpened(@NonNull CameraDevice camera) {
                // 启动相机预览
                cameraPreview.setCamera(camera);
            }

            @Override
            public void onDisconnected(@NonNull CameraDevice camera) {
                camera.close();
            }

            @Override
            public void onError(@NonNull CameraDevice camera, int error) {
                camera.close();
            }
        }, null);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

在拍照时，可以通过调用相机的 takePicture() 方法实现：

private void takePicture() {
    // 获取当前相机
    CameraDevice camera = cameraPreview.getCamera();

    // 创建拍照请求
    CaptureRequest.Builder captureRequestBuilder;
    try {
        captureRequestBuilder = camera.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
        captureRequestBuilder.addTarget(cameraPreview.getOutputSurface());
    } catch (CameraAccessException e) {
        e.printStackTrace();
        return;
    }

    // 设置拍照参数
    captureRequestBuilder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);

    // 发送拍照请求
    try {
        camera.createCaptureSession(Collections.singletonList(cameraPreview.getOutputSurface()), new CameraCaptureSession.StateCallback() {
            @Override
            public void onConfigured(@NonNull CameraCaptureSession session) {
                try {
                    session.capture(captureRequestBuilder.build(), new CameraCaptureSession.CaptureCallback() {
                        @Override
                        public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
                            // 拍照完成后的处理
                        }
                    }, null);
                } catch (CameraAccessException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void onConfigureFailed(@NonNull CameraCaptureSession session) {
                // 配置会话失败的处理
            }
        }, null);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

完整的 CameraPreview 类和布局文件示例：

public class CameraPreview extends SurfaceView implements SurfaceHolder.Callback {
    private SurfaceHolder surfaceHolder;
    private CameraDevice cameraDevice;
    private CameraManager cameraManager;
    private ImageReader imageReader;
    private Size previewSize;

    public CameraPreview(Context context, AttributeSet attrs) {
        super(context, attrs);

        // 初始化 SurfaceHolder
        surfaceHolder = getHolder();
        surfaceHolder.addCallback(this);
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        // Surface 创建时打开相机
        startCamera();
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        // Surface 改变时重新启动预览
        stopPreview();
        startPreview();
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        // Surface 销毁时关闭相机
        stopCamera();
    }

    public void setCameraManager(CameraManager cameraManager) {
        this.cameraManager = cameraManager;
    }

    public void setCamera(CameraDevice cameraDevice) {
        this.cameraDevice = cameraDevice;
    }

    public CameraDevice getCamera() {
        return cameraDevice;
    }

    public Surface getOutputSurface() {
        return imageReader.getSurface();
    }

    private void startCamera() {
        try {
            // 获取相机列表中的第一个相机
            String cameraId = cameraManager.getCameraIdList()[0];

            // 打开相机并设置预览视图
            cameraManager.openCamera(cameraId, new CameraDevice.StateCallback() {
                @Override
                public void onOpened(@NonNull CameraDevice camera) {
                    // 启动相机预览
                    cameraDevice = camera;
                    startPreview();
                }

                @Override
                public void onDisconnected(@NonNull CameraDevice camera) {
                    camera.close();
                }

                @Override
                public void onError(@NonNull CameraDevice camera, int error) {
                    camera.close();
                }
            }, null);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    private void stopCamera() {
        // 关闭相机
        if (cameraDevice != null) {
            cameraDevice.close();
            cameraDevice = null;
        }
    }

    private void startPreview() {
        try {
            // 获取相机的预览尺寸
            previewSize = getPreviewSize();

            // 创建 ImageReader 对象用于拍照
            imageReader = ImageReader.newInstance(previewSize.getWidth(), previewSize.getHeight(), ImageFormat.JPEG, 1);
            imageReader.setOnImageAvailableListener(new ImageReader.OnImageAvailableListener() {
                @Override
                public void onImageAvailable(ImageReader reader) {
                    // 获取拍照的图片
                    Image image = reader.acquireLatestImage();
                    ByteBuffer buffer = image.getPlanes()[0].getBuffer();
                    byte[] data = new byte[buffer.remaining()];
                    buffer.get(data);

                    // 保存图片到文件系统
                    File file = new File(getContext().getExternalFilesDir(null), "photo.jpg");
                    FileOutputStream outputStream;
                    try {
                        outputStream = new FileOutputStream(file);
                        outputStream.write(data);
                        outputStream.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }

                    // 关闭 Image 对象
                    image.close();
                }
            }, null);

            // 创建预览请求
            CaptureRequest.Builder previewRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
            previewRequestBuilder.addTarget(getHolder().getSurface());

            // 创建拍照请求
            CaptureRequest.Builder captureRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
            captureRequestBuilder.addTarget(imageReader.getSurface());

            // 设置自动对焦和自动曝光
            previewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
            previewRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);

            // 设置预览请求为连续自动对焦和自动曝光模式
            cameraDevice.createCaptureSession(Arrays.asList(getHolder().getSurface(), imageReader.getSurface()), new CameraCaptureSession.StateCallback() {
                @Override
                public void onConfigured(@NonNull CameraCaptureSession session) {
                    try {
                        // 发送预览请求
                        session.setRepeatingRequest(previewRequestBuilder.build(), null, null);
                    } catch (CameraAccessException e) {
                        e.printStackTrace();
                    }
                }

                @Override
                public void onConfigureFailed(@NonNull CameraCaptureSession session) {
                    // 配置会话失败的处理
                }
            }, null);
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    private void stopPreview() {
        // 停止预览
        if (cameraDevice != null) {
            cameraDevice.close();
            cameraDevice = null;
        }
    }

    private Size getPreviewSize() throws CameraAccessException {
        // 获取相机支持的所有输出尺寸
        StreamConfigurationMap map = cameraManager.getCameraCharacteristics(cameraDevice.getId()).get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
        Size[] sizes = map.getOutputSizes(SurfaceHolder.class);

        // 选择与屏幕尺寸最接近的预览尺寸
        DisplayMetrics displayMetrics = getResources().getDisplayMetrics();
        int screenWidth = displayMetrics.widthPixels;
        int screenHeight = displayMetrics.heightPixels;
        int minDiff = Integer.MAX_VALUE;
        Size bestSize = null;
        for (Size size : sizes) {
            int diff = Math.abs(size.getWidth() - screenWidth) + Math.abs(size.getHeight() - screenHeight);
            if (diff < minDiff) {
                minDiff = diff;
                bestSize = size;
            }
        }

        return bestSize;
    }
}

<com.example.camera.CameraPreview
    android:id="@+id/camera_preview"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />