Android相机开发——CameraView源码解析

2018-02-07 本文已影响1289人管弦_

前言

年底公司赶项目，忙得不亦乐乎，博客也很久没更新了。公司项目里用到了自定义摄像头的模块，也参考了Google开源项目CameraView来实现版本兼容的问题，这篇博客也是忙里偷闲来总结一下CameraView的源码。

相机开发需要注意的问题

随着Android版本的不断升级，Android对摄像头的调用方法也在不断更新，导致日趋严重的碎片化问题。

版本兼容性问题：Androd提供了两套调用摄像头的API，Android5.0以下的Camera和Android5.0以上的Camera2。同时，Android又提供了两种常用的摄像头预览控件：Android 4.0以下的SurfaceView和Android 4.0以上的TextureView。
设备兼容性问题：各个厂家硬件设计不同和对摄像头的调校力度不同，对Camera/Camera2的支持程度也不同，甚至有些5.0以上的设备并不支持Camera2，需要降级使用Camera。要解决这种设备兼容性问题需要不断积累，一点一点踩坑。
各个场景下的生命周期变化：如应用程序切换至后台运行、预览状态下锁屏、横竖屏切换等等，对应各个场景变化，我们需要随之执行摄像头的申请与释放、Surface的创建与销毁等一系列动作。

Android官方推出的开源项目CameraView，主要针对摄像头的版本兼容性问题提供了一种解决方案。Android5.0以下用Camera，Android5.0以上用Camera2；Android4.0以下用SurfaceView和Android4.0以上用TextureView。个别厂家设备Android5.0并不支持Camera2，这种情况不在我们的讨论范围内。

版本兼容策略，图片来源于参考资料

自定义相机的开发流程

自定义相机开发流程一般分为以下几个步骤：

检查权限：在AndroidManifest.xml中添加Camera相关功能使用的权限，Android6.0以上需要申请动态权限。
打开摄像头：检测并访问相机资源，打开指定的摄像头（前置或后置），这一动作比较耗时，一般在子线程中执行。打开成功后获取到摄像头对象，通过它可以获得该摄像头相关参数，也可以设置一些自定义参数（如闪光灯、对焦模式）。
开启预览：创建预览控件和设置预览参数，摄像头预览数据同步显示在预览控件上。
执行拍照：设置回调监听，获取拍照回传的图像数据。将拍摄获得的图像转换成位图文件，最终输出保存成各种常用格式的图片。
关闭预览：对应各个场景生命周期执行关闭预览。
关闭摄像头：当相机使用完毕后，应用程序必须正确地将其释放，以免消耗资源和发生异常冲突。

相机开发流程图，来源见水印

CameraView生命周期管理

我们在相机开发需要注意的问题一节中强调过对生命周期的管理。CameraView巧妙的将自身的生命周期封装在控件内部交由上层（Activity）进行维护，同时也简化了调用流程。我们可以看看CmaeraView项目首页上的用法介绍：

<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"/>

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

这里可以看到，只需要在Activity的onResume()执行mCameraView.start()和在onPause()执行mCameraView.stop()就可以简单维护整个CameraView的生命周期。

在CameraView内部，也在View的各个生命周期中做了相对应的操作。

CameraView内部生命周期方法

CameraView的版本兼容策略

CameraView为了解决版本兼容性问题，采用了策略模式，对应不同系统版本使用不同的实现方式。

CameraView的策略模式

上图可以看到，CameraView中包含两个抽象类接口，CameraViewImpl对应对摄像头操作的具体实现，根据系统版本分别对应Camera和Camera2；PreviewImpl对应对预览控件的具体实现，根据系统版本分别对应SurfaceView与TextureView。下面看一下具体代码：

    CameraViewImpl mImpl;
    
    public CameraView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        if (isInEditMode()){
            mCallbacks = null;
            mDisplayOrientationDetector = null;
            return;
        }
        // Internal setup
        final PreviewImpl preview = createPreviewImpl(context);
        mCallbacks = new CallbackBridge();
        if (Build.VERSION.SDK_INT < 21) {
            mImpl = new Camera1(mCallbacks, preview);
        } else if (Build.VERSION.SDK_INT < 23) {
            mImpl = new Camera2(mCallbacks, preview, context);
        } else {
            mImpl = new Camera2Api23(mCallbacks, preview, context);
        }
        // Attributes
        ...
        // Display orientation detector
        ...
    }

