[[432612]]

前言

今天給老鐵們介紹Camera2相機開發(fā)流程詳解;

Android 5.0對拍照API進行了全新的設計，新增了全新設計的Camera 2 API，這些API不僅大幅提高了Android系統(tǒng)拍照的功能，還能支持RAW照片輸出，甚至允許程序調整相機的對焦模式、曝光模式、快門等;

一、Camera2架構介紹

Camera2引用了管道的概念將安卓設備和攝像頭之間聯(lián)通起來，系統(tǒng)向攝像頭發(fā)送 Capture 請求，而攝像頭會返回 CameraMetadata。這一切建立在一個叫作 CameraCaptureSession 的會話中;

架構在核心參與類角色有：CameraManager、CameraDevice、CameraCharacteristics、CameraRequest與CameraRequest.Builder、CameraCaptureSession以及CaptureResult;

1、CameraManager

位于android.hardware.camera2.CameraManager下，也是Android 21(5.0)添加的，和其他系統(tǒng)服務一樣通過 Context.getSystemService(CameraManager.class ) 或者Context.getSystemService(Context.CAMERA_SERVICE) 來完成初始化，主要用于管理系統(tǒng)攝像頭：

• 通過getCameraIdList()方法獲取Android設備的攝像頭列表;
• getCameraCharacteristics(String cameraId)獲取攝像頭的詳細參數(shù)和支持的功能;

2、CameraDevice

• CameraDevice是Camera2中抽象出來的一個對象，直接與系統(tǒng)硬件攝像頭相聯(lián)系;
• 即攝像頭功能可被分為limit 和full 兩個級別，當攝像頭處于limited 級別時候，此時Camera2和早期的Camera功能差不多，除此之外在Camera2架構中，CameraDevice還承擔其他重要任務：
• 通過CameraDevice.StateCallback監(jiān)聽攝像頭的狀態(tài)(主要包括onOpened、onClosed、onDisconnected、onErro四種狀態(tài));
• 管理CameraCaptureSession，-通過方法createCaptureSession()方法和createReprocessableCaptureSession()方法創(chuàng)建會話 ，通常會在CameraDevice.StateCallback中調用對應方法創(chuàng)建預覽會話;
• 管理CaptureRequest，主要包括通過createCaptureRequest(int templateType)創(chuàng)建捕獲請求，在需要預覽、拍照、再次預覽的時候都需要通過創(chuàng)建請求來完成;

3、CameraCaptureSession

• 系統(tǒng)向攝像頭發(fā)送 Capture 請求，而攝像頭會返回 CameraMetadata，這一切都是在由對應的CameraDevice創(chuàng)建的CameraCaptureSession 會話完成，當程序需要預覽、拍照、再次預覽時，都需要先通過會話;
• CameraCaptureSession的有很多重要回調：
• 管理CameraCaptureSession.StateCallback狀態(tài)回調，用于接收有關CameraCaptureSession狀態(tài)的更新的回調對象;
• 管理CameraCaptureSession.CaptureCallback捕獲回調，用于接收捕獲請求狀態(tài)的回調，當請求觸發(fā)捕獲已啟動時;捕獲完成時;在捕獲圖像時發(fā)生錯誤的情況下;都會觸發(fā)該回調對應的方法;
• 通過調用方法capture()提交捕獲圖像請求即拍照，其中該請求定義了捕獲單個圖像的所有參數(shù)，包括傳感器，鏡頭，閃光燈和后處理參數(shù)，每一次請求的結果將產(chǎn)生一個CaptureResult，可以為一個或多個Surface生成新的幀，然后通過CaptureRequest.Builder的addTarget(Surface)方法附著到對應的Surface上顯示;
• 通過調用方法setRepeatingRequest()請求不斷重復捕獲圖像，即實現(xiàn)預覽;
• 通過方法調用stopRepeating()實現(xiàn)停止捕獲圖像，即停止預覽;

4、CameraCharacteristics

描述Cameradevice屬性的對象，可以使用CameraManager通過getCameraCharacteristics(String cameraId)進行查詢;

5、CameraRequest和CameraRequest.Builder

CameraRequest代表了一次捕獲請求，而CameraRequest.Builder用于描述捕獲圖片的各種參數(shù)設置，包含捕獲硬件(傳感器，鏡頭，閃存)，對焦模式、曝光模式，處理流水線，控制算法和輸出緩沖區(qū)的配置，然后傳遞到對應的會話中進行設置，CameraRequest.Builder則負責生成CameraRequest對象。當程序調用setRepeatingRequest()方法進行預覽時，或調用capture()方法進行拍照時，都需要傳入CameraRequest參數(shù)。CameraRequest可以通過CameraRequest.Builder來進行初始化，通過調用createCaptureRequest來獲得;

