CameraX 是一個 Jetpack 支持庫，利用了 camera2 的功能，可感知生命周期，解決了設備兼容性問題，向后兼容至 Android 5.0（API 級別 21），并提供一致且易用的 API 接口。借助 CameraX，開發者只需兩行代碼就能實現與預安裝的相機應用相同的相機體驗和功能！

它是一種架構，官方介紹它是非常強大好用，那么，嘗試用起來吧。

• 1、創建 CameraX 的練習項目

minSdkVersion 選 21，Android 5.0。

• 2、添加依賴

    // CameraX core library using camera2 implementation
    implementation "androidx.camera:camera-camera2:1.0.1"
    // CameraX Lifecycle Library
    implementation "androidx.camera:camera-lifecycle:1.0.1"
    // CameraX View class
    implementation "androidx.camera:camera-view:1.0.0-alpha27"

• 3、添加插件 kotlin-android-extensions

plugins {
    id 'com.android.application'
    id 'kotlin-android'
    id 'kotlin-android-extensions'
}

• 4、編寫布局文件 activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <Button
        android:id="@+id/camera_capture_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginBottom="30dp"
        android:elevation="2dp"
        android:scaleType="fitCenter"
        android:text="Take Photo"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent" />

    <androidx.camera.view.PreviewView
        android:id="@+id/viewFinder"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

• 5、打開 AndroidManifest.xml 添加權限

    <!-- 確保設備有 camera .any 意味著可能是前置攝像頭或者是后置攝像頭  -->
    <uses-feature android:name="android.hardware.camera.any" />
    <uses-permission android:name="android.permission.CAMERA" />

6、正式編寫代碼啦，包括了打開相機，截取圖像，保存圖片，圖片分析等等功能編寫。

步驟：

• 將 CameraX 依賴項加入到的項目中。
• 顯示相機取景器（使用預覽用例）。
• 實現照片捕獲，將圖像保存到存儲（使用 ImageCapture 用例）。
• 實時分析來自相機的幀（使用 ImageAnalysis 用例）。

package com.pyn.cameraxpractice

import android.Manifest
import android.content.pm.PackageManager
import android.net.Uri
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import android.widget.Toast
import androidx.camera.core.*
import androidx.camera.lifecycle.ProcessCameraProvider
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
import com.pyn.cameraxpractice.databinding.ActivityMainBinding
import kotlinx.android.synthetic.main.activity_main.*
import java.io.File
import java.nio.ByteBuffer
import java.text.SimpleDateFormat
import java.util.*
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors

class MainActivity : AppCompatActivity() {

    private lateinit var mBinding: ActivityMainBinding
    private var imageCapture: ImageCapture? = null
    private lateinit var outputDirectory: File
    private lateinit var cameraExecutor: ExecutorService

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        mBinding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(mBinding.root)

        if (allPermissionsGranted()) {
            // 權限請求完畢，且授權了
            startCamera()
        } else {
            ActivityCompat.requestPermissions(this, REQUIRED_PERMISSIONS, REQUEST_CODE_PERMISSIONS)
        }

