和你一起終身學習，這裏是程序員 Android

經典好文推薦，通過閱讀本文，您將收穫以下知識點:

一、Camera2架構概述
二、 Camera2中比較重要的類及方法
三、具體實現步驟
四、初始化相關參數
五、打開相機
六、創建預覽會話
七、拍照、保存
八、釋放相機及線程

一、Camera2架構概述

Camera2架構圖：

Camera2引用了管道的概念將安卓設備和攝像頭之間聯通起來，系統向攝像頭髮送 Capture 請求，而攝像頭會返回 CameraMetadata。這一切建立在一個叫作 CameraCaptureSession 的會話中。

Camera2拍照流程圖：

二、 Camera2中比較重要的類及方法

1. CameraManager

攝像頭管理器，用於打開和關閉系統攝像頭

getCameraIdList() ：
返回當前設備中可用的相機列表
getCameraCharacteristics(String cameraId) ：
根據攝像頭id返回該攝像頭的相關信息
openCamera(String cameraId, final CameraDevice.StateCallback callback,Handler handler)：
打開指定cameraId的相機。參數callback爲相機打開時的回調，參數handler爲callback被調用時所在的線程

2. CameraDevice

描述系統攝像頭，類似於早期的Camera

createCaptureRequest(int templateType)：
創建一個新的Capture請求。參數templateType代表了請求類型，請求類型一共分爲六種，分別爲：

TEMPLATE_PREVIEW : 創建預覽的請求

TEMPLATE_STILL_CAPTURE: 創建一個適合於靜態圖像捕獲的請求，圖像質量優先於幀速率

TEMPLATE_RECORD : 創建視頻錄製的請求

TEMPLATE_VIDEO_SNAPSHOT : 創建視視頻錄製時截屏的請求

TEMPLATE_ZERO_SHUTTER_LAG : 創建一個適用於零快門延遲的請求。在不影響預覽幀率的情況下最大化圖像質量

TEMPLATE_MANUAL : 創建一個基本捕獲請求，這種請求中所有的自動控制都是禁用的(自動曝光，自動白平衡、自動焦點)

createCaptureSession(List<Surface> outputs,CameraCaptureSession.StateCallback callback,Handler handler)：
創建CaptureSession會話。第一個參數 outputs 是一個 List 數組，相機會把捕捉到的圖片數據傳遞給該參數中的 Surface 。第二個參數 StateCallback 是創建會話的狀態回調。第三個參數描述了 StateCallback 被調用時所在的線程

3. CameraCharacteristics

描述攝像頭的各種特性，類似於Camera1中的CamerInfo。通過CameraManager的getCameraCharacteristics(String cameraId)方法來獲取

get(Key<T> key) ：
通過制定的key獲取相應的相機參數。

常用的key值有：

CameraCharacteristics.LENS_FACING :
獲取攝像頭方向。前置攝像頭（LENS_FACING_FRONT）或後置攝像頭（LENS_FACING_BACK）

CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL：
獲取當前設備支持的相機特性

CameraCharacteristics.SENSOR_ORIENTATION：
獲取攝像頭方向

CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP：
獲取StreamConfigurationMap，它是管理攝像頭支持的所有輸出格式和尺寸

CameraCharacteristics.FLASH_INFO_AVAILABLE：
是否支持閃光燈

CameraCharacteristics.STATISTICS_INFO_MAX_FACE_COUNT:
同時檢測到人臉的數量

CameraCharacteristics.STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES:
相機支持的人臉檢測模式

4. CaptureRequest

描述了一次操作請求，拍照、預覽等操作都需要先傳入CaptureRequest參數，具體的參數控制也是通過CameraRequest的成員變量來設置

addTarget(Surface outputTarget)：
給此次請求添加一個Surface對象作爲圖像的輸出目標
set(Key<T> key, T value)：
設置指定的參數值。

// 自動對焦
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)
// 人臉檢測模式
captureRequestBuilder.set(CaptureRequest.STATISTICS_FACE_DETECT_MODE, CameraCharacteristics.STATISTICS_FACE_DETECT_MODE_SIMPLE)

5. CameraCaptureSession

當需要拍照、預覽等功能時，需要先創建該類的實例，然後通過該實例裏的方法進行控制（例如：拍照 capture()）

setRepeatingRequest(CaptureRequest request,
CaptureCallback listener, Handler handler)：
根據傳入的 CaptureRequest 對象開始一個無限循環的捕捉圖像的請求。第二個參數 listener 爲捕捉圖像的回調，在回調中可以拿到捕捉到的圖像信息
capture( CaptureRequest request,
CaptureCallback listener, Handler handler)：
拍照。第二個參數爲拍照的結果回調

6. CaptureResult

描述拍照完成後的結果

7. ImageReader

