val cameraManager = context.getSystemService(
    Context.CAMERA_SERVICE
) as CameraManager

// 1. 拿到所有相机的 id 列表
val cameraIdList = cameraManager.cameraIdList

// 2. 遍历每个相机，根据描述信息筛选出目标信息
val cameraIds = cameraIdList.filter {
    val characteristics = cameraManager.getCameraCharacteristics(it)
    val capabilities = characteristics.get(
        CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES
    )
    // 过滤出向后兼容(又叫向下兼容，兼容旧代码)的功能集
    capabilities?.contains(
        CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE
    ) ?: false
}

val facing = characteristics.get(
    CameraCharacteristics.LENS_FACING
) ?: CameraMetadata.LENS_FACING_FRONT

val facingDesc = lensOrientationString(facing)

// 返回相机朝向的说明文本
private fun lensOrientationString(
    facing: Int
) = when(facing) {
    CameraCharacteristics.LENS_FACING_BACK -> "Back"
    CameraCharacteristics.LENS_FACING_FRONT -> "Front"
    CameraCharacteristics.LENS_FACING_EXTERNAL -> "External"
    else -> "Unknown"
}

private data class FormatItem(
    val title: String, 
    val cameraId: String, 
    val format: Int
)

// 3. 筛选出目标相机：包括支持 JPEG/RAW/JPEG DEPTH 格式的相机列表
cameraIds.forEach { id ->
    // 根据 id 获取相机信息
    val characteristics = cameraManager.getCameraCharacteristics(id)
    val facingDesc = lensOrientationString(
        characteristics.get(CameraCharacteristics.LENS_FACING)!!
    )

    // 查询可用的能力和输出格式
    val capabilities = characteristics.get(
        CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES
    )!!
    val outputFormats = characteristics.get(
        CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP
    )!!.outputFormats

    // 所有相机都必须支持 JPEG 格式，availableCameras 是目标相机列表
    targetCameras.add(
        FormatItem("$facingDesc JPEG ($id)", id, ImageFormat.JPEG)
    )

    // 判断是否支持 RAW，需要判断 capability 和 ImageFormat 两项
    if (capabilities.contains(
            CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_RAW
        ) && outputFormats.contains(
            ImageFormat.RAW_SENSOR
        )
    ) {
        targetCameras.add(
            FormatItem("$facingDesc RAW ($id)", id, ImageFormat.RAW_SENSOR)
        )
    }

    // 判断支持 JPEG DEPTH capability 的相机
    if (capabilities.contains(
            CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT
        ) && outputFormats.contains(
            ImageFormat.DEPTH_JPEG
        )
    ) {
        targetCameras.add(
            FormatItem("$facingDesc DEPTH ($id)", id, ImageFormat.DEPTH_JPEG)
        )
    }
}

public static abstract class StateCallback {
    // 由 onError 返回的错误码，表明相机设备已在使用中
    // 当其他更高优先级的 app 已在使用相机时，再打开对应相机会失败，并返回此错误
    public static final int ERROR_CAMERA_IN_USE = 1;
    // 由 onError 返回的错误码，表明打开的相机设备太多，无法再打开更多设备
    public static final int ERROR_MAX_CAMERAS_IN_USE = 2;
    // 由 onError 返回的错误码，表明由于设备策略而无法打开相机设备
    // 另见 DevicePolicyManager.setCameraDisabled(ComponentName, boolean)
    public static final int ERROR_CAMERA_DISABLED = 3;
    // 由 onError 返回的错误码，表明相机设备遇到了致命错误
    // 遇到此错误，相机设备需要重新调用 openCamera 方法才能再次使用
    public static final int ERROR_CAMERA_DEVICE = 4;
    // 由 onError 返回的错误码，表明相机服务出错，或者手机可能存在硬件问题
    // 遇到此错误，手机可能需要关机重启才能��复相机功能
    public static final int ERROR_CAMERA_SERVICE = 5;


