devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android录制视频，三种Camera的使用与预览及其简单封装

作者：花生_TL007 | 2024-05-28 22:16:05

赞

踩

android camera

三种Camera的使用与封装

前言

省流：先别慌别跑，本文只是涉及到 Android API 的使用以及封装，还没有涉及到专业音视频领域（PS：说的好像我会似的），大家如果想看哪一种 Camera API 直接点击分类查看即可。代码比较多全文阅读的话大概20分钟。

文末附源码。

作者：newki
链接：https://juejin.cn/post/7252597901762625596

正文部分

使用到相机大家都不陌生，很多应用都会使用到 Camera 硬件，一般是用于拍照或者录制视频，这都是很常见的功能。

一般来大家都是怎么使用的呢？说如果没有 UI 的限制或逻辑的限制，只是单纯的拍照或录制视频，我们其实可以通过 intent 的方式直接启动系统的拍照或录制 Activity 就能完成，这是最方便的方式。也就不需要此文了。

但是总有那么一些应用，那么一些需求，要么是需要自定义的 相机UI页面，要么是业务逻辑需要 ，一般我们就需要自己实现 Camera 的逻辑，比如显示预览页面，对回调的数据帧进行人脸判断？ 进行图片识别？ 或者需要自定义拍照与录制逻辑单击拍照长按录制？ 或者是对特效/滤镜视频的录制？

既然离不开 Camera API 的使用，那么本文就从应用的角度出发如何使用 Camera API 实现想要的效果。

那么需要具体到使用哪一种 Camera 呢？这个大家也能听说过，我们目前有三种 API 可以使用，分别是 Camera , Camera2 , CameraX ??? 谷歌是不是傻，为什么要增加我们开发者的工作量，搞这么复杂我怎么用嘛！

一、Camera的前世今生

其实主要是为了兼容性与安全性考虑，这里简单的总结一下：

Camera API 是允许应用程序直接与相机硬件交互的旧版 android.hardware.Camera 类在底层通过驱动程序直接访问相机硬件。

它提供了基本的控制与图片捕捉能力，但是这种方式具有一定的限制和设备兼容性问题。所以 Android 团队决定在 Android 5.0 引入全新的相机 API ，即Camera2 API。

Camera2 API引入了一种新的架构，应用程序通过 CameraManager 与系统 相机服务 进行通信，并使用CameraDevice、CameraCaptureSession等对象来控制相机功能。这种方式提供了更精细的控制和更高的性能，并解决了旧版API存在的一些限制。

其实这样很好，直接操作变为通过服务通信，并且它提供更精细的控制和更高的性能。到此的话应该没什么问题，为什么还要推出 CameraX 呢？

尽管 Camera2 API 提供了很多优势，但使用它仍然需要编写大量的代码来处理各种情况和设备兼容性。为了简化相机开发流程并提高跨设备兼容性，Google 推出了 CameraX 库

而 CameraX 库则是在 Camera2 API 的基础上进行封装和简化，以提供更一致和易用的相机接口。它抽象了底层的相机相关逻辑和设备差异，使开发者能够以统一的方式编写相机代码，而无需关心特定设备兼容性的细节。它提供了更高级别的API，使开发者能够更轻松地实现相机功能，同时保持跨设备兼容性。

所以其实我们用 Camera2 能实现的效果都能通过 CameraX 更简单的与方便的实现，所以个人也是比较推荐使用 CameraX 。

下面就把三种 Camera API 的如何使用与如何封装都写一遍。

二、Camera1 的使用与封装

一般来说我们使用 Camera1 的时候，我们都是使用 SurfaceView 或 TextureView 来承载预览画面。他们在此场景下的区别就是 TextureView 可以用一些动画实现自适应，裁剪布局等效果。

这里我们简单的 SurfaceView 来演示如何使用：

先创建 SurfaceView 并设置监听，然后添加到我们指定的容器中：

  1. public View initCamera(Context context) {
  2.         mSurfaceView = new SurfaceView(context);
  3.         mContext = context;
  4.         mSurfaceView.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
  5.  
  6.  
  7.         mSurfaceHolder = mSurfaceView.getHolder();
  8.         mSurfaceHolder.addCallback(new CustomCallBack());
  9.         mSurfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
  10.  
  11.  
  12.         return mSurfaceView;
  13.     }

在 SurfaceView 的回调中，我们初始化 Camera

  1. private class CustomCallBack implements SurfaceHolder.Callback {
  2.  
  3.  
  4.         @Override
  5.         public void surfaceCreated(SurfaceHolder holder) {
  6.             initCamera();
  7.         }
  8.  
  9.  
  10.         @Override
  11.         public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
  12.         }
  13.  
  14.  
  15.         @Override
  16.         public void surfaceDestroyed(SurfaceHolder holder) {
  17.             releaseAllCamera();
  18.         }
  19.     }
  20.  
  21.  
  22.  
  23.  
  24.       private void initCamera() {
  25.         if (mCamera != null) {
  26.             releaseAllCamera();
  27.         }
  28.  
  29.  
  30.         //打开摄像头
  31.         try {
  32.             mCamera = Camera.open();
  33.  
  34.  
  35.         } catch (Exception e) {
  36.             e.printStackTrace();
  37.             releaseAllCamera();
  38.         }
  39.         if (mCamera == null)
  40.             return;
  41.  
  42.  
  43.         //设置摄像头参数
  44.         setCameraParams();
  45.  
  46.  
  47.         try {
  48.             mCamera.setDisplayOrientation(90);   //设置拍摄方向为90度（竖屏）
  49.             mCamera.setPreviewDisplay(mSurfaceHolder);
  50.             mCamera.startPreview();
  51.             mCamera.unlock();
  52.  
  53.  
  54.         } catch (IllegalStateException e) {
  55.             e.printStackTrace();
  56.         } catch (RuntimeException e) {
  57.             e.printStackTrace();
  58.         } catch (Exception e) {
  59.             e.printStackTrace();
  60.         }
  61.  
  62.  
  63.     }

这里需要额外处理预览的方向与预览尺寸,代码太多了，在下面的工具类中放出。

上面的代码只是最简单的使用，关于切换前后镜头，镜像展示，预览方向，旋转角度，回调处理等等一系列的操作使用起来很是麻烦，所以这里贴一个自用的工具类统一管理他们。

先定义一个接口回调：

  1. public interface CameraListener {
  2.     /**
  3.      * 当打开时执行
  4.      *
  5.      * @param camera             相机实例
  6.      * @param cameraId           相机ID
  7.      * @param displayOrientation 相机预览旋转角度
  8.      * @param isMirror           是否镜像显示
  9.      */
  10.     void onCameraOpened(Camera camera, int cameraId, int displayOrientation, boolean isMirror);
  11.  
  12.  
  13.     /**
  14.      * 预览数据回调
  15.      *
  16.      * @param data   预览数据
  17.      * @param camera 相机实例
  18.      */
  19.     void onPreview(byte[] data, Camera camera);
  20.  
  21.  
  22.     /**
  23.      * 当相机关闭时执行
  24.      */
  25.     void onCameraClosed();
  26.  
  27.  
  28.     /**
  29.      * 当出现异常时执行
  30.      *
  31.      * @param e 相机相关异常
  32.      */
  33.     void onCameraError(Exception e);
  34.  
  35.  
  36.     /**
  37.      * 属性变化时调用
  38.      *
  39.      * @param cameraID           相机ID
  40.      * @param displayOrientation 相机旋转方向
  41.      */
  42.     void onCameraConfigurationChanged(int cameraID, int displayOrientation);
  43. }

