Android Camera2 API和拍照与录像过程

痛定思痛。 2022-05-31 05:29 699阅读 0赞

![这里写图片描述][70]

**简介**：

> Android 5.0开始出现了新的相机Camera 2 API，用来替代以前的camera api。
> 
> Camera2 API不仅提高了android系统的拍照性能，还支持RAW照片输出，还可以设置相机的对焦模式，曝光模式，快门等等。

**Camera2 中主要的API类**

*  **CameraManager类** : 摄像头管理类，用于检测、打开系统摄像头，通过`getCameraCharacteristics(cameraId)`可以获取摄像头特征。
 *  **CameraCharacteristics类**：相机特性类，例如，是否支持自动调焦，是否支持zoom，是否支持闪光灯一系列特征。
 *  **CameraDevice类**： 相机设备,类似早期的camera类。
 *  **CameraCaptureSession类**：用于创建预览、拍照的Session类。通过它的`setRepeatingRequest()`方法控制预览界面 , 通过它的`capture()`方法控制拍照动作或者录像动作。
 *  **CameraRequest类**：一次捕获的请求，可以设置一些列的参数，用于控制预览和拍照参数，例如：对焦模式，曝光模式，zoom参数等等。

接下来，进一步介绍，Camera2 API中的各种常见类和抽象类。

**CameraManager类**

--------------------

CameraCharacteristics cameraCharacteristics =manager.getCameraCharacteristics(cameraId);

通过以上代码可以获取摄像头的特征对象，例如： 前后摄像头，分辨率等。

**CameraCharacteristics类**

--------------------

相机特性类

CameraCharacteristics是一个包含相机参数的对象，可以通过一些key获取对应的values.

**以下几种常用的参数**：

*  LENS\_FACING:获取摄像头方向。LENS\_FACING\_FRONT是前摄像头，LENS\_FACING\_BACK是后摄像头。
 *  SENSOR\_ORIENTATION：获取摄像头拍照的方向。
 *  FLASH\_INFO\_AVAILABLE：获取是否支持闪光灯。
 *  SCALER\_AVAILABLE\_MAX\_DIGITAL\_ZOOM：获取最大的数字调焦值，也就是zoom最大值。
 *  LENS\_INFO\_MINIMUM\_FOCUS\_DISTANCE：获取最小的调焦距离，某些手机上获取到的该values为null或者0.0。前摄像头大部分有固定焦距，无法调节。
 *  INFO\_SUPPORTED\_HARDWARE\_LEVEL：获取摄像头支持某些特性的程度。
    
    以下手机中支持的若干种程度：
    
     *  INFO\_SUPPORTED\_HARDWARE\_LEVEL\_FULL：全方位的硬件支持，允许手动控制全高清的摄像、支持连拍模式以及其他新特性。
     *  INFO\_SUPPORTED\_HARDWARE\_LEVEL\_LIMITED：有限支持，这个需要单独查询。
     *  INFO\_SUPPORTED\_HARDWARE\_LEVEL\_LEGACY：所有设备都会支持，也就是和过时的Camera API支持的特性是一致的。

**CameraDevice类**

--------------------

CameraDevice的`reateCaptureRequest(int templateType)`方法创建CaptureRequest.Builder。

templateType参数有以下几种：

*  TEMPLATE\_PREVIEW ：预览
 *  TEMPLATE\_RECORD：拍摄视频
 *  TEMPLATE\_STILL\_CAPTURE：拍照
 *  TEMPLATE\_VIDEO\_SNAPSHOT：创建视视频录制时截屏的请求
 *  TEMPLATE\_ZERO\_SHUTTER\_LAG：创建一个适用于零快门延迟的请求。在不影响预览帧率的情况下最大化图像质量。
 *  TEMPLATE\_MANUAL：创建一个基本捕获请求，这种请求中所有的自动控制都是禁用的(自动曝光，自动白平衡、自动焦点)。

**CameraDevice.StateCallback抽象类**

--------------------

该抽象类用于CemeraDevice相机设备状态的回调。

/** * 当相机设备的状态发生改变的时候，将会回调。 */
        protected final CameraDevice.StateCallback stateCallback = new CameraDevice.StateCallback() {
            /** * 当相机打开的时候，调用 * @param cameraDevice */
            @Override
            public void onOpened(@NonNull CameraDevice cameraDevice) {
    
                mCameraDevice = cameraDevice;
                startPreView();
            }
    
            @Override
            public void onDisconnected(@NonNull CameraDevice cameraDevice) {
    
                cameraDevice.close();
                mCameraDevice = null;
            }
    
            /** * 发生异常的时候调用 * * 这里释放资源，然后关闭界面 * @param cameraDevice * @param error */
            @Override
            public void onError(@NonNull CameraDevice cameraDevice, int error) {
                cameraDevice.close();
                mCameraDevice = null;
    
            }
            /** *当相机被关闭的时候 */
            @Override
            public void onClosed(@NonNull CameraDevice camera) {
                super.onClosed(camera);
            }
        };

