logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

Android Camera1 2 X API

 创始元灵6666 2022-06-10 发布于河北

基础知识

Android Framework提供Camera API来实现拍照与录制视频的功能，目前Android有三类API，

  • Camera
    此类是用于控制设备相机的旧版 API，现已弃用，在Android5.0以下使用
  • Camera2
    此软件包是用于控制设备相机的主要 API，Android5.0以上使用
  • CameraX
    基于Camera 2 API封装，简化了开发流程，并增加生命周期控制

相关开发类

  • android.hardware.camera2
    控制相机的核心API，使用它可以实现拍照和录制视频的功能。
  • Camera
    此类是用于控制设备相机的旧版 API，现已弃用。
  • SurfaceView
    此类用于向用户呈现实时相机预览。
  • TextureView
    也是用于实时相机预览，Android4.0之后引入
  • MediaRecorder
    用于录制视频
  • Intent
    MediaStore.ACTION_IMAGE_CAPTURE 或 MediaStore.ACTION_VIDEO_CAPTURE 的 Intent 操作类型可用于捕获图像或视频，而无需直接使用 Camera 对象。

术语

  1. ISO(感光度)
    CMOS（或胶卷）对光线的敏感程度，用ISO100的胶卷，相机2秒可以正确曝光的话，同样光线条件下用ISO200的胶卷只需要1秒即可，用ISO400则只要0.5秒。
    常见的标准：ISO100，ISO200，ISO400
  2. 曝光时间
    曝光时间是为了将光投射到相机感光片上，相机快门所要打开至关闭的时间
  3. 光圈
    用来控制光线透过镜头，进入相机内感光面光量的装置
  4. 焦距
    指的是平行的光线穿过镜片后，所汇集的焦点至镜片间之距离。
    数值越小，代表可以拍摄的角度越广，数值越大，代表可以拍摄的角度越小
  5. 景深
    拍摄时，当镜头聚集于某个被摄体时，这个被摄体就能在相机上结成清晰影像。使被摄体产生较为清晰影像的纵深的范围叫景深
  6. 测光
    测光模式：中央平均测光(average metering)、中央局部测光、点测光(spot metering)、多点测光、评价测光
  7. 自动曝光(Auto Exposure)
    相机根据光线条件自动来调整曝光时间等来确定曝光量
  8. 对焦
    对焦模式：自动对焦 AE(Auto Focus)、手动对焦 MF(Manual Focus)
    自动对焦分为对比度对焦(contrast)、相位对焦(PDAF: Phase Detection Auto Focus)和混合对焦(hybrid)
  9. 闪光灯(Flashlight)
    通过闪光灯打闪照亮物体来达到拍出清晰图片的目的
  10. ScreenFlash
    通过屏幕打闪，照亮周围物体，拍出高清图片
  11. 高动态范围图像(HDR)
    HDR全称是High-Dynamic Range，即高动态范围图像技术。在拍照过程中开启HDR，可以让原先的暗场景变得更明亮更通透。
  12. 零延时拍照(ZSD)
    为了减少拍照延时,让拍照&回显瞬间完成的一种技术
  13. 连拍(ContinuousShot)
    通过节约数据传输时间来捕捉摄影时机
  14. 预览大小(PreviewSize)
    相机预览图片的大小
  15. 拍照大小(PictureSize)
    拍照生成图片的大小
  16. 自动白平衡(Auto white balance)
    AWB(Auto white balance)，自动白平衡是相机的默认设置，相机中有一结构复杂的矩形图，它可决定画面中的白平衡基准点，以此来达到白平衡调校
  17. 对比度
    图像最亮和最暗之间的区域之间的比率，比值越大，从黑到白的渐变层次就越多，从而色彩表现越丰富
  18. 饱和度
    指色彩的鲜艳程度
  19. 锐度
    是反映图像平面清晰度和图像边缘锐利程度的一个指标

相机功能

Android 支持多种相机功能，您可使用相机应用控制这些功能，如图片格式、闪光模式、对焦设置等等。
通过Camera.Parameters可以设置大部分的功能，下面介绍几个重要功能：

  • 区域测光和对焦
  • 人脸检测
  • 延时视频

区域测光和对焦

从 Android 4.0（API 级别 14）开始，通过Camera.Parameters来确定对焦或亮度设置的区域，然后进行拍照或者录像

人脸检测

这个和真正的人脸识别是不一样的 ，这里仅仅是检测人脸。
通过照片分析，检测照片中是否包含人脸，使用人脸识别技术来识别人脸并计算照片设置

延时视频

