相机

调用系统相机

添加权限

    <uses-permission android:name="android.permission.CAMERA" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />

Android 6.0 以上版本，还需处理动态权限

public class PhotoTools {

    public static final int REQUEST_CODE_TAKE_PICTURE = 10001;

    public static Uri takePicture(Activity activity,File file){
        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        Uri imgUri = null;

        // 7.0以上版本，必须使用FileProvider
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
            String authority = activity.getPackageName()+".fileprovider";
            imgUri = FileProvider.getUriForFile(activity, authority, file);
        } else {
            imgUri = Uri.fromFile(file);
        }
        // 设置拍照后保存的路径
        intent.putExtra(MediaStore.EXTRA_OUTPUT, imgUri);
        // 设置图片保存的格式
        intent.putExtra("outputFormat", Bitmap.CompressFormat.JPEG.toString());
        activity.startActivityForResult(intent, REQUEST_CODE_TAKE_PICTURE);

        return imgUri;
    }
}

拍照

File dir = new File(Environment.getExternalStorageDirectory(),"Pictures");
if (!dir.exists()) dir.mkdir();
File image = new File(dir,System.currentTimeMillis()+".jpg");
if (!image.exists()){
    try {
        image.createNewFile();
    } catch (IOException e) {
        e.printStackTrace();
    }
}
Log.d("PhotoTools",image.getAbsolutePath());
PhotoTools.takePicture(MainActivity.this,image);

拍照是否成功

protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode == PhotoTools.REQUEST_CODE_TAKE_PICTURE) {
        Log.d("PhotoTools","onActivityResult "+resultCode);
        if (resultCode == RESULT_OK) {
            Toast.makeText(this, "照片已保存", Toast.LENGTH_LONG).show();
        }
    }
}

关于系统相机的调用，具体可查看官方文档 拍照

注意，在API 24以上版本，不能直接使用file://型的URI，需使用FileProvider机制，具体参见 设置文件共享

FileProvider 配置文件filepaths.xml的标签：

<?xml version="1.0" encoding="utf-8"?>
<paths xmlns:android="http://schemas.android.com/apk/res/android">
    <external-path name="external-path" path="Pictures"/>
</paths>

上例中配置的路径，即为Environment.getExternalStorageDirectory()+"/Pictures"

调用相机API

• CameraManager：主要用于管理系统摄像头

• CameraDevice：用于代表一个摄像头。摄像头功能可被分为limit 和full 两个级别，当摄像头处于limited 级别时候，此时Camera2和早期的Camera功能相差不多。

  其主要承担的任务：

  • 通过CameraDevice.StateCallback监听摄像头的状态（主要包括onOpened、onClosed、onDisconnected、onErro四种状态）
  • 通过方法createCaptureSession方法创建会话

• CameraCharacteristics：描述CameraDevice属性的对象，内部携带大量的相机信息，包含摄像头的正反等

• CaptureRequest：代表一次捕获请求，包含传感器，镜头，闪光灯等。

• CaptureRequest.Builder：用于CaptureRequest对象的构造。

• CameraCaptureSession：请求抓取相机图像帧的会话，主要会建立起一个通道。一个CameraDevice一次只能开启一个会话。 源端是摄像头，另一端是可以是Preview，也可以是ImageReader。需要注意，创建会话是一项耗时的异步操作，可能需要几百毫秒。

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

预览示例：

public class CameraActivity extends Activity implements EasyPermissions.PermissionCallbacks{

    private CameraManager mCameraManager;
    private String mCameraId;
    private SurfaceView mSurfaceView;
    private SurfaceHolder mSurfaceHolder;
    private Handler mHandler;

    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mSurfaceView = findViewById(R.id.preview_view);
        mSurfaceHolder = mSurfaceView.getHolder();
        mSurfaceHolder.addCallback(new SurfaceHolder.Callback() {
            @Override
            public void surfaceCreated(SurfaceHolder holder) {
                initCamera();
            }

            @Override
            public void surfaceChanged(@NonNull SurfaceHolder holder, int format, int width, int height) {

            }

            @Override
            public void surfaceDestroyed(@NonNull SurfaceHolder holder) {

            }
        });