**CameraCaptureSession.StateCallback抽象类**

--------------------

该抽象类用于Session过程中状态的回调。

public static abstract class StateCallback {
    
            //摄像头完成配置，可以处理Capture请求了。
            public abstract void onConfigured(@NonNull CameraCaptureSession session);
    
            //摄像头配置失败
            public abstract void onConfigureFailed(@NonNull CameraCaptureSession session);
    
            //摄像头处于就绪状态，当前没有请求需要处理
            public void onReady(@NonNull CameraCaptureSession session) {}
    
            //摄像头正在处理请求
            public void onActive(@NonNull CameraCaptureSession session) {}
    
            //请求队列中为空，准备着接受下一个请求。
            public void onCaptureQueueEmpty(@NonNull CameraCaptureSession session) {}
    
            //会话被关闭
            public void onClosed(@NonNull CameraCaptureSession session) {}
    
            //Surface准备就绪
            public void onSurfacePrepared(@NonNull CameraCaptureSession session,@NonNull Surface surface) {}
    
    }

接下来，是介绍拍照和录像流程步骤。

--------------------

**使用流程**:

**1. 打开指定的方向的相机**

最先获取CameraManager对象，通过该对象的`getCameraIdList()`获取到一些列的摄像头参数。

通过循环匹配，获取到指定方向的摄像头，例如后摄像头等。

CameraManager manager = (CameraManager)getSystemService(Context.CAMERA_SERVICE);
    
    //获取到可用的相机
    for (String cameraId : manager.getCameraIdList()) {
    
          //获取到每个相机的参数对象，包含前后摄像头，分辨率等
         CameraCharacteristics  cameraCharacteristics = manager.getCameraCharacteristics(cameraId);
         //摄像头的方向
         Integer facing = cameraCharacteristics.get(CameraCharacteristics.LENS_FACING);
    
         if(facing==null){
             continue;
         }
         //匹配方向,指定打开后摄像头
         if(facing!=CameraCharacteristics.LENS_FACING_BACK){
              continue; 
         }
    
         //打开指定的摄像头
        manager.openCamera(mCameraId, stateCallback, workThreadManager.getBackgroundHandler());
    
        return;
    }

当然，实际开发中，还需要获取相机支持的特性(闪光灯，zoom调焦,手动调焦等)，和设置摄像头的参数（例如：预览的Size）。

**2. 创建预览的界面**：

创建 CameraDevice.StateCallback 对象，且开启一个相机。当相机开启后，将出现相机预览界面。

CameraDevice.StateCallback 对象传入CameraManager中`openCamera(mCameraId, stateCallback, workThreadManager.getBackgroundHandler())`的第二个参数，用于监听摄像头的状态。

/** * 相机设备 */
     protected CameraDevice mCameraDevice;
    
    
     /** * 当相机设备的状态发生改变的时候，将会回调。 */
     protected final CameraDevice.StateCallback stateCallback = new CameraDevice.StateCallback() {
            /** * 当相机打开的时候，调用 * @param cameraDevice */
            @Override
            public void onOpened(@NonNull CameraDevice cameraDevice) {
                mCameraDevice = cameraDevice;
                createCameraPreviewSession();
            }
    
           // 省略该状态接口的部分方法
           ...............
    
     };
    
     /** * 预览请求的Builder */
     private CaptureRequest.Builder mPreviewRequestBuilder;
    
    
     /** * 相机开始预览，创建一个CameraCaptureSession对象 */
     private void createCameraPreviewSession() {
    
          // 将CaptureRequest的构建器与Surface对象绑定在一起 
          mPreviewRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
    
          // 为相机预览，创建一个CameraCaptureSession对象
          mCameraDevice.createCaptureSession(Arrays.asList(surface, imageReader.getSurface()), stateCallback, null);        
     }

创建完预览的界面后，接下来需要开始刷新。

**3. 在预览界面过程中，需要间隔刷新界面**

相机预览使用TextureView来实现。创建一个CameraCaptureSession ，通过一个用于预览界面的CaptureRequest，间隔复用给CameraCaptureSession。

private CameraCaptureSession mCaptureSession;
    
     CameraCaptureSession.StateCallback stateCallback=new CameraCaptureSession.StateCallback() {
                    @Override
                    public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
    
                    //当cameraCaptureSession已经准备完成，开始显示预览界面
                        mCaptureSession = cameraCaptureSession;
                        setCameraCaptureSession();
                    }
    
                    //省略该接口的部分方法
                    .......
     }
    
     /** * 设置CameraCaptureSession的特征: * <p> * 自动对焦，闪光灯 */
     private void setCameraCaptureSession() {
    
         //设置预览界面的特征，通过mPreviewRequestBuilder.set()方法,例如，闪光灯，zoom调焦等
         ..........
    
          //为CameraCaptureSession设置间隔的CaptureRequest，用间隔刷新预览界面。
         mCaptureSession.setRepeatingRequest(mPreviewRequestBuilder.build(), mCaptureCallback, workThreadManager.getBackgroundHandler()); 
     }