延时视频功能允许用户将间隔几秒钟或几分钟拍摄的图片串联起来，创建视频剪辑。使用MediaRecorder录制时间流逝片段的图像。

其他重要功能API：

功能API

Camera1使用

流程：

  1. 检测设备摄像头，打开相机
  2. 创建预览画面，显示实时预览画面
  3. 设置相机参数，进行拍照监听
  4. 监听中，保存图片资源或者直接操作原始数据
  5. 释放相机资源

权限声明

  1. <uses-feature
  2.         android:name="android.hardware.camera"
  3.         android:required="true" />
  5. <uses-permission android:name="android.permission.CAMERA" />

相机必须声明CAMERA权限，在Android6.0上，你还需要在代码中动态申请权限

  1. ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CAMERA},
  2.                     REQUEST_CAMERA_PERMISSION);

开发流程

下图是一个开发流程的导览：

打开相机

Camera.open()

该方法的系统源码实现

  1. public static Camera open() {
  2.     int numberOfCameras = getNumberOfCameras();
  3.     CameraInfo cameraInfo = new CameraInfo();
  4.     for (int i = 0; i < numberOfCameras; i++) {
  5.         getCameraInfo(i, cameraInfo);
  6.         if (cameraInfo.facing == CameraInfo.CAMERA_FACING_BACK) {
  7.             return new Camera(i);
  8.         }
  9.     }
  10.     return null;
  11. }

这里会检查可用的摄像头，默认使用的CameraInfo.CAMERA_FACING_BACK后置摄像头

创建预览画面

这里使用的是SurfaceView

  1. private SurfaceView mSurfaceView;
  2. private SurfaceHolder mSurfaceHolder;
  3. ...
  4. mSurfaceHolder = mSurfaceView.getHolder();
  5. mSurfaceHolder.addCallback(new SurfaceHolder.Callback() {
  6.     @Override
  7.     public void surfaceCreated(SurfaceHolder holder) {
  8.         ...
  9.         startPreview();
  10.     }
  12.     @Override
  13.     public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
  15.     }
  17.     @Override
  18.     public void surfaceDestroyed(SurfaceHolder holder) {
  19.         releaseCamera();
  20.     }
  21. });
  22. ...
  23. private void startPreview() {
  24.     try {
  25.         //设置实时预览
  26.         mCamera.setPreviewDisplay(mSurfaceHolder);
  27.         //Orientation
  28.         setCameraDisplayOrientation();
  29.         //开始预览
  30.         mCamera.startPreview();
  32.         startFaceDetect();
  33.     } catch (Exception e) {
  34.         e.printStackTrace();
  35.     }
  36. }

设置预览的时候，可以设置setPreviewCallback监听预览数据的回调

void onPreviewFrame(byte[] data, Camera camera);

设置相机参数

设置相机参数后，需要重新启动预览，这边在初始化的时候，已经设置好了。

  1. private void initParameters(final Camera camera) {
  2.     mParameters = camera.getParameters();
  3.     mParameters.setPreviewFormat(ImageFormat.NV21); //default
  5.     if (isSupportFocus(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) {
  6.         mParameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
  7.     } else if (isSupportFocus(Camera.Parameters.FOCUS_MODE_AUTO)) {
  8.         mParameters.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
  9.     }
  11.     //设置预览图片大小
  12.     setPreviewSize();
  13.     //设置图片大小
  14.     setPictureSize();
  16.     camera.setParameters(mParameters);
  17. }

Camera.Parameters可以设置的参数非常多，这里就介绍几个比较常用的

 

Camera.Parameters

1.setFocusMode

设置对焦模式

  • FOCUS_MODE_AUTO：自动对焦
  • FOCUS_MODE_INFINITY：无穷远
  • FOCUS_MODE_MACRO：微距
  • FOCUS_MODE_FIXED：固定焦距
  • FOCUS_MODE_EDOF：景深扩展
  • FOCUS_MODE_CONTINUOUS_PICTURE：持续对焦(针对照片)
  • FOCUS_MODE_CONTINUOUS_VIDEO：(针对视频)

2.setPreviewSize

设置预览图片大小

3.setPreviewFormat

支持的格式：

  • ImageFormat.NV16
  • ImageFormat.NV21
  • ImageFormat.YUY2
  • ImageFormat.YV12
  • ImgaeFormat.RGB_565
  • ImageFormat.JPEG
    如果不设置，默认返回NV21的数据

4.setPictureSize

设置保存图片的大小

5.setPictureFormat

设置保存图片的格式，格式和setPreviewFormat一样

6.setDisplayOrientation

设置相机预览画面旋转的角度，degress取值0，90，180，270

7.setPreviewDisplay

设置实时预览SurfaceHolder

8.setPreviewCallback

监听相机预览数据回调

9.setParameters

设置相机的Parameters
其他一些设置，大家可以查看Android文档进行相应的设置

设置方向

设置相机的预览方向，orientation比较详细的介绍

  1. private void setCameraDisplayOrientation() {
  2.     Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
  3.     Camera.getCameraInfo(mCameraId, cameraInfo);
  4.     int rotation = getWindowManager().getDefaultDisplay().getRotation();  //自然方向
  5.     int degrees = 0;
  6.     switch (rotation) {
  7.         case Surface.ROTATION_0:
  8.             degrees = 0;
  9.             break;
  10.         case Surface.ROTATION_90:
  11.             degrees = 90;
  12.             break;
  13.         case Surface.ROTATION_180:
  14.             degrees = 180;
  15.             break;
  16.         case Surface.ROTATION_270:
  17.             degrees = 270;
  18.             break;
  19.     }
  21.     int result;
  22.     //cameraInfo.orientation 图像传感方向
  23.     if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
  24.         result = (cameraInfo.orientation + degrees) % 360;
  25.         result = (360 - result) % 360;
  26.     } else {
  27.         result = (cameraInfo.orientation - degrees + 360) % 360;
  28.     }
  30.     mOrientation = result;
  31.     //相机预览方向
  32.     mCamera.setDisplayOrientation(result);
  33. }

