基础知识

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

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

相关开发类

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

术语

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

相机功能

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

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

区域测光和对焦

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

人脸检测

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

延时视频

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

其他重要功能API：

功能API

Camera1使用

流程：

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

权限声明

<uses-feature
        android:name="android.hardware.camera"
        android:required="true" />

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

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

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

开发流程

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

打开相机

Camera.open()

该方法的系统源码实现

public static Camera open() {
    int numberOfCameras = getNumberOfCameras();
    CameraInfo cameraInfo = new CameraInfo();
    for (int i = 0; i < numberOfCameras; i++) {
        getCameraInfo(i, cameraInfo);
        if (cameraInfo.facing == CameraInfo.CAMERA_FACING_BACK) {
            return new Camera(i);
        }
    }
    return null;
}

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

创建预览画面

这里使用的是SurfaceView

private SurfaceView mSurfaceView;
private SurfaceHolder mSurfaceHolder;
...
mSurfaceHolder = mSurfaceView.getHolder();
mSurfaceHolder.addCallback(new SurfaceHolder.Callback() {
    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        ...
        startPreview();
    }

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

    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        releaseCamera();
    }
});
...
private void startPreview() {
    try {
        //设置实时预览
        mCamera.setPreviewDisplay(mSurfaceHolder);
        //Orientation
        setCameraDisplayOrientation();
        //开始预览
        mCamera.startPreview();

        startFaceDetect();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

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

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

设置相机参数

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

private void initParameters(final Camera camera) {
    mParameters = camera.getParameters();
    mParameters.setPreviewFormat(ImageFormat.NV21); //default

    if (isSupportFocus(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) {
        mParameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
    } else if (isSupportFocus(Camera.Parameters.FOCUS_MODE_AUTO)) {
        mParameters.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
    }

    //设置预览图片大小
    setPreviewSize();
    //设置图片大小
    setPictureSize();

    camera.setParameters(mParameters);
}

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

 

Camera.Parameters

1.setFocusMode

设置对焦模式

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

2.setPreviewSize

设置预览图片大小

3.setPreviewFormat

支持的格式：

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

4.setPictureSize

设置保存图片的大小

5.setPictureFormat

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

6.setDisplayOrientation

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

7.setPreviewDisplay

设置实时预览SurfaceHolder

8.setPreviewCallback

监听相机预览数据回调

9.setParameters

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

设置方向

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

private void setCameraDisplayOrientation() {
    Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
    Camera.getCameraInfo(mCameraId, cameraInfo);
    int rotation = getWindowManager().getDefaultDisplay().getRotation();  //自然方向
    int degrees = 0;
    switch (rotation) {
        case Surface.ROTATION_0:
            degrees = 0;
            break;
        case Surface.ROTATION_90:
            degrees = 90;
            break;
        case Surface.ROTATION_180:
            degrees = 180;
            break;
        case Surface.ROTATION_270:
            degrees = 270;
            break;
    }

    int result;
    //cameraInfo.orientation 图像传感方向
    if (cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
        result = (cameraInfo.orientation + degrees) % 360;
        result = (360 - result) % 360;
    } else {
        result = (cameraInfo.orientation - degrees + 360) % 360;
    }

    mOrientation = result;
    //相机预览方向
    mCamera.setDisplayOrientation(result);
}

拍照

private void takePicture() {
    if (null != mCamera) {
        mCamera.takePicture(new Camera.ShutterCallback() {
            @Override
            public void onShutter() {

            }
        }, new Camera.PictureCallback() {
            @Override
            public void onPictureTaken(byte[] data, Camera camera) {
                //base data
            }
        }, new Camera.PictureCallback() {
            @Override
            public void onPictureTaken(final byte[] data, Camera camera) {
                mCamera.startPreview();
                //save data
            }
        });
    }
}

takePicture的源码实现：

public final void takePicture(ShutterCallback shutter, PictureCallback raw,
            PictureCallback jpeg) {
        takePicture(shutter, raw, null, jpeg);
    }

• shutter(ShutterCallback)：快门按下后的回调
• raw(PictureCallback)：raw图像数据
• jpeg(PictureCallback)：jpeg图像生成以后的回调

释放相机资源

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

private void releaseCamera() {
    if (null != mCamera) {
        mCamera.stopPreview();
        mCamera.stopFaceDetection();
        mCamera.setPreviewCallback(null);
        mCamera.release();
        mCamera = null;
    }
}

• stopPreview：停止预览
• release：释放资源

Camera2使用

设计框架

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

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

优点

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

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

开发流程

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

类

CameraManager

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

CameraDevice

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

CameraCharacteristics

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

CaptureRequest

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

CaptureRequest.Builder

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

CameraCaptureSession

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

ImageReader

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

流程

 Camera2开发流程

获取CameraManager

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

获取相机信息

for (String cameraId : cameraManager.getCameraIdList()) {
    CameraCharacteristics characteristics = cameraManager.getCameraCharacteristics(cameraId);

    Integer facing = characteristics.get(CameraCharacteristics.LENS_FACING);
    if (null != facing && facing == CameraCharacteristics.LENS_FACING_FRONT) {
        continue;
    }
    ....
}

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

初始化ImageReader

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

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

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

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

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

打开相机设备

try {
    if (!mCameraOpenCloseLock.tryAcquire(2500, TimeUnit.MILLISECONDS)) {
        throw new RuntimeException("Time out waiting to lock camera opening.");
    }

    cameraManager.openCamera(mCameraId, mStateCallback, mBackgroundHandler);
} catch (Exception e) {
    e.printStackTrace();
}

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

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

其中callback回调：

private final CameraDevice.StateCallback mStateCallback = new CameraDevice.StateCallback() {
    @Override
    public void onOpened(@NonNull CameraDevice camera) {
        mCameraOpenCloseLock.release();
        mCameraDevice = camera;
        createCameraPreviewSession();
    }

    @Override
    public void onDisconnected(@NonNull CameraDevice camera) {
        mCameraOpenCloseLock.release();
        camera.close();
        mCameraDevice = null;
    }

    @Override
    public void onError(@NonNull CameraDevice camera, int error) {
        mCameraOpenCloseLock.release();
        camera.close();
        mCameraDevice = null;
    }

    @Override
    public void onClosed(@NonNull CameraDevice camera) {
        super.onClosed(camera);
    }
};

• onOpened：表示相机打开成功，可以真正开始使用相机，创建Capture会话
• onDisconnected：当相机断开连接时回调该方法，需要进行释放相机的操作
• onError：当相机打开失败时，需要进行释放相机的操作
• onClosed：调用Camera.close()后的回调方法

创建Capture会话

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

private void createCameraPreviewSession() {
    SurfaceTexture texture = mTextureView.getSurfaceTexture();
    assert texture != null;
    texture.setDefaultBufferSize(mPreviewSize.getWidth(), mPreviewSize.getHeight());
    Surface surface = new Surface(texture);

    try {
        mPreviewRequestBuilder = mCameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
        mPreviewRequestBuilder.addTarget(surface);

        // Here, we create a CameraCaptureSession for camera preview.
        mCameraDevice.createCaptureSession(Arrays.asList(surface, mImageReader.getSurface()),
                new CameraCaptureSession.StateCallback() {

                    @Override
                    public void onConfigured(@NonNull CameraCaptureSession cameraCaptureSession) {
                        // The camera is already closed
                        if (null == mCameraDevice) {
                            return;
                        }

                        // When the session is ready, we start displaying the preview.
                        mCaptureSession = cameraCaptureSession;
                        try {
                            // Auto focus should be continuous for camera preview.
                            mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE,
                                    CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
                            // Flash is automatically enabled when necessary.
                            setAutoFlash(mPreviewRequestBuilder);

                            // Finally, we start displaying the camera preview.
                            mPreviewRequest = mPreviewRequestBuilder.build();
                            mCaptureSession.setRepeatingRequest(mPreviewRequest,
                                    mCaptureCallback, mBackgroundHandler);
                        } catch (CameraAccessException e) {
                            e.printStackTrace();
                        }
                    }

                    @Override
                    public void onConfigureFailed(
                            @NonNull CameraCaptureSession cameraCaptureSession) {
                        Toast.makeText(Camera2Activity.this, "configureFailed", Toast.LENGTH_SHORT).show();
                    }
                }, null
        );
    } catch (CameraAccessException e) {
        e.printStackTrace();
    }
}

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

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

创建CaptureRequest

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

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

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

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

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

// Auto focus should be continuous for camera preview.
mPreviewRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE,
        CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE);
// Flash is automatically enabled when necessary.
setAutoFlash(mPreviewRequestBuilder);

// Finally, we start displaying the camera preview.
mPreviewRequest = mPreviewRequestBuilder.build();

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

预览

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

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

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

拍照

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

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

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

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

这里设置了mCaptureCallback：

private CameraCaptureSession.CaptureCallback mCaptureCallback = new CameraCaptureSession.CaptureCallback() {
    @Override
    public void onCaptureProgressed(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull CaptureResult partialResult) {
        process(partialResult);
    }

    @Override
    public void onCaptureCompleted(@NonNull CameraCaptureSession session, @NonNull CaptureRequest request, @NonNull TotalCaptureResult result) {
        process(result);
    }

    private void process(CaptureResult result) {
        switch (mState) {
            case STATE_PREVIEW: {
                // We have nothing to do when the camera preview is working normally.
                break;
            }
            case STATE_WAITING_LOCK: {
                Integer afState = result.get(CaptureResult.CONTROL_AF_STATE);
                Log.d("DEBUG", "##### process STATE_WAITING_LOCK: " + afState);
                if (afState == null) {
                    captureStillPicture();
                } else if (CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED == afState ||
                        CaptureResult.CONTROL_AF_STATE_NOT_FOCUSED_LOCKED == afState) {
                    // CONTROL_AE_STATE can be null on some devices
                    Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
                    if (aeState == null ||
                            aeState == CaptureResult.CONTROL_AE_STATE_CONVERGED) {
                        mState = STATE_PICTURE_TAKEN;
                        captureStillPicture();
                    } else {
                        runPrecaptureSequence();
                    }
                }
                break;
            }
            case STATE_WAITING_PRECAPTURE: {
                // CONTROL_AE_STATE can be null on some devices
                Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
                if (aeState == null ||
                        aeState == CaptureResult.CONTROL_AE_STATE_PRECAPTURE ||
                        aeState == CaptureRequest.CONTROL_AE_STATE_FLASH_REQUIRED) {
                    mState = STATE_WAITING_NON_PRECAPTURE;
                }
                break;
            }
            case STATE_WAITING_NON_PRECAPTURE: {
                // CONTROL_AE_STATE can be null on some devices
                Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
                if (aeState == null || aeState != CaptureResult.CONTROL_AE_STATE_PRECAPTURE) {
                    mState = STATE_PICTURE_TAKEN;
                    captureStillPicture();
                }
                break;
            }
        }
    }
};

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

关闭相机

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

private void closeCamera() {
    try {
        mCameraOpenCloseLock.acquire();
        if (null != mCaptureSession) {
            mCaptureSession.close();
            mCaptureSession = null;
        }
        if (null != mCameraDevice) {
            mCameraDevice.close();
            mCameraDevice = null;
        }
        if (null != mImageReader) {
            mImageReader.close();
            mImageReader = null;
        }
    } catch (InterruptedException e) {
        throw new RuntimeException("Interrupted while trying to lock camera closing.", e);
    } finally {
        mCameraOpenCloseLock.release();
    }
}

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

CameraView

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

开发流程

CameraView定义

xml中定义

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

xml中可以配置：

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

增加生命周期

@Override
protected void onResume() {
    super.onResume();
    mCameraView.start();
}

@Override
protected void onPause() {
    mCameraView.stop();
    super.onPause();
}

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

相机状态回调

在xml声明CameraView后，增加回调

if (mCameraView != null) {
    mCameraView.addCallback(mCallback);
}
...
private CameraView.Callback mCallback
            = new CameraView.Callback() {

    @Override
    public void onCameraOpened(CameraView cameraView) {
        Log.d(TAG, "onCameraOpened");
    }

    @Override
    public void onCameraClosed(CameraView cameraView) {
        Log.d(TAG, "onCameraClosed");
    }

    @Override
    public void onPictureTaken(CameraView cameraView, final byte[] data) {
        Log.d(TAG, "onPictureTaken " + data.length);
        Toast.makeText(cameraView.getContext(), R.string.picture_taken, Toast.LENGTH_SHORT)
                .show();
        getBackgroundHandler().post(new Runnable() {
            @Override
            public void run() {
                File file = new File(getExternalFilesDir(Environment.DIRECTORY_PICTURES),
                        "picture.jpg");
                Log.d(TAG, "onPictureTaken file path: " + file.getPath());
                OutputStream os = null;
                try {
                    os = new FileOutputStream(file);
                    os.write(data);
                    os.close();
                } catch (IOException e) {
                    Log.w(TAG, "Cannot write to " + file, e);
                } finally {
                    if (os != null) {
                        try {
                            os.close();
                        } catch (IOException e) {
                            // Ignore
                        }
                    }
                }
            }
        });
    }

};

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

拍照

mCameraView.takePicture();

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

CameraX

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

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

开发流程

库引用

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

dependencies {
    // CameraX core library.
    def camerax_version = "1.0.0-alpha06"
    implementation "androidx.camera:camera-core:${camerax_version}"
    // If you want to use Camera2 extensions.
    implementation "androidx.camera:camera-camera2:${camerax_version}"

    def camerax_view_version = "1.0.0-alpha03"
    def camerax_ext_version = "1.0.0-alpha03"
    //other
    // If you to use the Camera View class
    implementation "androidx.camera:camera-view:$camerax_view_version"
    // If you to use Camera Extensions
    implementation "androidx.camera:camera-extensions:$camerax_ext_version"
}

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

预览

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

PreviewConfig config = new PreviewConfig.Builder()
                .setLensFacing(CameraX.LensFacing.BACK)
                .setTargetRotation(mTextureView.getDisplay().getRotation())
                .setTargetResolution(new Size(640, 480))
                .build();

Preview preview = new Preview(config);
preview.setOnPreviewOutputUpdateListener(new Preview.OnPreviewOutputUpdateListener() {
    @Override
    public void onUpdated(@NonNull Preview.PreviewOutput output) {
        if (mTextureView.getParent() instanceof ViewGroup) {
            ViewGroup viewGroup = (ViewGroup) mTextureView.getParent();
            viewGroup.removeView(mTextureView);
            viewGroup.addView(mTextureView, 0);

            mTextureView.setSurfaceTexture(output.getSurfaceTexture());
            updateTransform();
        }
    }
});

//lifecycle
CameraX.bindToLifecycle(this, preview);

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

拍照

ImageCaptureConfig captureConfig = new ImageCaptureConfig.Builder()
        .setTargetAspectRatio(AspectRatio.RATIO_16_9)
        .setCaptureMode(ImageCapture.CaptureMode.MIN_LATENCY)
        .setTargetRotation(getWindowManager().getDefaultDisplay().getRotation())
        .build();

ImageCapture imageCapture = new ImageCapture(captureConfig);
mTakePicture.setOnClickListener((view) -> {
    final File file = new File(getExternalMediaDirs()[0], System.currentTimeMillis() + ".jpg");
    Log.d("DEBUG", "##### file path: " + file.getPath());
    imageCapture.takePicture(file, ContextCompat.getMainExecutor(getApplicationContext()), new ImageCapture.OnImageSavedListener() {
        @Override
        public void onImageSaved(@NonNull File file) {
            Log.d("DEBUG", "##### onImageSaved: " + file.getPath());
        }

        @Override
        public void onError(@NonNull ImageCapture.ImageCaptureError imageCaptureError, @NonNull String message, @Nullable Throwable cause) {
            Log.d("DEBUG", "##### onError: " + message);
        }
    });
});

CameraX.bindToLifecycle(this, preview, imageCapture);

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

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

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

图片分析

ImageAnalysisConfig analysisConfig = new ImageAnalysisConfig.Builder()
        .setImageReaderMode(ImageAnalysis.ImageReaderMode.ACQUIRE_LATEST_IMAGE)
        .build();

ImageAnalysis imageAnalysis = new ImageAnalysis(analysisConfig);
imageAnalysis.setAnalyzer(ContextCompat.getMainExecutor(getApplicationContext()),
        new LuminosityAnalyzer());

CameraX.bindToLifecycle(this, preview, imageCapture, imageAnalysis);

...
private class LuminosityAnalyzer implements ImageAnalysis.Analyzer {
    private long lastAnalyzedTimestamp = 0L;

    @Override
    public void analyze(ImageProxy image, int rotationDegrees) {
        final Image img = image.getImage();
        if (img != null) {
            Log.d("DEBUG", img.getWidth() + "," + img.getHeight());
        }
    }
}

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

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

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

 

 

 

一、摘要

本篇文章围绕实际相机功能的对焦场景阐述如何开发好一个功能完善的相机对焦功能。

相关文章：

1. Camera1 对焦(一) UI坐标系和相机坐标系
2. Camera1 对焦(二) 对焦区域计算的几种方式(Touch to Focus)
3. Camera1 Parameters参数详解(二)—— 3A算法 (对焦、曝光、白平衡)
4. Android AF Work Flow安卓自动对焦工作流程

二、对焦功能流程

2.1 功能分类

2.1.1 对焦模式

对焦模式
FOCUS_MODE_AUTO
FOCUS_MODE_INFINITY
FOCUS_MODE_MACRO
FOCUS_MODE_FIXED
FOCUS_MODE_EDOF
FOCUS_MODE_CONTINUOUS_VIDEO
FOCUS_MODE_CONTINUOUS_PICTURE

具体细节可参考Camera1 Parameters参数详解(二)—— 3A算法 (对焦、曝光、白平衡)【二.AF】

2.1.2 对焦功能

1. 连续对焦：用于相机移动预览画面，对应对焦模式为continuous
2. 单次对焦：touch focus，点击对焦

2.2 对焦工作流程

2.2.1 Part1： 【1、2、3】

1. 进入相机首先设置模式为连续对焦，拍照和视频对应不同的连续对焦

2.2.2 Part2：【5、6、7】

1. 单次对焦分为2种，一种为自己触发一次中心对焦。另外一种为根据onTouchEvent获取点击位置Touch Focus。
2. 自己触发一次中心对焦即坐标点为(mPreviewUIWidth/2f，mPreviewUIHeight/2f)，Touch Focus即(touchX, touchY)
3. 判断AUTO模式，判断maxMeterAreaNum、maxFocusAreaNum等
4. 具体代码可参考Camera1 对焦(二) 对焦区域计算的几种方式(Touch to Focus)

2.2.3 Part3：【8、9】

part2之后即锁定了对焦区域为Part2设置的rect。此时需要监听手机是否移动，如果不监听手机是否做移动就会出现对焦区域锁定在点击区域，移到别的场景就会出现不对焦的情况。

1. 监听手机传感器，根据阀值判断手机是否移动相关距离
2. 如果移动则切换到连续对焦
3. 这里需要延后一定时间如3000ms后开始检测移动，否则当点击固定区域对焦后手抖就会立马失焦

2.3 相关代码

2.3.1 设置连续对焦模式代码：

private void setAutoFocus(Camera camera) {
	if (camera is null) {
	   return;
	}
	try {
	   Camera.Parameters params = mCamera1Config.getCameraParameter(camera);
	   if (params == null) {
	       return;
	   }
	   List<String> modes = params.getSupportedFocusModes();
	   if (modes is null) {
	       return;
	   }
	   if (isVideo && modes.contains(FOCUS_MODE_CONTINUOUS_VIDEO)) {
	       params.setFocusMode(FOCUS_MODE_CONTINUOUS_VIDEO);
	   } else if (modes.contains(FOCUS_MODE_CONTINUOUS_PICTURE)) {
	       params.setFocusMode(FOCUS_MODE_CONTINUOUS_PICTURE);
	   } else if (modes.contains(FOCUS_MODE_FIXED)) {
	       params.setFocusMode(FOCUS_MODE_FIXED);
	   } else if (modes.contains(FOCUS_MODE_INFINITY)) {
	       params.setFocusMode(FOCUS_MODE_INFINITY);
	   } else {
	       params.setFocusMode(modes.get(0));
	   }
	   camera.setParameters(params);
	} catch (Exception e) {
		...
	}
}

2.3.2 touch Focus相关代码

传送门 => Camera1 对焦(二) 对焦区域计算的几种方式(Touch to Focus)

2.3.3 监听传感器移动

public class PhoneMovementDetector implements SensorEventListener {
    protected final String TAG = getClass().getSimpleName();
    private SensorManager sensorManager;
    private Sensor accelerometer;
    private Listener listener;
    private Semaphore lock = new Semaphore(1);
    
    private static PhoneMovementDetector mInstance = new PhoneMovementDetector();

    private void init() {
        sensorManager = (SensorManager) AppContexts.sContext.getSystemService(Context.SENSOR_SERVICE);
        accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_LINEAR_ACCELERATION);
    }

    public PhoneMovementDetector start(Listener listener) {
        this.listener = listener;
        sensorManager.registerListener(this, accelerometer, SensorManager.SENSOR_DELAY_NORMAL);
        return this;
    }

    public PhoneMovementDetector stop() {
        sensorManager.unregisterListener(this);
        this.listener = null;
        return this;
    }

    private long lastTime = 0;
    @Override
    public void onSensorChanged(SensorEvent event) {
        if (event.sensor.getType() == Sensor.TYPE_LINEAR_ACCELERATION) {
            try {
                float x = event.values[0];
                float y = event.values[1];
                float z = event.values[2];
                float diff = x * x + y * y + z * z;
                listener.onMotionDetected(diff);
            } catch (Exception e) {
            } finally {
            }
        }
    }
    
    public interface Listener {
        void onMotionDetected(float acceleration);
    }
}

综上，Android Camera里对焦功能开发基于上述流程即可。

音视频 系列文章
Android 音视频开发(一) – 使用AudioRecord 录制PCM(录音)；AudioTrack播放音频
Android 音视频开发(二) – Camera1 实现预览、拍照功能
Android 音视频开发(三) – Camera2 实现预览、拍照功能
Android 音视频开发(四) – CameraX 实现预览、拍照功能
Android 音视频开发(五) – 使用 MediaExtractor 分离音视频，并使用 MediaMuxer合成新视频(音视频同步)
音视频工程

Camera1 在 API 21 的时候已经被弃用了，虽然现在google 都推荐 使用 Camerax 来实现相机的一些功能，但这不妨碍我们学习 Camera1 和 Camera2，对此有基础了解，为后续学习 Camera2 和 Camerax 做铺垫

在这篇文章中，你将了解到：

1. 实现相机的开启与预览
2. 相机预览方向的矫正
3. 实现拍照功能，并矫正拍照图片

效果如下：

一. 相机的开启与预览

首先，先申请权限：

 <uses-permission android:name="android.permission.CAMERA" />
 <!-- 支持相机才能运行 -->
 <uses-feature
     android:name="android.hardware.camera"
     android:required="true" />

1.1. 获取相机个数

一般手机中，都有前置摄像头和后置摄像头，我们可以根据 Camera 的 getNumberOfCameras() 方法，来获取这些信息。比如：

 //获取相机个数
 int numberOfCameras = Camera.getNumberOfCameras();
 for (int i = 0; i < numberOfCameras; i++) {
     Camera.CameraInfo info = new Camera.CameraInfo();
     //获取相机信息
     Camera.getCameraInfo(i, info);
     //前置摄像头
     if (Camera.CameraInfo.CAMERA_FACING_FRONT == info.facing) {
         mFrontCameraId = i;
         mFrontCameraInfo = info;
     } else if (Camera.CameraInfo.CAMERA_FACING_BACK == info.facing) {
         mBackCameraId = i;
         mBackCameraInfo = info;
     }
 }

可以看到，通过 Camera.getCameraInfo(i, info) 就可以拿到当前的 CameraInfo 的信息，里面有个参数我们需要注意一下，就是 facing，它表示当前摄像机面对的方向，理解为前置和后置，然后我们把这些信息也保存起来。

1.2 打开摄像头

接着，我们可以使用 Camera.open(cameraid) 去打开摄像头

 //根据 cameraId 打开不同摄像头
 mCamera = Camera.open(cameraId);

打开我们的摄像头之后，可以对它进行一些配置，比如设置预览方向等，这个话题我们等到下面出现了再说。

1.3 配置摄像头属性

在开启相机预览之前，我们需要对相机进行一些参数配置，比如聚焦，预览尺寸等；这里我使用的是 SurfaceView，所以等SurfaceView 创建好之后，可以对它进行一些参数的设置：

  @Override
  public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
      startPreview(width, height);
  }