只要未开始拍照动作或者录像动作，该复用的CaptureRequest会重复的刷新预览界面。

接下来，等待用户点击拍照按钮或者录像按钮，进行拍照动作，或者录像动作。

**4. 拍照动作**：

首先锁住焦点，通过在相机预览界面个性CaptureRequest。然后，以类似方式，需要运行一个预捕获序列。接下来，可已经准备好捕捉图片。创建一个新的CaptureRequest，且拍照。

/** * 拍照一个静态的图片 * ,当在CaptureCallback监听器响应的时候调用该方法。 * <p> * 当数字调焦缩放的时候，在写入图片数中也要设置。 */
    private void captureStillPicture() {
        try {
    
                // 创建一个拍照的CaptureRequest.Builder
                final CaptureRequest.Builder captureBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
    
                 captureBuilder.addTarget(imageReader.getSurface());
    
                //设置一系列的拍照参数，这里省略
                ...........
    
                //先停止以前的预览状态
                mCaptureSession.stopRepeating();
                mCaptureSession.abortCaptures();
    
                //执行拍照动作
                mCaptureSession.capture(captureBuilder.build(), captureCallback, null);
        } catch (CameraAccessException e) {
                e.printStackTrace();
        }
    }

拍照界面产生的数据只是在手机内存中，图片是一个磁盘文件，还需要一个将拍照产生数据写入文件中的操作类ImageReader。

先是创建ImageReader对象，和设置监听器等一些列参数。

/** * 处理静态图片的输出 */
        private ImageReader imageReader;
    
          //对于静态图片，使用可用的最大值来拍摄。
          Size largest = Collections.max(Arrays.asList(map.getOutputSizes(ImageFormat.JPEG)), new CompareSizeByArea());
          //设置ImageReader,将大小，图片格式
          imageReader = ImageReader.newInstance(largest.getWidth(), largest.getHeight(), ImageFormat.JPEG, /*maxImages*/2);
          imageReader.setOnImageAvailableListener(onImageAvailableListener, workThreadManager.getBackgroundHandler());

接下来，将ImageReader的surface配置到captureBuilder对象中`captureBuilder.addTarget(imageReader.getSurface());`

最后，当拍照完成后，会在该监听状态中回调：

/** * ImageReader的回调监听器 * <p> * onImageAvailable被调用的时候，已经拍照完，准备保存的操作 * 通常写入磁盘文件中。 */
        protected final ImageReader.OnImageAvailableListener onImageAvailableListener = (ImageReader reader)
                -> writePictureData(reader.acquireNextImage());
    
    
        public void writePictureData(Image image) {
            if (camera2ResultCallBack != null) {
                camera2ResultCallBack.callBack(ObservableBuilder.createWriteCaptureImage(appContext, image));
            }
        }        
    
        /** * 将JPEG图片的数据，写入磁盘中 * * @param context * @param mImage * @return */
        public static Observable<String> createWriteCaptureImage(final Context context, final Image mImage) {
            Observable<String> observable = Observable.create(subscriber -> {
                File file = FileUtils.createPictureDiskFile(context, FileUtils.createBitmapFileName());
                ByteBuffer buffer = mImage.getPlanes()[0].getBuffer();
                byte[] bytes = new byte[buffer.remaining()];
                buffer.get(bytes);
                FileOutputStream output = null;
                try {
                    output = new FileOutputStream(file);
                    output.write(bytes);
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    mImage.close();
                    if (null != output) {
                        try {
                            output.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
                subscriber.onNext(file.getAbsolutePath());
            });
            return observable;
        }

这里采用RxJava+RxAndroid异步通讯，避免太多回调接口。

**5. 录像动作**

录像是长时间的动作，录像过程中需要重复性的刷新录制界面。其余的步骤和拍照动作基本类似。

/** * 开始视频录制。 */
    private void startRecordingVideo() {
        try {
                //创建录制的session会话中的请求
                mPreviewBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD);
    
                //设置录制参数，这里省略
                .........
    
                // Start a capture session
                // Once the session starts, we can update the UI and start recording
                mCameraDevice.createCaptureSession(surfaces, new CameraCaptureSession.StateCallback() {
                    @Override
                    public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
    
                         mPreviewSession = cameraCaptureSession;
                         Log.i(TAG, " startRecordingVideo 正式开始录制 ");
                         updatePreview();
                    }
                    //该接口的方法，部分省略
                    .............
    
                }, workThreadManager.getBackgroundHandler());
            } catch (CameraAccessException | IOException e) {
                e.printStackTrace();
            }
    }
    
    //录制过程中，不断刷新录制界面
    private void updatePreview() {
    
            try {
                mPreviewSession.setRepeatingRequest(mPreviewBuilder.build(), null, workThreadManager.getBackgroundHandler());
            } catch (CameraAccessException e) {
                e.printStackTrace();
            }
    }

和拍照类似，将视频数据写入磁盘文件中，也是需要一个操作类 MediaRecorder来实现的。

先是创建该操作类对象，设置一些列参数：

/** * MediaRecorder */
    private MediaRecorder mMediaRecorder;
    
     /** * 设置媒体录制器的配置参数 * <p> * 音频，视频格式，文件路径，频率，编码格式等等 * * @throws IOException */
        private void setUpMediaRecorder() throws IOException {
    
            mMediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
            mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.SURFACE);
            mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
            mNextVideoAbsolutePath = FileUtils.createVideoDiskFile(appContext, FileUtils.createVideoFileName()).getAbsolutePath();
            mMediaRecorder.setOutputFile(mNextVideoAbsolutePath);
            mMediaRecorder.setVideoEncodingBitRate(10000000);
            //每秒30帧
            mMediaRecorder.setVideoFrameRate(30);
            mMediaRecorder.setVideoSize(mVideoSize.getWidth(), mVideoSize.getHeight());
            mMediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264);
            mMediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC);
            int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
            switch (mSensorOrientation) {
                case SENSOR_ORIENTATION_DEFAULT_DEGREES:
                    mMediaRecorder.setOrientationHint(DEFAULT_ORIENTATIONS.get(rotation));
                    break;
                case SENSOR_ORIENTATION_INVERSE_DEGREES:
                    mMediaRecorder.setOrientationHint(ORIENTATIONS.get(rotation));
                    break;
                default:
                    break;
            }
            mMediaRecorder.prepare();
        }