拍照

  1. private void takePicture() {
  2.     if (null != mCamera) {
  3.         mCamera.takePicture(new Camera.ShutterCallback() {
  4.             @Override
  5.             public void onShutter() {
  7.             }
  8.         }, new Camera.PictureCallback() {
  9.             @Override
  10.             public void onPictureTaken(byte[] data, Camera camera) {
  11.                 //base data
  12.             }
  13.         }, new Camera.PictureCallback() {
  14.             @Override
  15.             public void onPictureTaken(final byte[] data, Camera camera) {
  16.                 mCamera.startPreview();
  17.                 //save data
  18.             }
  19.         });
  20.     }
  21. }

takePicture的源码实现：

  1. public final void takePicture(ShutterCallback shutter, PictureCallback raw,
  2.             PictureCallback jpeg) {
  3.         takePicture(shutter, raw, null, jpeg);
  4.     }
  • shutter(ShutterCallback)：快门按下后的回调
  • raw(PictureCallback)：raw图像数据
  • jpeg(PictureCallback)：jpeg图像生成以后的回调

释放相机资源

在使用完成后，onPause或者onDestory中进行相机资源的释放

  1. private void releaseCamera() {
  2.     if (null != mCamera) {
  3.         mCamera.stopPreview();
  4.         mCamera.stopFaceDetection();
  5.         mCamera.setPreviewCallback(null);
  6.         mCamera.release();
  7.         mCamera = null;
  8.     }
  9. }
  • stopPreview：停止预览
  • release：释放资源

Camera2使用

设计框架

来自官网的模型图，展示了相关的工作流程

重新设计 Android Camera API 的目的在于大幅提高应用对于 Android 设备上的相机子系统的控制能力，同时重新组织 API，提高其效率和可维护性。
在CaptureRequest中设置不同的Surface用于接收不同的图片数据，最后从不同的Surface中获取到图片数据和包含拍照相关信息的CaptureResult。

优点

通过设计框架的改造和优化，Camera2具备了以下优点:

  • 改进了新硬件的性能。Supported Hardware Level的概念，不同厂商对Camera2的支持程度不同，从低到高有LEGACY、LIMITED、FULL 和 LEVEL_3四个级别
  • 以更快的间隔拍摄图像
  • 显示来自多个摄像机的预览
  • 直接应用效果和滤镜

开发流程

框架上的变化，对整个使用流程变化也非常大，首先了解一些主要的开发类

类

CameraManager

相机系统服务，用于管理和连接相机设备

CameraDevice

相机设备类，和Camera1中的Camera同级

CameraCharacteristics

主要用于获取相机信息，内部携带大量的相机信息，包含摄像头的正反(LENS_FACING)、AE模式、AF模式等，和Camera1中的Camera.Parameters类似

CaptureRequest

相机捕获图像的设置请求，包含传感器，镜头，闪光灯等

CaptureRequest.Builder

CaptureRequest的构造器，使用Builder模式，设置更加方便

CameraCaptureSession

请求抓取相机图像帧的会话，会话的建立主要会建立起一个通道。一个CameraDevice一次只能开启一个CameraCaptureSession。
源端是相机，另一端是 Target，Target可以是Preview，也可以是ImageReader。