        try {
            mCameraManager = (CameraManager) getSystemService(Context.CAMERA_SERVICE);
            /**
             * 查询本机的摄像头情况，此操作无需权限
             */

            //遍历设备支持摄像头ID ，比如前置，后置等
            String[] cameraIdList = mCameraManager.getCameraIdList();
            for (String cameraId : cameraIdList) {
                Log.d("CameraActivity", "cameraId：" + cameraId);
                CameraCharacteristics characteristics = mCameraManager.getCameraCharacteristics(cameraId);
                //拿到摄像头的朝向：前置，后置，或者外部的
                Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING);

                if (facing != null) {
                        //后置摄像头
                    if (facing == CameraCharacteristics.LENS_FACING_BACK) {
                        mCameraId = cameraId;
                    } else if (facing == CameraCharacteristics.LENS_FACING_FRONT) {
                        //前置摄像头
                    }
                }

                //是否支持 Camera2 的高级特性
                Integer level = characteristics.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL);
                /**
                 * 不支持 Camera2 的特性
                 */
                if (level == null || level == CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY) {
                    Toast.makeText(this, "该手机不支持Camera2的高级特性", Toast.LENGTH_SHORT).show();
                }
            }
        } catch (CameraAccessException e) {
            e.printStackTrace();
        }
    }

    private void initCamera() {
        HandlerThread handlerThread = new HandlerThread("Camera2");
        handlerThread.start();
        mHandler = new Handler(handlerThread.getLooper());
        openCamera();
    }

    @SuppressLint("MissingPermission")
    private void openCamera() {
        try {
            if (EasyPermissions.hasPermissions(CameraActivity.this, Manifest.permission.CAMERA)) {
                Log.d("CameraActivity", "hasPermissions:permission.CAMERA");
                mCameraManager.openCamera(mCameraId, new CameraDeviceCallback(), null);
            } else {
                EasyPermissions.requestPermissions(CameraActivity.this, "该测试需要相机权限", 1, Manifest.permission.CAMERA);
            }
        } catch (CameraAccessException e) {
            Log.e("CameraActivity", "open camera failed." + e.getMessage());
        }
    }

    private void createCameraCaptureSession(CameraDevice device) throws CameraAccessException {
        final CaptureRequest.Builder requestBuilder =
                device.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
        // 添加surface容器，用于预览显示
        requestBuilder.addTarget(mSurfaceHolder.getSurface());

        device.createCaptureSession(Arrays.asList(mSurfaceHolder.getSurface()),
                new CameraCaptureSession.StateCallback() {
                    // 会话开始处理捕获请求
                    @Override
                    public void onConfigured(CameraCaptureSession session) {
                        try {
                            //设置自动聚焦
                            requestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
                            //设置自动曝光
                            requestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);
                            // 请求不断重复捕获图像，以此来实现预览
                            session.setRepeatingRequest(requestBuilder.build(), null, mHandler);
                        } catch (CameraAccessException e) {
                            Log.e("CameraActivity", "set preview builder failed." + e.getMessage());
                        }
                    }

                    @Override
                    public void onConfigureFailed(@NonNull CameraCaptureSession session) {
                        Toast.makeText(CameraActivity.this, "配置失败", Toast.LENGTH_SHORT).show();
                    }
                }, mHandler);
    }

    class CameraDeviceCallback extends CameraDevice.StateCallback{

        //此时摄像头已打开，可以预览了
        @Override
        public void onOpened(@NonNull CameraDevice camera) {
            try {
                createCameraCaptureSession(camera);
            } catch (CameraAccessException e) {
                e.printStackTrace();
            }
        }

        // 摄像头关闭
        @Override
        public void onDisconnected(@NonNull CameraDevice camera) {
            camera.close();
        }

        @Override
        public void onError(@NonNull CameraDevice camera, int error) {
            camera.close();
        }
    }

    // 动态权限处理。这里调用第三方库EasyPermissions来处理
    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this);
    }

    // 授权成功
    @Override
    public void onPermissionsGranted(int requestCode, @NonNull List<String> perms) {
        openCamera();
    }

    // 授权失败
    @Override
    public void onPermissionsDenied(int requestCode, @NonNull List<String> perms) {
        /**
     　　* 若是在权限弹窗中，用户选择拒绝权限。并且勾选了'不在提示'
     　　* 这时候，需要跳转到设置界面去，让用户手动开启权限
     　　*/
        if (EasyPermissions.somePermissionPermanentlyDenied(this, perms)) {
            new AppSettingsDialog.Builder(this).build().show();
        }
    }
}