6、CaptureResult

CaptureRequest描述是從圖像傳感器捕獲單個圖像的結果的子集的對象，當CaptureRequest被處理之后由CameraDevice生成;

7、Camera2 主要角色之間的聯(lián)系

CameraManager處于頂層管理位置負責檢測獲取所有攝像頭及其特性和傳入指定的CameraDevice.StateCallback回調打開指定攝像頭，CameraDevice是負責管理抽象對象，包括監(jiān)聽Camera 的狀態(tài)回調CameraDevice.StateCallback、創(chuàng)建CameraCaptureSession和CameraRequest;

二、Camera2 相機開發(fā)流程詳解

1、申請權限

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

2、在xml布局文件中定義一個TextureView

<TextureView 
   android:id="@+id/textureView" 
   android:layout_width="match_parent" 
   android:layout_height="match_parent" /> 

3、創(chuàng)建一個CameraHelper類，并給TextureView對象添加回調函數(shù)

class Camera2Helper(val mActivity: Activity, private val mTextureView: TextureView) { 
    companion object { 
        const val PREVIEW_WIDTH = 720        //預覽的寬度 
        const val PREVIEW_HEIGHT = 1280      //預覽的高度 
        const val SAVE_WIDTH = 720           //保存圖片的寬度 
        const val SAVE_HEIGHT = 1280         //保存圖片的高度 
    } 
    private lateinit var mCameraManager: CameraManager 
    private var mImageReader: ImageReader? = null 
    private var mCameraDevice: CameraDevice? = null 
    private var mCameraCaptureSession: CameraCaptureSession? = null 
    private var mCameraId = "0" 
    private lateinit var mCameraCharacteristics: CameraCharacteristics 
    private var mCameraSensorOrientation = 0        //攝像頭方向 
    private var mCameraFacing = CameraCharacteristics.LENS_FACING_BACK        //默認使用后置攝像頭 
    private val mDisplayRotation = mActivity.windowManager.defaultDisplay.rotation  //手機方向 
    private var canTakePic = true                   //是否可以拍照 
    private var canExchangeCamera = false           //是否可以切換攝像頭 
    private var mCameraHandler: Handler 
    private val handlerThread = HandlerThread("CameraThread") 
    private var mPreviewSize = Size(PREVIEW_WIDTH, PREVIEW_HEIGHT) //預覽大小 
    private var mSavePicSize = Size(SAVE_WIDTH, SAVE_HEIGHT)       //保存圖片大小 
    init { 
        handlerThread.start() 
        mCameraHandler = Handler(handlerThread.looper) 
        mTextureView.surfaceTextureListener = object : TextureView.SurfaceTextureListener { 
            override fun onSurfaceTextureSizeChanged(surface: SurfaceTexture?, width: Int, height: Int) { 
            } 
            override fun onSurfaceTextureUpdated(surface: SurfaceTexture?) { 
            } 
            override fun onSurfaceTextureDestroyed(surface: SurfaceTexture?): Boolean { 
                releaseCamera() 
                return true 
            } 
            override fun onSurfaceTextureAvailable(surface: SurfaceTexture?, width: Int, height: Int) { 
                initCameraInfo() 
            } 
        } 
    } 
} 

• 打開相機和創(chuàng)建會話等都是耗時操作，所以我們啟動一個HandlerThread在子線程中來處理;
• 有兩個關于尺寸的變量，一個是預覽尺寸(在屏幕上顯示)，一個是保存圖片的尺寸(保存到sd卡中圖片的尺寸);
• 有兩個方向，一個是手機方向(如果是豎屏應用的話此方向為0)，另一個是攝像頭方向(一般來說，前置攝像頭方向為270，后置攝像頭方向為90);

4、初始化相關參數(shù)