ImageReader

用于从相机打开的通道中读取需要的格式的原始图像数据，可以设置多个ImageReader。

流程

 Camera2开发流程

获取CameraManager

CameraManager cameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);

获取相机信息

  1. for (String cameraId : cameraManager.getCameraIdList()) {
  2.     CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId);
  4.     Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING);
  5.     if (null != facing && facing == CameraCharacteristics.LENS_FACING_FRONT) {
  6.         continue;
  7.     }
  8.     ....
  9. }

这里默认选择前置摄像头，并获取相关相机信息。

初始化ImageReader

  1. mImageReader = ImageReader.newInstance(largest.getWidth(), largest.getHeight(), ImageFormat.JPEG, 2);
  2. mImageReader.setOnImageAvailableListener(new ImageReader.OnImageAvailableListener() {
  3.     @Override
  4.     public void onImageAvailable(ImageReader reader) {
  5.         Log.d("DEBUG", "##### onImageAvailable: " + mFile.getPath());
  6.         mBackgroundHandler.post(new ImageSaver(reader.acquireNextImage(), mFile));
  7.     }
  8. }, mBackgroundHandler);

ImageReader是获取图像数据的重要途径，通过它可以获取到不同格式的图像数据，例如JPEG、YUV、RAW等。通过ImageReader.newInstance(int width, int height, int format, int maxImages)创建ImageReader对象，有4个参数：

  • width：图像数据的宽度
  • height：图像数据的高度
  • format：图像数据的格式，例如ImageFormat.JPEG，ImageFormat.YUV_420_888等
  • maxImages：最大Image个数，Image对象池的大小，指定了能从ImageReader获取Image对象的最大值，过多获取缓冲区可能导致OOM，所以最好按照最少的需要去设置这个值

ImageReader其他相关的方法和回调：

  • ImageReader.OnImageAvailableListener：有新图像数据的回调
  • acquireLatestImage()：从ImageReader的队列里面，获取最新的Image，删除旧的，如果没有可用的Image，返回null
  • acquireNextImage()：获取下一个最新的可用Image，没有则返回null
  • close()：释放与此ImageReader关联的所有资源
  • getSurface()：获取为当前ImageReader生成Image的Surface

打开相机设备

  1. try {
  2.     if (!mCameraOpenCloseLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) {
  3.         throw new RuntimeException("Time out waiting to lock camera opening.");
  4.     }
  6.     cameraManager.openCamera(mCameraId, mStateCallback, mBackgroundHandler);
  7. } catch (Exception e) {
  8.     e.printStackTrace();
  9. }

cameraManager.openCamera(@NonNull String cameraId,@NonNull final CameraDevice.StateCallback callback, @Nullable Handler handler)的三个参数:

  • cameraId：摄像头的唯一标识
  • callback：设备连接状态变化的回调
  • handler：回调执行的Handler对象，传入null则使用当前的主线程Handler

其中callback回调：

  1. private final CameraDevice.StateCallback mStateCallback = new CameraDevice.StateCallback() {
  2.     @Override
  3.     public void onOpened(@NonNull CameraDevice camera) {
  4.         mCameraOpenCloseLock.release();
  5.         mCameraDevice = camera;
  6.         createCameraPreviewSession();
  7.     }
  9.     @Override
  10.     public void onDisconnected(@NonNull CameraDevice camera) {
  11.         mCameraOpenCloseLock.release();
  12.         camera.close();
  13.         mCameraDevice = null;
  14.     }
  16.     @Override
  17.     public void onError(@NonNull CameraDevice camera, int error) {
  18.         mCameraOpenCloseLock.release();
  19.         camera.close();
  20.         mCameraDevice = null;
  21.     }
  23.     @Override
  24.     public void onClosed(@NonNull CameraDevice camera) {
  25.         super.onClosed(camera);
  26.     }
  27. };
  • onOpened：表示相机打开成功，可以真正开始使用相机，创建Capture会话
  • onDisconnected：当相机断开连接时回调该方法，需要进行释放相机的操作
  • onError：当相机打开失败时，需要进行释放相机的操作
  • onClosed：调用Camera.close()后的回调方法

创建Capture会话