用於接收拍照結果和訪問拍攝照片的圖像數據。
得到一個ImageReader對象的方法爲newInstance(int width, int height, int format, int maxImages)。前兩個參數是保存圖片的寬高，第三個參數爲保存圖片的格式，第四個參數代表用戶可以同時訪問到的最大圖片數量

注意：
這個參數應該根據具體需業務需求儘可能的小，因爲它的數值越大意味着需要消耗的內存就越高

acquireNextImage()：
得到ImageReader圖像隊列中的下一張圖片，返回值是一個Image對象

8. Image

一個完整的圖片緩存

getPlanes()：
獲取該圖像的像素平面數組。這個數組的大小跟圖片的格式有關，如 JPEG格式數組大小爲1

9. Plane

圖像數據的單色平面

getBuffer()：
獲取包含幀數據的ByteBuffer。通過這個ByteBuffer我們就可以把圖片保存下來

三、具體實現步驟

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.創建一個CameraHelper類，並給TextureView對象添加回調函數

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()
            }
        }
    }
}

各個參數都加的有註釋，應該都能看得懂哈~

簡單說幾點：

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

注：
如果對手機方向和攝像頭方向還不太理解的小夥伴，建議看一下Android: Camera相機開發詳解(上) —— 知識儲備，裏面有對這兩個方向的講解。

四、初始化相關參數

    /**
     * 初始化
     */
    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("預覽最優尺寸 ：${mPreviewSize.width} * ${mPreviewSize.height}, 比例  ${mPreviewSize.width.toFloat() / mPreviewSize.height}")
        log("保存圖片最優尺寸 ：${mSavePicSize.width} * ${mSavePicSize.height}, 比例  ${mSavePicSize.width.toFloat() / mSavePicSize.height}")

        //根據預覽的尺寸大小調整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()
    }

   /**
     * 根據提供的屏幕方向 [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
    }

    /**
     *
     * 根據提供的參數值返回與指定寬高相等或最接近的尺寸
     *
     * @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("系統支持的尺寸: ${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 實例
通過循環遍歷設備中可用的相機，通過 mCameraManager.getCameraCharacteristics(id) 獲取到相機的各種信息
mCameraCharacteristics.get(CameraCharacteristics.SENSOR_ORIENTATION) 獲取到相機傳感器的方向
通過 configurationMap.getOutputSizes(ImageFormat.JPEG) 和 configurationMap.getOutputSizes(SurfaceTexture::class.java) 獲取到相機支持的預覽尺寸和保存圖片的尺寸
exchangeWidthAndHeight(displayRotation: Int, sensorOrientation: Int)方法的作用是根據屏幕方向和攝像頭方向確定是否需要交換寬高

比如我們手機豎屏放置，設置的預覽寬高是 720 * 1280 ，我們希望設置的是寬爲 720，高爲 1280 。而後置攝像頭相對於豎直方向是 90°，也就說 720 相對於是攝像頭來說是它的高度，1280 是它的寬度，這跟我們想要設置的剛好相反。所以，我們通過exchangeWidthAndHeight這個方法得出來是否需要交換寬高值，如果需要，那變成了把 1280 * 720 設置給攝像頭，即它的寬爲 720，高爲 1280 。這樣就與我們預期的寬高值一樣了

通過 getBestSize(targetWidth: Int, targetHeight: Int, maxWidth: Int, maxHeight: Int, sizeList: List<Size>) 方法獲取到最優的寬和高。根據傳入的目標寬高值、最大寬高值（即屏幕大小）和相機支持的尺寸列表，從相機支持的尺寸列表中得到一個最優值。
通過mTextureView.surfaceTexture.setDefaultBufferSize(mPreviewSize.width, mPreviewSize.height) 方法用來設置TextureView的預覽尺寸
mImageReader = ImageReader.newInstance(mSavePicSize.width, mSavePicSize.height, ImageFormat.JPEG, 1)
mImageReader?.setOnImageAvailableListener(onImageAvailableListener, mCameraHandler)

創建一個ImageReader對象，並設置回調函數。前兩個參數代表保存圖片的寬高，第三個參數是保存圖片的格式，第四個參數代表用戶同時可以得到的圖片最大數

在onImageAvailableListener中處理得到的圖像數據，具體代碼在後面給出

五、打開相機

     /**
     * 打開相機
     */
    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)
    }

六、創建預覽會話

 /**
     * 創建預覽會話
     */
    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) // 自動對焦

        // 爲相機預覽，創建一個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) 創建一個用於預覽的Builder對象
爲該Builder對象添加一個Surface對象，並設置各種相關參數
通過cameraDevice.createCaptureSession創建一個會話，第一個參數中傳了一個 surface 和 mImageReader?.surface。這表明了這次會話的圖像數據的輸出到這兩個對象
當會話創建成功時，通過 session.setRepeatingRequest(captureRequestBuilder.build(), mCaptureCallBack, mCameraHandler) 發起預覽請求