然后就是我们的工具类，这里直接贴出：

  1. public class CameraHelper implements Camera.PreviewCallback {
  2.  
  3.  
  4.     private Camera mCamera;
  5.     private int mCameraId;
  6.     private Point previewViewSize;
  7.     private View previewDisplayView;
  8.     private Camera.Size previewSize;
  9.     private Point specificPreviewSize;
  10.     private int displayOrientation = 0;
  11.     private int rotation;
  12.     private int additionalRotation;
  13.     private boolean isMirror = false;
  14.  
  15.  
  16.     private Integer specificCameraId = null;
  17.     private CameraListener cameraListener;   //自定义监听回调
  18.  
  19.  
  20.     private CameraHelper(Builder builder) {
  21.         previewDisplayView = builder.previewDisplayView;
  22.         specificCameraId = builder.specificCameraId;
  23.         cameraListener = builder.cameraListener;
  24.         rotation = builder.rotation;
  25.         additionalRotation = builder.additionalRotation;
  26.         previewViewSize = builder.previewViewSize;
  27.         specificPreviewSize = builder.previewSize;
  28.         if (builder.previewDisplayView instanceof TextureView) {
  29.             isMirror = builder.isMirror;
  30.         } else if (isMirror) {
  31.             throw new RuntimeException("mirror is effective only when the preview is on a textureView");
  32.         }
  33.     }
  34.  
  35.  
  36.     public void init() {
  37.         if (previewDisplayView instanceof TextureView) {
  38.             ((TextureView) this.previewDisplayView).setSurfaceTextureListener(textureListener);
  39.         } else if (previewDisplayView instanceof SurfaceView) {
  40.             ((SurfaceView) previewDisplayView).getHolder().addCallback(surfaceCallback);
  41.         }
  42.  
  43.  
  44.         if (isMirror) {
  45.             previewDisplayView.setScaleX(-1);
  46.         }
  47.     }
  48.  
  49.  
  50.     public String start() {
  51.         String firstSize = null;
  52.         String finalSize = null;
  53.         synchronized (this) {
  54.             if (mCamera != null) {
  55.                 return null;
  56.             }
  57.             //相机数量为2则打开1,1则打开0,相机ID 1为前置，0为后置
  58.             mCameraId = Camera.getNumberOfCameras() - 1;
  59.             //若指定了相机ID且该相机存在，则打开指定的相机
  60.             if (specificCameraId != null && specificCameraId <= mCameraId) {
  61.                 mCameraId = specificCameraId;
  62.             }
  63.  
  64.  
  65.             //没有相机
  66.             if (mCameraId == -1) {
  67.                 if (cameraListener != null) {
  68.                     cameraListener.onCameraError(new Exception("camera not found"));
  69.                 }
  70.                 return null;
  71.             }
  72.  
  73.  
  74.             //开启相机
  75.             if (mCamera == null) {
  76.                 mCamera = Camera.open(mCameraId);
  77.             }
  78.  
  79.  
  80.             //获取预览方向
  81.             displayOrientation = getCameraOri(rotation);
  82.             mCamera.setDisplayOrientation(displayOrientation);
  83.  
  84.  
  85.             try {
  86.                 Camera.Parameters parameters = mCamera.getParameters();
  87.                 parameters.setPreviewFormat(ImageFormat.NV21);
  88.  
  89.  
  90.                 //预览大小设置
  91.                 previewSize = parameters.getPreviewSize();
  92.                 firstSize = previewSize.width + " - " + previewSize.height;
  93.                 List<Camera.Size> supportedPreviewSizes = parameters.getSupportedPreviewSizes();
  94.                 if (supportedPreviewSizes != null && supportedPreviewSizes.size() > 0) {
  95.                     previewSize = getBestSupportedSize(supportedPreviewSizes, previewViewSize);
  96.                     finalSize = previewSize.width + " - " + previewSize.height;
  97.                 }
  98.                 YYLogUtils.w("Base Preview Size ,Width:" + previewSize.width + " height:" + previewSize.height);
  99.                 parameters.setPreviewSize(previewSize.width, previewSize.height);
  100.  
  101.  
  102.                 //对焦模式设置
  103.                 List<String> supportedFocusModes = parameters.getSupportedFocusModes();
  104.                 if (supportedFocusModes != null && supportedFocusModes.size() > 0) {
  105.                     if (supportedFocusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) {
  106.                         parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
  107.                     } else if (supportedFocusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO)) {
  108.                         parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
  109.                     } else if (supportedFocusModes.contains(Camera.Parameters.FOCUS_MODE_AUTO)) {
  110.                         parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
  111.                     }
  112.                 }
  113.  
  114.  
  115.                 //Camera 配置完成，设置回去
  116.                 mCamera.setParameters(parameters);
  117.  
  118.  
  119.                 //绑定到 TextureView 或 SurfaceView
  120.                 if (previewDisplayView instanceof TextureView) {
  121.                     mCamera.setPreviewTexture(((TextureView) previewDisplayView).getSurfaceTexture());
  122.                 } else {
  123.                     mCamera.setPreviewDisplay(((SurfaceView) previewDisplayView).getHolder());
  124.                 }
  125.  
  126.  
  127.                 //启动预览并设置预览回调
  128.                 mCamera.setPreviewCallback(this);
  129.                 mCamera.startPreview();
  130.  
  131.  
  132.                 if (cameraListener != null) {
  133.                     cameraListener.onCameraOpened(mCamera, mCameraId, displayOrientation, isMirror);
  134.                 }
  135.             } catch (Exception e) {
  136.                 if (cameraListener != null) {
  137.                     cameraListener.onCameraError(e);
  138.                 }
  139.             }
  140.         }
  141.         return "firstSize :" + firstSize + " finalSize:" + finalSize;
  142.     }
  143.  
  144.  
  145.     private int getCameraOri(int rotation) {
  146.         int degrees = rotation * 90;
  147.         switch (rotation) {
  148.             case Surface.ROTATION_0:
  149.                 degrees = 0;
  150.                 break;
  151.             case Surface.ROTATION_90:
  152.                 degrees = 90;
  153.                 break;
  154.             case Surface.ROTATION_180:
  155.                 degrees = 180;
  156.                 break;
  157.             case Surface.ROTATION_270:
  158.                 degrees = 270;
  159.                 break;
  160.             default:
  161.                 break;
  162.         }
  163.         additionalRotation /= 90;
  164.         additionalRotation *= 90;
  165.         degrees += additionalRotation;
  166.         int result;
  167.         Camera.CameraInfo info = new Camera.CameraInfo();
  168.         Camera.getCameraInfo(mCameraId, info);
  169.         if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
  170.             result = (info.orientation + degrees) % 360;
  171.             result = (360 - result) % 360;
  172.         } else {
  173.             result = (info.orientation - degrees + 360) % 360;
  174.         }
  175.         return result;
  176.     }
  177.  
  178.  
  179.     public void stop() {
  180.         synchronized (this) {
  181.             if (mCamera == null) {
  182.                 return;
  183.             }
  184.             mCamera.setPreviewCallback(null);
  185.             mCamera.stopPreview();
  186.             mCamera.release();
  187.             mCamera = null;
  188.             if (cameraListener != null) {
  189.                 cameraListener.onCameraClosed();
  190.             }
  191.         }
  192.     }
  193.  
  194.  
  195.     public boolean isStopped() {
  196.         synchronized (this) {
  197.             return mCamera == null;
  198.         }
  199.     }
  200.  
  201.  
  202.     public void release() {
  203.         synchronized (this) {
  204.             stop();
  205.             previewDisplayView = null;
  206.             specificCameraId = null;
  207.             cameraListener = null;
  208.             previewViewSize = null;
  209.             specificPreviewSize = null;
  210.             previewSize = null;
  211.         }
  212.     }
  213.  
  214.  
  215.     /**
  216.      * 根据 Camera 获取支持的宽高，获取到最适合的预览宽高
  217.      */
  218.     private Camera.Size getBestSupportedSize(List<Camera.Size> sizes, Point previewViewSize) {
  219.         if (sizes == null || sizes.size() == 0) {
  220.             return mCamera.getParameters().getPreviewSize();
  221.         }
  222.         Camera.Size[] tempSizes = sizes.toArray(new Camera.Size[0]);
  223.         Arrays.sort(tempSizes, new Comparator<Camera.Size>() {
  224.             @Override
  225.             public int compare(Camera.Size o1, Camera.Size o2) {
  226.                 if (o1.width > o2.width) {
  227.                     return -1;
  228.                 } else if (o1.width == o2.width) {
  229.                     return o1.height > o2.height ? -1 : 1;
  230.                 } else {
  231.                     return 1;
  232.                 }
  233.             }
  234.         });
  235.         sizes = Arrays.asList(tempSizes);
  236.  
  237.  
  238.         Camera.Size bestSize = sizes.get(0);
  239.         float previewViewRatio;
  240.         if (previewViewSize != null) {
  241.             previewViewRatio = (float) previewViewSize.x / (float) previewViewSize.y;
  242.         } else {
  243.             previewViewRatio = (float) bestSize.width / (float) bestSize.height;
  244.         }
  245.  
  246.  
  247.         if (previewViewRatio > 1) {
  248.             previewViewRatio = 1 / previewViewRatio;
  249.         }
  250.         boolean isNormalRotate = (additionalRotation % 180 == 0);
  251.  
  252.  
  253.         for (Camera.Size s : sizes) {
  254.             if (specificPreviewSize != null && specificPreviewSize.x == s.width && specificPreviewSize.y == s.height) {
  255.                 return s;
  256.             }
  257.             if (isNormalRotate) {
  258.                 if (Math.abs((s.height / (float) s.width) - previewViewRatio) < Math.abs(bestSize.height / (float) bestSize.width - previewViewRatio)) {
  259.                     bestSize = s;
  260.                 }
  261.             } else {
  262.                 if (Math.abs((s.width / (float) s.height) - previewViewRatio) < Math.abs(bestSize.width / (float) bestSize.height - previewViewRatio)) {
  263.                     bestSize = s;
  264.                 }
  265.             }
  266.         }
  267.         return bestSize;
  268.     }
  269.  
  270.  
  271.     public List<Camera.Size> getSupportedPreviewSizes() {
  272.         if (mCamera == null) {
  273.             return null;
  274.         }
  275.         return mCamera.getParameters().getSupportedPreviewSizes();
  276.     }
  277.  
  278.  
  279.     public List<Camera.Size> getSupportedPictureSizes() {
  280.         if (mCamera == null) {
  281.             return null;
  282.         }
  283.         return mCamera.getParameters().getSupportedPictureSizes();
  284.     }
  285.  
  286.  
  287.  
  288.  
  289.     @Override
  290.     public void onPreviewFrame(byte[] nv21, Camera camera) {
  291.         if (cameraListener != null && nv21 != null) {
  292.             cameraListener.onPreview(nv21, camera);
  293.         }
  294.     }
  295.  
  296.  
  297.     /**
  298.      * TextureView 的监听回调
  299.      */
  300.     private TextureView.SurfaceTextureListener textureListener = new TextureView.SurfaceTextureListener() {
  301.         @Override
  302.         public void onSurfaceTextureAvailable(SurfaceTexture surfaceTexture, int width, int height) {
  303. //            start();
  304.             if (mCamera != null) {
  305.                 try {
  306.                     mCamera.setPreviewTexture(surfaceTexture);
  307.                 } catch (IOException e) {
  308.                     e.printStackTrace();
  309.                 }
  310.             }
  311.         }
  312.  
  313.  
  314.         @Override
  315.         public void onSurfaceTextureSizeChanged(SurfaceTexture surfaceTexture, int width, int height) {
  316.         }
  317.  
  318.  
  319.         @Override
  320.         public boolean onSurfaceTextureDestroyed(SurfaceTexture surfaceTexture) {
  321.             stop();
  322.             return false;
  323.         }
  324.  
  325.  
  326.         @Override
  327.         public void onSurfaceTextureUpdated(SurfaceTexture surfaceTexture) {
  328.  
  329.  
  330.         }
  331.     };
  332.  
  333.  
  334.     /**
  335.      * SurfaceView 的监听回调
  336.      */
  337.     private SurfaceHolder.Callback surfaceCallback = new SurfaceHolder.Callback() {
  338.         @Override
  339.         public void surfaceCreated(SurfaceHolder holder) {
  340.  
  341.  
  342.             if (mCamera != null) {
  343.                 try {
  344.                     mCamera.setPreviewDisplay(holder);
  345.                 } catch (IOException e) {
  346.                     e.printStackTrace();
  347.                 }
  348.             }
  349.         }
  350.  
  351.  
  352.         @Override
  353.         public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
  354.         }
  355.  
  356.  
  357.         @Override
  358.         public void surfaceDestroyed(SurfaceHolder holder) {
  359.             stop();
  360.         }
  361.     };
  362.  
  363.  
  364.     /**
  365.      * 切换摄像头方向
  366.      */
  367.     public void changeDisplayOrientation(int rotation) {
  368.         if (mCamera != null) {
  369.             this.rotation = rotation;
  370.             displayOrientation = getCameraOri(rotation);
  371.             mCamera.setDisplayOrientation(displayOrientation);
  372.             if (cameraListener != null) {
  373.                 cameraListener.onCameraConfigurationChanged(mCameraId, displayOrientation);
  374.             }
  375.         }
  376.     }
  377.  
  378.  
  379.     /**
  380.      * 翻转前后摄像镜头
  381.      */
  382.     public boolean switchCamera() {
  383.         if (Camera.getNumberOfCameras() < 2) {
  384.             return false;
  385.         }
  386.         // cameraId ,0为后置，1为前置
  387.         specificCameraId = 1 - mCameraId;
  388.         stop();
  389.         start();
  390.         return true;
  391.     }
  392.  
  393.  
  394.     /**
  395.      * 使用构建者模式创建，配置Camera
  396.      */
  397.     public static final class Builder {
  398.  
  399.  
  400.         //预览显示的view，目前仅支持surfaceView和textureView
  401.         private View previewDisplayView;
  402.  
  403.  
  404.         //是否镜像显示，只支持textureView
  405.         private boolean isMirror;
  406.  
  407.  
  408.         //指定的相机ID
  409.         private Integer specificCameraId;
  410.  
  411.  
  412.         //事件回调
  413.         private CameraListener cameraListener;
  414.  
  415.  
  416.         //屏幕的长宽，在选择最佳相机比例时用到
  417.         private Point previewViewSize;
  418.  
  419.  
  420.         //屏幕的方向，一般传入getWindowManager().getDefaultDisplay().getRotation()的值即可
  421.         private int rotation;
  422.  
  423.  
  424.         //指定的预览宽高，若系统支持则会以这个预览宽高进行预览
  425.         private Point previewSize;
  426.  
  427.  
  428.         //额外的旋转角度（用于适配一些定制设备）
  429.         private int additionalRotation;
  430.  
  431.  
  432.         public Builder() {
  433.         }
  434.  
  435.  
  436.         //必须要绑定到SurfaceView或者TextureView上
  437.         public Builder previewOn(View view) {
  438.             if (view instanceof SurfaceView || view instanceof TextureView) {
  439.                 previewDisplayView = view;
  440.                 return this;
  441.             } else {
  442.                 throw new RuntimeException("you must preview on a textureView or a surfaceView");
  443.             }
  444.         }
  445.  
  446.  
  447.         public Builder isMirror(boolean mirror) {
  448.             isMirror = mirror;
  449.             return this;
  450.         }
  451.  
  452.  
  453.         public Builder previewSize(Point point) {
  454.             previewSize = point;
  455.             return this;
  456.         }
  457.  
  458.  
  459.         public Builder previewViewSize(Point point) {
  460.             previewViewSize = point;
  461.             return this;
  462.         }
  463.  
  464.  
  465.         public Builder rotation(int rotation) {
  466.             rotation = rotation;
  467.             return this;
  468.         }
  469.  
  470.  
  471.         public Builder additionalRotation(int rotation) {
  472.             additionalRotation = rotation;
  473.             return this;
  474.         }
  475.  
  476.  
  477.         public Builder specificCameraId(Integer id) {
  478.             specificCameraId = id;
  479.             return this;
  480.         }
  481.  
  482.  
  483.         public Builder cameraListener(CameraListener listener) {
  484.             cameraListener = listener;
  485.             return this;
  486.         }
  487.  
  488.  
  489.         public CameraHelper build() {
  490.             if (previewViewSize == null) {
  491.                 throw new RuntimeException("previewViewSize is null, now use default previewSize");
  492.             }
  493.             if (cameraListener == null) {
  494.                 throw new RuntimeException("cameraListener is null, callback will not be called");
  495.             }
  496.             if (previewDisplayView == null) {
  497.                 throw new RuntimeException("you must preview on a textureView or a surfaceView");
  498.             }
  499.  
  500.  
  501.             //build的时候顺便执行初始化
  502.             CameraHelper cameraHelper = new CameraHelper(this);
  503.             cameraHelper.init();
  504.             return cameraHelper;
  505.         }
  506.     }
  507.  
  508.  
  509. }