        mBinding.btnCameraCapture.setOnClickListener { takePhoto() }
        outputDirectory = getOutputDirectory()
        cameraExecutor = Executors.newSingleThreadExecutor()
    }

    /**
     * 請求權限的回調
     */
    override fun onRequestPermissionsResult(
        requestCode: Int, permissions: Array<String>, grantResults:
        IntArray
    ) {
        if (requestCode == REQUEST_CODE_PERMISSIONS) {
            if (allPermissionsGranted()) {
                // 如果所有權限都授權成功了
                startCamera()
            } else {
                Toast.makeText(
                    this,
                    "Permissions not granted by the user.",
                    Toast.LENGTH_SHORT
                ).show()
                finish()
            }
        }
    }

    /**
     * 拍照
     */
    private fun takePhoto() {
        // 獲取對 ImageCapture 用例的引用
        val imageCapture = imageCapture ?: return
        // 創建文件來保存圖像。添加時間戳，以便文件名是唯一的。
        val photoFile = File(
            outputDirectory,
            SimpleDateFormat(FILENAME_FORMAT, Locale.US).format(System.currentTimeMillis()) + ".jpg"
        )
        // 指定將輸出內容保存在我們剛剛創建的文件中
        val outputOptions = ImageCapture.OutputFileOptions.Builder(photoFile).build()
        // 拍照
        imageCapture.takePicture(
            outputOptions,
            ContextCompat.getMainExecutor(this),
            object : ImageCapture.OnImageSavedCallback {
                override fun onError(exception: ImageCaptureException) {
                    Log.e(TAG, "Photo capture failed: ${exception.message}", exception)
                }

                override fun onImageSaved(outputFileResults: ImageCapture.OutputFileResults) {
                    val savedUri = Uri.fromFile(photoFile)
                    val msg = "Photo capture succeeded: $savedUri"
                    Toast.makeText(baseContext, msg, Toast.LENGTH_SHORT).show()
                    Log.d(TAG, msg)
                }
            }
        )
    }

    /**
     * 打開相機
     */
    private fun startCamera() {

        // 定義配置，創建用例實例，用于將相機的生命周期綁定到生命周期所有者，這消除了打開和關閉相機的任務，因為 CameraX 具有生命周期感知能力。
        val cameraProviderFuture = ProcessCameraProvider.getInstance(this)
        // 向 cameraProviderFuture 添加一個監聽器。
        // 參數一：Runnable
        // 參數二：ContextCompat.getMainExecutor() 將返回一個在主線程上運行的 Executor。
        cameraProviderFuture.addListener(Runnable {
            // 用于將相機的生命周期綁定到應用程序進程中的 LifecycleOwner
            val cameraProvider: ProcessCameraProvider = cameraProviderFuture.get()
            // 初始化預覽對象，取景器是用來讓用戶預覽照片的，CameraX Preview 實現取景器
            val preview = Preview.Builder().build().also {
                it.setSurfaceProvider(viewFinder.surfaceProvider)
            }
            imageCapture = ImageCapture.Builder().build()

            val imageAnalyzer = ImageAnalysis.Builder()
                .build()
                .also {
                    it.setAnalyzer(cameraExecutor, LuminosityAnalyzer { luma ->
                        Log.d(TAG, "Average luminosity: $luma")
                    })
                }

            // 默認選擇后置攝像頭
            val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA

            try {
                // 在重新綁定之前取消綁定用例
                cameraProvider.unbindAll()
                // 將cameraSelector 和預覽對象綁定到 cameraProvider
                cameraProvider.bindToLifecycle(this, cameraSelector, preview, imageCapture, imageAnalyzer)
            } catch (exc: Exception) {
                // 綁定失敗
                Log.e(TAG, "Use case binding failed", exc)
            }
        }, ContextCompat.getMainExecutor(this))

    }

    private fun allPermissionsGranted() = REQUIRED_PERMISSIONS.all {
        ContextCompat.checkSelfPermission(baseContext, it) == PackageManager.PERMISSION_GRANTED
    }

    private fun getOutputDirectory(): File {
        val mediaDir = externalMediaDirs.firstOrNull()?.let {
            File(it, resources.getString(R.string.app_name)).apply {
                mkdirs()
            }
        }
        return if (mediaDir != null && mediaDir.exists()) mediaDir else filesDir
    }

    override fun onDestroy() {
        super.onDestroy()
        cameraExecutor.shutdown()
    }

    companion object {
        private const val TAG = "CameraXBasic"
        private const val FILENAME_FORMAT = "yyyy-MM-dd-HH"
        private const val REQUEST_CODE_PERMISSIONS = 10
        private val REQUIRED_PERMISSIONS = arrayOf(Manifest.permission.CAMERA)
    }

    private class LuminosityAnalyzer(private val listener: LumaListener) : ImageAnalysis.Analyzer {

        private fun ByteBuffer.toByteArray(): ByteArray {
            // 倒帶
            rewind()
            val data = ByteArray(remaining())
            get(data)
            return data
        }

        override fun analyze(image: ImageProxy) {
            val buffer = image.planes[0].buffer
            val data = buffer.toByteArray()
            val pixels = data.map { it.toInt() and 0xFF }
            val luma = pixels.average()
            listener(luma)
            image.close()
        }
    }
}

typealias LumaListener = (luma: Double) -> Unit

保存了圖片后，可以從手機文件中找到該圖片，地址如下圖：

照片位置

分析日志如下：

分析日志

上述只是簡單照著官方文檔練習，具體更為詳細的還是需要再多去看看官方文檔研究下的，api 很靈活。多嘗試嘗試。

附：

CameraX 開發者社區 「論壇」：
https://groups.google.com/a/android.com/g/camerax-developers
CameraX API 最佳實踐：
https://github.com/android/camera-samples
官方介紹地址：
https://developer.android.com/training/camerax?hl=zh-cn