相机预览的基本步骤：

1. 获取相机设备信息（CameraManager）
2. 创建用于预览的显示区域（SurfaceView或TextureView）
3. 打开相机（openCamera，6.0以上版本需检查动态权限）
4. 创建Capture会话（createCaptureSession）
5. 创建CaptureRequest，并设置条件
6. 开始预览（setRepeatingRequest）
7. 关闭相机

增加拍照处理的逻辑

// 拍照
private void takePicture() {
    if (mCameraDevice == null) return;
    // 创建拍照需要的CaptureRequest
    final CaptureRequest.Builder captureBuilder;
    try {
        captureBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE);
        // 将imageReader的surface作为CaptureRequest.Builder的目标
        captureBuilder.addTarget(mImageReader.getSurface());
        // 自动聚焦、曝光
        captureBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
        captureBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH);

        // 根据设备方向计算设置照片的方向
        captureBuilder.set(CaptureRequest.JPEG_ORIENTATION, getDisplayRotation());
        // 先停止预览
        mCameraCaptureSession.stopRepeating();

        //拍照
        CaptureRequest request = captureBuilder.build();
        mCameraCaptureSession.capture(request, null, mHandler);
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

private int getDisplayRotation(){
    // 获取手机方向
    int rotation = getWindowManager().getDefaultDisplay().getRotation();
    switch (rotation){
        case Surface.ROTATION_0:
            rotation = 0;
            break;
        case Surface.ROTATION_90:
            rotation = 90;
            break;
        case Surface.ROTATION_180:
            rotation = 180;
            break;
        case Surface.ROTATION_270:
            rotation = 270;
            break;
    }
    return (mSensorOrientation - rotation + 360) % 360;
}