    // 当相机完全开启后，此回调生效。此时相机设备就可以使用了。
    // 之后可以调用 createCaptureSession 方法来创建 capture session。
    //
    // 方法的入参是已打开的相机设备。
    public abstract void onOpened(@NonNull CameraDevice camera);
    // 调用 CameraDevice.close 方法关闭相机设备时，此回调生效
    //
    // close 后，调用此 CameraDevice 上的任何方法，
    // 都将抛出 IllegalStateException。此方法的默认实现不执行任何操作。
    //
    // 方法的入参是已关闭的相机设备。
    public void onClosed(@NonNull CameraDevice camera) {
    }
    // 当相机设备断开连接不再可用，或者可能打开相机失败时，此回调生效
    // 
    // disconnect 后，调用此 CameraDevice 上的任何方法，
    // 都将引发 CameraAccessException。
    // 
    // 相机断开连接的原因可能有：
    //   - 安全策略或权限的更改
    //   - 可移动相机设备物理断开连接
    //   - 更高优先级的相机 app 需要使用此相机蛇别
    //
    // 调用此方法后，capture callbacks 可能仍会调用，或者
    // 新的 image buffers 仍会被传递到 active outputs。
    // 
    // 收到此回调后，我们应该调用 CameraDevice.close 方法关闭相机，进行清理
    //
    // 方法的入参是已经断开连接的相机设备
    public abstract void onDisconnected(@NonNull CameraDevice camera);
    // 当相机设备遇到严重错误时调用的方法。如果相机打开失败，可能会调用此回调。
    //
    // error 时，调用此 CameraDevice 上的任何方法都将抛出 CameraAccessException。
    //
    // 收到此错误后，可能仍会调用 capture completion，
    // 或者可能仍会调用 camera stream callbacks
    //
    // 收到此错误后，我们应该调用 CameraDevice.close 方法关闭相机，进行清理。
    // 恢复操作的尝试应该根据 errorCode 进行判断
    //
    // 方法的入参为出错的相机设备，及其对应的错误码
    public abstract void onError(
        @NonNull CameraDevice camera,
        @ErrorCode int error
    );
}

fun open() {
    // 相机操作运行的线程
    val cameraThread = HandlerThread(
        "CameraThread"
    ).apply { 
        start() 
    }

    val cameraHandler = Handler(cameraThread.looper)
    // 打开相机，类型是 CameraDevice
    var camera = openCamera(cameraId, cameraHandler)
}


// 打开相机的方法，用到了回调转协程
private suspend fun openCamera(
    cameraId: String,
    handler: Handler? = null
): CameraDevice = suspendCancellableCoroutine { cont ->
    // CameraManager.openCamera 方法
    manager.openCamera(
        cameraId, object : CameraDevice.StateCallback() {
            override fun onOpened(
                device: CameraDevice
            ) = cont.resume(device)

            override fun onDisconnected(
                device: CameraDevice
            ) {
                activity.finish()
            }

            override fun onError(
                device: CameraDevice, 
                error: Int
            ) {
                val msg = when (error) {
                    // 错误码定义在 CameraDevice.StateCallback 中
                    ERROR_CAMERA_DEVICE -> "Fatal (device)"
                    ERROR_CAMERA_DISABLED -> "Device policy"
                    ERROR_CAMERA_IN_USE -> "Camera in use"
                    ERROR_CAMERA_SERVICE -> "Fatal (service)"
                    ERROR_MAX_CAMERAS_IN_USE -> "Maximum cameras in use"
                    else -> "Unknown"
                }
                val exc = RuntimeException(
                    "Camera $cameraId error: ($error) $msg"
                )
                Log.e(TAG, exc.message, exc)
                if (cont.isActive) {
                    cont.resumeWithException(exc)
                }
            }
        }, 
        handler
    )
}

val size = characteristics.get(
    CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP
)!!.getOutputSizes(pixelFormat).maxBy { 
    // 从尺寸列表中选出面积最大的尺寸
    it.height * it.width
}!!