我们可以看到，Android5.0以下用Camera，Android5.0以上用Camera2，Android6.0以上在Camera2的基础上尝试输出最高清的分辨率。下面再来看一下createPreviewImpl方法：

@NonNull
    private PreviewImpl createPreviewImpl(Context context) {
        PreviewImpl preview;
        if (Build.VERSION.SDK_INT < 14) {
            preview = new SurfaceViewPreview(context, this);
        } else {
            preview = new TextureViewPreview(context, this);
        }
        return preview;
    }

上面代码展示了CameraView对与预览控件的版本兼容策略，Android4.0以下用SurfaceView，Android4.0以上用TextureView。

PreviewImpl内部封装了一系列对预览控件的操作方法，SurfaceViewPreview和TextureViewPreview分别对应了SurfaceView和TextureView对PreviewImpl的具体实现。在其具体实现类内部又实现了控件生命周期的回调接口，一些复杂的生命周期（如横竖屏切换）也在其内部做了相应处理。

由于篇幅原因，这里不再对SurfaceView和TextureView做过多讲解，关于SurfaceView与TextureView的详情，请参考Android 5.0(Lollipop)中的SurfaceTexture，TextureView，SurfaceView和GLSurfaceView。

Camera1的相机实现

这一小节将解析使用Camera API来实现相机开发，对应前文的相机开发流程我们进行逐步解析：

打开摄像头：调用Camera.open()，打开相机，默认为后置，可以根据摄像头ID来指定打开前置还是后置。
开启预览：调用Camera.getParameters()获取Camera.Parameters对象，在Camera.Parameters对象中设置自定义参数，调用Camera.setPreviewDispaly(SurfaceHolder holder)，指定预览控件的SurfaceHolder，调用Camera.startPreview()方法开启预览。
执行拍照：调用Camera.takePicture()方法进行拍照。
关闭预览：调用Camera.stopPreview()关闭预览。
关闭摄像头：调用Camera.release()关闭摄像头。

下面来看一下在Camera1类中的具体实现代码，首先看CameraViewImpl的入口start()方法：

@Override
    boolean start() {
        //选择指定摄像头
        chooseCamera();
        //打开摄像头
        openCamera();
        //设置预览控件
        if (mPreview.isReady()) {
            setUpPreview();
        }
        mShowingPreview = true;
        //开启预览
        mCamera.startPreview();
        return true;
    }

start()方法执行了打开摄像头、开启预览两个步骤，我们对这里调用的每一个方法进行分析：

private void chooseCamera() {
        //遍历所有摄像头设备，找到指定的摄像头
        for (int i = 0, count = Camera.getNumberOfCameras(); i < count; i++) {
            Camera.getCameraInfo(i, mCameraInfo);
            if (mCameraInfo.facing == mFacing) {
                mCameraId = i;
                return;
            }
        }
        mCameraId = INVALID_CAMERA_ID;
    }

