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

使用Camera2实现预览功能_camera2 打开预览

作者：笔触狂放9 | 2024-02-18 00:40:37

赞

踩

camera2 打开预览

前言

首先需要知道的是该博客只是简单的将摄像头打开并进行预览的一个操作，对于横屏竖屏切换的一个判断处理并没有实现，后续会进行完善，但是不会在这个博客中进行说明。

其次在编写之前应该对整个预览过程用到的一些重要方法或重要的类有一个理解！

技术前瞻

1. CameraManager

摄像头管理器，用于打开和关闭系统摄像头

  • getCameraIdList() ：
    返回当前设备中可用的相机列表

  • getCameraCharacteristics(String cameraId) ：
    根据摄像头id返回该摄像头的相关信息

  • openCamera(String cameraId, final CameraDevice.StateCallback callback,Handler handler)：
    打开指定cameraId的相机。参数callback为相机打开时的回调，参数handler为callback被调用时所在的线程

2. CameraDevice

描述系统摄像头，一般都是用于创建Capture请求以及创建CaptureSession会话

  • createCaptureRequest(int templateType)：
    创建一个新的Capture请求。参数templateType代表了请求类型，请求类型一共分为六种，分别为：
  1. TEMPLATE_PREVIEW : 创建预览的请求
  2. TEMPLATE_STILL_CAPTURE: 创建一个适合于静态图像捕获的请求，图像质量优先于帧速率
  3. TEMPLATE_RECORD : 创建视频录制的请求
  4. TEMPLATE_VIDEO_SNAPSHOT : 创建视视频录制时截屏的请求
  5. TEMPLATE_ZERO_SHUTTER_LAG : 创建一个适用于零快门延迟的请求。在不影响预览帧率的情况下最大化图像质量
  6. TEMPLATE_MANUAL : 创建一个基本捕获请求，这种请求中所有的自动控制都是禁用的(自动曝光，自动白平衡、自动焦点)
  • createCaptureSession(List<Surface> outputs,CameraCaptureSession.StateCallback callback,Handler handler)：
    创建CaptureSession会话。第一个参数 outputs 是一个 List 数组，相机会把捕捉到的图片数据传递给该参数中的 Surface 。第二个参数 StateCallback 是创建会话的状态回调。第三个参数描述了 StateCallback 被调用时所在的线程。

3. CameraCharacteristics

描述摄像头的各种特性，类似于Camera1中的CamerInfo。通过CameraManager的getCameraCharacteristics(String cameraId)方法来获取

  • get(Key<T> key) ：
    通过制定的key获取相应的相机参数。

常用的key值有：

  1. CameraCharacteristics.LENS_FACING :
    获取摄像头方向。前置摄像头（LENS_FACING_FRONT）或 后置摄像头（LENS_FACING_BACK）
  2. CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL：
    获取当前设备支持的相机特性
  3. CameraCharacteristics.SENSOR_ORIENTATION：
    获取摄像头方向
  4. CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP：
    获取StreamConfigurationMap，它是管理摄像头支持的所有输出格式和尺寸
  5. CameraCharacteristics.FLASH_INFO_AVAILABLE：
    是否支持闪光灯
  6. CameraCharacteristics.STATISTICS_INFO_MAX_FACE_COUNT:
    同时检测到人脸的数量
  7. CameraCharacteristics.STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES:
    相机支持的人脸检测模式

4. CaptureRequest

描述了一次操作请求，拍照、预览等操作都需要先传入CaptureRequest参数，具体的参数控制也是通过CameraRequest的成员变量来设置

  • addTarget(Surface outputTarget)：
    给此次请求添加一个Surface对象作为图像的输出目标

  • set(Key<T> key, T value)：
    设置指定的参数值。

// 自动对焦
captureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE)
// 闪光灯
captureRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH)
// 根据摄像头方向对保存的照片进行旋转，使其为"自然方向"
captureRequestBuilder.set(CaptureRequest.JPEG_ORIENTATION, mCameraSensorOrientation)
// 人脸检测模式
captureRequestBuilder.set(CaptureRequest.STATISTICS_FACE_DETECT_MODE, CameraCharacteristics.STATISTICS_FACE_DETECT_MODE_SIMPLE)

5. CameraCaptureSession

当需要拍照、预览等功能时，需要先创建该类的实例，然后通过该实例里的方法进行控制（例如：拍照 capture()）

  • setRepeatingRequest(CaptureRequest request,
    CaptureCallback listener, Handler handler)    ：
    根据传入的 CaptureRequest 对象开始一个无限循环的捕捉图像的请求。第二个参数 listener 为捕捉图像的回调，在回调中可以拿到捕捉到的图像信息

  • capture( CaptureRequest request,
    CaptureCallback listener, Handler handler)    ：
    拍照。第二个参数为拍照的结果回调

6. CaptureResult

描述拍照完成后的结果

7. ImageReader

用于接收拍照结果和访问拍摄照片的图像数据。
得到一个ImageReader对象的方法为newInstance(int width, int height, int format, int maxImages)。前两个参数是保存图片的宽高，第三个参数为保存图片的格式，第四个参数代表用户可以同时访问到的最大图片数量

注意：
这个参数应该根据具体需业务需求尽可能的小，因为它的数值越大意味着需要消耗的内存就越高

  • acquireNextImage()：
    得到ImageReader图像队列中的下一张图片，返回值是一个Image对象

8. Image

一个完整的图片缓存

  • getPlanes()：
    获取该图像的像素平面数组。这个数组的大小跟图片的格式有关，如 JPEG格式数组大小为1

9. Plane

图像数据的单色平面

  • getBuffer()：
    获取包含帧数据的ByteBuffer。通过这个ByteBuffer我们就可以把图片保存下来

知识前瞻部分的内容，看了一篇帖子写的挺好，就搬运过来，这一部分的顺序很大程度的就是映射着开发中使用他们的顺序。

作者：Smashing丶
链接：https://www.jianshu.com/p/0ea5e201260f
来源：简书

代码实现

 本次demo实现的是使用viewpage2进行左右滑动切换拍照与录像功能，对于布局文件及布局代码在这里不是重点，我就把它给码下来不进行详细的讲解。

MainActivity布局文件

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.     xmlns:app="http://schemas.android.com/apk/res-auto"
  4.     xmlns:tools="http://schemas.android.com/tools"
  5.     android:layout_width="match_parent"
  6.     android:layout_height="match_parent"
  7.     tools:context=".MainActivity">
  8.     <androidx.viewpager2.widget.ViewPager2
  9.         android:id="@+id/camerapage"
  10.         android:layout_width="match_parent"
  11.         android:layout_height="match_parent"/>
  12.  
  13.  
  14. </RelativeLayout>