我们使用起来就很简单了：

还是初始化 SurfaceView 并且添加到指定的布局容器中：

  1. public View initCamera(Context context) {
  2.         mSurfaceView = new SurfaceView(context);
  3.         mContext = context;
  4.         mSurfaceView.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
  5.  
  6.  
  7.  
  8.  
  9.         mSurfaceView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
  10.             @Override
  11.             public void onGlobalLayout() {
  12.  
  13.  
  14.                 mSurfaceView.post(() -> {
  15.  
  16.  
  17.                     setupCameraHelper();
  18.                 });
  19.  
  20.  
  21.                 mSurfaceView.getViewTreeObserver().removeOnGlobalLayoutListener(this);
  22.             }
  23.         });
  24.         return mSurfaceView;
  25.     }
  26.  
  27.  
  28.  
  29.  
  30.     private void setupCameraHelper() {
  31.         cameraHelper = new CameraHelper.Builder()
  32.                 .previewViewSize(new Point(mSurfaceView.getMeasuredWidth(), mSurfaceView.getMeasuredHeight()))
  33.                 .rotation(((Activity) mContext).getWindowManager().getDefaultDisplay().getRotation())
  34.                 .specificCameraId(Camera.CameraInfo.CAMERA_FACING_BACK)
  35.                 .isMirror(false)
  36.                 .previewOn(mSurfaceView) //预览容器 推荐TextureView
  37.                 .cameraListener(mCameraListener) //设置自定义的监听器
  38.                 .build();
  39.  
  40.  
  41.         cameraHelper.start();
  42.     }

所有的逻辑就在回调中处理：

  1. //自定义监听
  2.     private CameraListener mCameraListener = new CameraListener() {
  3.         @Override
  4.         public void onCameraOpened(Camera camera, int cameraId, int displayOrientation, boolean isMirror) {
  5.             YYLogUtils.w("CameraListener - onCameraOpened");
  6.  
  7.  
  8.             //你可以使用 MediaRecorder 去录制视频
  9.             mMediaRecorder = new MediaRecorder();
  10.             ...
  11.  
  12.  
  13.         }
  14.  
  15.  
  16.         @Override
  17.         public void onPreview(byte[] data, Camera camera) {
  18.             // nv21 数据
  19.             // 你也可以用 MediaCodec 自己编码去录制视频
  20.         }
  21.  
  22.  
  23.         @Override
  24.         public void onCameraClosed() {
  25.             YYLogUtils.w("CameraListener - onCameraClosed");
  26.         }
  27.  
  28.  
  29.         @Override
  30.         public void onCameraError(Exception e) {
  31.             YYLogUtils.w("CameraListener - onCameraError");
  32.         }
  33.  
  34.  
  35.         @Override
  36.         public void onCameraConfigurationChanged(int cameraID, int displayOrientation) {
  37.             YYLogUtils.w("CameraListener - onCameraConfigurationChanged");
  38.         }
  39.     };

停止与释放的逻辑

  1. @Override
  2.     public void releaseAllCamera() {
  3.         cameraHelper.stop();
  4.         cameraHelper.release();
  5.     }

效果：

02c8dec4b8b2aed70025463dd905f232.jpeg

细啊，真的是太细了，代码太详细了。

三、Camera2 的使用与封装

Camera2 的使用是通过服务获取的，使用起来相对步骤多一些。

这里我们使用 TextureView 来承载画面：

  1. public View initCamera(Context context) {
  2.         mTextureView = new TextureView(context);
  3.         mContext = context;
  4.         mTextureView.setLayoutParams(new ViewGroup.LayoutParams(720, 1280));
  5.         mTextureView.setSurfaceTextureListener(mSurfaceTextureListener);
  6.  
  7.  
  8.         return mTextureView;
  9.     }

