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

Android 使用Camera2 实现拍照录像的功能_android camera2

作者：我家小花儿 | 2024-05-19 04:53:42

赞

踩

android camera2

职场小白迷上优美句子:

还是电影  《无问西东》中的台词，这句有点感人：

沈光耀的妈妈对沈光耀说："当初你离家千里，来到这个地方读书，你父亲和我都没有反对过，因为，是我们想你，能享受到人生的乐趣，比如读万卷书行万里路，比如同你喜欢的女孩子结婚生子。注意不是给我增添子孙，而是你自己，能够享受为人父母的乐趣，你一生所要追求的功名利禄，没有什么是你的祖上没经历过的，那些只不过是人生的幻光。我怕，你还没想好怎么过这一生，你的命就没了啊！"

推荐两篇对Camera2的讲解非常详细的博客 

新根 - - - Android Camera2 API和拍照与录像过程

Camera2.0新API下的摄像头预览、原始图像数据获取等_黄政的博客-CSDN博客


效果图:

 源码地址：

github开源相机Camera2源码https://github.com/13767004362/Camera2App.git

拍照操作类代码：

  1. public class PictureOperater extends BaseCamera2Operator {
  2.     private static final String TAG = PictureOperater.class.getSimpleName();
  3.     private WorkThreadUtils workThreadManager;
  4.     /**
  5.      * 相机最大的预览宽度
  6.      */
  7.     private static final int MAX_PREVIEW_WIDTH = 1920;
  8.     /**
  9.      * 相机最大的预览高度
  10.      */
  11.     private static final int MAX_PREVIEW_HEIGHT = 1080;
  12.     /**
  13.      * 处理静态图片的输出
  14.      */
  15.     private ImageReader imageReader;
  16.     /**
  17.      * 相机传感器方向
  18.      */
  19.     private int mSensorOrientation;
  20.     /**
  21.      * 相机预览的大小Size
  22.      */
  23.     private Size mPreviewSize;
  24.     /**
  25.      * 是否支持自动对焦
  26.      */
  27.     private boolean mAutoFocusSupported;
  28.     /**
  29.      * 是否支持闪光灯
  30.      */
  31.     private boolean mFlashSupported;
  32.     /**
  33.      * 相机的Id
  34.      */
  35.     private String mCameraId;
  36.  
  37.     /**
  38.      * 预览请求的Builder
  39.      */
  40.     private CaptureRequest.Builder mPreviewRequestBuilder;
  41.     /**
  42.      * 预览的请求
  43.      */
  44.     private CaptureRequest mPreviewRequest;
  45.     private CameraCaptureSession mCaptureSession;
  46.     /**
  47.      * 开启相机的锁住时间
  48.      */
  49.     private final int LOCK_TIME = 2500;
  50.  
  51.     private Camera2Manager camera2Manager;
  52.  
  53.     /**
  54.      * 最小的焦距
  55.      */
  56.     private float minimalFocalDistance = 0;
  57.     /**
  58.      * 最大的数字变焦值，缩放值
  59.      */
  60.     private float maxZoom = 0;
  61.  
  62.  
  63.     public PictureOperater(Camera2Manager camera2Manager) {
  64.         this.camera2Manager = camera2Manager;
  65.         this.workThreadManager = camera2Manager.getWorkThreadManager();
  66.     }
  67.  
  68.     @Override
  69.     public void startOperate() {
  70.  
  71.         TextureView textureView = getTextureView();
  72.         if (textureView.isAvailable()) {
  73.             openCamera(getTextureViewContext(), textureView.getWidth(), textureView.getHeight());
  74.         } else {
  75.             textureView.setSurfaceTextureListener(mSurfaceTextureListener);
  76.         }
  77.     }
  78.  
  79.     @Override
  80.     public void stopOperate() {
  81.          Log.i(TAG, TAG+" 关闭相机的操作 ");
  82.         closeCamera();
  83.     }
  84.  
  85.     @Override
  86.     public void openCamera(Activity activity, int width, int height) {
  87.         if (PermissionsManager.checkCameraPermission(activity)) {
  88.             setUpCameraOutputs(activity, width, height);
  89.             configureTransform(activity, width, height);
  90.             CameraManager manager = (CameraManager) activity.getSystemService(Context.CAMERA_SERVICE);
  91.             try {
  92.                 //打开相机需要一定时间，因锁住2.5秒，防止程序退出关闭相机
  93.                 if (!mCameraOpenCloseLock.tryAcquire(LOCK_TIME, TimeUnit.MILLISECONDS)) {
  94.                     throw new RuntimeException("Time out waiting to lock camera opening.");
  95.                 }
  96.                 manager.openCamera(mCameraId, stateCallback, workThreadManager.getBackgroundHandler());
  97.             } catch (CameraAccessException e) {
  98.                 e.printStackTrace();
  99.             } catch (InterruptedException e) {
  100.                 throw new RuntimeException("Interrupted while trying to lock camera opening.", e);
  101.             }
  102.         }
  103.     }
  104.  
  105.     @Override
  106.     public void closePreviewSession() {
  107.         if (mCaptureSession != null) {
  108.             mCaptureSession.close();
  109.             mCaptureSession = null;
  110.         }
  111.     }
  112.  
  113.     @Override
  114.     public void configureTransform(Activity activity, int viewWidth, int viewHeight) {
  115.         if (null == getTextureView() || null == mPreviewSize || null == activity) {
  116.             return;
  117.         }
  118.         int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
  119.         Matrix matrix = new Matrix();
  120.         RectF viewRect = new RectF(0, 0, viewWidth, viewHeight);
  121.         RectF bufferRect = new RectF(0, 0, mPreviewSize.getHeight(), mPreviewSize.getWidth());
  122.         float centerX = viewRect.centerX();
  123.         float centerY = viewRect.centerY();
  124.         if (Surface.ROTATION_90 == rotation || Surface.ROTATION_270 == rotation) {
  125.             bufferRect.offset(centerX - bufferRect.centerX(), centerY - bufferRect.centerY());
  126.             matrix.setRectToRect(viewRect, bufferRect, Matrix.ScaleToFit.FILL);
  127.             float scale = Math.max((float) viewHeight / mPreviewSize.getHeight(), (float) viewWidth / mPreviewSize.getWidth());
  128.             matrix.postScale(scale, scale, centerX, centerY);
  129.             matrix.postRotate(90 * (rotation - 2), centerX, centerY);
  130.         } else if (Surface.ROTATION_180 == rotation) {
  131.             matrix.postRotate(180, centerX, centerY);
  132.         }
  133.         getTextureView().setTransform(matrix);
  134.     }
  135.  
  136.     @Override
  137.     public void writePictureData(Image image) {
  138.         if (camera2ResultCallBack != null) {
  139.             camera2ResultCallBack.callBack(ObservableBuilder.createWriteCaptureImage(appContext, image));
  140.         }
  141.     }
  142.  
  143.     @Override
  144.     public void startPreView() {
  145.         //开启相机预览界面
  146.         createCameraPreviewSession();
  147.     }
  148.  
  149.     @Override
  150.     public void cameraClick() {
  151.  
  152.         takePicture();
  153.     }
  154.  
  155.     /**
  156.      * 关闭当前的相机设备，释放资源
  157.      */
  158.     private void closeCamera() {
  159.         try {
  160.             mCameraOpenCloseLock.acquire();
  161.             closePreviewSession();
  162.             if (null != mCameraDevice) {
  163.                 mCameraDevice.close();
  164.                 mCameraDevice = null;
  165.             }
  166.             if (null != imageReader) {
  167.                 imageReader.close();
  168.                 imageReader = null;
  169.             }
  170.         } catch (InterruptedException e) {
  171.             throw new RuntimeException("Interrupted while trying to lock camera closi" + "ng.", e);
  172.         } finally {
  173.             mCameraOpenCloseLock.release();
  174.         }
  175.     }
  176.  
  177.     /**
  178.      * 拍照
  179.      */
  180.     public void takePicture() {
  181.         ToastUtils.showToast(camera2Manager.getContext()," 客官，请别抖动，正在拍照中。");
  182.         if (mAutoFocusSupported) {
  183.             Log.i(TAG,TAG+"支持自动调焦，正在锁住焦点");
  184.             lockFocus();
  185.         } else {//设备不支持自动对焦，则直接拍照。
  186.             Log.i(TAG,TAG+"不支持自动调焦，直接拍照");
  187.             captureStillPicture();
  188.         }
  189.     }
  190.  
  191.     /**
  192.      * 拍照的第一步，锁住焦点。
  193.      */
  194.     private void lockFocus() {
  195.         try {
  196.             //告诉相机，这里已经锁住焦点
  197.             mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_START);
  198.             // 标识，正在进行拍照动作
  199.             mState = STATE_WAITING_LOCK;
  200.             //进行拍照处理
  201.             mCaptureSession.capture(mPreviewRequestBuilder.build(), mCaptureCallback, workThreadManager.getBackgroundHandler());
  202.         } catch (CameraAccessException e) {
  203.             e.printStackTrace();
  204.         }
  205.     }
  206.  
  207.     /**
  208.      * 相机开始预览，创建一个CameraCaptureSession对象
  209.      */
  210.     private void createCameraPreviewSession() {
  211.         try {
  212.             SurfaceTexture texture = getTextureView().getSurfaceTexture();
  213.             //assert断言表达式，为true继续。
  214.             assert texture != null;
  215.  
  216.             // We configure the size of default buffer to be the size of camera preview we want.
  217.             texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight());
  218.  
  219.             // 创建一个预览界面需要用到的Surface对象
  220.             Surface surface = new Surface(texture);
  221.  
  222.             // 将CaptureRequest的构建器与Surface对象绑定在一起
  223.             mPreviewRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
  224.             mPreviewRequestBuilder.addTarget(surface);
  225.  
  226.             // 为相机预览，创建一个CameraCaptureSession对象
  227.             mCameraDevice.createCaptureSession(Arrays.asList(surface, imageReader.getSurface()), new CameraCaptureSession.StateCallback() {
  228.                 @Override
  229.                 public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
  230.                     // 相机已经关闭
  231.                     if (null == mCameraDevice) {
  232.                         return;
  233.                     }
  234.                     //当cameraCaptureSession已经准备完成，开始显示预览界面
  235.                     mCaptureSession = cameraCaptureSession;
  236.                     setCameraCaptureSession();
  237.                 }
  238.  
  239.                 @Override
  240.                 public void onConfigureFailed(@NonNull CameraCaptureSession cameraCaptureSession) {
  241.                     //配置失败
  242.                 }
  243.             }, null);
  244.         } catch (CameraAccessException e) {
  245.             e.printStackTrace();
  246.         }
  247.     }
  248.  
  249.  
  250.     /**
  251.      * 设置CameraCaptureSession的特征:
  252.      * <p>
  253.      * 自动对焦，闪光灯
  254.      */
  255.     private void setCameraCaptureSession() {
  256.         try {
  257.             setFocus(mPreviewRequestBuilder);
  258.             //若是需要则开启，闪光灯
  259.             setAutoFlash(mPreviewRequestBuilder);
  260.             // 最后，开启相机预览界面的显示
  261.             mPreviewRequest = mPreviewRequestBuilder.build();
  262.             //为CameraCaptureSession设置复用的CaptureRequest。
  263.             mCaptureSession.setRepeatingRequest(mPreviewRequest, mCaptureCallback, workThreadManager.getBackgroundHandler());
  264.         } catch (CameraAccessException e) {
  265.             e.printStackTrace();
  266.         }
  267.     }
  268.  
  269.     private float currentZoom;
  270.  
  271.     @Override
  272.     public void notifyFocusState() {
  273.         if (mPreviewRequestBuilder != null) {
  274.             try {
  275.                 currentZoom = maxZoom * camera2Manager.getZoomProportion();
  276.                 setZoom(currentZoom);
  277.             } catch (Exception e) {
  278.                 e.printStackTrace();
  279.             }
  280.         }
  281.     }
  282.  
  283.     private Rect zoomRect;
  284.  
  285.     private void setZoom(float currentZoom) {
  286.         try {
  287.             zoomRect=createZoomReact();
  288.             if (zoomRect==null){
  289.                 Log.i(TAG, "相机不支持 zoom " );
  290.                 return ;
  291.             }
  292.             mPreviewRequestBuilder.set(CaptureRequest.SCALER_CROP_REGION,zoomRect);
  293.             mPreviewRequest = mPreviewRequestBuilder.build();
  294.             Log.i(TAG, " 最大缩放值 " + maxZoom + " 设置缩放值 " + currentZoom );
  295.             //为CameraCaptureSession设置复用的CaptureRequest。
  296.             mCaptureSession.setRepeatingRequest(mPreviewRequest, mCaptureCallback, workThreadManager.getBackgroundHandler());
  297.         } catch (Exception e) {
  298.             e.printStackTrace();
  299.         }
  300.     }
  301.  
  302.     /**
  303.      * 计算出zoom所对应的裁剪区域
  304.      * @return
  305.      */
  306.     private Rect createZoomReact() {
  307.         if (currentZoom==0){
  308.             return null;
  309.         }
  310.         try {
  311.             Rect rect = cameraCharacteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE);
  312.             if (rect==null){
  313.                 return null;
  314.             }
  315.             zoomRect =Camera2Utils.createZoomRect(rect,currentZoom);
  316.             Log.i(TAG, "zoom对应的 rect对应的区域 " + zoomRect.left + " " + zoomRect.right + " " + zoomRect.top + " " + zoomRect.bottom);
  317.         } catch (Exception e) {
  318.             e.printStackTrace();
  319.         }
  320.         return zoomRect;
  321.     }
  322.  
  323.     /**
  324.      * -
  325.      * 设置调焦方式：自动连续对焦还是手动调焦
  326.      *
  327.      * @param requestBuilder
  328.      */
  329.     private void setFocus(CaptureRequest.Builder requestBuilder) {
  330. /*        if (camera2Manager.isManualFocus()) {
  331.             float focusDistance = minimum_focus_distance * camera2Manager.getZoomProportion();
  332.             setManualFocus(requestBuilder, focusDistance);
  333.         } else {
  335.         }*/
  336.         setAutoFocus(requestBuilder);
  337.     }
  338.  
  339.     /**
  340.      * 设置连续自动对焦
  341.      *
  342.      * @param requestBuilder
  343.      */
  344.     private void setAutoFocus(CaptureRequest.Builder requestBuilder) {
  345.         if (requestBuilder != null) {
  346.             //为相机预览设置连续对焦。
  347.             requestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
  348.         }
  349.     }
  350.  
  351.     /**
  352.      * 设置手动对焦，设置焦距值
  353.      *
  354.      * @param requestBuilder
  355.      */
  356.     private void setManualFocus(CaptureRequest.Builder requestBuilder, float distance) {
  357.         //若是机器不支持焦距设置，则需要检查。
  358.         try {
  359.             if (requestBuilder != null) {
  360.                 //先关闭自动对焦的模式
  361.                 requestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CameraMetadata.CONTROL_AE_MODE_OFF);
  362.                 requestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CameraMetadata.CONTROL_AF_MODE_OFF);
  363.                 Log.i(TAG, "手动调焦的 " + distance + " 最大范围值是 " + minimum_focus_distance);
  364.                 //设置焦距值
  365.                 requestBuilder.set(CaptureRequest.LENS_FOCUS_DISTANCE, distance);
  366.             }
  367.         } catch (Exception e) {
  368.             e.printStackTrace();
  369.         }
  370.  
  371.     }
  372.  
  373.     /**
  374.      * Camera state: Showing camera preview.
  375.      * 相机预览状态
  376.      */
  377.     private static final int STATE_PREVIEW = 0;
  378.  
  379.     /**
  380.      * Camera state: Waiting for the focus to be locked.
  381.      * <p>
  382.      * 相机拍照，被锁住，等待焦点状态
  383.      */
  384.     private static final int STATE_WAITING_LOCK = 1;
  385.  
  386.     /**
  387.      * Camera state: Waiting for the exposure to be precapture state.
  388.      */
  389.     private static final int STATE_WAITING_PRECAPTURE = 2;
  390.  
  391.     /**
  392.      * Camera state: Waiting for the exposure state to be something other than precapture.
  393.      */
  394.     private static final int STATE_WAITING_NON_PRECAPTURE = 3;
  395.  
  396.     /**
  397.      * Camera state: Picture was taken.
  398.      * 图片已经获取
  399.      */
  400.     private static final int STATE_PICTURE_TAKEN = 4;
  401.  
  402.     /**
  403.      * The current state of camera state for taking pictures.
  404.      *
  405.      * @see #mCaptureCallback
  406.      */
  407.     private int mState = STATE_PREVIEW;
  408.     /**
  409.      * CameraCaptureSession.CaptureCallback : 处理捕获到的JPEG事件。
  410.      */
  411.     private CameraCaptureSession.CaptureCallback mCaptureCallback = new CameraCaptureSession.CaptureCallback() {
  412.         private void process(CaptureResult result) {
  413.             switch (mState) {
  414.                 //正常预览状态
  415.                 case STATE_PREVIEW: {
  416.                     break;
  417.                 }
  418.                 //刚开始拍照，锁住，等待状态
  419.                 case STATE_WAITING_LOCK: {
  420.                     //当前自动对焦的状态
  421.                     Integer afState = result.get(CaptureResult.CONTROL_AF_STATE);
  422.                     if (afState == null) {
  423.                         captureStillPicture();
  424.                     } else if (CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED == afState || CaptureResult.CONTROL_AF_STATE_NOT_FOCUSED_LOCKED == afState) {
  425.                         // CONTROL_AE_STATE can be null on some devices
  426.                         Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
  427.                         if (aeState == null || aeState == CaptureResult.CONTROL_AE_STATE_CONVERGED) {
  428.                             mState = STATE_PICTURE_TAKEN;
  429.                             captureStillPicture();
  430.                         } else {
  431.                             runPrecaptureSequence();
  432.                         }
  433.                     }else{
  434.                         mState = STATE_PICTURE_TAKEN;
  435.                         captureStillPicture();
  436.                     }
  437.                     break;
  438.                 }
  439.                 //等待，预捕获
  440.                 case STATE_WAITING_PRECAPTURE: {
  441.                     // CONTROL_AE_STATE can be null on some devices
  442.                     Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
  443.                     if (aeState == null || aeState == CaptureResult.CONTROL_AE_STATE_PRECAPTURE || aeState == CaptureRequest.CONTROL_AE_STATE_FLASH_REQUIRED) {
  444.                         mState = STATE_WAITING_NON_PRECAPTURE;
  445.                     }
  446.                     break;
  447.                 }
  448.                 //已经完成预捕获，直接拍照。
  449.                 case STATE_WAITING_NON_PRECAPTURE: {
  450.                     // CONTROL_AE_STATE can be null on some devices
  451.                     Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
  452.                     if (aeState == null || aeState != CaptureResult.CONTROL_AE_STATE_PRECAPTURE) {
  453.                         mState = STATE_PICTURE_TAKEN;
  454.                         captureStillPicture();
  455.                     }
  456.                     break;
  457.  
  458.                 }
  459.                 default:
  460.                     break;
  461.             }
  462.         }
  463.  
  464.         @Override
  465.         public void onCaptureProgressed(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull CaptureResult partialResult) {
  466.             process(partialResult);
  467.         }
  468.  
  469.         @Override
  470.         public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
  471.             process(result);
  472.         }
  473.     };
  474.  
  475.     /**
  476.      * <p>
  477.      * 运行预捕获的序列，为捕获一个静态图片
  478.      */
  479.     private void runPrecaptureSequence() {
  480.         try {
  481.             // 告诉相机，这里触发.
  482.             mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER, CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER_START);
  483.             //设置成预捕获状态，将需等待。
  484.             mState = STATE_WAITING_PRECAPTURE;
  485.             mCaptureSession.capture(mPreviewRequestBuilder.build(), mCaptureCallback, workThreadManager.getBackgroundHandler());
  486.         } catch (CameraAccessException e) {
  487.             e.printStackTrace();
  488.         }
  489.     }
  490.  
  491.     /**
  492.      * 拍照一个静态的图片
  493.      * ,当在CaptureCallback监听器响应的时候调用该方法。
  494.      * <p>
  495.      * 当数字调焦缩放的时候，在写入图片数中也要设置。
  496.      */
  497.     private void captureStillPicture() {
  498.         try {
  499.             final Activity activity = getTextureViewContext();
  500.             if (null == activity || null == mCameraDevice) {
  501.                 return;
  502.             }
  503.             // 创建一个拍照的CaptureRequest.Builder
  504.             final CaptureRequest.Builder captureBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
  505.  
  506.             captureBuilder.addTarget(imageReader.getSurface());
  507.             // 使用相同的AE和AF模式作为预览.
  508.              captureBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
  509.  
  510.             //让相机中缩放效果和图片保持一致
  511.             //   zoomRect=createZoomReact();
  512.             if (zoomRect != null) {
  513.                 Log.i(TAG," 拍照 添加裁剪区域 "+zoomRect.toString());
  514.                 captureBuilder.set(CaptureRequest.SCALER_CROP_REGION, zoomRect);
  515.             }
  516.             setAutoFlash(captureBuilder);
  517.             // 方向
  518.             int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
  519.             captureBuilder.set(CaptureRequest.JPEG_ORIENTATION, Camera2Utils.getOrientation(ORIENTATIONS, mSensorOrientation, rotation));
  520.             CameraCaptureSession.CaptureCallback captureCallback = new CameraCaptureSession.CaptureCallback() {
  521.                 @Override
  522.                 public void onCaptureCompleted(@NonNull CameraCaptureSession session
  523.                         , @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
  524.                     //拍照完成，进行释放焦点操作。
  525.                     unlockFocus();
  526.                 }
  527.             };
  528.             //先停止以前的预览状态
  529.             mCaptureSession.stopRepeating();
  530.             mCaptureSession.abortCaptures();
  531.             //执行拍照状态
  532.             mCaptureSession.capture(captureBuilder.build(), captureCallback, null);
  533.         } catch (CameraAccessException e) {
  534.             e.printStackTrace();
  535.         }
  536.     }
  537.  
  538.     /**
  539.      * 完成一些列拍照后，释放焦点。
  540.      */
  541.     private void unlockFocus() {
  542.         try {
  543.             // 重置一系列的对焦
  544.             mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, CameraMetadata.CONTROL_AF_TRIGGER_CANCEL);
  545.             setAutoFlash(mPreviewRequestBuilder);
  546.             mCaptureSession.capture(mPreviewRequestBuilder.build(), mCaptureCallback, workThreadManager.getBackgroundHandler());
  547.             // 恢复正常状态
  548.             mState = STATE_PREVIEW;
  549.             mCaptureSession.setRepeatingRequest(mPreviewRequest, mCaptureCallback, workThreadManager.getBackgroundHandler());
  550.             Log.i(TAG, TAG+" 拍照完成，释放焦点  unlockFocus() ");
  551.         } catch (CameraAccessException e) {
  552.             e.printStackTrace();
  553.         }
  554.     }
  555.  
  556.     /**
  557.      * 设置是否开启闪光灯
  558.      *
  559.      * @param requestBuilder
  560.      */
  561.     private void setAutoFlash(CaptureRequest.Builder requestBuilder) {
  562.         if (mFlashSupported) {
  563.             requestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
  564.         }
  565.     }
  566.  
  567.     /**
  568.      * 获取到最大的焦距值
  569.      */
  570.     private float minimum_focus_distance;
  571.     /**
  572.      * 获取相机参数的类
  573.      */
  574.     private CameraCharacteristics cameraCharacteristics;
  575.  
  576.     /**
  577.      * 设置Camera的相关参数变量，长、宽，且返回相机的Id.
  578.      *
  579.      * @param width
  580.      * @param height
  581.      */
  582.     private void setUpCameraOutputs(Activity activity, int width, int height) {
  583.         CameraManager manager = (CameraManager) getTextureViewContext().getSystemService(Context.CAMERA_SERVICE);
  584.         try {
  585.             //获取到可用的相机
  586.             for (String cameraId : manager.getCameraIdList()) {
  587.                 //获取到每个相机的参数对象，包含前后摄像头，分辨率等
  588.                 cameraCharacteristics = manager.getCameraCharacteristics(cameraId);
  589.                 if (!Camera2Utils.matchCameraDirection(cameraCharacteristics, currentDirection)) {
  590.                     continue;
  591.                 }
  592.                 //存储流配置类
  593.                 StreamConfigurationMap map = cameraCharacteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
  594.                 if (map == null) {
  595.                     continue;
  596.                 }
  597.                 //检查设备,是否支持自动对焦
  598.                 mAutoFocusSupported = Camera2Utils.checkAutoFocus(cameraCharacteristics);
  599.                 //获取最小焦距值。
  600.                 Float minFocalDistance = Camera2Utils.getMinimumFocusDistance(cameraCharacteristics);
  601.                 if (minFocalDistance != null) {
  602.                     minimum_focus_distance = minFocalDistance;
  603.                 }
  604.  
  605.                 Float maxZoomValue = Camera2Utils.getMaxZoom(cameraCharacteristics);
  606.                 if (maxZoomValue != null) {
  607.                     maxZoom = maxZoomValue;
  608.                 }
  609.                 Log.i(TAG, (currentDirection == CameraCharacteristics.LENS_FACING_BACK ? "后" : "前") + " 摄像头 " + " 是否支持自动对焦 " + mAutoFocusSupported + " 获取到焦距的最大值 " + minimum_focus_distance + " 最大的缩放值 " + maxZoom);
  610.                 //对于静态图片，使用可用的最大值来拍摄。
  611.                 Size largest = Collections.max(Arrays.asList(map.getOutputSizes(ImageFormat.JPEG)), new CompareSizeByArea());
  612.                 //设置ImageReader,将大小，图片格式
  613.                 imageReader = ImageReader.newInstance(largest.getWidth(), largest.getHeight(), ImageFormat.JPEG, /*maxImages*/2);
  614.                 imageReader.setOnImageAvailableListener(onImageAvailableListener, workThreadManager.getBackgroundHandler());
  615.                 //获取到屏幕的旋转角度，进一步判断是否，需要交换维度来获取预览大小
  616.                 int displayRotation = activity.getWindowManager().getDefaultDisplay().getRotation();
  617.                 //获取相机传感器方向
  618.                 mSensorOrientation = cameraCharacteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
  619.                 boolean swappedDimensions = false;
  620.                 switch (displayRotation) {
  621.                     case Surface.ROTATION_0:
  622.                     case Surface.ROTATION_180:
  623.                         if (mSensorOrientation == 90 || mSensorOrientation == 270) {
  624.                             swappedDimensions = true;
  625.                         }
  626.                         break;
  627.                     case Surface.ROTATION_90:
  628.                     case Surface.ROTATION_270:
  629.                         if (mSensorOrientation == 0 || mSensorOrientation == 180) {
  630.                             swappedDimensions = true;
  631.                         }
  632.                         break;
  633.                     default:
  634.                         Log.e(TAG, "Display rotation is invalid: " + displayRotation);
  635.                 }
  636.                 Point displaySize = new Point();
  637.                 activity.getWindowManager().getDefaultDisplay().getSize(displaySize);
  638.                 int rotatedPreviewWidth = width;
  639.                 int rotatedPreviewHeight = height;
  640.                 int maxPreviewWidth = displaySize.x;
  641.                 int maxPreviewHeight = displaySize.y;
  642.                 //当角度反了的时候
  643.                 if (swappedDimensions) {
  644.                     rotatedPreviewWidth = height;
  645.                     rotatedPreviewHeight = width;
  646.                     maxPreviewWidth = displaySize.y;
  647.                     maxPreviewHeight = displaySize.x;
  648.                 }
  649.                 if (maxPreviewWidth > MAX_PREVIEW_WIDTH) {
  650.                     maxPreviewWidth = MAX_PREVIEW_WIDTH;
  651.                 }
  652.                 if (maxPreviewHeight > MAX_PREVIEW_HEIGHT) {
  653.                     maxPreviewHeight = MAX_PREVIEW_HEIGHT;
  654.                 }
  655.                 mPreviewSize = Camera2Utils.chooseOptimalSize(map.getOutputSizes(SurfaceTexture.class),
  656.                         rotatedPreviewWidth, rotatedPreviewHeight, maxPreviewWidth,
  657.                         maxPreviewHeight, largest, new CompareSizeByArea());
  658.                 // 计算出来的预览大小，设置成TextureView宽高.
  659.                 int orientation = activity.getResources().getConfiguration().orientation;
  660.                 AutoFitTextureView mTextureView = (AutoFitTextureView) getTextureView();
  661.                 //横屏
  662.                 if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
  663.                     mTextureView.setAspectRatio(mPreviewSize.getWidth(), mPreviewSize.getHeight());
  664.                 } else {
  665.                     mTextureView.setAspectRatio(mPreviewSize.getHeight(), mPreviewSize.getWidth());
  666.                 }
  667.                 // 检查，相机是否支持闪光。
  668.                 Boolean available = cameraCharacteristics.get(CameraCharacteristics.FLASH_INFO_AVAILABLE);
  669.                 mFlashSupported = available == null ? false : available;
  670.                 mCameraId = cameraId;
  671.                 // Log.i(TAG, " 根据相机的前后摄像头" + mCameraId + " 方向是：" + currentDirection);
  672.                 return;
  673.             }
  674.         } catch (Exception e) {
  675.             e.printStackTrace();
  676.             //不支持该设备
  677.             if (e instanceof NullPointerException) {
  678.                 ToastUtils.showToast(appContext, "设备不支持Camera2 API");
  679.             }
  680.         }
  681.     }
  682.  
  683.  
  684. }