MainActivity的Java文件

  1. package com.yjs.cameraapplication;
  2.  
  3. import androidx.appcompat.app.ActionBar;
  4. import androidx.appcompat.app.AppCompatActivity;
  5. import androidx.fragment.app.Fragment;
  6. import androidx.lifecycle.Lifecycle;
  7. import androidx.viewpager.widget.ViewPager;
  8. import androidx.viewpager2.widget.ViewPager2;
  9.  
  10. import android.Manifest;
  11. import android.graphics.Color;
  12. import android.os.Build;
  13. import android.os.Bundle;
  14. import android.view.TextureView;
  15. import android.view.View;
  16. import android.widget.Adapter;
  17.  
  18. import com.yjs.cameraapplication.FragmentPackage.RecorderVideoFragment;
  19. import com.yjs.cameraapplication.FragmentPackage.TakePhotoFragment;
  20.  
  21. import java.util.ArrayList;
  22. import java.util.List;
  23.  
  24. public class MainActivity extends AppCompatActivity {
  25.     private String[] permissions={Manifest.permission.WRITE_EXTERNAL_STORAGE,Manifest.permission.RECORD_AUDIO,Manifest.permission.CAMERA};
  26.     private ViewPager2 viewPager;
  27.     private List<Fragment> fragments;
  28.     @Override
  29.     protected void onCreate(Bundle savedInstanceState) {
  30.         super.onCreate(savedInstanceState);
  31.         setContentView(R.layout.activity_main);
  32.         /*修改各种状态栏状态*/
  33.         changeWindowStatus();
  34.         /*初始化各种view*/
  35.         initView();
  36.     }
  37.  
  38.     private void initView() {
  39.         fragments=new ArrayList<Fragment>();
  40.         viewPager = findViewById(R.id.camerapage);
  41.         TakePhotoFragment takePhotoFragment = new TakePhotoFragment();
  42.         fragments.add(takePhotoFragment);
  43.         RecorderVideoFragment recorderVideoFragment = new RecorderVideoFragment();
  44.         fragments.add(recorderVideoFragment);
  45.         MyViewAdapter myViewAdapter = new MyViewAdapter(getSupportFragmentManager(), getLifecycle(), fragments);
  46.         viewPager.setAdapter(myViewAdapter);
  47.     }
  48.  
  49.     private void changeWindowStatus() {
  50.         //隐藏通知栏状态栏
  51.         if (Build.VERSION.SDK_INT >= 21) {
  52.             View decorView=getWindow().getDecorView();//获取当前界面的decorView
  53.             int option = View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
  54.                     |View.SYSTEM_UI_FLAG_FULLSCREEN//隐藏状态栏
  55.                     |View.SYSTEM_UI_FLAG_LAYOUT_STABLE//保持整个View的稳定，使其不会随着SystemUI的变化而变化；
  56.                     |View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION//让导航栏悬浮在Activity上
  57.                     |View.SYSTEM_UI_FLAG_HIDE_NAVIGATION//隐藏导航栏
  58.                     | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY;//沉浸模式且状态栏和导航栏出现片刻后会自动隐藏
  59.             decorView.setSystemUiVisibility(option);
  60.             getWindow().setStatusBarColor(Color.TRANSPARENT);//设置透明颜色
  61.             getWindow().setNavigationBarColor(Color.TRANSPARENT);
  62.         }
  63.         ActionBar actionBar=getSupportActionBar();
  64.         actionBar.hide();
  65.     }
  66. }

使用PageView需要使用AdaptView对每一页进行一个管理 

MyViewAdapter文件

  1. package com.yjs.cameraapplication;
  2.  
  3. import androidx.annotation.NonNull;
  4. import androidx.fragment.app.Fragment;
  5. import androidx.fragment.app.FragmentManager;
  6. import androidx.fragment.app.FragmentPagerAdapter;
  7. import androidx.lifecycle.Lifecycle;
  8. import androidx.viewpager2.adapter.FragmentStateAdapter;
  9.  
  10. import java.util.List;
  11.  
  12. public class MyViewAdapter extends FragmentStateAdapter {
  13.     private List<Fragment> fragments;
  14.     public MyViewAdapter(@NonNull FragmentManager fragmentManager, @NonNull Lifecycle lifecycle, List<Fragment> fragmentList) {
  15.         super(fragmentManager, lifecycle);
  16.         this.fragments=fragmentList;
  17.     }
  18.  
  19.     @NonNull
  20.     @Override
  21.     public Fragment createFragment(int position) {
  22.         return fragments.get(position);
  23.     }
  24.  
  25.     @Override
  26.     public int getItemCount() {
  27.         return fragments.size();
  28.     }
  29. }

其实对于上面都是基本操作没有什么好说的，但是有一个点可以注意一下，就是对于手机状态栏、功能栏的一些设置。 我在上面的注释中也是表明的比较明白。接下来就是我们核心功能实现代码。

拍照界面Fragment

我们将着重看向拍照界面的预览。首先一个相机预览的流程大概就是初始化TextureView,然后在TextureView的回调中进行设置相机特性，设置完相机特性后将设备相机设备进行打开操作。具体的实现细节将结合代码进行理解。

首先还是最简单的Fragment的布局文件

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3.     xmlns:tools="http://schemas.android.com/tools"
  4.     android:layout_width="match_parent"
  5.     android:layout_height="match_parent"
  6.     tools:context=".FragmentPackage.TakePhotoFragment">
  7.  
  8.     <!-- TODO: Update blank fragment layout -->
  9.     <TextureView
  10.         android:layout_width="match_parent"
  11.         android:layout_height="match_parent"
  12.         android:id="@+id/textureView"/>
  13.  
  14.     <ImageButton
  15.         android:id="@+id/takePicture"
  16.         android:layout_width="wrap_content"
  17.         android:layout_height="wrap_content"
  18.         android:layout_alignParentBottom="true"
  19.         android:layout_centerHorizontal="true"
  20.         android:layout_marginBottom="50dp"
  21.         android:background="@drawable/shape_white_ring"
  22.         android:scaleX="0.4"
  23.         android:scaleY="0.4"
  24.         android:src="@drawable/cam" />
  25.     <ImageView
  26.         android:id="@+id/image_show"
  27.         android:layout_width="50dp"
  28.         android:layout_height="50dp"
  29.         android:layout_alignParentBottom="true"
  30.         android:layout_marginLeft="50dp"
  31.         android:layout_marginBottom="50dp" />
  32.     <ImageButton
  33.         android:id="@+id/change"
  34.         android:layout_width="wrap_content"
  35.         android:layout_height="wrap_content"
  36.         android:src="@drawable/changecam"
  37.         android:scaleY="0.2"
  38.         android:scaleX="0.2"
  39.         android:background="@drawable/shape_white_ring"
  40.         android:layout_alignParentBottom="true"
  41.         android:layout_marginRight="50dp"
  42.         android:layout_marginBottom="50dp"
  43.         android:layout_alignParentRight="true"
  44.         />
  45.  
  46. </RelativeLayout>

 实现预览主要还是对TextureView控件的一个操作。我们首先需要在fragment创建View的回调函数中进行控件的绑定，动态授权的操作，以及初始化TextureView

  1. @Override
  2.     public View onCreateView(LayoutInflater inflater, ViewGroup container,
  3.                              Bundle savedInstanceState) {
  4.         // Inflate the layout for this fragment
  5.         View view = inflater.inflate(R.layout.fragment_take_photo, container, false);
  6.         //控件绑定
  7.         initView(view);
  8.         //初始化TextureView
  9.         textureView.setSurfaceTextureListener(textureListener);
  10.         //动态授权
  11.         getPermission();
  12.  
  13.         return view;
  14.     }

控件的绑定、动态授权我这边就不在具体的去讲。下面我将动态授权的代码码出来。

  1. private void getPermission() {
  2.         Log.d(TAG, "getPermission: success");
  3.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
  4.             for (String permission : permissions) {
  5.                 if (ContextCompat.checkSelfPermission(getContext(), permission) != PackageManager.PERMISSION_GRANTED) {
  6.                     permissionList.add(permission);
  7.                 }
  8.             }
  9.             if (!permissionList.isEmpty()) {
  10.                 //进行授权
  11.                 requestPermissions(permissionList.toArray(new String[permissionList.size()]), 1);
  12.             } else {
  13.                 //表示全部已经授权
  14.                 //这时候回调一个预览view的回调函数
  15.                 textureView.setSurfaceTextureListener(textureListener);
  16.             }
  17.         }
  18.     }