// 保存照片
private void saveImage(File file){
    FileOutputStream fos = null;
    Image image = null;
    try {
        fos = new FileOutputStream(file);
        //获取捕获的照片数据
        image = mImageReader.acquireLatestImage();
        //拿到所有的 Plane 数组
        Image.Plane[] planes = image.getPlanes();
        //由于是 JPEG ，数组只有一个元素
        ByteBuffer buffer = planes[0].getBuffer();
        byte[] data = new byte[buffer.remaining()];
        buffer.get(data);
        Bitmap bitmap = BitmapFactory.decodeByteArray(data,0,data.length);
        bitmap.compress(Bitmap.CompressFormat.JPEG,100,fos);
        fos.flush();
    }catch (Exception e){
        Log.e("CameraActivity", ""+e.toString());
    }finally {
        if (fos != null){
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (image != null) {
            image.close();
        }
    }
}

修改之前预览的代码

在initCamera方法中增加ImageReader的创建

private void initCamera() {
    mHandlerThread = new HandlerThread("Camera2");
    mHandlerThread.start();
    mHandler = new Handler(mHandlerThread.getLooper());
    mImageReader = ImageReader.newInstance(mSurfaceView.getWidth(), mSurfaceView.getHeight(),
                                           ImageFormat.JPEG, 2);
    // 当有图像数据生成时，回调OnImageAvailableListener的onImageAvailable方法
    mImageReader.setOnImageAvailableListener(new ImageReader.OnImageAvailableListener() {

        @Override
        public void onImageAvailable(ImageReader reader) {
            File file = new File(Environment.getExternalStorageDirectory(), "take.jpg");
            Log.d("CameraActivity", file.getAbsolutePath());
            saveImage(file);
        }
    }, mHandler);
    openCamera();
}

此外需注意，在createCameraCaptureSession方法中，增加mImageReader.getSurface()

device.createCaptureSession(Arrays.asList(mSurfaceHolder.getSurface(),mImageReader.getSurface()),

在查询摄像头信息时，增加摄像头方向的查询代码

mSensorOrientation = characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);

拍照时，有一个问题需要特别注意，即设置照片的方向。当我们使用 TextureView 或者 SurfaceView 进行画面预览时，系统会根据设备自然方向、摄像头方向和显示方向自动矫正预览画面的方向，但该矫正规则只适用于显示方向和和设备自然方向一致的情况。而当我们拍照时，则需要手动去处理照片方向的问题。

由于手机摄像头的方向和手机自然方向是不同的，通常相差90度，因此我们拍出的照片就需要进行旋转矫正。总结规律，我们可以归纳出一个计算公式

后置摄像头：

矫正角度 = (摄像头方向 - 手机方向 + 360) % 360

前置摄像头：

矫正角度 = (360 - (摄像头方向 + 手机方向) % 360) % 360

我们在拍照时停止了预览，可以设置监听器，在完成后重新开启预览

mCameraCaptureSession.capture(request, new CameraCaptureSession.CaptureCallback() {
                    @Override
                    public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
                        super.onCaptureCompleted(session, request, result);
                        try {
                            //拍完之后，继续预览
                            CaptureRequest.Builder request1 = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
                            request1.addTarget(mSurfaceHolder.getSurface());
                            mCameraCaptureSession.setRepeatingRequest(request1.build(),null,mHandler);
                        } catch (CameraAccessException e) {
                            e.printStackTrace();
                        }
                    }
                }, mHandler);

最后，还有一个问题需要来探讨一下，即预览、拍照的最佳尺寸选择。

当摄像头获取的图像宽高比与预览区域的宽高比不一致时，画面会变形

解决这种变形问题，无外乎两种方式，一种是让预览区域的TextureView的宽高比和摄像头采集的画面宽高比保持一致，这就要重新调整TextureView的宽高，调用TextureView的setDefaultBufferSize方法设置；另一种则是修改画面绘制在 TextureView 上的方式，类似于剪裁，调用TextureView的setTransform()。（注意，SurfaceView没有这些方法，只能通过布局调整它的宽高）

摄像头采集的画面会包含多组宽高尺寸，这里我们先选出最佳尺寸

// 获取预览最佳尺寸
// 注意surface的宽高和获取的Size的宽高是反过来的
private Size getBestPreviewSize(CameraCharacteristics characteristics,int surfaceWidth, int surfaceHeight) {
    Size bestSize = null;
    // 获取摄像头支持的所有输出尺寸
    StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
    Size[] sizeArray = map.getOutputSizes(SurfaceHolder.class);
    for (Size size : sizeArray) {
        Log.d("CameraActivity", "Size: " + size.getWidth()+" - "+size.getHeight());
        // 寻找宽高比相等的尺寸
        if ((size.getWidth() * surfaceWidth/surfaceHeight) == size.getHeight()) {
            bestSize = size;
            break;
        }
    }

    if (bestSize == null){
        // 寻找宽高差值最小的尺寸
        int diffs = Integer.MAX_VALUE;
        for (Size s : sizeArray) {
            int newDiffs = Math.abs(s.getHeight() - surfaceWidth) + Math.abs(s.getWidth() - surfaceHeight);
            if (newDiffs <= diffs) {
                bestSize = s;
                diffs = newDiffs;
            }
        }
    }
    return bestSize;
}