同样的逻辑，我们在 TextureView 的回调中启动 Camera2 ：

  1. private TextureView.SurfaceTextureListener mSurfaceTextureListener = new TextureView.SurfaceTextureListener() {
  2.  
  3.  
  4.         @Override
  5.         public void onSurfaceTextureAvailable(SurfaceTexture texture, int width, int height) {
  6.             // 当TextureView可用时，打开摄像头
  7.             YYLogUtils.w("当TextureView可用时,width:" + width + " height:" + height);
  8.  
  9.  
  10.             openCamera(width, height);
  11.         }
  12.  
  13.  
  14.         @Override
  15.         public void onSurfaceTextureSizeChanged(SurfaceTexture texture, int width, int height) {
  16.             // 当TextureView尺寸改变时，更新预览尺寸
  17.             configureTransform(width, height);
  18.         }
  19.  
  20.  
  21.  
  22.  
  23.         @Override
  24.         public boolean onSurfaceTextureDestroyed(SurfaceTexture texture) {
  25.             // 当TextureView销毁时，释放资源
  26.             return true;
  27.         }
  28.  
  29.  
  30.         @Override
  31.         public void onSurfaceTextureUpdated(SurfaceTexture texture) {
  32.             // 监听纹理更新事件
  33.         }
  34.     };
  35.  
  36.  
  37.     private void openCamera(int width, int height) {
  38.         // 获取相机管理器
  39.         mCameraManager = (CameraManager) mContext.getSystemService(Context.CAMERA_SERVICE);
  40.  
  41.  
  42.         // 设置自定义的线程处理
  43.         HandlerThread handlerThread = new HandlerThread("Camera2Manager");
  44.         handlerThread.start();
  45.         mBgHandler = new Handler(handlerThread.getLooper());
  46.         
  47.         try {
  48.  
  49.  
  50.             //获取到相机信息并赋值
  51.             getCameraListCameraCharacteristics(width,height);
  52.  
  53.  
  54.  
  55.  
  56.             YYLogUtils.w("打开的摄像头id:" + mCurrentCameraId);
  57.  
  58.  
  59.             // 打开摄像头
  60.             mCameraManager.openCamera(mCurrentCameraId, new CameraDevice.StateCallback() {
  61.                 @Override
  62.                 public void onOpened(CameraDevice cameraDevice) {
  63.                     // 当摄像头打开时，创建预览会话
  64.                     mCameraDevice = cameraDevice;
  65.                     createCameraPreviewSession(mBgHandler, mTextureView.getWidth(), mTextureView.getHeight());
  66.                 }
  67.  
  68.  
  69.                 @Override
  70.                 public void onDisconnected(CameraDevice cameraDevice) {
  71.                     if (mCameraDevice != null) {
  72.                         mCameraDevice.close();
  73.                         mCameraDevice = null;
  74.                     }
  75.                 }
  76.  
  77.  
  78.                 @Override
  79.                 public void onError(CameraDevice cameraDevice, int error) {
  80.                     if (mCameraDevice != null) {
  81.                         mCameraDevice.close();
  82.                         mCameraDevice = null;
  83.                     }
  84.                 }
  85.  
  86.  
  87.             }, mBgHandler);
  88.  
  89.  
  90.         } catch (CameraAccessException e) {
  91.             e.printStackTrace();
  92.         }
  93.     }

这里我们使用的 mBgHandler 我们使用的主线程，其实在子线程中更好，这里只用作展示而已（具体的后面工具类会给出）。

我们继续往下走，打开相机之后需要创建预览的会话，创建预览Surface，并且在预览会话回调中发起预览请求：

  1. /**
  2.      * 创建相机预览会话
  3.      */
  4.     private void createCameraPreviewSession(Handler handler, int width, int height) {
  5.         try {
  6.             // 获取SurfaceTexture并设置默认缓冲区大小
  7.             SurfaceTexture texture = mTextureView.getSurfaceTexture();
  8.             texture.setDefaultBufferSize(mTextureView.getWidth(), mTextureView.getHeight());
  9.  
  10.  
  11.             // 创建预览Surface
  12.             Surface surface = new Surface(texture);
  13.  
  14.  
  15.             // 创建CaptureRequest.Builder并设置预览Surface为目标
  16.             mPreviewRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
  17.             mPreviewRequestBuilder.addTarget(surface);
  18.  
  19.  
  20.             // 创建ImageReader并设置回调
  21.             YYLogUtils.w("创建ImageReader并设置回调,width:" + width + " height:" + height);
  22. //            mImageReader = ImageReader.newInstance(mTextureView.getWidth(), mTextureView.getHeight(), ImageFormat.JPEG, 1);
  23.             mImageReader = ImageReader.newInstance(width, height, ImageFormat.YUV_420_888, 2);
  24.             mImageReader.setOnImageAvailableListener(mOnImageAvailableListener, handler);
  25.  
  26.  
  27.             // 将ImageReader的Surface添加到CaptureRequest.Builder中
  28.             Surface readerSurface = mImageReader.getSurface();
  29.             mPreviewRequestBuilder.addTarget(readerSurface);
  30.  
  31.  
  32.             // 创建预览会话
  33.             mCameraDevice.createCaptureSession(Arrays.asList(surface, readerSurface), mSessionCallback, handler);
  34.  
  35.  
  36.         } catch (CameraAccessException e) {
  37.             e.printStackTrace();
  38.         }
  39.     }
  40.  
  41.  
  42.  
  43.  
  44.     private CameraCaptureSession.StateCallback mSessionCallback = new CameraCaptureSession.StateCallback() {
  45.  
  46.  
  47.         @Override
  48.         public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
  49.             // 预览会话已创建成功，开始预览
  50.             mPreviewSession = cameraCaptureSession;
  51.             updatePreview();
  52.         }
  53.  
  54.  
  55.         @Override
  56.         public void onConfigureFailed(@NonNull CameraCaptureSession cameraCaptureSession) {
  57.             ToastUtils.INSTANCE.makeText(mContext, "Failed to create camera preview session");
  58.         }
  59.     };
  60.  
  61.  
  62.     private void updatePreview() {
  63.         try {
  64.             // 设置自动对焦模式
  65.             mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
  66.  
  67.  
  68.             // 构建预览请求
  69.             mPreviewRequest = mPreviewRequestBuilder.build();
  70.  
  71.  
  72.             // 发送预览请求
  73.             mPreviewSession.setRepeatingRequest(mPreviewRequest, null, null);
  74.         } catch (CameraAccessException e) {
  75.             e.printStackTrace();
  76.         }
  77.     }
  78.  
  79.  
  80.     private ImageReader.OnImageAvailableListener mOnImageAvailableListener = new ImageReader.OnImageAvailableListener() {
  81.  
  82.  
  83.         @Override
  84.         public void onImageAvailable(ImageReader reader) {
  85.         
  86.             // YUV_420 格式
  87.             Image image = reader.acquireLatestImage();
  88.             saveImage(bytes);
  89.             
  90.             image.close();
  91.         }
  92.     };

可以看到，Camera2 的基本使用比起 Camera1 来说复杂了不少，这里还是省略了一些旋转角度，预览方向，最佳尺寸等逻辑的代码（后面工具类会给出）。所以难怪谷歌要出 CameraX，自己都看不下去了呗。

当然，我们封装一下之后使用起来也是很简单的，看我的工具类。

这里分别不同的实例提供，一种是基本的预览，一种是AllSize的裁剪模式，一种是提供了 ImageReader 帧回调的终极模式。

这里真的不能全部贴出来，不然代码太多，大家可以看文章底部的源码查看。所以这里贴出的是关键代码：

由于 Camera2 的很多操作都推荐在子线程处理，这里先定义子线程的 Loop 与 Handler ：

  1. public abstract class BaseMessageLoop {
  2.  
  3.  
  4.     private volatile MsgHandlerThread mHandlerThread;
  5.     private volatile Handler mHandler;
  6.     private String mName;
  7.  
  8.  
  9.     public BaseMessageLoop(Context context, String name) {
  10.         mName = name;
  11.     }
  12.  
  13.  
  14.     public MsgHandlerThread getHandlerThread() {
  15.         return mHandlerThread;
  16.     }
  17.  
  18.  
  19.     public Handler getHandler() {
  20.         return mHandler;
  21.     }
  22.  
  23.  
  24.     public void Run() {
  25.         Quit();
  26.         //LogUtil.v(TAG,  mName + " HandlerThread Run");
  27.         synchronized (this) {
  28.             mHandlerThread = new MsgHandlerThread(mName);
  29.             mHandlerThread.start();
  30.             mHandler = new Handler(mHandlerThread.getLooper(), mHandlerThread);
  31.         }
  32.     }
  33.  
  34.  
  35.     public void Quit() {
  36.         //LogUtil.v(TAG,  mName + " HandlerThread Quit");
  37.         synchronized (this) {
  38.             if (mHandlerThread != null) {
  39.                 mHandlerThread.quit();
  40.             }
  41.  
  42.  
  43.             if (mHandler != null) {
  44.                 mHandler.removeCallbacks(mHandlerThread);
  45.             }
  46.  
  47.  
  48.             mHandlerThread = null;
  49.             mHandler = null;
  50.         }
  51.     }
  52.  
  53.  
  54.     ...
  55. }