接下来我们来看看TextureView的初始化代码运行。

 //初始化TextureView
 textureView.setSurfaceTextureListener(textureListener);

 初始化其实就是设置一个SurfaceTexture的监听者，当其可用的时候进行回调函数

  1. /*SurfaceView状态回调*/
  2.     TextureView.SurfaceTextureListener textureListener = new TextureView.SurfaceTextureListener() {
  3.         @Override
  4.         public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
  5.             Log.d(TAG, "onSurfaceTextureAvailable: success");
  6.             //首先就需要设置相机，然后再打开相机
  7.             setupCamera(width,height);
  8.             openCamera();
  9.         }
  10.         //下面的方法可以先不看，我们先实现相机预览
  11.         @Override
  12.         public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
  13.  
  14.         }
  15.  
  16.         @Override
  17.         public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
  18.             return false;
  19.         }
  20.  
  21.         @Override
  22.         public void onSurfaceTextureUpdated(SurfaceTexture surface) {
  23.  
  24.         }
  25.     };

可以看到回调函数中其实就做了两件事， 在SufaceTexture可用的时候，设置相机的特性，设置完之后便打开相机相关操作，首先我们先看一下setupCamera方法进行设置相机

  1. private void setupCamera(int width,int height) {
  2.         Log.d(TAG, "setupCamera: success");
  3.         CameraManager cameraManager = (CameraManager) getActivity().getSystemService(Context.CAMERA_SERVICE);
  4.         try {
  5.             String[] cameraIdList = cameraManager.getCameraIdList();
  6.             for (String cameraId : cameraIdList) {
  7.                 CameraCharacteristics cameraCharacteristics = cameraManager.getCameraCharacteristics(cameraId);
  8.                 if (cameraCharacteristics.get(CameraCharacteristics.LENS_FACING) == CameraCharacteristics.LENS_FACING_FRONT) {
  9.                     continue;
  10.                 }
  11.                 StreamConfigurationMap map = cameraCharacteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
  12.                 //相机支持的所有分辨率，下一步就是获取最合适的分辨率
  13.                 Size[] outputSizes = map.getOutputSizes(SurfaceTexture.class);
  14.                 Size size = getOptimalSize(outputSizes, width, height);
  15.                 previewSize = size;
  16.                 mCameraId = cameraId;
  17.                 break;
  18.             }
  19.         } catch (CameraAccessException e) {
  20.             e.printStackTrace();
  21.         }
  22.     }
  1. //选择sizeMap中大于并且接近width和height的size
  2.     private Size getOptimalSize(Size[] outputSizes, int width, int height) {
  3.         Size tempSize=new Size(width,height);
  4.         List<Size> sizes = new ArrayList<>();
  5.         for (Size outputSize : outputSizes) {
  6.             if (width > height) {
  7.                 //横屏的时候
  8.                 if (outputSize.getHeight() > height && outputSize.getWidth() > width) {
  9.                     sizes.add(outputSize);
  10.                 }
  11.             } else {
  12.                 //竖屏的时候
  13.                 if (outputSize.getWidth() > height && outputSize.getHeight() > width) {
  14.                     sizes.add(outputSize);
  15.                 }
  16.             }
  17.         }
  18.         if (sizes.size() > 0) {
  19.             //如果有多个符合条件找到一个差距最小的，最接近预览分辨率的
  20.              tempSize= sizes.get(0);
  21.             int minnum = 999999;
  22.             for (Size size : sizes) {
  23.                 int num = size.getHeight() * size.getHeight() - width * height;
  24.                 if (num < minnum) {
  25.                     minnum = num;
  26.                     tempSize = size;
  27.                 }
  28.             }
  29.         }
  30.         return tempSize;
  31.         /*if (sizes.size() > 0) {
  32.             return Collections.min(sizes, new Comparator<Size>() {
  33.                 @Override
  34.                 public int compare(Size size, Size t1) {
  35.                     return Long.signum(size.getWidth() * size.getHeight() - t1.getWidth() * t1.getHeight());
  36.                 }
  37.             });
  38.         }
  39.         return outputSizes[0];*/
  40.  
  41.     }