在CameraDevice.StateCallback的onOpened回调中执行：

  1. private void createCameraPreviewSession() {
  2.     SurfaceTexture texture = mTextureView.getSurfaceTexture();
  3.     assert texture != null;
  4.     texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight());
  5.     Surface surface = new Surface(texture);
  7.     try {
  8.         mPreviewRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
  9.         mPreviewRequestBuilder.addTarget(surface);
  11.         // Here, we create a CameraCaptureSession for camera preview.
  12.         mCameraDevice.createCaptureSession(Arrays.asList(surface, mImageReader.getSurface()),
  13.                 new CameraCaptureSession.StateCallback() {
  15.                     @Override
  16.                     public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
  17.                         // The camera is already closed
  18.                         if (null == mCameraDevice) {
  19.                             return;
  20.                         }
  22.                         // When the session is ready, we start displaying the preview.
  23.                         mCaptureSession = cameraCaptureSession;
  24.                         try {
  25.                             // Auto focus should be continuous for camera preview.
  26.                             mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE,
  27.                                     CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
  28.                             // Flash is automatically enabled when necessary.
  29.                             setAutoFlash(mPreviewRequestBuilder);
  31.                             // Finally, we start displaying the camera preview.
  32.                             mPreviewRequest = mPreviewRequestBuilder.build();
  33.                             mCaptureSession.setRepeatingRequest(mPreviewRequest,
  34.                                     mCaptureCallback, mBackgroundHandler);
  35.                         } catch (CameraAccessException e) {
  36.                             e.printStackTrace();
  37.                         }
  38.                     }
  40.                     @Override
  41.                     public void onConfigureFailed(
  42.                             @NonNull CameraCaptureSession cameraCaptureSession) {
  43.                         Toast.makeText(Camera2Activity.this, "configureFailed", Toast.LENGTH_SHORT).show();
  44.                     }
  45.                 }, null
  46.         );
  47.     } catch (CameraAccessException e) {
  48.         e.printStackTrace();
  49.     }
  50. }

这段的代码核心方法是mCameraDevice.createCaptureSession()创建Capture会话，它接受了三个参数：

  • outputs：用于接受图像数据的surface集合，这里传入的是一个preview的surface
  • callback：用于监听 Session 状态的CameraCaptureSession.StateCallback对象
  • handler：用于执行CameraCaptureSession.StateCallback的Handler对象，传入null则使用当前的主线程Handler

创建CaptureRequest

CaptureRequest是向CameraCaptureSession提交Capture请求时的信息载体，其内部包括了本次Capture的参数配置和接收图像数据的Surface。

  1. mPreviewRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
  2. mPreviewRequestBuilder.addTarget(surface);

通过CameraDevice.createCaptureRequest()创建CaptureRequest.Builder对象，传入一个templateType参数，templateType用于指定使用何种模板创建CaptureRequest.Builder对象，templateType的取值：

  • TEMPLATE_PREVIEW：预览模式
  • TEMPLATE_STILL_CAPTURE：拍照模式
  • TEMPLATE_RECORD：视频录制模式
  • TEMPLATE_VIDEO_SNAPSHOT：视频截图模式
  • TEMPLATE_MANUAL：手动配置参数模式

除了模式的配置，CaptureRequest还可以配置很多其他信息，例如图像格式、图像分辨率、传感器控制、闪光灯控制、3A(自动对焦-AF、自动曝光-AE和自动白平衡-AWB)控制等。在createCaptureSession的回调中可以进行设置

  1. // Auto focus should be continuous for camera preview.
  2. mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE,
  3.         CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
  4. // Flash is automatically enabled when necessary.
  5. setAutoFlash(mPreviewRequestBuilder);
  7. // Finally, we start displaying the camera preview.
  8. mPreviewRequest = mPreviewRequestBuilder.build();

代码中设置了AF为设置未图片模式下的连续对焦，并设置自动闪光灯。最后通过build()方法生成CaptureRequest对象。

预览

Camera2中，通过连续重复的Capture实现预览功能，每次Capture会把预览画面显示到对应的Surface上。连续重复的Capture操作通过mCaptureSession.setRepeatingRequest(mPreviewRequest,mCaptureCallback, mBackgroundHandler)实现，该方法有三个参数：

  • request：CaptureRequest对象
  • listener：监听Capture 状态的回调
  • handler：用于执行CameraCaptureSession.CaptureCallback的Handler对象，传入null则使用当前的主线程Handler

停止预览使用mCaptureSession.stopRepeating()方法。

拍照

设置上面的request，session后，就可以真正的开始拍照操作

mCaptureSession.capture(mPreviewRequestBuilder.build(), mCaptureCallback, mBackgroundHandler);

该方法也有三个参数，和mCaptureSession.setRepeatingRequest一样：

  • request：CaptureRequest对象
  • listener：监听Capture 状态的回调
  • handler：用于执行CameraCaptureSession.CaptureCallback的Handler对象，传入null则使用当前的主线程Handler