/** 
     * 初始化 
     */ 
    private fun initCameraInfo() { 
        mCameraManager = mActivity.getSystemService(Context.CAMERA_SERVICE) as CameraManager 
        val cameraIdList = mCameraManager.cameraIdList 
        if (cameraIdList.isEmpty()) { 
            mActivity.toast("沒有可用相機") 
            return 
        } 
        for (id in cameraIdList) { 
            val cameraCharacteristics = mCameraManager.getCameraCharacteristics(id) 
            val facing = cameraCharacteristics.get(CameraCharacteristics.LENS_FACING) 
            if (facing == mCameraFacing) { 
                mCameraId = id 
                mCameraCharacteristics = cameraCharacteristics 
            } 
            log("設備中的攝像頭 $id") 
        } 
        val supportLevel = mCameraCharacteristics.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL) 
        if (supportLevel == CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY) { 
            mActivity.toast("相機硬件不支持新特性") 
        } 
        //獲取攝像頭方向 
        mCameraSensorOrientation = mCameraCharacteristics.get(CameraCharacteristics.SENSOR_ORIENTATION) 
        //獲取StreamConfigurationMap，它是管理攝像頭支持的所有輸出格式和尺寸 
        val configurationMap = mCameraCharacteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP) 
        val savePicSize = configurationMap.getOutputSizes(ImageFormat.JPEG)          //保存照片尺寸 
        val previewSize = configurationMap.getOutputSizes(SurfaceTexture::class.java) //預覽尺寸 
        val exchange = exchangeWidthAndHeight(mDisplayRotation, mCameraSensorOrientation) 
        mSavePicSize = getBestSize( 
                if (exchange) mSavePicSize.height else mSavePicSize.width, 
                if (exchange) mSavePicSize.width else mSavePicSize.height, 
                if (exchange) mSavePicSize.height else mSavePicSize.width, 
                if (exchange) mSavePicSize.width else mSavePicSize.height, 
                savePicSize.toList()) 
        mPreviewSize = getBestSize( 
                if (exchange) mPreviewSize.height else mPreviewSize.width, 
                if (exchange) mPreviewSize.width else mPreviewSize.height, 
                if (exchange) mTextureView.height else mTextureView.width, 
                if (exchange) mTextureView.width else mTextureView.height, 
                previewSize.toList()) 
        mTextureView.surfaceTexture.setDefaultBufferSize(mPreviewSize.width, mPreviewSize.height) 
        log("預覽最優(yōu)尺寸 ：${mPreviewSize.width} * ${mPreviewSize.height}, 比例  ${mPreviewSize.width.toFloat() / mPreviewSize.height}") 
        log("保存圖片最優(yōu)尺寸 ：${mSavePicSize.width} * ${mSavePicSize.height}, 比例  ${mSavePicSize.width.toFloat() / mSavePicSize.height}") 
        //根據(jù)預覽的尺寸大小調整TextureView的大小，保證畫面不被拉伸 
        val orientation = mActivity.resources.configuration.orientation 
        if (orientation == Configuration.ORIENTATION_LANDSCAPE) 
            mTextureView.setAspectRatio(mPreviewSize.width, mPreviewSize.height) 
        else 
            mTextureView.setAspectRatio(mPreviewSize.height, mPreviewSize.width) 
        mImageReader = ImageReader.newInstance(mPreviewSize.width, mPreviewSize.height, ImageFormat.JPEG, 1) 
        mImageReader?.setOnImageAvailableListener(onImageAvailableListener, mCameraHandler) 
        if (openFaceDetect) 
            initFaceDetect() 
        openCamera() 
    } 
   /** 
     * 根據(jù)提供的屏幕方向 [displayRotation] 和相機方向 [sensorOrientation] 返回是否需要交換寬高 
     */ 
    private fun exchangeWidthAndHeight(displayRotation: Int, sensorOrientation: Int): Boolean { 
        var exchange = false 
        when (displayRotation) { 
            Surface.ROTATION_0, Surface.ROTATION_180 -> 
                if (sensorOrientation == 90 || sensorOrientation == 270) { 
                    exchange = true 
                } 
            Surface.ROTATION_90, Surface.ROTATION_270 -> 
                if (sensorOrientation == 0 || sensorOrientation == 180) { 
                    exchange = true 
                } 
            else -> log("Display rotation is invalid: $displayRotation") 
        } 
        log("屏幕方向  $displayRotation") 
        log("相機方向  $sensorOrientation") 
        return exchange 
    } 
    /** 
     * 
     * 根據(jù)提供的參數(shù)值返回與指定寬高相等或最接近的尺寸 
     * 
     * @param targetWidth   目標寬度 
     * @param targetHeight  目標高度 
     * @param maxWidth      最大寬度(即TextureView的寬度) 
     * @param maxHeight     最大高度(即TextureView的高度) 
     * @param sizeList      支持的Size列表 
     * 
     * @return  返回與指定寬高相等或最接近的尺寸 
     * 
     */ 
    private fun getBestSize(targetWidth: Int, targetHeight: Int, maxWidth: Int, maxHeight: Int, sizeList: List<Size>): Size { 
        val bigEnough = ArrayList<Size>()     //比指定寬高大的Size列表 
        val notBigEnough = ArrayList<Size>()  //比指定寬高小的Size列表 
        for (size in sizeList) { 
            //寬<=最大寬度  &&  高<=最大高度  &&  寬高比 == 目標值寬高比 
            if (size.width <= maxWidth && size.height <= maxHeight 
                    && size.width == size.height * targetWidth / targetHeight) { 
                if (size.width >= targetWidth && size.height >= targetHeight) 
                    bigEnough.add(size) 
                else 
                    notBigEnough.add(size) 
            } 
            log("系統(tǒng)支持的尺寸: ${size.width} * ${size.height} ,  比例 ：${size.width.toFloat() / size.height}") 
        } 
        log("最大尺寸 ：$maxWidth * $maxHeight, 比例 ：${targetWidth.toFloat() / targetHeight}") 
        log("目標尺寸 ：$targetWidth * $targetHeight, 比例 ：${targetWidth.toFloat() / targetHeight}") 
        //選擇bigEnough中最小的值  或 notBigEnough中最大的值 
        return when { 
            bigEnough.size > 0 -> Collections.min(bigEnough, CompareSizesByArea()) 
            notBigEnough.size > 0 -> Collections.max(notBigEnough, CompareSizesByArea()) 
            else -> sizeList[0] 
        } 
    } 