看着上面的设置相机部分代码，我们可以知道， 我们通过getActivity().getSystemService(Context.CAMERA_SERVICE)去获得CameraManager去对相机特性进行设置。其中cameraCharacteristics是获取相机的所有特性，例如分辨率、相机前后摄像头等特性的设置。设置相机代码主要设置了后摄的最佳分辨率的一个选择初始化。

 设置好相机之后，我们便可以进行打开相机的操作，在打开相机操作的过程中再初始化一下ImageReader为后面拍照保存图片做好准备。

  1. //打开摄像头
  2.     private void openCamera() {
  3.         Log.d(TAG, "openCamera: success");
  4.         CameraManager cameraManager = (CameraManager) getActivity().getSystemService(Context.CAMERA_SERVICE);
  5.         try {
  6.             if (ActivityCompat.checkSelfPermission(getContext(), Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
  7.                 // TODO: Consider calling
  8.                 //    ActivityCompat#requestPermissions
  9.                 // here to request the missing permissions, and then overriding
  10.                 //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
  11.                 //                                          int[] grantResults)
  12.                 // to handle the case where the user grants the permission. See the documentation
  13.                 // for ActivityCompat#requestPermissions for more details.
  14.                 return;
  15.             }
  16.             cameraManager.openCamera(mCameraId, stateCallback, null);
  17.         } catch (CameraAccessException e) {
  18.             e.printStackTrace();
  19.         }
  20.     }

其实打开相机函数，就是通过CameraManager进行openCamera方法，这个方法有三个参数去进行完善，首先第一个参数是相机的Id，因为一个设备上可能有多个相机设备，刚刚的设置相机中已经提及，第二个参数则是监控相机设备状态的回调，第三个参数是设置该方法在哪个线程进行操作，如果是null则代表是在当前线程下进行opencamera。接下来我们来看一下第二个参数监控相机设备的回调函数。

  1. //摄像头状态回调
  2.     private CameraDevice.StateCallback stateCallback = new CameraDevice.StateCallback() {
  3.         @Override
  4.         public void onOpened(@NonNull CameraDevice camera) {
  5.             Log.d(TAG, "onOpened: success");
  6.             mCameraDevice = camera;
  7.             //开启预览
  8.             startPreview();
  9.         }
  10.  
  11.         @Override
  12.         public void onDisconnected(@NonNull CameraDevice camera) {
  13.             Toast.makeText(getContext(), "摄像头设备连接失败", Toast.LENGTH_SHORT).show();
  14.         }
  15.  
  16.         @Override
  17.         public void onError(@NonNull CameraDevice camera, int error) {
  18.             Toast.makeText(getContext(), "摄像头设备连接出错", Toast.LENGTH_SHORT).show();
  19.         }
  20.     };

当检测到相机设备打开时回调onOpened函数，首先在这时我们可以获得对应的cameradevice对象，再其后开启预览界面startPreview()。

  1. //预览功能
  2.     private void startPreview() {
  3.         Log.d(TAG, "startPreview: success");
  4.         //设置图片阅读器
  5.         setImageReader();
  6.         //注意这里：sufacetexture跟surfaceview是两个东西，需要注意！
  7.         //sufacetexture是textureview的重要属性
  8.         SurfaceTexture surfaceTexture = textureView.getSurfaceTexture();
  9.         //设置textureview的缓存区大小
  10.         surfaceTexture.setDefaultBufferSize(previewSize.getWidth(), previewSize.getHeight());
  11.         //设置surface进行预览图像数据
  12.         mPreviewSurface = new Surface(surfaceTexture);
  13.         //创建CaptureRequest
  14.         setCaptureRequest();
  15.         //创建capturesession
  16.         /*Surface表示有多个输出流，我们有几个显示载体，就需要几个输出流。
  17.         对于拍照而言，有两个输出流：一个用于预览、一个用于拍照。
  18.         对于录制视频而言，有两个输出流：一个用于预览、一个用于录制视频。*/
  19.         // previewSurface 用于预览， mImageReader.getSurface() 用于拍照
  20.         try {
  21.             mCameraDevice.createCaptureSession(Arrays.asList(mPreviewSurface, mImageReader.getSurface()), new CameraCaptureSession.StateCallback() {
  22.                 @Override
  23.                 public void onConfigured(@NonNull CameraCaptureSession session) {
  24.                     //当回调创建成功就会调用这个回调
  25.                     mCaptureSession = session;
  26.                     setRepeatCapture();
  27.                 }
  28.  
  29.                 @Override
  30.                 public void onConfigureFailed(@NonNull CameraCaptureSession session) {
  31.  
  32.                 }
  33.             }, null);
  34.         } catch (CameraAccessException e) {
  35.             e.printStackTrace();
  36.         }
  37.  
  38.     }

在打开预览界面之前，我们先对ImageReader进行一个初始化，为后续拍照做准备。ImageReader主要时实现对图片的保存，以及通知广播对图库数据库进行一个更新。过程还是比较直白，就直接贴一下代码

  1. //设置图片阅读器
  2.     private void setImageReader() {
  3.         Log.d(TAG, "setImageReader: success");
  4.         //创建ImageReader实例，接下来应该是设置一些属性参数
  5.         mImageReader = ImageReader.newInstance(previewSize.getWidth(), previewSize.getHeight(), ImageFormat.JPEG, 1);
  6.         //果然跟我想的一样，接下来是设置监听当图片流可用的时候的监听器,即为拍照之后产生照片流
  7.         mImageReader.setOnImageAvailableListener(new ImageReader.OnImageAvailableListener() {
  8.             @Override
  9.             public void onImageAvailable(ImageReader reader) {
  10.                 Image image = reader.acquireLatestImage();
  11.                 //进行保存图片，开一个线程进行保存
  12.                 ImageSaver imageSaver = new ImageSaver(getContext(), image);
  13.                 new Thread(imageSaver).start();
  14.                 Toast.makeText(getContext(), "保存图片成功", Toast.LENGTH_SHORT).show();
  15.             }
  16.         }, null);
  17.     }
  1. //创建一个图片保存类
  2.     public class ImageSaver implements Runnable {
  3.         private Context context;
  4.         private Image image;
  5.  
  6.         public ImageSaver(Context context, Image image) {
  7.             Log.d(TAG, "ImageSaver: success");
  8.             this.context = context;
  9.             this.image = image;
  10.         }
  11.  
  12.         @Override
  13.         public void run() {
  14.             Image.Plane[] planes = image.getPlanes();
  15.             ByteBuffer buffer = planes[0].getBuffer();
  16.             byte[] bytes = new byte[buffer.remaining()];
  17.             buffer.get(bytes);
  18.             System.out.println(planes);
  19.             String filname = Environment.getExternalStorageDirectory() + "/DCIM/Camera/"  + System.currentTimeMillis() + ".jpg";
  20.             File file = new File(filname);
  21.             FileOutputStream fileOutputStream=null;
  22.             try {
  23.                 //保存图片
  24.                 fileOutputStream = new FileOutputStream(file);
  25.                 fileOutputStream.write(bytes,0,bytes.length);
  26.  
  27.             } catch (FileNotFoundException e) {
  28.                 e.printStackTrace();
  29.             } catch (IOException e) {
  30.                 e.printStackTrace();
  31.             }
  32.             finally {
  33.                 if (fileOutputStream!=null){
  34.                     try {
  35.                         fileOutputStream.close();
  36.                     } catch (IOException e) {
  37.                         e.printStackTrace();
  38.                     }
  39.                 }
  40.                 //最后还要广播通知相册更新数据库
  41.                 notiBroadcast();
  42.                 //保存操作结束后，需要用handle进行主线程数据的更新
  43.                 Message message = new Message();
  44.                 message.what=0;
  45.                 Bundle bundle = new Bundle();
  46.                 bundle.putString("path",filname);
  47.                 message.setData(bundle);
  48.                 handler.sendMessage(message);
  49.                 //image也算是个流也需要进行关闭，否则可能拍照的时候会报错
  50.                 image.close();
  51.             }
  52.         }
  53.     }
  1. private void notiBroadcast(){
  2.         String path = Environment.getExternalStorageDirectory() + "/DCIM/";
  3.         Intent intent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
  4.         Uri uri = Uri.fromFile(new File(path));
  5.         intent.setData(uri);
  6.         getContext().sendBroadcast(intent);
  7.     }
  8. private void setLastImagePath(String path){
  9.         Log.d(TAG, "setLastImagePath: success");
  10.         //拿到最后一张拍照照片
  11.         Bitmap bitmap = BitmapFactory.decodeFile(path);
  12.         mImageView.setImageBitmap(bitmap);
  13.     }
  1. private Handler handler=new Handler(Looper.myLooper()){
  2.         @Override
  3.         public void handleMessage(Message msg) {
  4.             super.handleMessage(msg);
  5.             if (msg.what==0){
  6.                 Bundle pathdata = msg.getData();
  7.                 String path = (String) pathdata.get("path");
  8.                 imageList.add(path);
  9.                 //设置拍照界面显示的一个图片（左下角的图片预览）
  10.                 setLastImagePath(path);
  11.             }
  12.         }
  13.     };

 设置好ImageReader之后，以及对Surface进行设置尺寸大小之后，便需要setCaptureRequest();还没讲解setCaptureRequest()之前，可能会疑问Surface是拿来干什么的，接下来，我把setCaptureRequest()码出来就好理解很多。

  1. //无论是预览还是拍照都需要设置capturerequest
  2.     private void setCaptureRequest(){
  3.         try {
  4.             mPreviewRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
  5.             mPreviewRequestBuilder.addTarget(mPreviewSurface);
  6.             //手动对焦，还不会
  7.             /*
  8.                 TODO
  9.              */
  10.             // 自动对焦
  11.             mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
  12.             // 闪光灯
  13.             mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
  14.             // 人脸检测模式
  15.             mPreviewRequestBuilder.set(CaptureRequest.STATISTICS_FACE_DETECT_MODE, CameraCharacteristics.STATISTICS_FACE_DETECT_MODE_SIMPLE);
  16.         } catch (CameraAccessException e) {
  17.             e.printStackTrace();
  18.         }
  19.     }

可以看到我们设计的相机怎么知道预览界面的，便是通过 mPreviewRequestBuilder.addTarget(mPreviewSurface)进行一个设置，然后builder还可以对自动对焦、闪光灯等进行一个设置，当builder都设置好之后，便可以调用build进行captureRequire的生成。创建好captureRequire之后我们便需要capturesession去调用预览方法，预览方法中需要captureRequire，其实整个过程都是迭迭相加的。

  1. private void setRepeatCapture(){
  2.         Log.d(TAG, "setRepeatCapture: success");
  3.         mPreviewRequestBuilder.setTag(TAG);
  4.         //首先要知道整个调用顺序 devices创建出capturebuilder，当builder设置好各种参数之后，就可以build出capturerequire
  5.         mPreviewRequest=mPreviewRequestBuilder.build();
  6.         //session中需要用到capturerequire
  7.         try {
  8.             mCaptureSession.setRepeatingRequest(mPreviewRequest, new CameraCaptureSession.CaptureCallback() {
  9.                 @Override
  10.                 public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
  11.                     super.onCaptureCompleted(session, request, result);
  12.                 }
  13.             },null);
  14.         } catch (CameraAccessException e) {
  15.             e.printStackTrace();
  16.         }
  17.     }

 致辞预览就简单实现了，但是我个人文字逻辑并不清晰，估计这个就我自己能看懂，我就把拍照的Fragement的所有代码进行码。大家一步一步慢慢看，总能看懂。

  1. package com.yjs.cameraapplication.FragmentPackage;
  2.  
  3. import android.Manifest;
  4. import android.app.AlertDialog;
  5. import android.content.Context;
  6. import android.content.DialogInterface;
  7. import android.content.Intent;
  8. import android.content.pm.PackageManager;
  9. import android.graphics.Bitmap;
  10. import android.graphics.BitmapFactory;
  11. import android.graphics.Canvas;
  12. import android.graphics.ColorFilter;
  13. import android.graphics.ImageFormat;
  14. import android.graphics.Matrix;
  15. import android.graphics.Paint;
  16. import android.graphics.Path;
  17. import android.graphics.PixelFormat;
  18. import android.graphics.SurfaceTexture;
  19. import android.graphics.drawable.Drawable;
  20. import android.hardware.camera2.CameraAccessException;
  21. import android.hardware.camera2.CameraCaptureSession;
  22. import android.hardware.camera2.CameraCharacteristics;
  23. import android.hardware.camera2.CameraDevice;
  24. import android.hardware.camera2.CameraManager;
  25. import android.hardware.camera2.CaptureRequest;
  26. import android.hardware.camera2.TotalCaptureResult;
  27. import android.hardware.camera2.params.StreamConfigurationMap;
  28. import android.media.Image;
  29. import android.media.ImageReader;
  30. import android.net.Uri;
  31. import android.os.Build;
  32. import android.os.Bundle;
  33.  
  34. import androidx.annotation.NonNull;
  35. import androidx.annotation.Nullable;
  36. import androidx.core.app.ActivityCompat;
  37. import androidx.core.content.ContextCompat;
  38. import androidx.core.graphics.drawable.RoundedBitmapDrawable;
  39. import androidx.core.graphics.drawable.RoundedBitmapDrawableFactory;
  40. import androidx.fragment.app.DialogFragment;
  41. import androidx.fragment.app.Fragment;
  42.  
  43. import android.os.Environment;
  44. import android.os.Handler;
  45. import android.os.Looper;
  46. import android.os.Message;
  47. import android.util.Log;
  48. import android.util.Size;
  49. import android.view.LayoutInflater;
  50. import android.view.Surface;
  51. import android.view.TextureView;
  52. import android.view.View;
  53. import android.view.ViewGroup;
  54. import android.widget.ImageButton;
  55. import android.widget.ImageView;
  56. import android.widget.Toast;
  57.  
  58. import com.yjs.cameraapplication.MainActivity;
  59. import com.yjs.cameraapplication.R;
  60. import com.yjs.cameraapplication.SelfView.MyImageView;
  61.  
  62. import java.io.File;
  63. import java.io.FileNotFoundException;
  64. import java.io.FileOutputStream;
  65. import java.io.FilenameFilter;
  66. import java.io.IOException;
  67. import java.nio.ByteBuffer;
  68. import java.sql.Time;
  69. import java.util.ArrayList;
  70. import java.util.Arrays;
  71. import java.util.Collections;
  72. import java.util.Comparator;
  73. import java.util.List;
  74. import java.util.concurrent.TimeUnit;
  75.  
  76. /**
  77.  * A simple {@link Fragment} subclass.
  78.  * Use the {@link TakePhotoFragment#newInstance} factory method to
  79.  * create an instance of this fragment.
  80.  */
  81. public class TakePhotoFragment extends Fragment implements View.OnClickListener {
  82.     private static final String TAG = "TakePhotoFragment";
  83.     private static final String ARG_PARAM1 = "param1";
  84.     private static final String ARG_PARAM2 = "param2";
  85.     private String mParam1;
  86.     private String mParam2;
  87.     /*fragment空间声明*/
  88.     private TextureView textureView;
  89.     private ImageButton takePhotoBtn;
  90.     private ImageView mImageView;
  91.     /*private MyImageView mImageView;*/
  92.     private ImageButton changeCamBtn;
  93.     /*除此之外，还需要一些参数*/
  94.     private String mCameraId; //摄像头ID
  95.     private Size previewSize; //预览分辨率
  96.     private ImageReader mImageReader; //图片阅读器
  97.     private static CameraDevice mCameraDevice;   //摄像头设备
  98.     private static CameraCaptureSession mCaptureSession;   //获取会话
  99.     private CaptureRequest mPreviewRequest;      //获取预览请求
  100.     private CaptureRequest.Builder mPreviewRequestBuilder;   //获取到预览请求的Builder通过它创建预览请求
  101.     private Surface mPreviewSurface;  //预览显示图
  102.     //新建一个权限链
  103.     private String[] permissions = {Manifest.permission.CAMERA, Manifest.permission.READ_EXTERNAL_STORAGE,
  104.             Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.RECORD_AUDIO};
  105.     private List<String> permissionList = new ArrayList();
  106.     //添加一个图片集合
  107.     List<String> imageList = new ArrayList<>();
  108.     private Boolean isCreated=false;
  109.     private Boolean isLeave=false;
  110.  
  111.  
  112.     public TakePhotoFragment() {
  113.         // Required empty public constructor
  114.     }
  115.  
  116.     /**
  117.      * Use this factory method to create a new instance of
  118.      * this fragment using the provided parameters.
  119.      *
  120.      * @param param1 Parameter 1.
  121.      * @param param2 Parameter 2.
  122.      * @return A new instance of fragment TakePhotoFragment.
  123.      */
  124.     // TODO: Rename and change types and number of parameters
  125.     public static TakePhotoFragment newInstance(String param1, String param2) {
  126.         TakePhotoFragment fragment = new TakePhotoFragment();
  127.         Bundle args = new Bundle();
  128.         args.putString(ARG_PARAM1, param1);
  129.         args.putString(ARG_PARAM2, param2);
  130.         fragment.setArguments(args);
  131.         return fragment;
  132.     }
  133.  
  134.     @Override
  135.     public void onCreate(Bundle savedInstanceState) {
  136.         super.onCreate(savedInstanceState);
  137.         if (getArguments() != null) {
  138.             mParam1 = getArguments().getString(ARG_PARAM1);
  139.             mParam2 = getArguments().getString(ARG_PARAM2);
  140.         }
  141.     }
  142.  
  143.     @Override
  144.     public View onCreateView(LayoutInflater inflater, ViewGroup container,
  145.                              Bundle savedInstanceState) {
  146.         Log.d(TAG, "onCreateView: success");
  147.         // Inflate the layout for this fragment
  148.         View view = inflater.inflate(R.layout.fragment_take_photo, container, false);
  149.         initView(view);
  150.         textureView.setSurfaceTextureListener(textureListener);
  151.         //动态授权
  152.         getPermission();
  153.         isCreated=true;
  154.         return view;
  155.     }
  156.     //看看viewpage对fragment的生命周期的影响
  157.     @Override
  158.     public void onPause() {
  159.         super.onPause();
  160.         Log.d(TAG, "onPause: success");
  161.         closeCamera();
  162.         System.out.println(textureView.isAvailable());
  163.         if (textureView.isAvailable()){
  164.             //如果可用，就是除了进行切换pageview之外的所有操作
  165.             isLeave=true;
  166.         }
  167.         else {
  168.             //不可用说明就是直接切换了pageview
  169.             closeCamera();
  170.         }
  171.  
  172.     }
  173.  
  174.     @Override
  175.     public void onStop() {
  176.         super.onStop();
  177.         Log.d(TAG, "onStop: success");
  178.     }
  179.  
  180.     @Override
  181.     public void onDestroyView() {
  182.         super.onDestroyView();
  183.         Log.d(TAG, "onDestroyView: success");
  184.     }
  185.  
  186.     @Override
  187.     public void onDestroy() {
  188.         super.onDestroy();
  189.         Log.d(TAG, "onDestroy: success");
  190.     }
  191.  
  192.     @Override
  193.     public void onResume() {
  194.         super.onResume();
  195.         Log.d(TAG, "onResume: success");
  196.         System.out.println("++++++++++");
  197.         System.out.println(textureView.isAvailable());
  198.         if (textureView.isAvailable()){
  199.             if (isLeave)
  200.             {
  201.                 //息屏等操作会自动关闭camera，所以就得手动再打开一次
  202.                 openCamera();
  203.                 isLeave=false;
  204.             }
  205.         }
  206.  
  207.     }
  208.  
  209.     @Override
  210.     public void onStart() {
  211.         super.onStart();
  212.         Log.d(TAG, "onStart: success");
  213.         /*if (textureView.isAvailable()){
  215.             openCamera();
  216.         }*/
  217.     }
  218.  
  219.     @Override
  220.     public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
  221.         super.onViewCreated(view, savedInstanceState);
  222.         Log.d(TAG, "onViewCreated: success");
  223.     }
  224.  
  225.  
  226.  
  227.  
  228.     private void closeCamera(){
  229.         Log.d(TAG, "closeCamera: success");
  230.         //首先要关闭session
  231.         if (mCaptureSession!=null){
  232.             mCaptureSession.close();
  233.         }
  234.         if (mCameraDevice!=null){
  235.             mCameraDevice.close();
  236.         }
  237.     }
  238.  
  239.     //绑定控件
  240.     private void initView(View view) {
  241.         textureView = view.findViewById(R.id.textureView);
  242.         takePhotoBtn = view.findViewById(R.id.takePicture);
  243.         mImageView = view.findViewById(R.id.image_show);
  244.         changeCamBtn = view.findViewById(R.id.change);
  245.         changeCamBtn.setOnClickListener(this);
  246.     }
  247.  
  248.     private void getPermission() {
  249.         Log.d(TAG, "getPermission: success");
  250.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
  251.             for (String permission : permissions) {
  252.                 if (ContextCompat.checkSelfPermission(getContext(), permission) != PackageManager.PERMISSION_GRANTED) {
  253.                     permissionList.add(permission);
  254.                 }
  255.             }
  256.             if (!permissionList.isEmpty()) {
  257.                 //进行授权
  258.                 ActivityCompat.requestPermissions(getActivity(),permissionList.toArray(new String[permissionList.size()]),1);
  259.             } else {
  260.                 //表示全部已经授权
  261.                 //这时候回调一个预览view的回调函数
  262.                 textureView.setSurfaceTextureListener(textureListener);
  263.             }
  264.         }
  265.     }
  266.     //只能写在Activity中，下次把授权写到activity中，减少麻烦
  267.     /*@Override
  268.     public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
  269.         Log.d(TAG, "onRequestPermissionsResult: success");
  270.         super.onRequestPermissionsResult(requestCode, permissions, grantResults);
  271.         if (requestCode==1){
  272.             if (grantResults.length!=0){
  273.                 //表示有权限没有授权
  274.                 getPermission();
  275.             }
  276.             else {
  277.                 //表示都授权
  278.                 openCamera();
  279.             }
  280.         }
  281.     }*/
  282.  
  283.     /*SurfaceView状态回调*/
  284.     TextureView.SurfaceTextureListener textureListener = new TextureView.SurfaceTextureListener() {
  285.         @Override
  286.         public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
  287.             Log.d(TAG, "onSurfaceTextureAvailable: success");
  288.             //首先就需要设置相机，然后再打开相机
  289.             setLastImagePath();
  290.             setupCamera(width,height);
  291.             openCamera();
  292.         }
  293.  
  294.         @Override
  295.         public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
  296.  
  297.         }
  298.  
  299.         @Override
  300.         public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
  301.             return false;
  302.         }
  303.  
  304.         @Override
  305.         public void onSurfaceTextureUpdated(SurfaceTexture surface) {
  306.  
  307.         }
  308.     };
  309.  
  310.     private void setupCamera(int width,int height) {
  311.         Log.d(TAG, "setupCamera: success");
  312.         CameraManager cameraManager = (CameraManager) getActivity().getSystemService(Context.CAMERA_SERVICE);
  313.         try {
  314.             String[] cameraIdList = cameraManager.getCameraIdList();
  315.             for (String cameraId : cameraIdList) {
  316.                 CameraCharacteristics cameraCharacteristics = cameraManager.getCameraCharacteristics(cameraId);
  317.                 if (cameraCharacteristics.get(CameraCharacteristics.LENS_FACING) == CameraCharacteristics.LENS_FACING_FRONT) {
  318.                     continue;
  319.                 }
  320.                 StreamConfigurationMap map = cameraCharacteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
  321.                 //相机支持的所有分辨率，下一步就是获取最合适的分辨率
  322.                 Size[] outputSizes = map.getOutputSizes(SurfaceTexture.class);
  323.                 Size size = getOptimalSize(outputSizes, width, height);
  324.                 previewSize = size;
  325.                 mCameraId = cameraId;
  326.                 break;
  327.             }
  328.         } catch (CameraAccessException e) {
  329.             e.printStackTrace();
  330.         }
  331.     }
  332.  
  333.     //打开摄像头
  334.     private void openCamera() {
  335.         Log.d(TAG, "openCamera: success");
  336.         CameraManager cameraManager = (CameraManager) getActivity().getSystemService(Context.CAMERA_SERVICE);
  337.         try {
  338.             if (ActivityCompat.checkSelfPermission(getContext(), Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
  339.                 // TODO: Consider calling
  340.                 //    ActivityCompat#requestPermissions
  341.                 // here to request the missing permissions, and then overriding
  342.                 //   public void onRequestPermissionsResult(int requestCode, String[] permissions,
  343.                 //                                          int[] grantResults)
  344.                 // to handle the case where the user grants the permission. See the documentation
  345.                 // for ActivityCompat#requestPermissions for more details.
  346.                 AlertDialog.Builder builder = new AlertDialog.Builder(getContext());
  347.                 builder.setMessage("该应用需要相机授权，点击授权按钮跳转到设置进行设置");
  348.                 builder.setNegativeButton("取消", new DialogInterface.OnClickListener() {
  349.                     @Override
  350.                     public void onClick(DialogInterface dialog, int which) {
  351.                         getActivity().finish();
  352.                     }
  353.                 });
  354.                 builder.setPositiveButton("设置", new DialogInterface.OnClickListener() {
  355.                     @Override
  356.                     public void onClick(DialogInterface dialog, int which) {
  357.                         Intent intent = new Intent("android.settings.APPLICATION_DETAILS_SETTINGS");
  358.                         intent.setData(Uri.fromParts("package", getActivity().getPackageName(), null));
  359.                         startActivity(intent);
  360.                     }
  361.                 }).create().show();
  362.                 return;
  363.             }
  364.             cameraManager.openCamera(mCameraId, stateCallback, null);
  365.         } catch (CameraAccessException e) {
  366.             e.printStackTrace();
  367.         }
  368.     }
  369.  
  370.     //摄像头状态回调
  371.     private CameraDevice.StateCallback stateCallback = new CameraDevice.StateCallback() {
  372.         @Override
  373.         public void onOpened(@NonNull CameraDevice camera) {
  374.             Log.d(TAG, "onOpened: success");
  375.             mCameraDevice = camera;
  376.             //开启预览
  377.             startPreview();
  378.         }
  379.  
  380.         @Override
  381.         public void onDisconnected(@NonNull CameraDevice camera) {
  382.             Toast.makeText(getContext(), "摄像头设备连接失败", Toast.LENGTH_SHORT).show();
  383.         }
  384.  
  385.         @Override
  386.         public void onError(@NonNull CameraDevice camera, int error) {
  387.             Toast.makeText(getContext(), "摄像头设备连接出错", Toast.LENGTH_SHORT).show();
  388.         }
  389.     };
  390.  
  391.  
  392.     //预览功能
  393.     private void startPreview() {
  394.         Log.d(TAG, "startPreview: success");
  395.         //设置图片阅读器
  396.         setImageReader();
  397.         //注意这里：sufacetexture跟surfaceview是两个东西，需要注意！
  398.         //sufacetexture是textureview的重要属性
  399.         SurfaceTexture surfaceTexture = textureView.getSurfaceTexture();
  400.         //设置textureview的缓存区大小
  401.         surfaceTexture.setDefaultBufferSize(previewSize.getWidth(), previewSize.getHeight());
  402.         //设置surface进行预览图像数据
  403.         mPreviewSurface = new Surface(surfaceTexture);
  404.         //创建CaptureRequest
  405.         setCaptureRequest();
  406.         //创建capturesession
  407.         /*Surface表示有多个输出流，我们有几个显示载体，就需要几个输出流。
  408.         对于拍照而言，有两个输出流：一个用于预览、一个用于拍照。
  409.         对于录制视频而言，有两个输出流：一个用于预览、一个用于录制视频。*/
  410.         // previewSurface 用于预览， mImageReader.getSurface() 用于拍照
  411.         try {
  412.             mCameraDevice.createCaptureSession(Arrays.asList(mPreviewSurface, mImageReader.getSurface()), new CameraCaptureSession.StateCallback() {
  413.                 @Override
  414.                 public void onConfigured(@NonNull CameraCaptureSession session) {
  415.                     //当回调创建成功就会调用这个回调
  416.                     mCaptureSession = session;
  417.                     setRepeatCapture();
  418.                 }
  419.  
  420.                 @Override
  421.                 public void onConfigureFailed(@NonNull CameraCaptureSession session) {
  422.  
  423.                 }
  424.             }, null);
  425.         } catch (CameraAccessException e) {
  426.             e.printStackTrace();
  427.         }
  428.  
  429.     }
  430.  
  431.     //设置图片阅读器
  432.     private void setImageReader() {
  433.         Log.d(TAG, "setImageReader: success");
  434.         //创建ImageReader实例，接下来应该是设置一些属性参数
  435.         mImageReader = ImageReader.newInstance(previewSize.getWidth(), previewSize.getHeight(), ImageFormat.JPEG, 1);
  436.         //果然跟我想的一样，接下来是设置监听当图片流可用的时候的监听器,即为拍照之后产生照片流
  437.         mImageReader.setOnImageAvailableListener(new ImageReader.OnImageAvailableListener() {
  438.             @Override
  439.             public void onImageAvailable(ImageReader reader) {
  440.                 Image image = reader.acquireLatestImage();
  441.                 //进行保存图片，开一个线程进行保存
  442.                 ImageSaver imageSaver = new ImageSaver(getContext(), image);
  443.                 new Thread(imageSaver).start();
  444.                 Toast.makeText(getContext(), "保存图片成功", Toast.LENGTH_SHORT).show();
  445.             }
  446.         }, null);
  447.     }
  448.  
  449.     //选择sizeMap中大于并且接近width和height的size
  450.     private Size getOptimalSize(Size[] outputSizes, int width, int height) {
  451.         Size tempSize=new Size(width,height);
  452.         List<Size> sizes = new ArrayList<>();
  453.         for (Size outputSize : outputSizes) {
  454.             if (width > height) {
  455.                 //横屏的时候
  456.                 if (outputSize.getHeight() > height && outputSize.getWidth() > width) {
  457.                     sizes.add(outputSize);
  458.                 }
  459.             } else {
  460.                 //竖屏的时候
  461.                 if (outputSize.getWidth() > height && outputSize.getHeight() > width) {
  462.                     sizes.add(outputSize);
  463.                 }
  464.             }
  465.         }
  466.         if (sizes.size() > 0) {
  467.             //如果有多个符合条件找到一个差距最小的，最接近预览分辨率的
  468.              tempSize= sizes.get(0);
  469.             int minnum = 999999;
  470.             for (Size size : sizes) {
  471.                 int num = size.getHeight() * size.getHeight() - width * height;
  472.                 if (num < minnum) {
  473.                     minnum = num;
  474.                     tempSize = size;
  475.                 }
  476.             }
  477.         }
  478.         return tempSize;
  479.         /*if (sizes.size() > 0) {
  480.             return Collections.min(sizes, new Comparator<Size>() {
  481.                 @Override
  482.                 public int compare(Size size, Size t1) {
  483.                     return Long.signum(size.getWidth() * size.getHeight() - t1.getWidth() * t1.getHeight());
  484.                 }
  485.             });
  486.         }
  487.         return outputSizes[0];*/
  488.  
  489.     }
  490.  
  491.     /*Fragment控件点击事件*/
  492.     @Override
  493.     public void onClick(View v) {
  494.         switch (v.getId()){
  495.             case R.id.change:
  496.                 changeLens();
  497.                 break;
  498.         }
  499.     }
  500.  
  501.     private void changeLens(){
  502.         Log.d(TAG, "changeLens: success");
  503.         if (mCameraId.equals(String.valueOf(CameraCharacteristics.LENS_FACING_BACK))){
  504.             mCameraId=String.valueOf(CameraCharacteristics.LENS_FACING_FRONT);
  505.         }
  506.         else {
  507.             if (mCameraId.equals(String.valueOf(CameraCharacteristics.LENS_FACING_FRONT))){
  508.                 mCameraId=String.valueOf(CameraCharacteristics.LENS_FACING_BACK);
  509.             }
  510.         }
  511.         CameraManager cameraManager = (CameraManager) getActivity().getSystemService(Context.CAMERA_SERVICE);
  512.         try {
  513.             CameraCharacteristics cameraCharacteristics = cameraManager.getCameraCharacteristics(mCameraId);
  514.             StreamConfigurationMap map = cameraCharacteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
  515.             Size[] outputSizes = map.getOutputSizes(SurfaceTexture.class);
  516.             Size optimalSize = getOptimalSize(outputSizes, textureView.getWidth(), textureView.getHeight());
  517.             previewSize=optimalSize;
  518.         } catch (CameraAccessException e) {
  519.             e.printStackTrace();
  520.         }
  521.         /*这里不能直接使用关闭camera这个方法*/
  522.         /*closeCamera();*/
  523.         closeCamera();
  524.         openCamera();
  525.     }
  526.  
  527.     //创建一个图片保存类
  528.     public class ImageSaver implements Runnable {
  529.         private Context context;
  530.         private Image image;
  531.  
  532.         public ImageSaver(Context context, Image image) {
  533.             Log.d(TAG, "ImageSaver: success");
  534.             this.context = context;
  535.             this.image = image;
  536.         }
  537.  
  538.         @Override
  539.         public void run() {
  540.             Image.Plane[] planes = image.getPlanes();
  541.             ByteBuffer buffer = planes[0].getBuffer();
  542.             byte[] bytes = new byte[buffer.remaining()];
  543.             buffer.get(bytes);
  544.             System.out.println(planes);
  545.             String filname = Environment.getExternalStorageDirectory() + "/DCIM/Camera/"  + System.currentTimeMillis() + ".jpg";
  546.             File file = new File(filname);
  547.             FileOutputStream fileOutputStream=null;
  548.             try {
  549.                 //保存图片
  550.                 fileOutputStream = new FileOutputStream(file);
  551.                 fileOutputStream.write(bytes,0,bytes.length);
  552.  
  553.             } catch (FileNotFoundException e) {
  554.                 e.printStackTrace();
  555.             } catch (IOException e) {
  556.                 e.printStackTrace();
  557.             }
  558.             finally {
  559.                 if (fileOutputStream!=null){
  560.                     try {
  561.                         fileOutputStream.close();
  562.                     } catch (IOException e) {
  563.                         e.printStackTrace();
  564.                     }
  565.                 }
  566.                 //最后还要广播通知相册更新数据库
  567.                 notiBroadcast();
  568.                 //保存操作结束后，需要用handle进行主线程数据的更新
  569.                 Message message = new Message();
  570.                 message.what=0;
  571.                 Bundle bundle = new Bundle();
  572.                 bundle.putString("path",filname);
  573.                 message.setData(bundle);
  574.                 handler.sendMessage(message);
  575.                 //image也算是个流也需要进行关闭，否则可能下一次拍照的时候会报错
  576.                 image.close();
  577.             }
  578.         }
  579.     }
  580.     private Handler handler=new Handler(Looper.myLooper()){
  581.         @Override
  582.         public void handleMessage(Message msg) {
  583.             super.handleMessage(msg);
  584.             if (msg.what==0){
  585.                 Bundle pathdata = msg.getData();
  586.                 String path = (String) pathdata.get("path");
  587.                 imageList.add(path);
  588.                 //设置拍照界面显示的一个图片（左下角的图片预览）
  589.                 setLastImagePath();
  590.             }
  591.         }
  592.     };
  593.  
  594.     private void notiBroadcast(){
  595.         String path = Environment.getExternalStorageDirectory() + "/DCIM/";
  596.         Intent intent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
  597.         Uri uri = Uri.fromFile(new File(path));
  598.         intent.setData(uri);
  599.         getContext().sendBroadcast(intent);
  600.     }
  601.  
  602.     private void setLastImagePath(){
  603.         Log.d(TAG, "setLastImagePath: success");
  604.         //先判断一下手机有没有权限
  605.         if (ActivityCompat.checkSelfPermission(getContext(), Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED){
  606.             return;
  607.         }
  608.         //拿到最后一张拍照照片，遍历所有相册照片
  609.         String DCIMPath=Environment.getExternalStorageDirectory()+"/DCIM/Camera";
  610.         File file = new File(DCIMPath);
  611.         //对该文件夹进行遍历
  612.         String[] jpgs = file.list(new FilenameFilter() {
  613.             @Override
  614.             public boolean accept(File dir, String name) {
  615.                 if (name.contains("jpg")) {
  616.                     return true;
  617.                 } else {
  618.                     return false;
  619.                 }
  620.             }
  621.         });
  622.         String finalImagePath=Environment.getExternalStorageDirectory()+"/DCIM/Camera/"+jpgs[jpgs.length-1];
  623.         Bitmap bitmap = BitmapFactory.decodeFile(finalImagePath);
  624.         /*Canvas canvas = new Canvas();
  625.         canvas.drawBitmap(bitmap,0,0,new Paint());
  626.         canvas.drawCircle(bitmap.getWidth()/2,bitmap.getHeight()/2,bitmap.getWidth()/2,new Paint());
  627.         mImageView.draw(canvas);*/
  628.         RoundedBitmapDrawable roundedBitmapDrawable = RoundedBitmapDrawableFactory.create(getResources(), bitmap);
  629.         roundedBitmapDrawable.setCircular(true);
  630.         /*mImageView.setImageBitmap(bitmap);*/
  631.         mImageView.setImageDrawable(roundedBitmapDrawable);
  632.  
  633.     }
  634.  
  635.     //无论是预览还是拍照都需要设置capturerequest
  636.     private void setCaptureRequest(){
  637.         try {
  638.             mPreviewRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
  639.             mPreviewRequestBuilder.addTarget(mPreviewSurface);
  640.             //手动对焦，还不会
  641.             /*
  642.                 TODO
  643.              */
  644.             // 自动对焦
  645.             mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
  646.             // 闪光灯
  647.             mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
  648.             // 人脸检测模式
  649.             mPreviewRequestBuilder.set(CaptureRequest.STATISTICS_FACE_DETECT_MODE, CameraCharacteristics.STATISTICS_FACE_DETECT_MODE_SIMPLE);
  650.         } catch (CameraAccessException e) {
  651.             e.printStackTrace();
  652.         }
  653.     }
  654.  
  655.     private void setRepeatCapture(){
  656.         Log.d(TAG, "setRepeatCapture: success");
  657.         mPreviewRequestBuilder.setTag(TAG);
  658.         //首先要知道整个调用顺序 devices创建出capturebuilder，当builder设置好各种参数之后，就可以build出capturerequire
  659.         mPreviewRequest=mPreviewRequestBuilder.build();
  660.         //session中需要用到capturerequire
  661.         try {
  662.             mCaptureSession.setRepeatingRequest(mPreviewRequest, new CameraCaptureSession.CaptureCallback() {
  663.                 @Override
  664.                 public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
  665.                     super.onCaptureCompleted(session, request, result);
  666.                 }
  667.             },null);
  668.         } catch (CameraAccessException e) {
  669.             e.printStackTrace();
  670.         }
  671.     }
  672. }