# startPreview
private void startPreview(int width, int height) {
	//配置camera参数
    initPreviewParams(width, height);
    //设置预览 SurfaceHolder
    Camera camera = mCamera;
    if (camera != null) {
        try {
            camera.setPreviewDisplay(mSurfaceView.getHolder());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    //开始显示
    camera.startPreview();
}

在Camra 中，我们可以通过 camera.getParameters() 拿到相机默认的参数，如果要配置自己的参数，可以使用 camera.setParameters(parameters) 去设置，不过这个比较比较好使，所以相机的配置开启这些，可以使用 HandlerThread 去开启，这里就不增加多余代码了。
initPreviewParams 的完整代码如下：

    private void initPreviewParams(int shortSize, int longSize) {
        Camera camera = mCamera;
        if (camera != null) {
            Camera.Parameters parameters = camera.getParameters();
            //获取手机支持的尺寸
            List<Camera.Size> sizes = parameters.getSupportedPreviewSizes();
            Camera.Size bestSize = getBestSize(shortSize, longSize, sizes);
            //设置预览大小
            parameters.setPreviewSize(bestSize.width, bestSize.height);
            //设置图片大小，拍照
            parameters.setPictureSize(bestSize.width, bestSize.height);
            //设置格式,所有的相机都支持 NV21格式
            parameters.setPreviewFormat(ImageFormat.NV21);
            //设置聚焦
            parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);

            camera.setParameters(parameters);
        }
    }

1.3.1 相机预览大小

首先，应该根据自己UI的大小去设置相机预览的大小，如果你的控件为 200x200，但相机的数据为 1920x1080 ，这样填充过去，画面肯定是会被拉伸的。
所以，可以通过

List<Camera.Size> sizes = parameters.getSupportedPreviewSizes()

拿到手机相机支持的所有尺寸；所以，我们需要找到比例相同，或者近似的大小，跟UI配合，这样画面才不会拉伸，注意相机的 width > height，所以获取一个最佳的预览尺寸可以这样写：

/**
  * 获取预览最后尺寸
  */
 private Camera.Size getBestSize(int shortSize, int longSize, List<Camera.Size> sizes) {
     Camera.Size bestSize = null;
     float uiRatio = (float) longSize / shortSize;
     float minRatio = uiRatio;
     for (Camera.Size previewSize : sizes) {
         float cameraRatio = (float) previewSize.width / previewSize.height;

         //如果找不到比例相同的，找一个最近的,防止预览变形
         float offset = Math.abs(cameraRatio - minRatio);
         if (offset < minRatio) {
             minRatio = offset;
             bestSize = previewSize;
         }
         //比例相同
         if (uiRatio == cameraRatio) {
             bestSize = previewSize;
             break;
         }

     }
     return bestSize;
 }

当 UI 的比例跟相机支持的比例相同，直接返回，否则则找近似的。

接着调用

效果如下：

咦，发现预览的方向是反的；这个时候就需要使用 setDisplayOrientation() 去设置预览方向了

二. 调整预览方向

首先，在调整预览方向钱，我们需要先了解一些知识。

• 屏幕坐标： Android 坐标系中，在 （0,0） 坐标那，向右为 x 轴，向下为 y 轴。
• 自然方向： 设置的自然方向，比如手机默认就是竖直是自然方向，平板的话，横向就是自然方向
• 图片传感器方向： 手机的图片数据都来自摄像头硬件传感器，这个传感器有个默认的方向，一般是手机是横向的，这就跟手机的自然方向成 90° 关系了。

所以，我们要做的就是，就是把传感器拿到的图片，进行一个角度的变化，使图像能跟自然方向一致：
图片来源

所以，我们的方向调整可以这样写：

    private void adjustCameraOrientation(Camera.CameraInfo info) {
        //判断当前的横竖屏
        int rotation = getWindowManager().getDefaultDisplay().getRotation();

        int degress = 0;
        //获取手机的方向
        switch (rotation) {
            case Surface.ROTATION_0:
                degress = 0;
                break;
            case Surface.ROTATION_90:
                degress = 90;
                break;
            case Surface.ROTATION_180:
                degress = 180;
                break;
            case Surface.ROTATION_270:
                degress = 270;
                break;
        }
        int result = 0;
        //后置摄像头
        if (info.facing == Camera.CameraInfo.CAMERA_FACING_BACK) {
            result = (info.orientation - degress + 360) % 360;
        } else if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
            //先镜像
            result = (info.orientation + degress) % 360;
            result = (360 - result) % 360;
        }
        mCamera.setDisplayOrientation(result);

    }