这里设置了mCaptureCallback：

  1. private CameraCaptureSession.CaptureCallback mCaptureCallback = new CameraCaptureSession.CaptureCallback() {
  2.     @Override
  3.     public void onCaptureProgressed(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull CaptureResult partialResult) {
  4.         process(partialResult);
  5.     }
  7.     @Override
  8.     public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
  9.         process(result);
  10.     }
  12.     private void process(CaptureResult result) {
  13.         switch (mState) {
  14.             case STATE_PREVIEW: {
  15.                 // We have nothing to do when the camera preview is working normally.
  16.                 break;
  17.             }
  18.             case STATE_WAITING_LOCK: {
  19.                 Integer afState = result.get(CaptureResult.CONTROL_AF_STATE);
  20.                 Log.d("DEBUG", "##### process STATE_WAITING_LOCK: " + afState);
  21.                 if (afState == null) {
  22.                     captureStillPicture();
  23.                 } else if (CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED == afState ||
  24.                         CaptureResult.CONTROL_AF_STATE_NOT_FOCUSED_LOCKED == afState) {
  25.                     // CONTROL_AE_STATE can be null on some devices
  26.                     Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
  27.                     if (aeState == null ||
  28.                             aeState == CaptureResult.CONTROL_AE_STATE_CONVERGED) {
  29.                         mState = STATE_PICTURE_TAKEN;
  30.                         captureStillPicture();
  31.                     } else {
  32.                         runPrecaptureSequence();
  33.                     }
  34.                 }
  35.                 break;
  36.             }
  37.             case STATE_WAITING_PRECAPTURE: {
  38.                 // CONTROL_AE_STATE can be null on some devices
  39.                 Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
  40.                 if (aeState == null ||
  41.                         aeState == CaptureResult.CONTROL_AE_STATE_PRECAPTURE ||
  42.                         aeState == CaptureRequest.CONTROL_AE_STATE_FLASH_REQUIRED) {
  43.                     mState = STATE_WAITING_NON_PRECAPTURE;
  44.                 }
  45.                 break;
  46.             }
  47.             case STATE_WAITING_NON_PRECAPTURE: {
  48.                 // CONTROL_AE_STATE can be null on some devices
  49.                 Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
  50.                 if (aeState == null || aeState != CaptureResult.CONTROL_AE_STATE_PRECAPTURE) {
  51.                     mState = STATE_PICTURE_TAKEN;
  52.                     captureStillPicture();
  53.                 }
  54.                 break;
  55.             }
  56.         }
  57.     }
  58. };

通过设置mState来区分当前状态，是在预览还是拍照

关闭相机

退到后台或者当前页面被关闭的时候，已经不需要使用相机了，需要进行相机关闭操作，释放资源，

  1. private void closeCamera() {
  2.     try {
  3.         mCameraOpenCloseLock.acquire();
  4.         if (null != mCaptureSession) {
  5.             mCaptureSession.close();
  6.             mCaptureSession = null;
  7.         }
  8.         if (null != mCameraDevice) {
  9.             mCameraDevice.close();
  10.             mCameraDevice = null;
  11.         }
  12.         if (null != mImageReader) {
  13.             mImageReader.close();
  14.             mImageReader = null;
  15.         }
  16.     } catch (InterruptedException e) {
  17.         throw new RuntimeException("Interrupted while trying to lock camera closing.", e);
  18.     } finally {
  19.         mCameraOpenCloseLock.release();
  20.     }
  21. }

先后对CaptureSession，CameraDevice，ImageReader进行close操作，释放资源。
这里仅仅对Camera2基本使用流程做了介绍，一些更高级的用法需要大家自行去实践。在Camera1中需要对画面进行方向矫正，而Camera2是否需要呢，关于相机Orientation相关的知识，通过后面的章节再进行介绍。

CameraView

CameraView的目的就是帮助开发者能够快速集成Camera1和Camera2的特性，可以用下面这张表来说明：

开发流程

CameraView定义

xml中定义

  1. <com.google.android.cameraview.CameraView
  2.     android:id="@+id/camera"
  3.     android:layout_width="match_parent"
  4.     android:layout_height="wrap_content"
  5.     android:keepScreenOn="true"
  6.     android:adjustViewBounds="true"
  7.     app:autoFocus="true"
  8.     app:aspectRatio="4:3"
  9.     app:facing="back"
  10.     app:flash="auto"/>

xml中可以配置：

  • autoFocus：是否自动对焦
  • aspectRatio：预览画面比例
  • facing：前后摄像头
  • flash：闪光灯模式