到這一步，程序已經能夠正常跑起來了。下面是我的手機跑起來時打印的日誌：

注意 :
Camera2在一些低端機器上會出現預覽畫面拉伸問題。
在android 5.0，硬件兼容級別爲legacy時，Camera2輸出的寬高比和Camera Sensor保持一致。也就是說我們設置的預覽寬高 720 * 1280 並不起作用，所以出現了畫面拉伸。
對於這個問題，我在網上看到的答案是如果遇到這種情況放棄使用Camra2，使用舊的Camera1。這並不是一種優雅的解決方法，如果小夥們們有更好的解決方法的話歡迎提出來

七、拍照、保存

    /**
     * 拍照
     */
    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)      //根據攝像頭方向對保存的照片進行旋轉，使其爲"自然方向"
            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) 創建一個拍照請求的Builder對象
然後設置各種參數。注意，captureRequestBuilder.set(CaptureRequest.JPEG_ORIENTATION, mCameraSensorOrientation)用來設置保存照片的旋轉方向。如果不設置的話，保存的照片不是"自然方向"

在 Android: Camera相機開發詳解(上) —— 知識儲備中有講解

拍照的結果是在 OnImageAvailableListener 對象中得到的。首先通過 acquireNextImage() 方法獲取到一個Image對象，然後通過 image.planes[0].buffer 得到 byteBuffer，將這個 byteBuffer 轉換成 byteArray 。這個 byteArray 就是拍照所得到的圖像數據。然後就可以把這個 byteArray 保存成圖片到手機存儲中

八、釋放相機及線程

    fun releaseCamera() {
        mCameraCaptureSession?.close()
        mCameraCaptureSession = null

        mCameraDevice?.close()
        mCameraDevice = null

        mImageReader?.close()
        mImageReader = null

        canExchangeCamera = false
    }

    fun releaseThread() {
        handlerThread.quitSafely()
    }

效果展示

完整代碼

https://github.com/smashinggit/Study

原文鏈接：https://www.jianshu.com/p/0ea5e201260f

至此，本篇已結束。轉載網絡的文章，小編覺得很優秀，歡迎點擊閱讀原文，支持原創作者，如有侵權，懇請聯繫小編刪除，歡迎您的建議與指正。同時期待您的關注，感謝您的閱讀，謝謝！

Android Camera 預覽、拍照、保存照片實現一、Camera2架構概述二、 Camera2中比較重要的類及方法三、具體實現步驟效果展示完整代碼

和你一起終身學習，這裏是程序員 Android

一、Camera2架構概述

二、 Camera2中比較重要的類及方法

1. CameraManager

2. CameraDevice

3. CameraCharacteristics

4. CaptureRequest

5. CameraCaptureSession

6. CaptureResult

7. ImageReader

8. Image

9. Plane

三、具體實現步驟

1.申請權限：

2.在xml佈局文件中定義一個TextureView

3.創建一個CameraHelper類，並給TextureView對象添加回調函數

四、初始化相關參數

五、打開相機

六、創建預覽會話

七、拍照、保存

八、釋放相機及線程

效果展示

完整代碼

使用c#強大的表達式樹實現對象的深克隆之解決循環引用的問題

痞子衡嵌入式：恩智浦i.MX RT1xxx系列MCU啓動那些事（12.A）- uSDHC eMMC啓動時間(RT1170)

GPT-4o 引領人機交互新風向，向量數據庫賽道沸騰了

企業大模型如何成爲自己數據的“百科全書”？

本地SSL證書過期輸入命令在IIS自動生成

基於Ubuntu-22.04安裝K8s-v1.28.2實驗（二）使用kube-vip實現集羣VIP訪問

.NET週刊【5月第2期 2024-05-12】

高通相機bringup guide

MTK 人像雙攝虛化導通guide

MTK 相機功耗問題學習筆記

MTK 平臺相機bringup點亮

C語言測試題舉例

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

Android Camera 預覽、拍照、保存照片 實現 一、Camera2架構概述 二、 Camera2中比較重要的類及方法 三、具體實現步驟 效果展示 完整代碼

和你一起終身學習，這裏是程序員 Android

一、Camera2架構概述

二、 Camera2中比較重要的類及方法

1. CameraManager

2. CameraDevice

3. CameraCharacteristics

4. CaptureRequest

5. CameraCaptureSession

6. CaptureResult

7. ImageReader

8. Image

9. Plane

三、具體實現步驟

1.申請權限：

2.在xml佈局文件中定義一個TextureView

3.創建一個CameraHelper類，並給TextureView對象添加回調函數

四、初始化相關參數

五、打開相機

六、創建預覽會話

七、拍照、保存

八、 釋放相機及線程

效果展示

完整代碼

Android Camera 預覽、拍照、保存照片實現一、Camera2架構概述二、 Camera2中比較重要的類及方法三、具體實現步驟效果展示完整代碼

八、釋放相機及線程