调用chooseCamera()遍历所有摄像头设备，找到指定的摄像头。

    private void openCamera() {
        if (mCamera != null) {
            //如果摄像头已经开启，先释放掉
            releaseCamera();
        }
        //打开摄像头
        mCamera = Camera.open(mCameraId);
        //获得Camera.Parameters对象
        mCameraParameters = mCamera.getParameters();
        //获取该摄像头支持的所有预览尺寸
        mPreviewSizes.clear();
        for (Camera.Size size : mCameraParameters.getSupportedPreviewSizes()) {
            mPreviewSizes.add(new Size(size.width, size.height));
        }
        //获取该摄像头支持的所有拍照尺寸
        mPictureSizes.clear();
        for (Camera.Size size : mCameraParameters.getSupportedPictureSizes()) {
            mPictureSizes.add(new Size(size.width, size.height));
        }
        // AspectRatio
        if (mAspectRatio == null) {
            mAspectRatio = Constants.DEFAULT_ASPECT_RATIO;
        }
        //根据需求设置自定义参数，这里主要是设置预览尺寸、拍照尺寸、对焦模式、闪光灯等。
        adjustCameraParameters();
        //设置水平垂直方向
        mCamera.setDisplayOrientation(calcDisplayOrientation(mDisplayOrientation));
        //执行开启摄像头成功的回调方法
        mCallback.onCameraOpened();
    }