基本的预览提供：

  1. public class BaseCommonCameraProvider extends BaseCameraProvider {
  2.     protected Activity mContext;
  3.     protected String mCameraId;
  4.     protected Handler mCameraHandler;
  5.     private final BaseMessageLoop mThread;
  6.     protected CameraDevice mCameraDevice;
  7.     protected CameraCaptureSession session;
  8.     protected AspectTextureView[] mTextureViews;
  9.     protected CameraManager cameraManager;
  10.  
  11.  
  12.     protected OnCameraInfoListener mCameraInfoListener;
  13.  
  14.  
  15.     public interface OnCameraInfoListener {
  16.         void getBestSize(Size outputSizes);
  17.  
  18.  
  19.         void onFrameCannback(Image image);
  20.  
  21.  
  22.         void initEncode();
  23.  
  24.  
  25.         void onSurfaceTextureAvailable(SurfaceTexture surfaceTexture, int width, int height);
  26.     }
  27.  
  28.  
  29.     public void setCameraInfoListener(OnCameraInfoListener cameraInfoListener) {
  30.         this.mCameraInfoListener = cameraInfoListener;
  31.     }
  32.  
  33.  
  34.     protected BaseCommonCameraProvider(Activity mContext) {
  35.         this.mContext = mContext;
  36.  
  37.  
  38.         mThread = new BaseMessageLoop(mContext, "camera") {
  39.             @Override
  40.             protected boolean recvHandleMessage(Message msg) {
  41.                 return false;
  42.             }
  43.         };
  44.         mThread.Run();
  45.  
  46.  
  47.         mCameraHandler = mThread.getHandler();
  48.  
  49.  
  50.         cameraManager = (CameraManager) mContext.getSystemService(Context.CAMERA_SERVICE);
  51.     }
  52.  
  53.  
  54.     protected String getCameraId(boolean useFront) {
  55.         try {
  56.             for (String cameraId : cameraManager.getCameraIdList()) {
  57.                 CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId);
  58.                 int cameraFacing = characteristics.get(CameraCharacteristics.LENS_FACING);
  59.                 if (useFront) {
  60.                     if (cameraFacing == CameraCharacteristics.LENS_FACING_FRONT) {
  61.                         return cameraId;
  62.                     }
  63.                 } else {
  64.                     if (cameraFacing == CameraCharacteristics.LENS_FACING_BACK) {
  65.                         return cameraId;
  66.                     }
  67.                 }
  68.             }
  69.         } catch (CameraAccessException e) {
  70.             e.printStackTrace();
  71.         }
  72.  
  73.  
  74.         return null;
  75.     }
  76.  
  77.  
  78.     protected Size getCameraBestOutputSizes(String cameraId, Class clz) {
  79.         try {
  80.             //拿到支持的全部Size,并从大到小排序
  81.             CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId);
  82.             StreamConfigurationMap configs = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
  83.             List<Size> sizes = Arrays.asList(configs.getOutputSizes(clz));
  84.             Collections.sort(sizes, new Comparator<Size>() {
  85.                 @Override
  86.                 public int compare(Size o1, Size o2) {
  87.                     return o1.getWidth() * o1.getHeight() - o2.getWidth() * o2.getHeight();
  88.                 }
  89.             });
  90.             Collections.reverse(sizes);
  91.             YYLogUtils.w("all_sizes:" + sizes);
  92.  
  93.  
  94.             //去除一些不合适的预览尺寸
  95.             List<Size> suitableSizes = new ArrayList();
  96.             for (int i = 0; i < sizes.size(); i++) {
  97.                 Size option = sizes.get(i);
  98.                 if (textureViewSize.getWidth() > textureViewSize.getHeight()) {
  99.                     if (option.getWidth() >= textureViewSize.getWidth() && option.getHeight() >= textureViewSize.getHeight()) {
  100.                         suitableSizes.add(option);
  101.                     }
  102.                 } else {
  103.                     if (option.getWidth() >= textureViewSize.getHeight() && option.getHeight() >= textureViewSize.getWidth()) {
  104.                         suitableSizes.add(option);
  105.                     }
  106.                 }
  107.             }
  108.  
  109.  
  110.             YYLogUtils.w("suitableSizes:" + suitableSizes);
  111.  
  112.  
  113.             //获取最小占用的Size
  114.             if (!suitableSizes.isEmpty()) {
  115.                 return suitableSizes.get(suitableSizes.size() - 1);
  116.             } else {
  117.                 //异常情况下只能找默认的了
  118.                 return sizes.get(0);
  119.             }
  120.  
  121.  
  122.         } catch (CameraAccessException e) {
  123.             e.printStackTrace();
  124.         }
  125.  
  126.  
  127.         return null;
  128.     }
  129.  
  130.  
  131.     protected List<Size> getCameraAllSizes(String cameraId, int format) {
  132.         try {
  133.             CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId);
  134.             StreamConfigurationMap configs = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
  135.             return Arrays.asList(configs.getOutputSizes(format));
  136.         } catch (CameraAccessException e) {
  137.             e.printStackTrace();
  138.         }
  139.  
  140.  
  141.         return null;
  142.     }
  143.  
  144.  
  145.     protected void releaseCameraDevice(CameraDevice cameraDevice) {
  146.         if (cameraDevice != null) {
  147.             cameraDevice.close();
  148.             cameraDevice = null;
  149.         }
  150.     }
  151.  
  152.  
  153.     protected void releaseCameraSession(CameraCaptureSession session) {
  154.         if (session != null) {
  155.             session.close();
  156.             session = null;
  157.         }
  158.     }
  159.  
  160.  
  161.     protected void releaseCamera() {
  162.         releaseCameraDevice(mCameraDevice);
  163.         releaseCameraSession(session);
  164.     }
  165. }

对内部的一些监听与回调做了抽取，内部对切换镜头，支持的Size选择，等做了一些实现，这样简单的就能实现预览的操作。

我们常用的应该是可以裁切拉伸的 TextureView , 这里单独对它做一个预览的处理：

  1. /**
  2.  * 只用于预览，没有帧回调
  3.  */
  4. public class Camera2AllSizeProvider extends BaseCommonCameraProvider {
  5.     private CaptureRequest.Builder mPreviewBuilder;
  6.     private Size outputSize;
  7.  
  8.  
  9.     public Camera2AllSizeProvider(Activity mContext) {
  10.         super(mContext);
  11.         Point displaySize = new Point();
  12.         mContext.getWindowManager().getDefaultDisplay().getSize(displaySize);
  13.         screenSize = new Size(displaySize.x, displaySize.y);
  14.     }
  15.  
  16.  
  17.     private void initCamera() {
  18.         mCameraId = getCameraId(false);//默认使用后置相机
  19.         //获取指定相机的输出尺寸列表，降序排序
  20.         outputSize = getCameraBestOutputSizes(mCameraId, SurfaceTexture.class);
  21.         //初始化预览尺寸
  22.         previewSize = outputSize;
  23.         YYLogUtils.w("previewSize,width:" + previewSize.getWidth() + "height:" + previewSize.getHeight());
  24.  
  25.  
  26.         if (mCameraInfoListener != null) {
  27.             mCameraInfoListener.getBestSize(outputSize);
  28.         }
  29.     }
  30.  
  31.  
  32.     int index = 0;
  33.  
  34.  
  35.     /**
  36.      * 关联并初始化TextTure
  37.      */
  38.     public void initTexture(AspectTextureView... textureViews) {
  39.  
  40.  
  41.         mTextureViews = textureViews;
  42.         int size = textureViews.length;
  43.         for (AspectTextureView aspectTextureView : textureViews) {
  44.             aspectTextureView.setSurfaceTextureListener(new Camera2SimpleInterface.SimpleSurfaceTextureListener() {
  45.                 @Override
  46.                 public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
  47.                     textureViewSize = new Size(width, height);
  48.                     YYLogUtils.w("textureViewSize,width:" + textureViewSize.getWidth() + "height:" + textureViewSize.getHeight());
  49.                     YYLogUtils.w("screenSize,width:" + screenSize.getWidth() + "height:" + screenSize.getHeight());
  50.                     if (++index == size) {
  51.                         initCamera();
  52.                         openCamera();
  53.                     }
  54.                 }
  55.             });
  56.         }
  57.     }
  58.  
  59.  
  60.     @SuppressLint("MissingPermission")
  61.     private void openCamera() {
  62.         try {
  63.  
  64.  
  65.             cameraManager.openCamera(mCameraId, mStateCallback, mCameraHandler);
  66.  
  67.  
  68.         } catch (CameraAccessException e) {
  69.             e.printStackTrace();
  70.         }
  71.     }
  72.  
  73.  
  74.     private final CameraDevice.StateCallback mStateCallback = new Camera2SimpleInterface.SimpleCameraDeviceStateCallback() {
  75.         @Override
  76.         public void onOpened(CameraDevice camera) {
  77.             mCameraDevice = camera;
  78.  
  79.  
  80.             MediaCodecList allMediaCodecLists = new MediaCodecList(-1);
  81.             MediaCodecInfo avcCodecInfo = null;
  82.             for (MediaCodecInfo mediaCodecInfo : allMediaCodecLists.getCodecInfos()) {
  83.                 if (mediaCodecInfo.isEncoder()) {
  84.                     String[] supportTypes = mediaCodecInfo.getSupportedTypes();
  85.                     for (String supportType : supportTypes) {
  86.                         if (supportType.equals(MediaFormat.MIMETYPE_VIDEO_AVC)) {
  87.                             avcCodecInfo = mediaCodecInfo;
  88.                             Log.d("TAG", "编码器名称:" + mediaCodecInfo.getName() + "  " + supportType);
  89.                             MediaCodecInfo.CodecCapabilities codecCapabilities = avcCodecInfo.getCapabilitiesForType(MediaFormat.MIMETYPE_VIDEO_AVC);
  90.                             int[] colorFormats = codecCapabilities.colorFormats;
  91.                             for (int colorFormat : colorFormats) {
  92.                                 switch (colorFormat) {
  93.                                     case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV411Planar:
  94.                                     case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV411PackedPlanar:
  95.                                     case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Planar:
  96.                                     case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedPlanar:
  97.                                     case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420SemiPlanar:
  98.                                     case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedSemiPlanar:
  99.                                         Log.d("TAG", "支持的格式::" + colorFormat);
  100.                                         break;
  101.                                 }
  102.                             }
  103.                         }
  104.                     }
  105.                 }
  106.             }
  107.  
  108.  
  109.             //根据什么Size来展示PreView
  110.             startPreviewSession(previewSize);
  111.         }
  112.     };
  113.  
  114.  
  115.     public void startPreviewSession(Size size) {
  116.         YYLogUtils.w("startPreviewSession 真正的Size,width:" + size.getWidth() + " height:" + size.getHeight());
  117.         try {
  118.  
  119.  
  120.             releaseCameraSession(session);
  121.             mPreviewBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
  122.  
  123.  
  124.             List<Surface> outputs = new ArrayList<>();
  125.             for (AspectTextureView aspectTextureView : mTextureViews) {
  126.                 //设置预览大小与展示的裁剪模式
  127.                 aspectTextureView.setScaleType(AspectInterface.ScaleType.FIT_CENTER);
  128.                 aspectTextureView.setSize(size.getHeight(), size.getWidth());
  129.  
  130.  
  131.                 SurfaceTexture surfaceTexture = aspectTextureView.getSurfaceTexture();
  132.                 surfaceTexture.setDefaultBufferSize(size.getWidth(), size.getHeight());
  133.  
  134.  
  135.                 Surface previewSurface = new Surface(surfaceTexture);
  136.                 mPreviewBuilder.addTarget(previewSurface);
  137.                 outputs.add(previewSurface);
  138.             }
  139.  
  140.  
  141.             mCameraDevice.createCaptureSession(outputs, mStateCallBack, mCameraHandler);
  142.  
  143.  
  144.         } catch (CameraAccessException e) {
  145.             e.printStackTrace();
  146.         }
  147.     }
  148.  
  149.  
  150.     private final CameraCaptureSession.StateCallback mStateCallBack = new Camera2SimpleInterface.SimpleStateCallback() {
  151.         @Override
  152.         public void onConfigured(CameraCaptureSession session) {
  153.             try {
  154.  
  155.  
  156.                 Camera2AllSizeProvider.this.session = session;
  157.  
  158.  
  159.                 //设置拍照前持续自动对焦
  160.                 mPreviewBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
  161.  
  162.  
  163.                 CaptureRequest request = mPreviewBuilder.build();
  164.                 session.setRepeatingRequest(request, null, mCameraHandler);
  165.  
  166.  
  167.             } catch (CameraAccessException e) {
  168.                 e.printStackTrace();
  169.             }
  170.         }
  171.     };
  172.  
  173.  
  174.     public void closeCamera() {
  175.         releaseCamera();
  176.         if (mCameraDevice != null) {
  177.             mCameraDevice.close();
  178.         }
  179.     }
  180. }

