CameraEnumuration.kt

const val TAG = "Util"

class Util {
    private fun lensOrientationString(value: Int) = when (value) {
        CameraCharacteristics.LENS_FACING_BACK -> CameraFacing.BACK
        CameraCharacteristics.LENS_FACING_FRONT -> CameraFacing.FRONT
        CameraCharacteristics.LENS_FACING_EXTERNAL -> CameraFacing.EXTERNAL
        else -> CameraFacing.UNKNOWN
    }

    enum class CameraFacing {
        FRONT,
        BACK,
        EXTERNAL,
        UNKNOWN
    }

    data class FormatItem(
        val title: String,
        val cameraId: String,
        val format: Int,
        val isCamera2: Boolean = true,
        val facing: CameraFacing = CameraFacing.BACK
    )

    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    private fun enumerateCameras2(cameraManager: CameraManager): List<FormatItem> {
        val availableCameras: MutableList<FormatItem> = mutableListOf()

        val cameraIds = cameraManager.cameraIdList.filter {
            val characteristics = cameraManager.getCameraCharacteristics(it)
            val capabilities = characteristics.get(
                CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES
            )
            capabilities?.contains(
                CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE
            ) ?: false
        }

        Log.d(TAG, "cameraCaptureComp :enumerateCameras: ${cameraIds.size} ")
        cameraIds.forEach { id ->
            val characteristics = cameraManager.getCameraCharacteristics(id)

            val lensFacing = characteristics.get(CameraCharacteristics.LENS_FACING)

            if (lensFacing != null) {
                val orientation = lensOrientationString(lensFacing)

                val capabilities =
                    characteristics.get(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES)
                val outputFormats =
                    characteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)?.outputFormats

                availableCameras.add(
                    FormatItem(
                        "$orientation JPEG ($id)",
                        id,
                        ImageFormat.JPEG,
                        true,
                        orientation
                    )
                )

                if (capabilities?.contains(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_RAW) == true &&
                    outputFormats?.contains(ImageFormat.RAW_SENSOR) == true
                ) {
                    availableCameras.add(
                        FormatItem(
                            "$orientation RAW ($id)",
                            id,
                            ImageFormat.RAW_SENSOR,
                            true,
                            orientation
                        )
                    )
                }

                if (capabilities?.contains(
                        CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_DEPTH_OUTPUT
                    ) == true &&
                    outputFormats?.contains(ImageFormat.DEPTH_JPEG) == true
                ) {
                    availableCameras.add(
                        FormatItem(
                            "$orientation DEPTH ($id)",
                            id,
                            ImageFormat.DEPTH_JPEG,
                            true,
                            orientation
                        )
                    )
                }
            }
        }

        return availableCameras
    }

    private fun enumerateCamera1(): List<FormatItem> {
        val availableCameras: MutableList<FormatItem> = mutableListOf()

        for (i in 0 until Camera.getNumberOfCameras()) {
            val cameraInfo = Camera.CameraInfo()
            Camera.getCameraInfo(i, cameraInfo)
            val title = if (cameraInfo.facing == 1) "Front $i" else "Back $i"
            val facing = if (cameraInfo.facing == 1) CameraFacing.FRONT else CameraFacing.BACK

            availableCameras.add(
                FormatItem(title, i.toString(), ImageFormat.JPEG, false, facing)
            )
        }

        return availableCameras
    }


    fun getListOfCameras(context: Context): List<FormatItem> {
        return if (isCamera2Supported(context)) {
            Log.i(TAG, "getListOfCameras: Using camera 2")
            enumerateCameras2(context.getSystemService(Context.CAMERA_SERVICE) as CameraManager)
        } else {
            Log.i(TAG, "getListOfCameras: Using camera 1")
            enumerateCamera1()
        }
    }

    private fun isCamera2Supported(context: Context): Boolean {
        try {
            val cameraManager = context.getSystemService(Context.CAMERA_SERVICE) as CameraManager
            val cameraIds = cameraManager.cameraIdList
            val var4 = cameraIds.size
            for (var5 in 0 until var4) {
                val id = cameraIds[var5]
                val characteristics = cameraManager.getCameraCharacteristics(id)
                if (characteristics.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL) == 2) {
                    return false
                }
            }
            return true
        } catch (var8: Exception) {
            Log.e("Camera2Enumerator", "Camera access exception: $var8")
            return false
        } catch (e: AssertionError) {
            return false
        }
    }
}