打开摄像头，根据需求设置预览尺寸、拍照尺寸、对焦模式、闪光灯等参数，设置水平垂直方向，执行开启摄像头成功的回调方法。

    void setUpPreview() {
        try {
            if (mPreview.getOutputClass() == SurfaceHolder.class) {
                final boolean needsToStopPreview = mShowingPreview && Build.VERSION.SDK_INT < 14;
                if (needsToStopPreview) {
                    mCamera.stopPreview();
                }
                mCamera.setPreviewDisplay(mPreview.getSurfaceHolder());
                if (needsToStopPreview) {
                    mCamera.startPreview();
                }
            } else {
                mCamera.setPreviewTexture((SurfaceTexture) mPreview.getSurfaceTexture());
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

setUpPreview()方法主要是根据系统版本和预览状态来指定预览控件。

所有准备工作完成以后，调用Camera.startPreview()方法开启预览。预览开启以后就可以触发执行拍照动作，来看一下拍照的具体方法takePicture()：

@Override
    void takePicture() {
        //如果摄像头未开启，抛出异常
        if (!isCameraOpened()) {
            throw new IllegalStateException(
                    "Camera is not ready. Call start() before takePicture().");
        }
        //判断有没有开启自动对焦，如果有自动对焦则监听对焦完成以后执行拍照
        if (getAutoFocus()) {
            mCamera.cancelAutoFocus();
            mCamera.autoFocus(new Camera.AutoFocusCallback() {
                @Override
                public void onAutoFocus(boolean success, Camera camera) {
                    takePictureInternal();
                }
            });
        } else {
            //没有自动对焦，直接拍照
            takePictureInternal();
        }
    }
    
    void takePictureInternal() {
        if (!isPictureCaptureInProgress.getAndSet(true)) {
            //拍照，并监听拍照完成的回调
            mCamera.takePicture(null, null, null, new Camera.PictureCallback() {
                @Override
                public void onPictureTaken(byte[] data, Camera camera) {
                    isPictureCaptureInProgress.set(false);
                   //拍照完成，byte[] data为拍照的图像数据
                   //这里是使用回调方法将数据传到外部去执行下一步动作。
                    mCallback.onPictureTaken(data);
                    camera.cancelAutoFocus();
                    camera.startPreview();
                }
            });
        }
    }

拍照完成以后，可以根据需求来关闭预览和关闭摄像头，这里主要解析一下stop()方法：

@Override
    void stop() {
        if (mCamera != null) {
            //关闭预览
            mCamera.stopPreview();
        }
        mShowingPreview = false;
        //关闭摄像头
        releaseCamera();
    }
    
    private void releaseCamera() {
        if (mCamera != null) {
            //释放摄像头
            mCamera.release();
            mCamera = null;
            //摄像头关闭以后执行回调方法
            mCallback.onCameraClosed();
        }
    }

到这里Camera1的拍照流程解析完成了，我们可以学习到相机开发流程各个步骤所对应的Camera API的常用实现方法。

Camera2的相机实现

Android 5.0以上版本将原来的camera API弃用转而推荐使用新增的camera2 API，camera2 API理解起来更为抽象，开发难度也更大，但是功能也更加强大。

camera2 流程示意图图片来源见参考资料

这里引用了管道的概念将安卓设备和摄像头之间联通起来，系统向摄像头发送 Capture 请求，而摄像头会返回 CameraMetadata。这一切建立在一个叫作 CameraCaptureSession 的会话中。

camera2 拍照流程图图片来源见参考资料

上图可以简单的了解Camera2的拍照流程，对应前文的相机开发流程我们进行逐步解析：

打开摄像头：首先通过Context.getSystemService(Context.CAMERA_SERVICE)获得CameraManager对象，通过CameraManager找到指定的摄像头对象CameraDevice和对应的CameraId，再调用CameraManager.openCamera(currentCameraId, stateCallback, backgroundHandler)打开摄像头。
开启预览：Camera2需要通过创建请求来实现调用。CameraDevice.createCaptureSession(...)方法创建CaptureSession，在createCaptureSession()方法参数中设置请求类型和预览参数，再在回调函数中执行cameraCaptureSession.setRepeatingRequest(...)方法请求预览。
执行拍照：先设置好CaptureRequest请求的相关参数，在调用cameraCaptureSession.capture()完成拍照，拍照的图片数据在ImageReader对象的回调接口中获取。
关闭预览：CaptureSession.close()关闭会话对象。
关闭摄像头：CameraDevice.close()关闭摄像头。

下面来看一下在Camera2类中的具体实现代码，还是start()方法开始：

    private final CameraManager mCameraManager;
    
    Camera2(Callback callback, PreviewImpl preview, Context context) {
        super(callback, preview);
        //构造函数中获取CameraManager对象
        mCameraManager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
        mPreview.setCallback(new PreviewImpl.Callback() {
            @Override
            public void onSurfaceChanged() {
                startCaptureSession();
            }
        });
    }
    
    @Override
    boolean start() {
        //找到指定的摄像头
        if (!chooseCameraIdByFacing()) {
            return false;
        }
        //设置相关配置，预览尺寸、拍照尺寸等
        collectCameraInfo();
        //设置ImageReader及其拍照数据的回调接口
        prepareImageReader();
        //打开摄像头
        startOpeningCamera();
        return true;
    }

首先在构造函数中获取CameraManager对象为摄像头管理类，用于检测摄像头，打开系统摄像头，获取摄像头特性等。

private boolean chooseCameraIdByFacing() {
        try {
            int internalFacing = INTERNAL_FACINGS.get(mFacing);
            //获得所有摄像头的cameraId
            final String[] ids = mCameraManager.getCameraIdList();
            if (ids.length == 0) { // No camera
                throw new RuntimeException("No camera available.");
            }
            //遍历查找指定的摄像头
            for (String id : ids) {
                //获取该摄像头的描述信息
                CameraCharacteristics characteristics = mCameraManager.getCameraCharacteristics(id);
                
                ...
                
                if (internal == internalFacing) {
                    mCameraId = id;
                    mCameraCharacteristics = characteristics;
                    return true;
                }
            }
            
            ...
            
            return true;
        } catch (CameraAccessException e) {
            throw new RuntimeException("Failed to get a list of camera devices", e);
        }
    }

chooseCameraIdByFacing()方法就是遍历所有摄像头设备，根据摄像头描述类CameraCharacteristics获取指定到的摄像头。

    private void collectCameraInfo() {
        StreamConfigurationMap map = mCameraCharacteristics.get(
                CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP);
        if (map == null) {
            throw new IllegalStateException("Failed to get configuration map: " + mCameraId);
        }
        //遍历摄像头所支持的预览尺寸
        mPreviewSizes.clear();
        for (android.util.Size size : map.getOutputSizes(mPreview.getOutputClass())) {
            int width = size.getWidth();
            int height = size.getHeight();
            if (width <= MAX_PREVIEW_WIDTH && height <= MAX_PREVIEW_HEIGHT) {
                mPreviewSizes.add(new Size(width, height));
            }
        }
        //遍历摄像头所支持的拍照尺寸
        mPictureSizes.clear();
        collectPictureSizes(mPictureSizes, map);
        //通过比例进行筛选
        for (AspectRatio ratio : mPreviewSizes.ratios()) {
            if (!mPictureSizes.ratios().contains(ratio)) {
                mPreviewSizes.remove(ratio);
            }
        }

        if (!mPreviewSizes.ratios().contains(mAspectRatio)) {
            mAspectRatio = mPreviewSizes.ratios().iterator().next();
        }
    }

collectCameraInfo()就是通过mCameraCharacteristics来设置相关配置，预览尺寸、拍照尺寸等。

    private void prepareImageReader() {
        if (mImageReader != null) {
            mImageReader.close();
        }
        //这里直接选择适合比例的最大的拍照尺寸
        Size largest = mPictureSizes.sizes(mAspectRatio).last();
        //设置用于拍照数据的ImageReader对象，并设置回调函数
        mImageReader = ImageReader.newInstance(largest.getWidth(), largest.getHeight(),
                ImageFormat.JPEG, /* maxImages */ 2);
        mImageReader.setOnImageAvailableListener(mOnImageAvailableListener, null);
    }
    
     private final ImageReader.OnImageAvailableListener mOnImageAvailableListener
            = new ImageReader.OnImageAvailableListener() {
        @Override
        public void onImageAvailable(ImageReader reader) {
            try (Image image = reader.acquireNextImage()) {
                Image.Plane[] planes = image.getPlanes();
                if (planes.length > 0) {
                    ByteBuffer buffer = planes[0].getBuffer();
                    byte[] data = new byte[buffer.remaining()];
                    buffer.get(data);
                    //同样，完成拍照后使用回调方法将数据传到外部去处理
                    mCallback.onPictureTaken(data);
                }
            }
        }
    };

prepareImageReader()设置了ImageReader的拍照尺寸和拍照的监听回调接口。

    private void startOpeningCamera() {
        try {
            //打开相机
            mCameraManager.openCamera(mCameraId, mCameraDeviceCallback, null);
        } catch (CameraAccessException e) {
            throw new RuntimeException("Failed to open camera: " + mCameraId, e);
        }
    }
    
    private final CameraDevice.StateCallback mCameraDeviceCallback
            = new CameraDevice.StateCallback() {

        @Override
        public void onOpened(@NonNull CameraDevice camera) {
            mCamera = camera;
            //执行打开相机完成的回调方法
            mCallback.onCameraOpened();
            //开始预览
            startCaptureSession();
        }

        @Override
        public void onClosed(@NonNull CameraDevice camera) {
            //执行关闭相机完成的回调方法
            mCallback.onCameraClosed();
        }

        @Override
        public void onDisconnected(@NonNull CameraDevice camera) {
            mCamera = null;
        }

        @Override
        public void onError(@NonNull CameraDevice camera, int error) {
            Log.e(TAG, "onError: " + camera.getId() + " (" + error + ")");
            mCamera = null;
        }

    };

startOpeningCamera()就是打开摄像头并设置监听回调，当摄像头打开完成后开启预览。

    void startCaptureSession() {
        if (!isCameraOpened() || !mPreview.isReady() || mImageReader == null) {
            return;
        }
        //选择最合适的预览尺寸
        Size previewSize = chooseOptimalSize();
        mPreview.setBufferSize(previewSize.getWidth(), previewSize.getHeight());
        Surface surface = mPreview.getSurface();
        try {
            //创建摄像头预览的请求
            mPreviewRequestBuilder = mCamera.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW);
            //将请求关联预览控件的surface
            mPreviewRequestBuilder.addTarget(surface);
            //发送请求建立会话session的请求并监听回调
            mCamera.createCaptureSession(Arrays.asList(surface, mImageReader.getSurface()),
                    mSessionCallback, null);
        } catch (CameraAccessException e) {
            throw new RuntimeException("Failed to start camera session");
        }
    }
    
    //监听CameraCaptureSession状态的回调接口
    private final Session.StateCallback mSessionCallback
            = new CameraCaptureSession.StateCallback() {

        @Override
        public void onConfigured(@NonNull CameraCaptureSession session) {
            if (mCamera == null) {
                return;
            }
            //获得CameraCaptureSession对象，控制摄像头的预览或者拍照
            mCaptureSession = session;
            updateAutoFocus();
            updateFlash();
            try {
                开启预览并设置监听回调
                mCaptureSession.setRepeatingRequest(mPreviewRequestBuilder.build(),
                        mCaptureCallback, null);
            } catch (CameraAccessException e) {
                Log.e(TAG, "Failed to start camera preview because it couldn't access camera", e);
            } catch (IllegalStateException e) {
                Log.e(TAG, "Failed to start camera preview.", e);
            }
        }

        @Override
        public void onConfigureFailed(@NonNull CameraCaptureSession session) {
            Log.e(TAG, "Failed to configure capture session.");
        }

        @Override
        public void onClosed(@NonNull CameraCaptureSession session) {
            if (mCaptureSession != null && mCaptureSession.equals(session)) {
                mCaptureSession = null;
            }
        }

    };

首先请求建立会话，获得CameraCaptureSession对象后请求开启预览，并设置CaptureCallback回调接口进行监听。

    @Override
    void takePicture() {
        //如果有设置自动对焦，则对焦完成后拍照
        if (mAutoFocus) {
            lockFocus();
        } else {
            //直接拍照
            captureStillPicture();
        }
    }
    
    void captureStillPicture() {
        try {
            //创建捕捉静态图片的请求
            CaptureRequest.Builder captureRequestBuilder = mCamera.createCaptureRequest(
                    CameraDevice.TEMPLATE_STILL_CAPTURE);
            //关联ImageReader的Surface对象
            captureRequestBuilder.addTarget(mImageReader.getSurface());
            //设置预览模式
            captureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE,
                    mPreviewRequestBuilder.get(CaptureRequest.CONTROL_AF_MODE));
            
            ...
            
            //设置拍照的格式和方向
            // Calculate JPEG orientation.
            @SuppressWarnings("ConstantConditions")
            int sensorOrientation = mCameraCharacteristics.get(
                    CameraCharacteristics.SENSOR_ORIENTATION);
            captureRequestBuilder.set(CaptureRequest.JPEG_ORIENTATION,
                    (sensorOrientation +
                            mDisplayOrientation * (mFacing == Constants.FACING_FRONT ? 1 : -1) +
                            360) % 360);
            //停止连续取景
            // Stop preview and capture a still picture.
            mCaptureSession.stopRepeating();
            //拍照
            mCaptureSession.capture(captureRequestBuilder.build(),
                    new CameraCaptureSession.CaptureCallback() {
                        @Override
                        public void onCaptureCompleted(@NonNull CameraCaptureSession session,
                                @NonNull CaptureRequest request,
                                @NonNull TotalCaptureResult result) {
                            //取消对焦
                            unlockFocus();
                        }
                    }, null);
        } catch (CameraAccessException e) {
            Log.e(TAG, "Cannot capture a still picture.", e);
        }
    }

takePicture()方法执行拍照动作，先建立拍照请求，设置相关参数，再发送请求完成拍照，照片数据在前文的ImageReader的监听接口中获得。再看一下stop()方法，这个比较简单：

    @Override
    void stop() {
        if (mCaptureSession != null) {
            //关闭会话
            mCaptureSession.close();
            mCaptureSession = null;
        }
        if (mCamera != null) {
            //关闭摄像头
            mCamera.close();
            mCamera = null;
        }
        if (mImageReader != null) {
            //关闭ImageReader对象
            mImageReader.close();
            mImageReader = null;
        }
    }

至此Camera2的拍照流程解析完成，Camera2采用客户端/服务端式的请求/回调的设计模式，也将上层API和底层硬件层彻底分离与解耦。