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

前言

年底公司赶项目，忙得不亦乐乎，博客也很久没更新了。公司项目里用到了自定义摄像头的模块，也参考了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项目首页上的用法介绍：

    @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和底层硬件层彻底分离与解耦。

总结

这篇文章讲解了Android相机开发中需要注意的问题和它们的解决方案，同时通过分析Google官方的CameraView项目源码，学习了如何管理相机的生命周期和解决版本兼容问题，最后我们又解析了Android的相机开发流程，通过camera和camera2两种API分别实现相机功能。

本文在很大程度上参考了以下资料，特此感谢！

Android相机开发那些坑

Android Camera2 拍照入门学习

Android平台Camera开发实践指南

android camera2 详解说明（一）

android.hardware.camera2 使用指南

前言