最后再看一下：

三. 切换摄像头

现在用到的都是后置摄像头，切换也比较简单，首先先释放相机支援，然后再从配置参数，预览再来一遍即可：

  //关闭摄像头
  closeCamera();
  
  mCameraID = mCameraID == mFrontCameraId ? mBackCameraId : mFrontCameraId;
  //打开相机
  openCamera(mCameraID);
  //开启预览
  startPreview(mSurfaceView.getWidth(), mSurfaceView.getHeight());

#closeCamera
 private void closeCamera() {
     //停止预览
     mCamera.stopPreview();
     mCamera.release();
     mCamera = null;
 }

四. 拍照及调整图片方向

Camera 的拍照也比较简单，使用 takePicture(ShutterCallback shutter, PictureCallback raw， PictureCallback jpeg) 方法即可，它的三个参数如下：

• ShutterCallback ：拍照瞬间调用，如果空回调，则由声音，传 null ，则没效果
• PictureCallback ：图片的原始数据，即没处理过的
• PictureCallback ： 图片的 JPEG 数据

拿到 byte 数据后，转换成bitmap即可，如下：

Camera camera = mCamera;
camera.takePicture(new Camera.ShutterCallback() {
    @Override
    public void onShutter() {
        
    }
}, null, new Camera.PictureCallback() {
    @Override
    public void onPictureTaken(byte[] data, Camera camera) {
        new SavePicAsyncTask(data).executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
    }
});