对于预览的回调，我们可以再做一个单独的实例提供：

  1. /**
  2.  * 在预览的基础上加入ImageReader的帧回调，可以用于编码H264视频流等操作
  3.  */
  4. public class Camera2ImageReaderProvider extends BaseCommonCameraProvider {
  5.     private CaptureRequest.Builder mPreviewBuilder;
  6.     protected ImageReader mImageReader;
  7.     private Size outputSize;
  8.  
  9.  
  10.     public Camera2ImageReaderProvider(Activity mContext) {
  11.         super(mContext);
  12.         Point displaySize = new Point();
  13.         mContext.getWindowManager().getDefaultDisplay().getSize(displaySize);
  14.         screenSize = new Size(displaySize.x, displaySize.y);
  15.         YYLogUtils.w("screenSize,width:" + screenSize.getWidth() + "height:" + screenSize.getHeight(), "Camera2ImageReaderProvider");
  16.     }
  17.  
  18.  
  19.     private void initCamera() {
  20.         mCameraId = getCameraId(false);//默认使用后置相机
  21.         //获取指定相机的输出尺寸列表，降序排序
  22.         outputSize = getCameraBestOutputSizes(mCameraId, SurfaceTexture.class);
  23.         //初始化预览尺寸
  24.         previewSize = outputSize;
  25.         YYLogUtils.w("previewSize,width:" + previewSize.getWidth() + "height:" + previewSize.getHeight(), "Camera2ImageReaderProvider");
  26.  
  27.  
  28.         if (mCameraInfoListener != null) {
  29.             mCameraInfoListener.getBestSize(outputSize);
  30.         }
  31.     }
  32.  
  33.  
  34.     int index = 0;
  35.  
  36.  
  37.     /**
  38.      * 关联并初始化TextTure
  39.      */
  40.     public void initTexture(AspectTextureView... textureViews) {
  41.  
  42.  
  43.         mTextureViews = textureViews;
  44.         int size = textureViews.length;
  45.         for (AspectTextureView aspectTextureView : textureViews) {
  46.             aspectTextureView.setSurfaceTextureListener(new Camera2SimpleInterface.SimpleSurfaceTextureListener() {
  47.                 @Override
  48.                 public void onSurfaceTextureAvailable(SurfaceTexture surfaceTexture, int width, int height) {
  49.                     textureViewSize = new Size(width, height);
  50.                     YYLogUtils.w("textureViewSize,width:" + textureViewSize.getWidth() + "height:" + textureViewSize.getHeight(), "Camera2ImageReaderProvider");
  51.  
  52.  
  53.                     if (mCameraInfoListener != null) {
  54.                         mCameraInfoListener.onSurfaceTextureAvailable(surfaceTexture, width, height);
  55.                     }
  56.  
  57.  
  58.                     if (++index == size) {
  59.                         initCamera();
  60.                         openCamera();
  61.                     }
  62.                 }
  63.             });
  64.         }
  65.     }
  66.  
  67.  
  68.     //初始化编码格式
  69.     public void initEncord() {
  70.         if (mCameraInfoListener != null) {
  71.             mCameraInfoListener.initEncode();
  72.         }
  73.     }
  74.  
  75.  
  76.     @SuppressLint("MissingPermission")
  77.     private void openCamera() {
  78.         try {
  79.  
  80.  
  81.             cameraManager.openCamera(mCameraId, mStateCallback, mCameraHandler);
  82.  
  83.  
  84.         } catch (CameraAccessException e) {
  85.             e.printStackTrace();
  86.         }
  87.     }
  88.  
  89.  
  90.     private final CameraDevice.StateCallback mStateCallback = new Camera2SimpleInterface.SimpleCameraDeviceStateCallback() {
  91.         @Override
  92.         public void onOpened(CameraDevice camera) {
  93.             mCameraDevice = camera;
  94.             initEncord();
  95.  
  96.  
  97.             MediaCodecList allMediaCodecLists = new MediaCodecList(-1);
  98.             MediaCodecInfo avcCodecInfo = null;
  99.             for (MediaCodecInfo mediaCodecInfo : allMediaCodecLists.getCodecInfos()) {
  100.                 if (mediaCodecInfo.isEncoder()) {
  101.                     String[] supportTypes = mediaCodecInfo.getSupportedTypes();
  102.                     for (String supportType : supportTypes) {
  103.                         if (supportType.equals(MediaFormat.MIMETYPE_VIDEO_AVC)) {
  104.                             avcCodecInfo = mediaCodecInfo;
  105.                             Log.d("TAG", "编码器名称:" + mediaCodecInfo.getName() + "  " + supportType);
  106.                             MediaCodecInfo.CodecCapabilities codecCapabilities = avcCodecInfo.getCapabilitiesForType(MediaFormat.MIMETYPE_VIDEO_AVC);
  107.                             int[] colorFormats = codecCapabilities.colorFormats;
  108.                             for (int colorFormat : colorFormats) {
  109.                                 switch (colorFormat) {
  110.                                     case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV411Planar:
  111.                                     case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV411PackedPlanar:
  112.                                     case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Planar:
  113.                                     case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedPlanar:
  114.                                     case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420SemiPlanar:
  115.                                     case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedSemiPlanar:
  116.                                         Log.d("TAG", "支持的格式::" + colorFormat);
  117.                                         break;
  118.                                 }
  119.                             }
  120.                         }
  121.                     }
  122.                 }
  123.             }
  124.  
  125.  
  126.             //根据什么Size来展示PreView
  127.             startPreviewSession(previewSize);
  128.         }
  129.     };
  130.  
  131.  
  132.     public void startPreviewSession(Size size) {
  133.         YYLogUtils.w("真正的预览Size,width:" + size.getWidth() + " height:" + size.getHeight(), "Camera2ImageReaderProvider");
  134.  
  135.  
  136.         try {
  137.  
  138.  
  139.             releaseCameraSession(session);
  140.             mPreviewBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
  141.  
  142.  
  143.             List<Surface> outputs = new ArrayList<>();
  144.             for (AspectTextureView aspectTextureView : mTextureViews) {
  145.                 //设置预览大小与展示的裁剪模式
  146.                 aspectTextureView.setScaleType(AspectInterface.ScaleType.FIT_CENTER);
  147.                 aspectTextureView.setSize(size.getHeight(), size.getWidth());
  148.  
  149.  
  150.                 SurfaceTexture surfaceTexture = aspectTextureView.getSurfaceTexture();
  151.                 surfaceTexture.setDefaultBufferSize(size.getWidth(), size.getHeight());
  152.  
  153.  
  154.                 Surface previewSurface = new Surface(surfaceTexture);
  155.                 mPreviewBuilder.addTarget(previewSurface);
  156.                 outputs.add(previewSurface);
  157.             }
  158.  
  159.  
  160.             //这里的回调监听
  161.             mImageReader = ImageReader.newInstance(size.getWidth(), size.getHeight(), ImageFormat.YUV_420_888, 10);
  162.             mImageReader.setOnImageAvailableListener(mOnImageAvailableListener, mCameraHandler);
  163.             Surface readerSurface = mImageReader.getSurface();
  164.             mPreviewBuilder.addTarget(readerSurface);
  165.             outputs.add(readerSurface);
  166.  
  167.  
  168.             mCameraDevice.createCaptureSession(outputs, mStateCallBack, mCameraHandler);
  169.  
  170.  
  171.         } catch (CameraAccessException e) {
  172.             e.printStackTrace();
  173.         }
  174.     }
  175.  
  176.  
  177.     private ImageReader.OnImageAvailableListener mOnImageAvailableListener = new ImageReader.OnImageAvailableListener() {
  178.         @Override
  179.         public void onImageAvailable(ImageReader reader) {
  180.             Image image = reader.acquireLatestImage();
  181.             if (image == null) {
  182.                 return;
  183.             }
  184.  
  185.  
  186.             if (mCameraInfoListener != null) {
  187.                 mCameraInfoListener.onFrameCannback(image);
  188.             }
  189.  
  190.  
  191.             image.close();
  192.         }
  193.     };
  194.  
  195.  
  196.     private final CameraCaptureSession.StateCallback mStateCallBack = new Camera2SimpleInterface.SimpleStateCallback() {
  197.         @Override
  198.         public void onConfigured(CameraCaptureSession session) {
  199.             try {
  200.  
  201.  
  202.                 Camera2ImageReaderProvider.this.session = session;
  203.  
  204.  
  205.                 //设置拍照前持续自动对焦
  206.                 mPreviewBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
  207. //                mPreviewBuilder.set(CaptureRequest.JPEG_ORIENTATION, 90);
  208.  
  209.  
  210.                 CaptureRequest request = mPreviewBuilder.build();
  211.                 session.setRepeatingRequest(request, null, mCameraHandler);
  212.  
  213.  
  214.             } catch (CameraAccessException e) {
  215.                 e.printStackTrace();
  216.             }
  217.         }
  218.     };
  219.  
  220.  
  221.     public void closeCamera() {
  222.         releaseCamera();
  223.  
  224.  
  225.         if (mImageReader != null) {
  226.             mImageReader.close();
  227.         }
  228.         if (mCameraDevice != null) {
  229.             mCameraDevice.close();
  230.         }
  231.     }
  232.  
  233.  
  234. }