• 首先，通過mActivity.getSystemService(Context.CAMERA_SERVICE) as CameraManager 獲取到 CameraManager 實例;
• 通過循環(huán)遍歷設備中可用的相機，通過 mCameraManager.getCameraCharacteristics(id) 獲取到相機的各種信息;
• mCameraCharacteristics.get(CameraCharacteristics.SENSOR_ORIENTATION) 獲取到相機傳感器的方向;
• 通過 configurationMap.getOutputSizes(ImageFormat.JPEG) 和 configurationMap.getOutputSizes(SurfaceTexture::class.java) 獲取到相機支持的預覽尺寸和保存圖片的尺寸;
• exchangeWidthAndHeight(displayRotation: Int, sensorOrientation: Int)方法的作用是根據(jù)屏幕方向和攝像頭方向確定是否需要交換寬高;
• 通過 getBestSize() 方法獲取到最優(yōu)的寬和高。根據(jù)傳入的 目標寬高值、最大寬高值(即屏幕大小)和 相機支持的尺寸列表，從相機支持的尺寸列表中得到一個最優(yōu)值;
• 通過mTextureView.surfaceTexture.setDefaultBufferSize() 方法用來設置TextureView的預覽尺寸;
• 創(chuàng)建一個ImageReader對象，并設置回調函數(shù);
• 在onImageAvailableListener中處理得到的圖像數(shù)據(jù);

5、打開相機

/** 
     * 打開相機 
     */ 
    private fun openCamera() { 
        if (ContextCompat.checkSelfPermission(mActivity, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) { 
            mActivity.toast("沒有相機權限！") 
            return 
        } 
        mCameraManager.openCamera(mCameraId, object : CameraDevice.StateCallback() { 
            override fun onOpened(camera: CameraDevice) { 
                log("onOpened") 
                mCameraDevice = camera 
                createCaptureSession(camera) 
            } 
            override fun onDisconnected(camera: CameraDevice) { 
                log("onDisconnected") 
            } 
            override fun onError(camera: CameraDevice, error: Int) { 
                log("onError $error") 
                mActivity.toast("打開相機失敗！$error") 
            } 
        }, mCameraHandler) 
    } 

6、創(chuàng)建預覽會話

/** 
     * 創(chuàng)建預覽會話 
     */ 
    private fun createCaptureSession(cameraDevice: CameraDevice) { 
        val captureRequestBuilder = cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW) 
        val surface = Surface(mTextureView.surfaceTexture) 
        captureRequestBuilder.addTarget(surface)  // 將CaptureRequest的構建器與Surface對象綁定在一起 
        captureRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH)      // 閃光燈 
        captureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE) // 自動對焦 
        // 為相機預覽，創(chuàng)建一個CameraCaptureSession對象 
        cameraDevice.createCaptureSession(arrayListOf(surface, mImageReader?.surface), object : CameraCaptureSession.StateCallback() { 
            override fun onConfigureFailed(session: CameraCaptureSession?) { 
                mActivity.toast("開啟預覽會話失??！") 
            } 
            override fun onConfigured(session: CameraCaptureSession) { 
                mCameraCaptureSession = session 
                session.setRepeatingRequest(captureRequestBuilder.build(), mCaptureCallBack, mCameraHandler) 
            } 
        }, mCameraHandler) 
    } 
    private val mCaptureCallBack = object : CameraCaptureSession.CaptureCallback() { 
        override fun onCaptureCompleted(session: CameraCaptureSession, request: CaptureRequest?, result: TotalCaptureResult) { 
            super.onCaptureCompleted(session, request, result) 
            canExchangeCamera = true 
            canTakePic = true 
        } 
        override fun onCaptureFailed(session: CameraCaptureSession?, request: CaptureRequest?, failure: CaptureFailure?) { 
            super.onCaptureFailed(session, request, failure) 
            log("onCaptureFailed") 
            mActivity.toast("開啟預覽失敗！") 
        } 
    } 