// 然后调用setDefaultBufferSize，设置上述方法返回的Size
// Size bestSize = getBestPreviewSize()
 textureView.setDefaultBufferSize(bestSize.getWidth(), bestSize.getHeight());

关于拍照的尺寸，我们可以选择最大分辨率，以获取最佳质量

// 设置图片尺寸，选择最大的分辨率即可
StreamConfigurationMap map = characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
Size[] sizes = map.getOutputSizes(ImageFormat.JPEG);
// 自定义一个比较器，选出sizes数组的最大值
Size largest = Collections.max(Arrays.asList(sizes),new CompareSizesByArea());
//设置ImageReader
mImageReader = ImageReader.newInstance(largest.getWidth(),largest.getHeight(),
                                       ImageFormat.JPEG,1);

class CompareSizesByArea implements Comparator<Size> {
    @Override
    public int compare(Size lhs, Size rhs) {
        // 比较Size对象的大小，这里以面积大小来比较
        return Long.signum((long) lhs.getWidth() * lhs.getHeight() - (long) rhs.getWidth() * rhs.getHeight());
    }
}

相机相关参数

• createCaptureRequest：该方法需要传入一个模版类型，六种类型如下
  • TEMPLATE_PREVIEW : 配置预览的模板
  • TEMPLATE_STILL_CAPTURE: 用于拍照的模板，图像质量优先于帧速率
  • TEMPLATE_RECORD : 用于视频录制的模板
  • TEMPLATE_VIDEO_SNAPSHOT: 用于视频录制时截图的模板
  • TEMPLATE_ZERO_SHUTTER_LAG : 用于零快门延迟的请求。（在不影响预览帧率的情况下最大化图像质量）
  • TEMPLATE_MANUAL : 手动配置参数的模板，请求中所有的自动控制都是禁用的(自动曝光，自动白平衡、自动焦点)
• CameraCharacteristics.get()：获取相机的各种参数
• CaptureRequest.Builder.set()：设置指定的参数

CameraCharacteristics 常用的Key值属性：

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

CaptureRequest 常用设置的属性字段

• 自动对焦 requestBuilder.set(CaptureRequest.CONTROL_AF_MODE,CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTUR)
• 闪光灯 requestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH)
• 拍照时对照片进行旋转 requestBuilder.set(CaptureRequest.JPEG_ORIENTATION, mCameraSensorOrientation)
• 人脸检测模式 requestBuilder.set(CaptureRequest.STATISTICS_FACE_DETECT_MODE,CameraCharacteristics.STATISTICS_FACE_DETECT_MODE_SIMPLE)

这里还需要注意，CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL属性用于查询硬件层面支持的Camera2功能的等级，主要分为五个等级：

• INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY

  向后兼容模式, 基本没有额外功能，相当于Camera API接口

• INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED

  除了基本的功能, 还支持一些额外的高级功能， 这些高级功能是LEVEL_FULL的子集

• INFO_SUPPORTED_HARDWARE_LEVEL_FULL

  支持对每一帧数据进行控制,还支持高速率的图片拍摄

• INFO_SUPPORTED_HARDWARE_LEVEL_3

  支持YUV后处理和Raw格式图片拍摄, 还支持额外的输出流配置

• INFO_SUPPORTED_HARDWARE_LEVEL_EXTERNAL

  API28中加入，对应的是外接摄像头，功能类似LIMITED等级

支持的功能多少排序为：LEGACY < LIMITED < FULL < LEVEL_3

更多属性，可查看官方文档 CameraCharacteristics 或者查看以下附录内容

相机API的使用，可参考Google的2个Java写的Demo工程

• https://github.com/googlearchive/android-Camera2Basic

• https://github.com/googlearchive/android-Camera2Raw

附录：

CameraCharacteristics 属性

CaptureRequest 和 CaptureResult 属性

公众号“编程之路从0到1”