目录

compileOptions {
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8
}
kotlinOptions {
    jvmTarget = "1.8"
}

buildFeatures {
    viewBinding = true
}

package com.android.example.cameraxapp

import android.Manifest
import android.content.ContentValues
import android.content.pm.PackageManager
import android.os.Build
import android.os.Bundle
import android.provider.MediaStore
import android.util.Log
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.camera.core.CameraSelector
import androidx.camera.core.ImageCapture
import androidx.camera.core.ImageCaptureException
import androidx.camera.core.Preview
import androidx.camera.lifecycle.ProcessCameraProvider
import androidx.camera.video.FallbackStrategy
import androidx.camera.video.MediaStoreOutputOptions
import androidx.camera.video.Quality
import androidx.camera.video.QualitySelector
import androidx.camera.video.Recorder
import androidx.camera.video.Recording
import androidx.camera.video.VideoCapture
import androidx.camera.video.VideoRecordEvent
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
import androidx.core.content.PermissionChecker
import com.android.example.cameraxapp.databinding.ActivityMainBinding
import java.text.SimpleDateFormat
import java.util.Locale

class MainActivity : AppCompatActivity() {

    // 等价于 static
    companion object {
        private const val TAG = "CameraXApp"
        private const val FILENAME_FORMAT = "yyyy-MM-dd-HH-mm-ss-SSS"
        private const val REQUEST_CODE_PERMISSIONS = 10
        private val REQUIRED_PERMISSIONS =
            mutableListOf(Manifest.permission.CAMERA, Manifest.permission.RECORD_AUDIO).apply {
                    if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.P) {
                        add(Manifest.permission.WRITE_EXTERNAL_STORAGE)
                    }
                }.toTypedArray()
    }

    // 视图绑定
    private lateinit var viewBinding: ActivityMainBinding

    // 图像捕获用例和视频捕获用例（以及录像实例）
    private var imageCapture: ImageCapture? = null
    private var videoCapture: VideoCapture<Recorder>? = null
    private var recording: Recording? = null

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

        // 请求权限
        if (allPermissionsGranted()) {
            startCamera()
        } else {
            ActivityCompat.requestPermissions(this, REQUIRED_PERMISSIONS, REQUEST_CODE_PERMISSIONS)
        }

        // 按钮监听
        viewBinding.imageCaptureButton.setOnClickListener { takePhoto() }
        viewBinding.videoCaptureButton.setOnClickListener { captureVideo() }
    }

    // 请求权限回调
    override fun onRequestPermissionsResult(
        requestCode: Int, permissions: Array<String>, grantResults: IntArray
    ) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        if (requestCode == REQUEST_CODE_PERMISSIONS) {
            if (allPermissionsGranted()) {
                startCamera()
            } else {
                Toast.makeText(
                    this, "相机权限被拒绝！", Toast.LENGTH_SHORT
                ).show()
                finish()
            }
        }
    }

    /**
     * 获取相机提供者实例，启动相机
     */
    private fun startCamera() {
        // 获取相机提供者实例
        // 这个过程是异步的，使用了 ListenableFuture 处理获取相机提供者之后的逻辑
        val cameraProviderFuture = ProcessCameraProvider.getInstance(this)
        cameraProviderFuture.addListener({
            // 相机提供者 ProcessCameraProvider
            val cameraProvider = cameraProviderFuture.get()

            // 创建预览用例
            val preview = Preview.Builder().build().also {
                    it.surfaceProvider = viewBinding.viewFinder.surfaceProvider
                }

            // 创建图像捕获用例
            imageCapture = ImageCapture.Builder().build()

            // 创建视频捕获用例，设置输出
            val recorder = Recorder.Builder().setQualitySelector(
                    QualitySelector.from(
                        Quality.HIGHEST, FallbackStrategy.higherQualityOrLowerThan(Quality.SD) // 回调策略
                    )
                ).build()
            videoCapture = VideoCapture.withOutput(recorder)

            // 相机选择器，默认选择后置
            val cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA

            // 将相机用例绑定到 MainActivity 的生命周期
            try {
                // 每次绑定前清除已有的用例
                cameraProvider.unbindAll()
                // 将相机用例绑定到 MainActivity 的生命周期
                cameraProvider.bindToLifecycle(
                    this, cameraSelector, preview, imageCapture, videoCapture
                )
            } catch (exc: Exception) {
                Log.e(TAG, "用例绑定失败", exc)
            }

        }, ContextCompat.getMainExecutor(this)) // 监听器需要在主线程上执行，可以更安全地更新 UI，做主线程才能做的操作
    }

    /**
     * 使用图像捕获用例，实现拍照
     */
    private fun takePhoto() {
        Log.d(TAG, "准备拍照。")

        // 确保图像捕获用例不为空
        val imageCapture = imageCapture ?: return

        // 设置图像文件的信息
        val name = SimpleDateFormat(FILENAME_FORMAT, Locale.US).format(System.currentTimeMillis())
        // ContentValues 是一个键值对集合，用于存储数据，这里用来存储有关图片的信息
        val contentValues = ContentValues().apply {
            put(MediaStore.MediaColumns.DISPLAY_NAME, name)
            put(MediaStore.MediaColumns.MIME_TYPE, "image/jpeg")
            if (Build.VERSION.SDK_INT > Build.VERSION_CODES.P) {
                put(MediaStore.Images.Media.RELATIVE_PATH, "Pictures/CameraX-Image")
            }
        }

        // 创建图像输出选项（输出文件 UIR、输出图像文件的信息）
        val outputOptions = ImageCapture.OutputFileOptions.Builder(
            contentResolver, MediaStore.Images.Media.EXTERNAL_CONTENT_URI, contentValues
        ).build()

        // 拍照和回调
        imageCapture.takePicture(
            outputOptions,
            ContextCompat.getMainExecutor(this), // 需要在主线程上执行
            object : ImageCapture.OnImageSavedCallback { // 回调函数
                override fun onError(exc: ImageCaptureException) {
                    Log.e(TAG, "拍照失败：${exc.message}", exc)
                }
                override fun onImageSaved(output: ImageCapture.OutputFileResults) {
                    val msg = "拍照成功：${output.savedUri}"
                    Toast.makeText(baseContext, msg, Toast.LENGTH_SHORT).show()
                    Log.d(TAG, msg)
                }
            })
    }

    /**
     * 使用视频捕获用例，实现录像或结束录像
     */
    private fun captureVideo() {
        Log.d(TAG, "开始录像。")

        // 确保视频捕获用例不为空，并临时禁用按钮
        val videoCapture = this.videoCapture ?: return
        viewBinding.videoCaptureButton.isEnabled = false

        // 如果当前正在录像，那就结束录像
        val currentRecording = recording
        if (currentRecording != null) {
            currentRecording.stop() // 结束录像，触发结束事件
            recording = null
            return
        }

        // 如果不在录像，那就准备录像
        // 设置视频文件的基本属性
        val name = SimpleDateFormat(FILENAME_FORMAT, Locale.US).format(System.currentTimeMillis())
        val contentValues = ContentValues().apply {
            put(MediaStore.MediaColumns.DISPLAY_NAME, name)
            put(MediaStore.MediaColumns.MIME_TYPE, "video/mp4")
            if (Build.VERSION.SDK_INT > Build.VERSION_CODES.P) {
                put(MediaStore.Video.Media.RELATIVE_PATH, "Movies/CameraX-Video")
            }
        }

        // 创建视频输出选项，使用 MediaStore 输出录像文件
        val mediaStoreOutputOptions = MediaStoreOutputOptions.Builder(
            contentResolver, MediaStore.Video.Media.EXTERNAL_CONTENT_URI
        ).setContentValues(contentValues).build()

        // 设置录像事件监听，并创建录像实例开始录像
        recording = videoCapture.output.prepareRecording(this, mediaStoreOutputOptions).apply { // 准备
            // 跟据录音权限决定是否录音
            if (PermissionChecker.checkSelfPermission(
                    this@MainActivity, Manifest.permission.RECORD_AUDIO
                ) == PermissionChecker.PERMISSION_GRANTED
            ) {
                withAudioEnabled()
            }
        }.start(ContextCompat.getMainExecutor(this)) { recordEvent -> // 设置录像事件监听并开始录像，触发开始事件
            when (recordEvent) {
                // 开始事件
                is VideoRecordEvent.Start -> {
                    viewBinding.videoCaptureButton.apply { // 重新启用按钮
                        text = getString(R.string.stop_capture)
                        isEnabled = true
                    }
                }
                // 结束事件
                is VideoRecordEvent.Finalize -> {
                    if (!recordEvent.hasError()) {
                        val msg = "录像成功：" + "${recordEvent.outputResults.outputUri}"
                        Toast.makeText(baseContext, msg, Toast.LENGTH_SHORT).show()
                        Log.d(TAG, msg)
                    } else {
                        recording?.close()
                        recording = null
                        Log.e(TAG, "录像出错： " + "${recordEvent.error}")
                    }
                    viewBinding.videoCaptureButton.apply { // 重新启用按钮
                        text = getString(R.string.start_capture)
                        isEnabled = true
                    }
                }
            }
        }
    }

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

}