录像操作类代码：

  1. public class VideoRecordOperator extends BaseCamera2Operator {
  2.     public static final String TAG = VideoRecordOperator.class.getSimpleName();
  3.     private WorkThreadUtils workThreadManager;
  4.  
  5.     /**
  6.      * 视频录制的大小
  7.      */
  8.     private Size mVideoSize;
  9.     /**
  10.      * 相机预览的大小Size
  11.      */
  12.     private Size mPreviewSize;
  13.     /**
  14.      * MediaRecorder
  15.      */
  16.     private MediaRecorder mMediaRecorder;
  17.     /**
  18.      * 当前是否是在录制视频
  19.      */
  20.     private boolean mIsRecordingVideo;
  21.     /**
  22.      * 传感器的方向
  23.      */
  24.     private Integer mSensorOrientation;
  25.     /**
  26.      * 相机预览请求的Builder
  27.      */
  28.     private CaptureRequest.Builder mPreviewBuilder;
  29.     /**
  30.      * 点击开启录制时候创建的新视频文件路径
  31.      */
  32.     private String mNextVideoAbsolutePath;
  33.     private CompositeSubscription compositeSubscription;
  34.  
  35.     private Camera2Manager camera2Manager;
  36.  
  37.     public VideoRecordOperator(Camera2Manager camera2Manager) {
  38.         this.camera2Manager = camera2Manager;
  39.         this.workThreadManager = camera2Manager.getWorkThreadManager();
  40.         this.oldVideoPath = new CopyOnWriteArrayList<>();
  41.         this.compositeSubscription = new CompositeSubscription();
  42.     }
  43.  
  44.     @Override
  45.     public void writePictureData(Image image) {
  46.  
  47.     }
  48.  
  49.     /**
  50.      * 开始相机的预览界面，创建一个预览的session会话。
  51.      */
  52.     @Override
  53.     public void startPreView() {
  54.         TextureView mTextureView = getTextureView();
  55.         if (null == mCameraDevice || !mTextureView.isAvailable() || null == mPreviewSize) {
  56.             return;
  57.         }
  58.         //开始相机预览
  59.         try {
  60.             closePreviewSession();
  61.             SurfaceTexture texture = mTextureView.getSurfaceTexture();
  62.             assert texture != null;
  63.             texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight());
  64.             mPreviewBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
  65.             Surface previewSurface = new Surface(texture);
  66.             mPreviewBuilder.addTarget(previewSurface);
  67.             //从拍照切换到摄像头，获取录像完成后需要重新恢复以前的状态
  68.             float currentZoom = camera2Manager.getZoomProportion() * maxZoom;
  69.             updateZoomRect(currentZoom);
  70.             mCameraDevice.createCaptureSession(Collections.singletonList(previewSurface),
  71.                     new CameraCaptureSession.StateCallback() {
  72.                         @Override
  73.                         public void onConfigured(@NonNull CameraCaptureSession session) {
  74.                             mPreviewSession = session;
  75.                             updatePreview();
  76.                         }
  77.  
  78.                         @Override
  79.                         public void onConfigureFailed(@NonNull CameraCaptureSession session) {
  80.                             Activity activity = getTextureViewContext();
  81.                             if (null != activity) {
  82.                                 Toast.makeText(activity, "相机预览配置失败", Toast.LENGTH_SHORT).show();
  83.                             }
  84.                         }
  85.                     }, workThreadManager.getBackgroundHandler());
  86.         } catch (CameraAccessException e) {
  87.             e.printStackTrace();
  88.         }
  89.         if (null != mTextureView) {
  90.             configureTransform(getTextureViewContext(), mTextureView.getWidth(), mTextureView.getHeight());
  91.         }
  92.     }
  93.  
  94.     /**
  95.      * 在 startPreView()之后执行用于更新相机预览界面
  96.      */
  97.     private void updatePreview() {
  98.         if (null == mCameraDevice) {
  99.             return;
  100.         }
  101.         try {
  102.             setUpCaptureRequestBuilder(mPreviewBuilder);
  103.             mPreviewSession.setRepeatingRequest(mPreviewBuilder.build(), null, workThreadManager.getBackgroundHandler());
  104.         } catch (CameraAccessException e) {
  105.             e.printStackTrace();
  106.         }
  107.     }
  108.  
  109.     private void setUpCaptureRequestBuilder(CaptureRequest.Builder builder) {
  110.         builder.set(CaptureRequest.CONTROL_MODE, CameraMetadata.CONTROL_MODE_AUTO);
  111.     }
  112.  
  113.  
  114.     /**
  115.      * 为相机创建一个CameraCaptureSession
  116.      */
  117.     private CameraCaptureSession mPreviewSession;
  118.  
  119.     @Override
  120.     public void closePreviewSession() {
  121.         if (mPreviewSession != null) {
  122.             mPreviewSession.close();
  123.             mPreviewSession = null;
  124.         }
  125.     }
  126.  
  127.  
  128.     @Override
  129.  
  130.  
  131.     public void cameraClick() {
  132.         if (mIsRecordingVideo) {
  133.             stopRecordingVideo(true);
  134.         } else {
  135.             startRecordingVideo();
  136.         }
  137.     }
  138.  
  139.  
  140.  
  141.     /**
  142.      * 停止录制
  143.      */
  144.     private void stopRecordingVideo(final boolean isFinish) {
  145.  
  146.         // UI
  147.         mIsRecordingVideo = false;
  148.         /**
  149.          * 在MediaRecorder停止前，停止相机预览，防止抛出serious error异常。
  150.          *
  151.          * android.hardware.camera2.CameraAccessException: The camera device has encountered a serious error
  152.          *
  153.          * 解决方式：https://stackoverflow.com/questions/27907090/android-camera-2-api
  154.          */
  155.         try {
  156.             mPreviewSession.stopRepeating();
  157.             mPreviewSession.abortCaptures();
  158.         } catch (CameraAccessException e) {
  159.             e.printStackTrace();
  160.         }
  161.         Subscription subscription = Observable
  162.                 //延迟三十毫秒
  163.                 .timer(30, TimeUnit.MICROSECONDS, Schedulers.computation())
  164.                 .observeOn(AndroidSchedulers.mainThread())
  165.                 .subscribe(l -> {
  166.                     // 停止录制
  167.                     mMediaRecorder.stop();
  168.                     mMediaRecorder.reset();
  169.                     if (isFinish) {
  170.                         isRecordGonging = false;
  171.                         Log.i(TAG, "stopRecordingVideo 录制完成");
  172.                         if (camera2VideoRecordCallBack != null) {
  173.                             camera2VideoRecordCallBack.finishRecord();
  174.                         }
  175.                         mergeMultipleFileCallBack();
  176.                         mNextVideoAbsolutePath = null;
  177.                         this.oldVideoPath.clear();
  178.                     } else {//暂停的操作
  179.                         Log.i(TAG, "pauseRecordingVideo 录制暂停");
  180.                         //若是开始新的录制，原本暂停产生的多个文件合并成一个文件。
  181.                         this.oldVideoPath.add(mNextVideoAbsolutePath);
  182.                         if (oldVideoPath.size() > 1) {
  183.                             mergeMultipleFile();
  184.                         }
  185.                         mNextVideoAbsolutePath = null;
  186.                     }
  187.                     startPreView();
  188.                 });
  189.         this.compositeSubscription.add(subscription);
  190.     }
  191.  
  192.     /**
  193.      * 暂停后又从新恢复录制，合并多个视频文件
  194.      */
  195.     private void mergeMultipleFile() {
  196.         Log.i(TAG, " mergeMultipleFile  开始操作：文件个数 " + this.oldVideoPath.size());
  197.         Subscription subscription = ObservableBuilder.createMergeMuiltFile(appContext, this.oldVideoPath.get(0), this.oldVideoPath.get(1))
  198.                 .subscribeOn(Schedulers.io())
  199.                 .observeOn(AndroidSchedulers.mainThread())
  200.                 .subscribe(filePath -> {
  201.                     this.oldVideoPath.clear();
  202.                     this.oldVideoPath.add(filePath);
  203.                     Log.i(TAG, " mergeMultipleFile  完成： 文件个数" + this.oldVideoPath.size());
  204.                 });
  205.         this.compositeSubscription.add(subscription);
  206.     }
  207.  
  208.     /**
  209.      * 完成录制，输出最终的视频录制文件
  210.      */
  211.     private void mergeMultipleFileCallBack() {
  212.         if (this.oldVideoPath.size() > 0) {
  213.             Log.i(TAG, " mergeMultipleFileCallBack 开始操作：文件个数 " + this.oldVideoPath.size());
  214.             Subscription subscription = ObservableBuilder.createMergeMuiltFile(appContext, this.oldVideoPath.get(0), mNextVideoAbsolutePath)
  215.                     .subscribeOn(Schedulers.io())
  216.                     .observeOn(AndroidSchedulers.mainThread())
  217.                     .subscribe(s -> {
  218.                         if (camera2ResultCallBack != null) {
  219.                             camera2ResultCallBack.callBack(ObservableBuilder.createVideo(s));
  220.                         }
  221.                         Log.i(TAG, " mergeMultipleFileCallBack 完成 且回调");
  222.                         ToastUtils.showToast(appContext, "视频文件保存在" + s);
  223.                     });
  224.             this.compositeSubscription.add(subscription);
  225.         } else {
  226.             if (camera2ResultCallBack != null) {
  227.                 camera2ResultCallBack.callBack(ObservableBuilder.createVideo(mNextVideoAbsolutePath));
  228.             }
  229.             ToastUtils.showToast(appContext, "视频文件保存在" + mNextVideoAbsolutePath);
  230.         }
  231.     }
  232.  
  233.     /**
  234.      * 暂停录制
  235.      */
  236.     public void pauseRecordingVideo() {
  237.         stopRecordingVideo(false);
  238.     }
  239.  
  240.     /**
  241.      * 开始视频录制，创建一个录像的session会话。
  242.      */
  243.     private void startRecordingVideo() {
  244.  
  245.         Log.i(TAG, " startRecordingVideo  录制初始化 ");
  246.         TextureView mTextureView = getTextureView();
  247.         if (null == mCameraDevice || !mTextureView.isAvailable() || null == mPreviewSize) {
  248.             return;
  249.         }
  250.  
  251.         try {
  252.             closePreviewSession();
  253.             setUpMediaRecorder();
  254.             SurfaceTexture texture = mTextureView.getSurfaceTexture();
  255.             assert texture != null;
  256.             texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight());
  257.             //创建录制的session会话
  258.             mPreviewBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_RECORD);
  259.             List<Surface> surfaces = new ArrayList<>();
  260.             // 为相机预览设置Surface
  261.             Surface previewSurface = new Surface(texture);
  262.             surfaces.add(previewSurface);
  263.             mPreviewBuilder.addTarget(previewSurface);
  264.             // 为 MediaRecorder设置Surface
  265.             Surface recorderSurface = mMediaRecorder.getSurface();
  266.             surfaces.add(recorderSurface);
  267.             mPreviewBuilder.addTarget(recorderSurface);
  268.             //与未录像的状态保持一致。
  269.             if (zoomRect != null) {
  270.                 mPreviewBuilder.set(CaptureRequest.SCALER_CROP_REGION, zoomRect);
  271.             }
  272.             // Start a capture session
  273.             // Once the session starts, we can update the UI and start recording
  274.             mCameraDevice.createCaptureSession(surfaces, new CameraCaptureSession.StateCallback() {
  275.                 @Override
  276.                 public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
  277.                     mPreviewSession = cameraCaptureSession;
  278.                     updatePreview();
  279.                     Log.i(TAG, " startRecordingVideo  正式开始录制 ");
  280.                     getTextureViewContext().runOnUiThread(() -> {
  281.                         mIsRecordingVideo = true;
  282.                         isRecordGonging = true;
  283.                         mMediaRecorder.start();
  284.                         if (camera2VideoRecordCallBack != null) {
  285.                             camera2VideoRecordCallBack.startRecord();
  286.                         }
  287.                     });
  288.                 }
  289.  
  290.                 @Override
  291.                 public void onConfigureFailed(@NonNull CameraCaptureSession cameraCaptureSession) {
  292.                     Activity activity = getTextureViewContext();
  293.                     if (null != activity) {
  294.                         Toast.makeText(activity.getApplicationContext(), "相机设备配置失败", Toast.LENGTH_SHORT).show();
  295.                     }
  296.                 }
  297.             }, workThreadManager.getBackgroundHandler());
  298.         } catch (CameraAccessException | IOException e) {
  299.             e.printStackTrace();
  300.         }
  301.     }
  302.  
  303.  
  304.     /**
  305.      * 设置媒体录制器的配置参数
  306.      * <p>
  307.      * 音频，视频格式，文件路径，频率，编码格式等等
  308.      *
  309.      * @throws IOException
  310.      */
  311.     private void setUpMediaRecorder() throws IOException {
  312.         final Activity activity = getTextureViewContext();
  313.         if (null == activity) {
  314.             return;
  315.         }
  316.         mMediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
  317.         mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.SURFACE);
  318.         mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.MPEG_4);
  319.         mNextVideoAbsolutePath = FileUtils.createVideoDiskFile(appContext, FileUtils.createVideoFileName()).getAbsolutePath();
  320.         mMediaRecorder.setOutputFile(mNextVideoAbsolutePath);
  321.         mMediaRecorder.setVideoEncodingBitRate(10000000);
  322.         //每秒30帧
  323.         mMediaRecorder.setVideoFrameRate(30);
  324.         mMediaRecorder.setVideoSize(mVideoSize.getWidth(), mVideoSize.getHeight());
  325.         mMediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H264);
  326.         mMediaRecorder.setAudioEncoder(MediaRecorder.AudioEncoder.AAC);
  327.         int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
  328.         switch (mSensorOrientation) {
  329.             case SENSOR_ORIENTATION_DEFAULT_DEGREES:
  330.                 mMediaRecorder.setOrientationHint(DEFAULT_ORIENTATIONS.get(rotation));
  331.                 break;
  332.             case SENSOR_ORIENTATION_INVERSE_DEGREES:
  333.                 mMediaRecorder.setOrientationHint(ORIENTATIONS.get(rotation));
  334.                 break;
  335.             default:
  336.                 break;
  337.         }
  338.         mMediaRecorder.prepare();
  339.     }
  340.  
  341.     private List<String> oldVideoPath;
  342.  
  343.     @Override
  344.     public void startOperate() {
  345.         TextureView textureView = getTextureView();
  346.         if (textureView.isAvailable()) {
  347.             openCamera(getTextureViewContext(), textureView.getWidth(), textureView.getHeight());
  348.         } else {
  349.             textureView.setSurfaceTextureListener(mSurfaceTextureListener);
  350.         }
  351.     }
  352.  
  353.     @Override
  354.     public void stopOperate() {
  355.         try {
  356.             mCameraOpenCloseLock.acquire();
  357.             closePreviewSession();
  358.             if (null != mCameraDevice) {
  359.                 mCameraDevice.close();
  360.                 mCameraDevice = null;
  361.             }
  362.             if (null != mMediaRecorder) {
  363.                 mMediaRecorder.release();
  364.                 mMediaRecorder = null;
  365.             }
  366.  
  367.         } catch (InterruptedException e) {
  368.             throw new RuntimeException("Interrupted while trying to lock camera closing.");
  369.         } finally {
  370.             mCameraOpenCloseLock.release();
  371.         }
  372.     }
  373.  
  374.     private boolean isRecordGonging = false;
  375.  
  376.     /**
  377.      * 是否在进行视频录制，录制状态，包含进行中，暂停中。
  378.      *
  379.      * @return
  380.      */
  381.     public boolean isVideoRecord() {
  382.         return isRecordGonging;
  383.     }
  384.  
  385.     private Rect zoomRect;
  386.  
  387.     /**
  388.      * 更新缩放，数字调焦
  389.      *
  390.      * @param currentZoom
  391.      */
  392.     private void updateZoomRect(float currentZoom) {
  393.         try {
  394.             Rect rect = characteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE);
  395.             if (rect == null) {
  396.                 return;
  397.             }
  398.             zoomRect = Camera2Utils.createZoomRect(rect, currentZoom);
  399.             if (zoomRect == null) {
  400.                 return;
  401.             }
  402.             Log.i(TAG, "zoom对应的 rect对应的区域 " + zoomRect.left + " " + zoomRect.right + " " + zoomRect.top + " " + zoomRect.bottom);
  403.             mPreviewBuilder.set(CaptureRequest.SCALER_CROP_REGION, zoomRect);
  404.  
  405.         } catch (Exception e) {
  406.             e.printStackTrace();
  407.         }
  408.     }
  409.  
  410.     private float maxZoom;
  411.     private CameraCharacteristics characteristics;
  412.  
  413.     @Override
  414.     protected void openCamera(Activity activity, int width, int height) {
  415.         if (PermissionsManager.checkVideoRecordPermission(getTextureViewContext())) {
  416.             if (null == activity || activity.isFinishing()) {
  417.                 return;
  418.             }
  419.  
  420.             AutoFitTextureView textureView = (AutoFitTextureView) getTextureView();
  421.             CameraManager manager = (CameraManager) activity.getSystemService(Context.CAMERA_SERVICE);
  422.             try {
  423.                 Log.d(TAG, "tryAcquire");
  424.                 if (!mCameraOpenCloseLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) {
  425.                     throw new RuntimeException("锁住相机开启，超时");
  426.                 }
  427.                 for (String cameraId : manager.getCameraIdList()) {
  428.                     characteristics = manager.getCameraCharacteristics(cameraId);
  429.                     if (!Camera2Utils.matchCameraDirection(characteristics, currentDirection)) {
  430.                         continue;
  431.                     }
  432.                     //存储流配置类
  433.                     StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
  434.                     if (map == null) {
  435.                         continue;
  436.                     }
  437.                     Log.i(TAG, "视频录制，重新配置相机设备" + currentDirection + " " + cameraId);
  438.                     mSensorOrientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
  439.                     Float maxZoomValue = Camera2Utils.getMaxZoom(characteristics);
  440.                     if (maxZoomValue != null) {
  441.                         maxZoom = maxZoomValue;
  442.                     }
  443.                     // 计算相机预览和视频录制的的Size
  444.                     mVideoSize = Camera2Utils.chooseVideoSize(map.getOutputSizes(MediaRecorder.class));
  445.                     mPreviewSize = Camera2Utils.chooseOptimalSize(map.getOutputSizes(SurfaceTexture.class), width, height, mVideoSize);
  446.                     int orientation = activity.getResources().getConfiguration().orientation;
  447.                     if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
  448.                         textureView.setAspectRatio(mPreviewSize.getWidth(), mPreviewSize.getHeight());
  449.                     } else {
  450.                         textureView.setAspectRatio(mPreviewSize.getHeight(), mPreviewSize.getWidth());
  451.                     }
  452.                     configureTransform(activity, width, height);
  453.                     mMediaRecorder = new MediaRecorder();
  454.                     manager.openCamera(cameraId, stateCallback, null);
  455.                     return;
  456.                 }
  457.             } catch (CameraAccessException e) {
  458.                 ToastUtils.showToast(appContext, "不能访问相机");
  459.                 activity.finish();
  460.             } catch (NullPointerException e) {
  461.                 ToastUtils.showToast(appContext, "当前设备不支持Camera2 API");
  462.             } catch (InterruptedException e) {
  463.                 throw new RuntimeException("在锁住相机开启期间被打断.");
  464.             }
  465.         }
  466.     }
  467.  
  468.     @Override
  469.     protected void configureTransform(Activity activity, int viewWidth, int viewHeight) {
  470.         TextureView textureView = getTextureView();
  471.         if (null == textureView || null == mPreviewSize || null == activity) {
  472.             return;
  473.         }
  474.         int rotation = activity.getWindowManager().getDefaultDisplay().getRotation();
  475.         Matrix matrix = new Matrix();
  476.         RectF viewRect = new RectF(0, 0, viewWidth, viewHeight);
  477.         RectF bufferRect = new RectF(0, 0, mPreviewSize.getHeight(), mPreviewSize.getWidth());
  478.         float centerX = viewRect.centerX();
  479.         float centerY = viewRect.centerY();
  480.         if (Surface.ROTATION_90 == rotation || Surface.ROTATION_270 == rotation) {
  481.             bufferRect.offset(centerX - bufferRect.centerX(), centerY - bufferRect.centerY());
  482.             matrix.setRectToRect(viewRect, bufferRect, Matrix.ScaleToFit.FILL);
  483.             float scale = Math.max((float) viewHeight / mPreviewSize.getHeight(), (float) viewWidth / mPreviewSize.getWidth());
  484.             matrix.postScale(scale, scale, centerX, centerY);
  485.             matrix.postRotate(90 * (rotation - 2), centerX, centerY);
  486.         }
  487.         textureView.setTransform(matrix);
  488.     }
  489.  
  490.     @Override
  491.     public void notifyFocusState() {
  492.         float currentZoom = camera2Manager.getZoomProportion() * maxZoom;
  493.         updateZoomRect(currentZoom);
  494.         updatePreview();
  495.     }
  496.  
  497.     private Camera2VideoRecordCallBack camera2VideoRecordCallBack;
  498.  
  499.     public void setCamera2VideoRecordCallBack(Camera2VideoRecordCallBack camera2VideoRecordCallBack) {
  500.         this.camera2VideoRecordCallBack = camera2VideoRecordCallBack;
  501.     }
  502. }