• 通過cameraDevice.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW) 創(chuàng)建一個用于預覽的Builder對象;
• 為該Builder對象添加一個Surface對象，并設置各種相關參數(shù);
• 通過cameraDevice.createCaptureSession創(chuàng)建一個會話，第一個參數(shù)中傳了一個 surface 和 mImageReader?.surface。這表明了這次會話的圖像數(shù)據(jù)的輸出到這兩個對象;
• 當會話創(chuàng)建成功時，通過 session.setRepeatingRequest(captureRequestBuilder.build(), mCaptureCallBack, mCameraHandler) 發(fā)起預覽請求;

7、拍照、保存

/** 
     * 拍照 
     */ 
    fun takePic() { 
        if (mCameraDevice == null || !mTextureView.isAvailable || !canTakePic) return 
        mCameraDevice?.apply { 
            val captureRequestBuilder = createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE) 
            captureRequestBuilder.addTarget(mImageReader?.surface) 
            captureRequestBuilder.set(CaptureRequest.CONTROL_AF_MODE, CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE) // 自動對焦 
            captureRequestBuilder.set(CaptureRequest.CONTROL_AE_MODE, CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH)     // 閃光燈 
            captureRequestBuilder.set(CaptureRequest.JPEG_ORIENTATION, mCameraSensorOrientation)      //根據(jù)攝像頭方向對保存的照片進行旋轉，使其為"自然方向" 
            mCameraCaptureSession?.capture(captureRequestBuilder.build(), null, mCameraHandler) 
                    ?: mActivity.toast("拍照異常！") 
        } 
    } 
    private val onImageAvailableListener = OnImageAvailableListener { 
        val image = it.acquireNextImage() 
        val byteBuffer = image.planes[0].buffer 
        val byteArray = ByteArray(byteBuffer.remaining()) 
        byteBuffer.get(byteArray) 
        it.close() 
        BitmapUtils.savePic(byteArray, mCameraSensorOrientation == 270, { savedPath, time -> 
            mActivity.runOnUiThread { 
                mActivity.toast("圖片保存成功！保存路徑：$savedPath 耗時：$time") 
            } 
        }, { msg -> 
            mActivity.runOnUiThread { 
                mActivity.toast("圖片保存失??！$msg") 
            } 
        }) 
    } 

• 通過createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE) 創(chuàng)建一個拍照請求的Builder對象;
• 然后設置各種參數(shù)。注意，captureRequestBuilder.set(CaptureRequest.JPEG_ORIENTATION, mCameraSensorOrientation)用來設置保存照片的旋轉方向。如果不設置的話，保存的照片不是"自然方向";
• 拍照的結果是在 OnImageAvailableListener 對象中得到的;
• 通過 acquireNextImage() 方法獲取到一個Image對象，然后通過 image.planes[0].buffer 得到 byteBuffer，將這個 byteBuffer 轉換成 byteArray ;
• 這個 byteArray 就是拍照所得到的圖像數(shù)據(jù)。然后就可以把這個 byteArray 保存成圖片到手機存儲中;

8、 釋放相機及線程

fun releaseCamera() { 
        mCameraCaptureSession?.close() 
        mCameraCaptureSession = null 
        mCameraDevice?.close() 
        mCameraDevice = null 
        mImageReader?.close() 
        mImageReader = null 
        canExchangeCamera = false 
    } 
    fun releaseThread() { 
        handlerThread.quitSafely() 
    } 

總結

Camera2 API和舊的Camera API區(qū)別很大, 剛開始用可能會很不習慣, 但Camera2有很多優(yōu)勢, 提供了非常多的參數(shù)供我們控制;

一起學習加油老鐵們;