间隔性的随着视频录制而输出数据到文件中。

// 为 MediaRecorder设置Surface
    Surface recorderSurface = mMediaRecorder.getSurface();
    surfaces.add(recorderSurface);
    mPreviewBuilder.addTarget(recorderSurface);

最后，当录制视频结束后，停止输出：

// 停止录制
     mMediaRecorder.stop();
     mMediaRecorder.reset();

**6. 恢复到预览界面**：

完成一些列拍照或录像动作后,重新恢复到预览界面。

/** * 完成一些列拍照或录像动作后，释放焦点。 */
    private void unlockFocus() {
       try {
             //向session重新发送，预览的间隔性请求，出现预览界面。
             mCaptureSession.setRepeatingRequest(mPreviewRequest, mCaptureCallback, workThreadManager.getBackgroundHandler());
        } catch (CameraAccessException e) {
                e.printStackTrace();
        }
    }

当然，还有关闭相机操作，和与Activity生命周期绑定的操作，这里不再做介绍了。

以上代码来源于，[Camera2App项目][Camera2App]。

下一篇，开始介绍，如何开发一个真正的相机程序。

--------------------

**资源参考**：

*  **官方关于camera2 博客介绍**:  
    [https://medium.com/google-developers/detecting-camera-features-with-camera2-61675bb7d1bf][https_medium.com_google-developers_detecting-camera-features-with-camera2-61675bb7d1bf]
 *  **极客学院关于Camera2的介绍**：  
    [http://wiki.jikexueyuan.com/project/android-actual-combat-skills/android-hardware-camera2-operating-guide.html][http_wiki.jikexueyuan.com_project_android-actual-combat-skills_android-hardware-camera2-operating-guide.html]
 *  [**Google的CameraView库**][Google_CameraView]
 *  [android-Camera2Basic][]
 *  [android-Camera2Raw][]
 *  [官方的android-Camera2Video][android-Camera2Video]

[70]: /images/20220531/74bf54666202493f8111c173d973467c.png
[Camera2App]: https://github.com/13767004362/Camera2App
[https_medium.com_google-developers_detecting-camera-features-with-camera2-61675bb7d1bf]: https://medium.com/google-developers/detecting-camera-features-with-camera2-61675bb7d1bf
[http_wiki.jikexueyuan.com_project_android-actual-combat-skills_android-hardware-camera2-operating-guide.html]: http://wiki.jikexueyuan.com/project/android-actual-combat-skills/android-hardware-camera2-operating-guide.html
[Google_CameraView]: https://github.com/google/cameraview
[android-Camera2Basic]: https://github.com/googlesamples/android-Camera2Basic/#readme
[android-Camera2Raw]: https://github.com/googlesamples/android-Camera2Raw/#readme
[android-Camera2Video]: https://github.com/googlesamples/android-Camera2Video/#readme