增加生命周期

  1. @Override
  2. protected void onResume() {
  3.     super.onResume();
  4.     mCameraView.start();
  5. }
  7. @Override
  8. protected void onPause() {
  9.     mCameraView.stop();
  10.     super.onPause();
  11. }

这样声明后，就可以完成预览的工作了

相机状态回调

在xml声明CameraView后，增加回调

  1. if (mCameraView != null) {
  2.     mCameraView.addCallback(mCallback);
  3. }
  4. ...
  5. private CameraView.Callback mCallback
  6.             = new CameraView.Callback() {
  8.     @Override
  9.     public void onCameraOpened(CameraView cameraView) {
  10.         Log.d(TAG, "onCameraOpened");
  11.     }
  13.     @Override
  14.     public void onCameraClosed(CameraView cameraView) {
  15.         Log.d(TAG, "onCameraClosed");
  16.     }
  18.     @Override
  19.     public void onPictureTaken(CameraView cameraView, final byte[] data) {
  20.         Log.d(TAG, "onPictureTaken " + data.length);
  21.         Toast.makeText(cameraView.getContext(), R.string.picture_taken, Toast.LENGTH_SHORT)
  22.                 .show();
  23.         getBackgroundHandler().post(new Runnable() {
  24.             @Override
  25.             public void run() {
  26.                 File file = new File(getExternalFilesDir(Environment.DIRECTORY_PICTURES),
  27.                         "picture.jpg");
  28.                 Log.d(TAG, "onPictureTaken file path: " + file.getPath());
  29.                 OutputStream os = null;
  30.                 try {
  31.                     os = new FileOutputStream(file);
  32.                     os.write(data);
  33.                     os.close();
  34.                 } catch (IOException e) {
  35.                     Log.w(TAG, "Cannot write to " + file, e);
  36.                 } finally {
  37.                     if (os != null) {
  38.                         try {
  39.                             os.close();
  40.                         } catch (IOException e) {
  41.                             // Ignore
  42.                         }
  43.                     }
  44.                 }
  45.             }
  46.         });
  47.     }
  49. };

有三个回调方法，相机打开，相机关闭，和拍照。

拍照

mCameraView.takePicture();

就是这么简单，点击后拍照，然后回调中处理图像数据

CameraX

CameraX 是一个 Jetpack 支持库，目的是简化Camera的开发工作，它是基于Camera2 API的基础，向后兼容至 Android 5.0（API 级别 21）。
它有以下几个特性：

  • 易用性，只需要几行代码就可以实现预览和拍照
  • 保持设备的一致性，在不同相机设备上，对宽高比、屏幕方向、旋转、预览大小和高分辨率图片大小，做到都可以正常使用
  • 相机特性的扩展，增加人像、HDR、夜间模式和美颜等功能

开发流程

库引用

目前CameraX最新版本是1.0.0-alpha06，在app的build.gradle引用：

  1. dependencies {
  2.     // CameraX core library.
  3.     def camerax_version = "1.0.0-alpha06"
  4.     implementation "androidx.camera:camera-core:${camerax_version}"
  5.     // If you want to use Camera2 extensions.
  6.     implementation "androidx.camera:camera-camera2:${camerax_version}"
  8.     def camerax_view_version = "1.0.0-alpha03"
  9.     def camerax_ext_version = "1.0.0-alpha03"
  10.     //other
  11.     // If you to use the Camera View class
  12.     implementation "androidx.camera:camera-view:$camerax_view_version"
  13.     // If you to use Camera Extensions
  14.     implementation "androidx.camera:camera-extensions:$camerax_ext_version"
  15. }

因为CameraX是一个 Jetpack 支持库，相机的打开和释放都是使用了Jetpack的Lifecycle来进行处理。

预览

预览参数设置，使用PreviewConfig.Builder()实现：

  1. PreviewConfig config = new PreviewConfig.Builder()
  2.                 .setLensFacing(CameraX.LensFacing.BACK)
  3.                 .setTargetRotation(mTextureView.getDisplay().getRotation())
  4.                 .setTargetResolution(new Size(640, 480))
  5.                 .build();
  7. Preview preview = new Preview(config);
  8. preview.setOnPreviewOutputUpdateListener(new Preview.OnPreviewOutputUpdateListener() {
  9.     @Override
  10.     public void onUpdated(@NonNull Preview.PreviewOutput output) {
  11.         if (mTextureView.getParent() instanceof ViewGroup) {
  12.             ViewGroup viewGroup = (ViewGroup) mTextureView.getParent();
  13.             viewGroup.removeView(mTextureView);
  14.             viewGroup.addView(mTextureView, 0);
  16.             mTextureView.setSurfaceTexture(output.getSurfaceTexture());
  17.             updateTransform();
  18.         }
  19.     }
  20. });
  22. //lifecycle
  23. CameraX.bindToLifecycle(this, preview);