Fragment中进行调用：

  1. public class CameraFragment extends Fragment implements CameraContract.View<CameraContract.Presenter>
  2.         , View.OnClickListener, RadioGroup.OnCheckedChangeListener
  3.         , VerticalProgressBarLayout.VerticalMoveResultListener {
  4.  
  5.     public static final String TAG = CameraFragment.class.getSimpleName();
  6.     private ImageView show_result_iv;
  7.     private ImageView controller_state_iv;
  8.     private VerticalProgressBarLayout verticalProgressBarLayout;
  9.  
  10.     public static CameraFragment newInstance() {
  11.         CameraFragment cameraFragment = new CameraFragment();
  12.         return cameraFragment;
  13.     }
  14.  
  15.     private AutoFitTextureView textureView;
  16.     private TextView show_record_tv, record_tip_circle;
  17.     private View rootView;
  18.     private CameraContract.Presenter presenter;
  19.     private Animator flashAnimator;
  20.     
  21.     
  22.     @Nullable
  23.     @Override
  24.     public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
  25.         this.rootView = inflater.inflate(R.layout.fragment_camera, container, false);
  26.         initView();
  27.         return this.rootView;
  28.     }
  29.  
  30.     @Override
  31.     public void showToast(String content) {
  32.         ToastUtils.showToastRunUIThread(getActivity(), content);
  33.     }
  34.  
  35.     private void initView() {
  36.         this.textureView = rootView.findViewById(R.id.camera_auto_fit_texture_view);
  37.         this.show_result_iv = rootView.findViewById(R.id.camera_show);
  38.         this.show_record_tv = rootView.findViewById(R.id.camera_video_record_tip_time_tv);
  39.         this.record_tip_circle = rootView.findViewById(R.id.camera_video_record_tip_bg);
  40.         this.rootView.findViewById(R.id.camera_btn).setOnClickListener(this);
  41.         this.verticalProgressBarLayout = rootView.findViewById(R.id.camera_vertical_progress_bar);
  42.         this.controller_state_iv = this.rootView.findViewById(R.id.camera_right_top_controller);
  43.         this.controller_state_iv.setTag(CameraContract.View.MODE_RECORD_FINISH);
  44.         this.controller_state_iv.setOnClickListener(this);
  45.         this.show_result_iv.setOnClickListener(this);
  46.         ((RadioGroup) this.rootView.findViewById(R.id.camera_switch_radioGroup)).setOnCheckedChangeListener(this);
  47.         ((RadioGroup) this.rootView.findViewById(R.id.camera_direction_radioGroup)).setOnCheckedChangeListener(this);
  48.         this.verticalProgressBarLayout.setVerticalMoveResultListener(this);
  49.     }
  50.  
  51.     @Override
  52.     public void onResume() {
  53.         super.onResume();
  54.         if (presenter != null) {
  55.             presenter.onResume();
  56.         }
  57.     }
  58.  
  59.     @Override
  60.     public void onPause() {
  61.         super.onPause();
  62.         if (presenter != null) {
  63.             presenter.onPause();
  64.         }
  65.     }
  66.     
  67.  
  68.     @Override
  69.     public void setPresenter(CameraContract.Presenter presenter) {
  70.         this.presenter = presenter;
  71.     }
  72.  
  73.     @Override
  74.     public TextureView getCameraView() {
  75.         return textureView;
  76.     }
  77.  
  78.     protected String filePath;
  79.  
  80.     @Override
  81.     public void loadPictureResult(String filePath) {
  82.         this.filePath = filePath;
  83.         GlideLoader.loadNetWorkResource(getActivity(), filePath, show_result_iv);
  84.     }
  85.  
  86.     @Override
  87.     public void onClick(View v) {
  88.         switch (v.getId()) {
  89.             //点击按钮，进行拍照或录像
  90.             case R.id.camera_btn:
  91.                 this.presenter.takePictureOrVideo();
  92.                 break;
  93.             // 控制视频录制的开关,包含暂停，恢复录制
  94.             case R.id.camera_right_top_controller:
  95.                 int mode = (int) controller_state_iv.getTag();
  96.                 //录制状态中，可以暂停
  97.                 if (mode == CameraContract.View.MODE_RECORD_START) {
  98.                     this.presenter.stopRecord();
  99.                 }//暂停状态，可以继续开始录制
  100.                 else if (mode == CameraContract.View.MODE_RECORD_STOP) {
  101.                     this.presenter.restartRecord();
  102.                 }
  103.                 break;
  104.             //查看大图
  105.             case R.id.camera_show:
  106.                 if (!TextUtils.isEmpty(filePath)) {
  107.                     PictureActivity.openActivity(getActivity(), filePath);
  108.                 }
  109.                 break;
  110.             default:
  111.                 break;
  112.         }
  113.     }
  114.  
  115.     @Override
  116.     public void setTimingShow(String timing) {
  117.         this.show_record_tv.setText(timing);
  118.     }
  119.  
  120.     @Override
  121.     public void switchRecordMode(int mode) {
  122.         switch (mode) {
  123.             //录制开始
  124.             case CameraContract.View.MODE_RECORD_START:
  125.                 this.show_record_tv.setVisibility(View.VISIBLE);
  126.                 this.record_tip_circle.setVisibility(View.VISIBLE);
  127.                 this.controller_state_iv.setImageResource(R.drawable.camera_stop_iv);
  128.                 if (flashAnimator != null && flashAnimator.isRunning()) {
  129.                     flashAnimator.cancel();
  130.                 }
  131.                 break;
  132.             //录制暂停
  133.             case CameraContract.View.MODE_RECORD_STOP:
  134.                 this.controller_state_iv.setImageResource(R.drawable.camera_start_iv);
  135.                 this.show_record_tv.setVisibility(View.INVISIBLE);
  136.                 flashAnimator = AnimatorBuilder.createFlashAnimator(this.record_tip_circle);
  137.                 flashAnimator.start();
  138.                 break;
  139.             //录制完成
  140.             case CameraContract.View.MODE_RECORD_FINISH:
  141.                 this.show_record_tv.setText("");
  142.                 this.show_record_tv.setVisibility(View.GONE);
  143.                 this.record_tip_circle.setVisibility(View.GONE);
  144.                 this.controller_state_iv.setImageResource(R.drawable.camera_init_iv);
  145.                 break;
  146.             default:
  147.                 break;
  148.         }
  149.         this.controller_state_iv.setTag(mode);
  150.     }
  151.  
  152.     @Override
  153.     public void onCheckedChanged(RadioGroup group, @IdRes int checkedId) {
  154.         switch (checkedId) {
  155.             //切换成录像模式
  156.             case R.id.camera_video_record_btn:
  157.                 this.presenter.switchMode(Constant.MODE_VIDEO_RECORD);
  158.                 break;
  159.             //切换到拍照模式
  160.             case R.id.camera_switch_picture_btn:
  161.                 this.presenter.switchMode(Constant.MODE_CAMERA);
  162.                 break;
  163.             //切换到前摄像头
  164.             case R.id.camera_direction_front:
  165.                 this.presenter.switchCamera(Camera2Manager.CAMERA_DIRECTION_FRONT);
  166.                 break;
  167.             //切换到后摄像头
  168.             case R.id.camera_direction_back:
  169.                 this.presenter.switchCamera(Camera2Manager.CAMERA_DIRECTION_BACK);
  170.                 break;
  171.             default:
  172.  
  173.                 break;
  174.         }
  175.     }
  176.  
  177.     @Override
  178.     public void moveDistance(float verticalBias) {
  179.         Log.d(TAG, "moveDistance--verticalBias: " + verticalBias);
  180.         if (presenter != null) {
  181.             presenter.setManualFocus(verticalBias);
  182.         }
  183.     }
  184. }

另外一个项目的效果图:

 源码地址：

github开源专业相机https://github.com/SereneGuest/Camera2

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

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

  

闽ICP备14008679号