binding.surfaceView.holder.addCallback(
    object : SurfaceHolder.Callback {
        override fun surfaceDestroyed(holder: SurfaceHolder) = Unit

        override fun surfaceChanged(
            holder: SurfaceHolder,
            format: Int,
            width: Int,
            height: Int
         ) = Unit

        override fun surfaceCreated(holder: SurfaceHolder) {
            realOpenCamera()
        }
})

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

val imageReader = ImageReader.newInstance(
    size.width, 
    size.height, 
    pixelFormat, 
    3 // image reader 的 buffer 中最多缓存 3 张图片
)

val targets = listOf(
    surfaceView.holder.surface, 
    imageReader.surface
)

val session = createCaptureSession(
    camera, 
    targets, 
    cameraHandler
)
// 回调转协程
private suspend fun createCaptureSession(
    device: CameraDevice,
    targets: List<Surface>,
    handler: Handler? = null
): CameraCaptureSession = suspendCoroutine { cont ->
    device.createCaptureSession(
        targets, 
        object : CameraCaptureSession.StateCallback() {
            override fun onConfigured(
                session: CameraCaptureSession
            ) = cont.resume(session)

            override fun onConfigureFailed(
                session: CameraCaptureSession
            ) {
                val exc = RuntimeException(
                    "Camera ${device.id} session configure failed"
                )
                Log.e(TAG, exc.message, exc)
                cont.resumeWithException(exc)
            }
        }, 
        handler
    )
}

// camera 是 CameraDevice 实例
val captureRequest = camera.createCaptureRequest(
    // 1. 创建预览请求
    CameraDevice.TEMPLATE_PREVIEW
)
// 2. 画面输出到 SurfaceView
captureRequest.addTarget(surfaceView.holder.surface) 
// 3. 提交重复请求图像数据，直到会话断开或调用了 session.stopRepeating()
session.setRepeatingRequest(
    captureRequest.build(), 
    null, 
    cameraHandler
)

val captureRequest = session.device.createCaptureRequest(
    CameraDevice.TEMPLATE_STILL_CAPTURE
)

captureRequest.addTarget(imageReader.surface) 

val imageReaderThread = HandlerThread("imageReaderThread").apply { 
    start() 
}
val imageReaderHandler = Handler(imageReaderThread.looper)
// 最多缓存 3 张图片
val imageQueue = ArrayBlockingQueue<Image>(3)
// 设置监听，在图像可用时，将图像存入队列中
imageReader.setOnImageAvailableListener({ reader ->
    val image = reader.acquireNextImage()
    Log.d(TAG, "Image available in queue: ${image.timestamp}")
    // 图片塞入阻塞队列中，如果已满则抛出异常
    imageQueue.add(image)
}, imageReaderHandler)

public abstract class CameraCaptureSession 
    implements AutoCloseable {
    // 提交一个 CaptureRequest
    public abstract int capture(
        @NonNull CaptureRequest request,
        @Nullable CaptureCallback listener, 
        @Nullable Handler handler
    ) throws CameraAccessException;
    // 提交一个 CaptureRequest 列表
    public abstract int captureBurst(
        @NonNull List<CaptureRequest> requests,
        @Nullable CaptureCallback listener, 
        @Nullable Handler handler
    ) throws CameraAccessException;
    // 提交一个 Repeat 模式的 CaptureRequest
    public abstract int setRepeatingRequest(
        @NonNull CaptureRequest request,
        @Nullable CaptureCallback listener, 
        @Nullable Handler handler
    ) throws CameraAccessException;
    // 提交一个 Repeat 模式的 CaptureRequest 列表
    public abstract int setRepeatingBurst(
        @NonNull List<CaptureRequest> requests,
        @Nullable CaptureCallback listener, 
        @Nullable Handler handler
    ) throws CameraAccessException;
}