关于  Camera2 的尺寸，其实我们要了解的是三种尺寸，当前屏幕尺寸，当前 textureView 尺寸，以及当前预览的尺寸。

比较容易混淆的就是 textureView 尺寸和预览的尺寸，一个是显示控件的尺寸，一个是 Camera 支持的预览尺寸，他们的大小可能相同，但更多的可能是不同，宽高比例也可能不同 ，所以我们才需要居中裁剪或居中展示的方式来预览画面，上文关于这三种尺寸的定义与使用都有详细的注释。

上文的代码中还省略了一些非关键的类与回调，有兴趣可以去源码中查看。（本文结尾有链接）

如何使用？ 定义完成之后我们就可以来一个简单的使用示例：

这里以 H264 的编码为例：

  1. fun setupCamera(activity: Activity, container: ViewGroup) {
  2.  
  3.  
  4.         file = File(CommUtils.getContext().externalCacheDir, "${System.currentTimeMillis()}-record.h264")
  5.         if (!file.exists()) {
  6.             file.createNewFile()
  7.         }
  8.         if (!file.isDirectory) {
  9.             outputStream = FileOutputStream(file, true)
  10.         }
  11.  
  12.  
  13.         val textureView = AspectTextureView(activity)
  14.         textureView.layoutParams = ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)
  15.  
  16.  
  17.         mCamera2Provider = Camera2ImageReaderProvider(activity)
  18.         mCamera2Provider?.initTexture(textureView)
  19.  
  20.  
  21.         mCamera2Provider?.setCameraInfoListener(object :
  22.             BaseCommonCameraProvider.OnCameraInfoListener {
  23.             override fun getBestSize(outputSizes: Size?) {
  24.                 mPreviewSize = outputSizes
  25.             }
  26.  
  27.  
  28.             override fun onFrameCannback(image: Image) {
  29.                 if (isRecording) {
  30.  
  31.  
  32.                     // 使用C库获取到I420格式，对应 COLOR_FormatYUV420Planar
  33.                     val yuvFrame = yuvUtils.convertToI420(image)
  34.                     // 与MediaFormat的编码格式宽高对应
  35.                     val yuvFrameRotate = yuvUtils.rotate(yuvFrame, 90)
  36.  
  37.  
  38.                     // 用于测试RGB图片的回调预览
  39.                     bitmap = Bitmap.createBitmap(yuvFrameRotate.width, yuvFrameRotate.height, Bitmap.Config.ARGB_8888)
  40.                     yuvUtils.yuv420ToArgb(yuvFrameRotate, bitmap!!)
  41.                     mBitmapCallback?.invoke(bitmap)
  42.  
  43.  
  44.                     // 旋转90度之后的I420格式添加到同步队列
  45.                     val bytesFromImageAsType = yuvFrameRotate.asArray()
  46.  
  47.  
  48.                     //使用Java工具类转换Image对象为NV21格式,对应 COLOR_FormatYUV420Flexible
  49. //                    val bytesFromImageAsType = getBytesFromImageAsType(image, Camera2ImageUtils.YUV420SP)
  50.                     originVideoDataList.offer(bytesFromImageAsType)
  51.                 }
  52.             }
  53.  
  54.  
  55.             override fun initEncode() {
  56.                 mediaCodecEncodeToH264()
  57.             }
  58.  
  59.  
  60.             override fun onSurfaceTextureAvailable(surfaceTexture: SurfaceTexture?, width: Int, height: Int) {
  61.                 this@VideoH264RecoderUtils.surfaceTexture = surfaceTexture
  62.             }
  63.         })
  64.  
  65.  
  66.         container.addView(textureView)
  67.     }

由于这里返回的是 YUV420 ，所以这里我们需要转换为 I420 或 NV21 格式。这里我分别展示了 C 库转为 I420(YUV420) , Java 库转换为 NV21(YUV420SP) 格式。

然后我们就能把 I420 与 NV21 这两种我们常见的格式编码为 H264 文件，而怎么编码反倒不是今天的主题了，只能说方式太多了，这里先略过。

只需要这一个 setupCamera 方法，就能完成绑定，我们在 Activity 中使用即可一行代码设置进去就可以了。

  1. class RecoderVideo1Activity : BaseActivity() {
  2.  
  3.  
  4.     override fun init() {
  5.  
  6.  
  7.        val flContainer = findViewById<FrameLayout>(R.id.fl_container)
  8.  
  9.  
  10.        val videoRecodeUtils = VideoH264RecoderUtils()
  11.  
  12.  
  13.        videoRecodeUtils.setupCamera(this, container)
  14.   
  15.    }
  16.  
  17.  
  18. }

效果：

d9e981e44cc0aee889ff92aa669a46b6.jpeg

四、CameraX 的使用与封装

相比前面两种 API 的使用，CameraX 的使用就简单多了，网上也很多 CameraX 的使用教程，这里我们就快速过一下。

我们初始化 PreviewView 对象，然后添加到我们指定的容器中。

  1. public View initCamera(Context context) {
  2.         mPreviewView = new PreviewView(context);
  3.         mContext = context;
  4.         mPreviewView.setScaleType(PreviewView.ScaleType.FIT_CENTER);
  5.         mPreviewView.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
  6.  
  7.  
  8.         mPreviewView.getViewTreeObserver().addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
  9.             @Override
  10.             public void onGlobalLayout() {
  11.                 if (mPreviewView.isShown()) {
  12.                     startCamera();
  13.                 }
  14.                 mPreviewView.getViewTreeObserver().removeOnGlobalLayoutListener(this);
  15.             }
  16.         });
  17.  
  18.  
  19.         return mPreviewView;
  20.     }

其次我们就可以启动相机并绑定到生命周期。

  1. private void startCamera() {
  2.  
  3.  
  4.         //获取屏幕的分辨率
  5.         DisplayMetrics displayMetrics = new DisplayMetrics();
  6.         mPreviewView.getDisplay().getRealMetrics(displayMetrics);
  7.         //获取宽高比
  8.         int screenAspectRatio = aspectRatio(displayMetrics.widthPixels, displayMetrics.heightPixels);
  9.  
  10.  
  11.         int rotation = mPreviewView.getDisplay().getRotation();
  12.  
  13.  
  14.         ListenableFuture<ProcessCameraProvider> cameraProviderFuture = ProcessCameraProvider.getInstance(mContext);
  15.         cameraProviderFuture.addListener(() -> {
  16.             try {
  17.                 //获取相机信息
  18.                 mCameraProvider = cameraProviderFuture.get();
  19.  
  20.  
  21.                 //镜头选择
  22.                 mLensFacing = getLensFacing();
  23.                 mCameraSelector = new CameraSelector.Builder().requireLensFacing(mLensFacing).build();
  24.  
  25.  
  26.                 //预览对象
  27.                 Preview.Builder previewBuilder = new Preview.Builder()
  28.                         .setTargetAspectRatio(screenAspectRatio)
  29.                         .setTargetRotation(rotation);
  30.                 Preview preview = previewBuilder.build();
  31.  
  32.  
  33.                 preview.setSurfaceProvider(mPreviewView.getSurfaceProvider());
  34.  
  35.  
  36.                 //录制视频对象
  37.                 mVideoCapture = new VideoCapture.Builder()
  38.                         .setTargetAspectRatio(screenAspectRatio)  //设置高宽比
  39.                         .setAudioRecordSource(MediaRecorder.AudioSource.MIC) //设置音频源麦克风
  40.                         .setTargetRotation(rotation)
  41.                         //视频帧率
  42.                         .setVideoFrameRate(30)
  43.                         //bit率
  44.                         .setBitRate(3 * 1024 * 1024)
  45.                         .build();
  46.  
  47.  
  48. //                ImageAnalysis imageAnalysis = new ImageAnalysis.Builder()
  49. //                        .setTargetAspectRatio(screenAspectRatio)
  50. //                        .setTargetRotation(rotation)
  51. //                        .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
  52. //                        .build();
  53. //
  54. //                // 在每一帧上应用颜色矩阵
  55. //                imageAnalysis.setAnalyzer(Executors.newSingleThreadExecutor(), new MyAnalyzer(mContext));
  56.  
  57.  
  58.                 //开启CameraX
  59.                 mCameraProvider.unbindAll();
  60.  
  61.  
  62.                 if (mContext instanceof FragmentActivity) {
  63.                     FragmentActivity fragmentActivity = (FragmentActivity) mContext;
  64.                     mCameraProvider.bindToLifecycle(fragmentActivity, mCameraSelector, preview, mVideoCapture/*,imageAnalysis*/);
  65.                 }
  66.  
  67.  
  68.  
  69.  
  70.             } catch (ExecutionException | InterruptedException e) {
  71.                 e.printStackTrace();
  72.             }
  73.  
  74.  
  75.         }, ContextCompat.getMainExecutor(mContext));
  76.  
  77.  
  78.     }

这里我们使用了四个用例，预览，拍照，录制，分析。但是我们注释了分析用例，因为录制与分析这两个用例是不能同时使用的。