PreivewConfig.Builder可以设置的属性很多，这里只设置了摄像头、旋转方向、预览分辨率，还有很多其他方法，大家可以自行试验。
在preview回调监听中，把output的SurfaceTexture设置到mTextureView中，实现图像预览，最后增加Lifecycle的绑定。

拍照

  1. ImageCaptureConfig captureConfig = new ImageCaptureConfig.Builder()
  2.         .setTargetAspectRatio(AspectRatio.RATIO_16_9)
  3.         .setCaptureMode(ImageCapture.CaptureMode.MIN_LATENCY)
  4.         .setTargetRotation(getWindowManager().getDefaultDisplay().getRotation())
  5.         .build();
  7. ImageCapture imageCapture = new ImageCapture(captureConfig);
  8. mTakePicture.setOnClickListener((view) -> {
  9.     final File file = new File(getExternalMediaDirs()[0], System.currentTimeMillis() + ".jpg");
  10.     Log.d("DEBUG", "##### file path: " + file.getPath());
  11.     imageCapture.takePicture(file, ContextCompat.getMainExecutor(getApplicationContext()), new ImageCapture.OnImageSavedListener() {
  12.         @Override
  13.         public void onImageSaved(@NonNull File file) {
  14.             Log.d("DEBUG", "##### onImageSaved: " + file.getPath());
  15.         }
  17.         @Override
  18.         public void onError(@NonNull ImageCapture.ImageCaptureError imageCaptureError, @NonNull String message, @Nullable Throwable cause) {
  19.             Log.d("DEBUG", "##### onError: " + message);
  20.         }
  21.     });
  22. });
  24. CameraX.bindToLifecycle(this, preview, imageCapture);

拍照的参数通过ImageCaptureConfig.Builder设置，这里只设置了图片宽高比、拍摄模式和旋转方向，还有很多其他方法，大家可以自行试验。
真正调用拍照的方法：

  • takePicture(OnImageCapturedListener)：此方法为拍摄的图片提供内存缓冲区。
  • takePicture(File, OnImageSavedListener)：此方法将拍摄的图片保存到提供的文件位置。
  • takePicture(File, OnImageSavedListener, Metadata)：此方法可用于指定要嵌入已保存文件的 Exif 中的元数据。

例子调用的是takePicture(File, OnImageSavedListener)，直接存为文件。最后再增加Lifecycle的绑定。

图片分析

  1. ImageAnalysisConfig analysisConfig = new ImageAnalysisConfig.Builder()
  2.         .setImageReaderMode(ImageAnalysis.ImageReaderMode.ACQUIRE_LATEST_IMAGE)
  3.         .build();
  5. ImageAnalysis imageAnalysis = new ImageAnalysis(analysisConfig);
  6. imageAnalysis.setAnalyzer(ContextCompat.getMainExecutor(getApplicationContext()),
  7.         new LuminosityAnalyzer());
  9. CameraX.bindToLifecycle(this, preview, imageCapture, imageAnalysis);
  11. ...
  12. private class LuminosityAnalyzer implements ImageAnalysis.Analyzer {
  13.     private long lastAnalyzedTimestamp = 0L;
  15.     @Override
  16.     public void analyze(ImageProxy image, int rotationDegrees) {
  17.         final Image img = image.getImage();
  18.         if (img != null) {
  19.             Log.d("DEBUG", img.getWidth() + "," + img.getHeight());
  20.         }
  21.     }
  22. }

图片分析，不是必要的步骤，但是ImageAnalysis，可以对每帧图像进行分析。
设置参数通过ImageAnalysisConfig.Builder()，这里只设置了ImageReaderMode，它有两种模式：

  • 阻止模式(ImageReaderMode.ACQUIRE_NEXT_IMAGE)：就是Camera2中的acquireNextImage()，获取下一个最新的可用Image
  • 非阻止模式(ImageReaderMode.ACQUIRE_LATEST_IMAGE)：Camera2中的acquireLatestImage()，获得图像队列中最新的图片，并且会清空队列,删除已有的旧的图像

最后还是增加Lifecycle的绑定。CameraX的使用也非常简单，把Camera2中复杂的API封装到统一的config中，只需要几行代码，就实现需要的功能。

 

 

 

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： 创始元灵6666 > 《work》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多