session.capture(
    captureRequest.build(), 
    object : CameraCaptureSession.CaptureCallback() {
        override fun onCaptureStarted(
            session: CameraCaptureSession,
            request: CaptureRequest,
            timestamp: Long,
            frameNumber: Long
        ) {
            super.onCaptureStarted(
                session, 
                request, 
                timestamp, 
                frameNumber
            )
            // 拍摄开始时播放动画
            surfaceView.post(animationTask)
        }

        override fun onCaptureCompleted(
            session: CameraCaptureSession,
            request: CaptureRequest,
            result: TotalCaptureResult
        ) {
            // 拍照完成的代码后面单独讲
        }, 
    cameraHandler
)

override fun onCaptureCompleted(
    session: CameraCaptureSession,
    request: CaptureRequest,
    result: TotalCaptureResult
) {
    super.onCaptureCompleted(session, request, result)
    // 获取当前会话处理的 request 的图片的完成时间
    val resultTimestamp = result.get(
        CaptureResult.SENSOR_TIMESTAMP
    )
    Log.d(TAG, "Capture result received: $resultTimestamp")
    // 设置获取图片的等待时长，5 秒后取消获取图片的动作
    val exc = TimeoutException("Image dequeuing took too long")
    val timeoutRunnable = Runnable { throw exc }
    imageReaderHandler.postDelayed(timeoutRunnable, 5000)

    // 死循环获取目标图片数据
    lifecycleScope.launch(cont.context) {
        while (true) {
            // 将元素从出队，队列中无元素时会阻塞并等待
            val image = imageQueue.take()
            // 如果图片与当前回调对应的图片不同，则不处理
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q 
                && image.format != ImageFormat.DEPTH_JPEG 
                && image.timestamp != resultTimestamp
            ) {
                continue
            }
            Log.d(TAG, "Matching image dequeued: ${image.timestamp}")
            // 拿到图片后取消超时回调，并移除剩余图片数据
            imageReaderHandler.removeCallbacks(timeoutRunnable)
            imageReader.setOnImageAvailableListener(null, null)  
            while (imageQueue.size > 0) {
                imageQueue.take().close()
            }

            // 计算旋转角度与朝向
            val rotation = relativeOrientation.value ?: 0

            val mirrored = characteristics.get(
                CameraCharacteristics.LENS_FACING
            ) == CameraCharacteristics.LENS_FACING_FRONT

            val exifOrientation = computeExifOrientation(
                rotation, 
                mirrored
            )

            return CombinedCaptureResult(
                image, 
                result, 
                exifOrientation, 
                imageReader.imageFormat
            )
        }
    }
}

private suspend fun saveResult(
    result: CombinedCaptureResult
): File = suspendCoroutine { cont ->
    when (result.format) {
        // 图片格式如果是 JPEG 或者 DEPTH JPEG
        // 则可以直接使用 inputStream 保存到 File
        ImageFormat.JPEG, 
        ImageFormat.DEPTH_JPEG -> {
            val buffer = result.image.planes[0].buffer
            // 使用 ByteBuffer 构建 ByteArray
            val bytes = ByteArray(buffer.remaining()).apply { 
                buffer.get(this) 
            }
            try {
                val output = createFile(requireContext(), "jpg")
                // 图片数据保存到文件
                FileOutputStream(output).use { 
                    it.write(bytes) 
                }
                cont.resume(output)
            } catch (e: IOException) {
                Log.e(TAG, "fail to write JPEG image to file", e)
                cont.resumeWithException(exc)
            }
        }

        // 图片格式如果是 RAW
        // 则需要使用 DngCreator 工具类将图片保存为 dng
        ImageFormat.RAW_SENSOR -> {
            // characteristics 是当前被打开相机的属性集
            val dngCreator = DngCreator(
                characteristics, 
                result.metadata
            )
            try {
                val output = createFile(requireContext(), "dng")
                FileOutputStream(output).use { 
                    dngCreator.writeImage(it, result.image) 
                }
                cont.resume(output)
            } catch (exc: IOException) {
                Log.e(TAG, "fail to write DNG image to file", exc)
                cont.resumeWithException(exc)
            }
        }

        // 本示例暂不支持其他格式
        else -> {
            val e = RuntimeException(
                "Unknown image format: ${result.image.format}"
            )
            Log.e(TAG, exc.message, e)
            cont.resumeWithException(e)
        }
    }
}