录制视频的话，我们就能直接使用录制用例的方法就能录制，这是最简单的。

  1. public void startCameraRecord() {
  2.         if (mVideoCapture == null) return;
  3.  
  4.  
  5.         VideoCapture.OutputFileOptions outputFileOptions = new VideoCapture.OutputFileOptions.Builder(getOutFile()).build();
  6.  
  7.  
  8.         mVideoCapture.startRecording(outputFileOptions, mExecutorService, new VideoCapture.OnVideoSavedCallback() {
  9.             @Override
  10.             public void onVideoSaved(@NonNull VideoCapture.OutputFileResults outputFileResults) {
  11.  
  12.  
  13.                 YYLogUtils.w("视频保存成功,outputFileResults:" + outputFileResults.getSavedUri());
  14.  
  15.  
  16.                 if (mCameraCallback != null) mCameraCallback.takeSuccess();
  17.             }
  18.  
  19.  
  20.             @Override
  21.             public void onError(int videoCaptureError, @NonNull String message, @Nullable Throwable cause) {
  22.                 YYLogUtils.e(message);
  23.             }
  24.         });
  25.     }

内部一些镜头选择，比例选择等代码省略了，在下面的工具类中会给出。

可以看到虽然 CameraX 的使用已经是够简单的了，但是由于都是一些重复的代码，我们还是可以对其做一些封装，代码如下：

  1. class CameraXController {
  2.  
  3.  
  4.     private var mCameraProvider: ProcessCameraProvider? = null
  5.     private var mLensFacing = 0
  6.     private var mCameraSelector: CameraSelector? = null
  7.     private var mVideoCapture: VideoCapture? = null
  8.     private var mCameraCallback: ICameraCallback? = null
  9.     private val mExecutorService = Executors.newSingleThreadExecutor()
  10.  
  11.  
  12.     //初始化 CameraX 相关配置
  13.     fun setUpCamera(context: Context, surfaceProvider: Preview.SurfaceProvider) {
  14.  
  15.  
  16.         //获取屏幕的分辨率与宽高比
  17.         val displayMetrics = context.resources.displayMetrics
  18.         val screenAspectRatio = aspectRatio(displayMetrics.widthPixels, displayMetrics.heightPixels)
  19.  
  20.  
  21.         val cameraProviderFuture = ProcessCameraProvider.getInstance(context)
  22.  
  23.  
  24.         cameraProviderFuture.addListener({
  25.  
  26.  
  27.             mCameraProvider = cameraProviderFuture.get()
  28.  
  29.  
  30.             //镜头选择
  31.             mLensFacing = lensFacing
  32.             mCameraSelector = CameraSelector.Builder().requireLensFacing(mLensFacing).build()
  33.  
  34.  
  35.             //预览对象
  36.             val preview: Preview = Preview.Builder()
  37.                 .setTargetAspectRatio(screenAspectRatio)
  38.                 .build()
  39.  
  40.  
  41.             preview.setSurfaceProvider(surfaceProvider)
  42.  
  43.  
  44.  
  45.  
  46.             //录制视频对象
  47.             mVideoCapture = VideoCapture.Builder()
  48.                 .setTargetAspectRatio(screenAspectRatio)
  49.                 .setAudioRecordSource(MediaRecorder.AudioSource.MIC) //设置音频源麦克风
  50.                 //视频帧率
  51.                 .setVideoFrameRate(30)
  52.                 //bit率
  53.                 .setBitRate(3 * 1024 * 1024)
  54.                 .build()
  55.  
  56.  
  57.             //绑定到页面
  58.             mCameraProvider?.unbindAll()
  59.             val camera = mCameraProvider?.bindToLifecycle(
  60.                 context as LifecycleOwner,
  61.                 mCameraSelector!!,
  62.                 mVideoCapture,
  63.                 preview
  64.             )
  65.  
  66.  
  67.             val cameraInfo = camera?.cameraInfo
  68.             val cameraControl = camera?.cameraControl
  69.  
  70.  
  71.         }, ContextCompat.getMainExecutor(context))
  72.     }
  1. //根据屏幕宽高比设置预览比例为4:3还是16:9
  2.     private fun aspectRatio(widthPixels: Int, heightPixels: Int): Int {
  3.         val previewRatio = Math.max(widthPixels, heightPixels).toDouble() / Math.min(widthPixels, heightPixels).toDouble()
  4.         return if (Math.abs(previewRatio - 4.0 / 3.0) <= Math.abs(previewRatio - 16.0 / 9.0)) {
  5.             AspectRatio.RATIO_4_3
  6.         } else {
  7.             AspectRatio.RATIO_16_9
  8.         }
  9.     }
  10.  
  11.  
  12.     //优先选择哪一个摄像头镜头
  13.     private val lensFacing: Int
  14.         private get() {
  15.             if (hasBackCamera()) {
  16.                 return CameraSelector.LENS_FACING_BACK
  17.             }
  18.             return if (hasFrontCamera()) {
  19.                 CameraSelector.LENS_FACING_FRONT
  20.             } else -1
  21.         }
  22.  
  23.  
  24.     //是否有后摄像头
  25.     private fun hasBackCamera(): Boolean {
  26.         if (mCameraProvider == null) {
  27.             return false
  28.         }
  29.         try {
  30.             return mCameraProvider!!.hasCamera(CameraSelector.DEFAULT_BACK_CAMERA)
  31.         } catch (e: CameraInfoUnavailableException) {
  32.             e.printStackTrace()
  33.         }
  34.         return false
  35.     }
  36.  
  37.  
  38.     //是否有前摄像头
  39.     private fun hasFrontCamera(): Boolean {
  40.         if (mCameraProvider == null) {
  41.             return false
  42.         }
  43.         try {
  44.             return mCameraProvider!!.hasCamera(CameraSelector.DEFAULT_BACK_CAMERA)
  45.         } catch (e: CameraInfoUnavailableException) {
  46.             e.printStackTrace()
  47.         }
  48.         return false
  49.     }
  50.  
  51.  
  52.  
  53.  
  54.     // 开始录制
  55.     fun startCameraRecord(outFile: File) {
  56.         mVideoCapture ?: return
  57.  
  58.  
  59.         val outputFileOptions: VideoCapture.OutputFileOptions = VideoCapture.OutputFileOptions.Builder(outFile).build()
  60.  
  61.  
  62.         mVideoCapture!!.startRecording(outputFileOptions, mExecutorService, object : VideoCapture.OnVideoSavedCallback {
  63.             override fun onVideoSaved(outputFileResults: VideoCapture.OutputFileResults) {
  64.                 YYLogUtils.w("视频保存成功,outputFileResults:" + outputFileResults.savedUri)
  65.                 mCameraCallback?.takeSuccess()
  66.             }
  67.  
  68.  
  69.             override fun onError(videoCaptureError: Int, message: String, cause: Throwable?) {
  70.                 YYLogUtils.e(message)
  71.             }
  72.         })
  73.     }
  74.  
  75.  
  76.     // 停止录制
  77.     fun stopCameraRecord(cameraCallback: ICameraCallback?) {
  78.         mCameraCallback = cameraCallback
  79.         mVideoCapture?.stopRecording()
  80.     }
  81.  
  82.  
  83.     // 释放资源
  84.     fun releseAll() {
  85.         mVideoCapture?.stopRecording()
  86.         mExecutorService.shutdown()
  87.         mCameraProvider?.unbindAll()
  88.         mCameraProvider?.shutdown()
  89.         mCameraProvider = null
  90.     }
  91. }

对与封装之后的工具类来说，使用起来就更简单了：

  1. override fun initCamera(context: Context): View {
  2.         mPreviewView = PreviewView(context)
  3.         mContext = context
  4.         mPreviewView.layoutParams = ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)
  5.  
  6.  
  7.         mPreviewView.viewTreeObserver.addOnGlobalLayoutListener(object : OnGlobalLayoutListener {
  8.             override fun onGlobalLayout() {
  9.                 if (mPreviewView.isShown) {
  10.                     startCamera()
  11.                 }
  12.                 mPreviewView.viewTreeObserver.removeOnGlobalLayoutListener(this)
  13.             }
  14.         })
  15.  
  16.  
  17.         return mPreviewView
  18.     }
  19.  
  20.  
  21.     private fun startCamera() {
  22.         cameraXController.setUpCamera(mContext, mPreviewView.surfaceProvider)
  23.     }

如果想开启视频录制：

  1. override fun startCameraRecord() {
  2.         cameraXController.startCameraRecord(outFile)
  3.     }

同时 CameraX 自身就自带裁剪功能，也不需要我们自定义 TextureView 实现了。

居中显示与居中裁剪的效果如下：

2212dd87c897d8834ecdf07a17754934.jpeg

7278856531b9bb360e36aa81dab4f7d1.jpeg

太好了，使用起来真的是超级简单，兼容性也很好，爱了爱了。

总结

本文对于常见的三种 Camera API 做了示例代码及其对于分别进行封装。对于使用哪一种 Camera 实现效果，大家可以自行选择。

如果我想要回调 NV21 的数据，其实我会选择 Camera1 ,因为它本身返回就是这个格式不需要转换，如果我想要回调 I420 格式，我会选择 Camera2 或 CameraX ，反正需要转换，他们更方便，特别是配合 libyuv 库，效率会更高。

如果想实现录制视频的功能呢？如果是普通的录制我会选择 CameraX 自带的录制视频功能，更加的简单方便。如果是特效的录制，那么我会选择 Camera2 或 CameraX 配合 GLSurfaceView 实现。因为他们性能更好。

是的摊牌了，我就是喜欢 CameraX ，别的 CameraX 能实现的不能实现的，它都能实现，使用还简单，兼容性还更高，不得不爱。（一些个人的观点与喜好大家可以无视，反正三个 API 都能用，自己选择即可）

本文中如果贴出的代码有不全的，可以点击源码打开项目进行查看，传送门。同时你也可以关注我的开源项目，后续会持续更新。

关于如何录制视频的问题，有哪几种方法？，优缺点？ 后期会单独再出文章做出介绍。

惯例，我如有讲解不到位或错漏的地方，希望同学们可以指出。有疑问也可以评论区交流。虽然我也不一定会 - -|

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/639515
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。