这里的图片保存，用一个 AsyncTask 来保存：

    /**
     * 保存图片
     */
    class SavePicAsyncTask extends AsyncTask<Void, Void, File> {

        byte[] data;
        File file;

        public SavePicAsyncTask(byte[] data) {
            this.data = data;
            File dir = new File(Constants.PATH);
            if (!dir.exists()) {
                dir.mkdirs();
            }
            String name = "test.jpg";
            file = new File(dir, name);
        }

        @Override
        protected File doInBackground(Void... voids) {
            Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0, data.length);
            if (bitmap == null) {
                return null;
            }
            FileOutputStream fos = null;
            try {
                fos = new FileOutputStream(file);
                //保存之前先调整方向
                Camera.CameraInfo info = mCameraID == mFrontCameraId ? mFrontCameraInfo : mBackCameraInfo;
                if (info.facing == Camera.CameraInfo.CAMERA_FACING_BACK) {
                    bitmap = BitmapUtils.rotate(bitmap, 90);
                } else {
                    bitmap = BitmapUtils.rotate(bitmap, 270);
                }
                bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fos);


            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } finally {
                CloseUtils.close(fos);
            }
            return file;
        }

        @Override
        protected void onPostExecute(File file) {
            super.onPostExecute(file);
            if (file != null) {
                Toast.makeText(Camera1Activity.this, "图片保存成功", Toast.LENGTH_SHORT).show();
            } else {
                Toast.makeText(Camera1Activity.this, "图片保存失败", Toast.LENGTH_SHORT).show();
            }
        }
    }
#BitmapUtils#rotate

    public static Bitmap rotate(Bitmap bitmap,float degress){
        Matrix matrix = new Matrix();
        matrix.postRotate(degress);
        return Bitmap.createBitmap(bitmap,0,0,bitmap.getWidth(),bitmap.getHeight(),matrix,true);
    }

当拿到 byte[] 数据时，使用 BitmapFactory.decodeByteArray 解析 bitmap ，但此时的图片也是不对的，需要对它进行一个旋转，如上所示，这样，我们的拍照就也完成了。

参考:
https://developer.android.google.cn/reference/android/hardware/Camera?hl=en#takePicture(android.hardware.Camera.ShutterCallback,%20android.hardware.Camera.PictureCallback,%20android.hardware.Camera.PictureCallback,%20android.hardware.Camera.PictureCallback)

https://www.jianshu.com/p/f8d0d1467584