后续补充

这是写完这篇文章的一个补充，上面的所有代码示例，我也更新到完善Bug之后的代码。首先说一下这次预览主要遇到的问题：因为我设计的这个demo是搭载在Fragment上，所以出现的问题都是在当Fragment不可见的时候出现的问题，例如当切换ViewPage时，切换回相机预览页面，CameraDevice的回调会调disconnnect方法表示连接出错；以及当息屏时，亮屏预览只显示息屏前一帧；以及当在该Activity跳转到其他Activity时，返回的时候，预览也停留在离开该Activity的前一帧。

对于这几个bug的解决之路也是非常艰辛，一开始的时候就发现了第一个情况的bug，没当回事直接找到onPause调用closeCamera方法，然后再resume的时候再重新打开，但是随着调试的不断进行，这个方法只能将第一种情况的bug解决。后续又尝试了getUserVisibleHint回调方法，但是发现程序并不会回调这个方法。

后来没办法，只能从fragment的生命周期出发，发现viewpage切换的时候，textureview会自动变为不可用，滑动回预览界面的时候，textureview在加载完之后会回调自己的监听函数进行重新打开相机的操作，也就是说我们在onpause的时候记得将camera关闭就行，而对于锁屏或是跳到其他Activity返回的时候，可以发现textureview时一直可用的，也就是说上面两个情况重新回到页面，是不会自动调用textureview的加载完的回调函数，所以我们这时候就可以设置一个标识符，然后在resume函数中进行判断，如果符合这个标识符就进行重新打开相机。（onpause的时候也要关闭camera，否则后续会报错）。具体看代码实现

  1. //回调这个函数的时候，无论什么情况都要关闭相机
  2. //若是已经离开该活动的相关操作，只需要将isLeave置为true就可
  3. @Override
  4.     public void onPause() {
  5.         super.onPause();
  6.         Log.d(TAG, "onPause: success");
  7.         closeCamera();
  8.         System.out.println(textureView.isAvailable());
  9.         if (textureView.isAvailable()){
  10.             //如果可用，就是除了进行切换pageview之外的所有操作
  11.             isLeave=true;
  12.         }
  13.         /*else {
  14.             //不可用说明就是直接切换了pageview
  15.             closeCamera();
  16.         }*/
  17.  
  18.     }
  19.  
  20. //这个方法是无论什么操作，回到预览界面都会被回调的，这时候只要稍加区别
  21. //就可以很好的解决预览的各种极端情况下的问题
  22. @Override
  23.     public void onResume() {
  24.         super.onResume();
  25.         Log.d(TAG, "onResume: success");
  26.         System.out.println("++++++++++");
  27.         System.out.println(textureView.isAvailable());
  28.         if (textureView.isAvailable()){
  29.             if (isLeave)
  30.             {
  31.                 //息屏等操作会自动关闭camera，所以就得手动再打开一次
  32.                 openCamera();
  33.                 isLeave=false;
  34.             }
  35.         }

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

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

  

闽ICP备14008679号