안드로이드 Camera2 API를 활용한 문서 촬영 가이드라인 화면 개발 및 이미지 회전(Exif) 트러블슈팅

CameraManager
  -> cameraId 선택
  -> openCamera()
  -> CameraDevice.StateCallback
  -> CameraDevice
  -> CaptureRequest 생성
  -> CameraCaptureSession 생성
  -> Preview Surface와 ImageReader Surface로 출력

java.lang.IllegalArgumentException: surfaceTexture must not be null
    at android.view.Surface.<init>(Surface.java:219)

val surfaceTexture = textureView.surfaceTexture ?: run {
    Log.e(TAG, "SurfaceTexture가 아직 준비되지 않았습니다")
    return
}

val previewSurface = Surface(surfaceTexture)

private lateinit var cameraManager: CameraManager
private var cameraDevice: CameraDevice? = null

cameraManager = getSystemService(CAMERA_SERVICE) as CameraManager

for (id in cameraManager.cameraIdList) {
    // 후면 카메라 등 사용할 cameraId를 선택한다.
}

cameraManager.openCamera(cameraId, stateCallback, backgroundHandler)

private val stateCallback = object : CameraDevice.StateCallback() {
    override fun onOpened(camera: CameraDevice) {
        cameraDevice = camera
        createPreviewSession()
    }

    override fun onDisconnected(camera: CameraDevice) {
        camera.close()
        cameraDevice = null
    }

    override fun onError(camera: CameraDevice, error: Int) {
        camera.close()
        cameraDevice = null

        val errorMessage = when (error) {
            ERROR_CAMERA_IN_USE -> "카메라가 다른 앱에서 사용 중입니다"
            ERROR_MAX_CAMERAS_IN_USE -> "최대 카메라 사용 개수를 초과했습니다"
            ERROR_CAMERA_DISABLED -> "카메라가 비활성화되었습니다"
            ERROR_CAMERA_DEVICE -> "카메라 장치 오류가 발생했습니다"
            ERROR_CAMERA_SERVICE -> "카메라 서비스 오류가 발생했습니다"
            else -> "알 수 없는 카메라 오류가 발생했습니다"
        }

        runOnUiThread {
            Toast.makeText(this@DocumentCameraActivity, errorMessage, Toast.LENGTH_LONG).show()
            finish()
        }
    }
}

val surfaceTexture = textureView.surfaceTexture ?: return
val previewSurface = Surface(surfaceTexture)

previewRequestBuilder =
    cameraDevice?.createCaptureRequest(CameraDevice.TEMPLATE_PREVIEW)

previewRequestBuilder?.addTarget(previewSurface)

cameraDevice?.createCaptureSession(
    surfaces,
    object : CameraCaptureSession.StateCallback() {
        override fun onConfigured(session: CameraCaptureSession) {
            captureSession = session

            val previewRequest = previewRequestBuilder?.build() ?: return
            session.setRepeatingRequest(previewRequest, null, backgroundHandler)
        }

        override fun onConfigureFailed(session: CameraCaptureSession) {
            Log.e(TAG, "CameraCaptureSession 구성 실패")
        }
    },
    backgroundHandler
)

private fun captureImage() {
    val captureRequestBuilder =
        cameraDevice?.createCaptureRequest(CameraDevice.TEMPLATE_STILL_CAPTURE)

    captureRequestBuilder?.addTarget(imageReader?.surface!!)
    captureRequestBuilder?.set(
        CaptureRequest.CONTROL_AF_MODE,
        CaptureRequest.CONTROL_AF_MODE_CONTINUOUS_PICTURE
    )
    captureRequestBuilder?.set(CaptureRequest.JPEG_QUALITY, 95.toByte())
    captureRequestBuilder?.set(CaptureRequest.JPEG_ORIENTATION, getJpegOrientation())

    captureSession?.capture(
        captureRequestBuilder?.build()!!,
        null,
        backgroundHandler
    )
}

private val imageAvailableListener = ImageReader.OnImageAvailableListener { reader ->
    val image = reader.acquireLatestImage() ?: return@OnImageAvailableListener

    backgroundHandler?.post {
        saveImage(image)
    }
}

runOnUiThread {
    val resultIntent = Intent()
    resultIntent.data = imageUri
    setResult(Activity.RESULT_OK, resultIntent)
    finish()
}

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

<uses-feature
    android:name="android.hardware.camera"
    android:required="true" />

<uses-feature
    android:name="android.hardware.camera.autofocus"
    android:required="false" />

private fun checkCameraPermission(): Boolean {
    return ContextCompat.checkSelfPermission(
        this,
        Manifest.permission.CAMERA
    ) == PackageManager.PERMISSION_GRANTED
}

private fun requestCameraPermission() {
    ActivityCompat.requestPermissions(
        this,
        arrayOf(Manifest.permission.CAMERA),
        CAMERA_PERMISSION_REQUEST
    )
}

override fun onRequestPermissionsResult(
    requestCode: Int,
    permissions: Array<String>,
    grantResults: IntArray
) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults)

    if (requestCode == CAMERA_PERMISSION_REQUEST) {
        if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            openCamera()
        } else {
            Toast.makeText(this, "카메라 권한이 필요합니다.", Toast.LENGTH_SHORT).show()
            finish()
        }
    }
}

private fun configureTransform(viewWidth: Int, viewHeight: Int) {
    val rotation = windowManager.defaultDisplay.rotation
    val matrix = Matrix()
    val viewRect = RectF(0f, 0f, viewWidth.toFloat(), viewHeight.toFloat())
    val centerX = viewRect.centerX()
    val centerY = viewRect.centerY()

    if (Surface.ROTATION_90 == rotation || Surface.ROTATION_270 == rotation) {
        // 회전과 스케일 보정
    } else if (Surface.ROTATION_180 == rotation) {
        matrix.postRotate(180f, centerX, centerY)
    }

    textureView.setTransform(matrix)
}

captureRequestBuilder?.set(
    CaptureRequest.JPEG_ORIENTATION,
    getJpegOrientation(cameraCharacteristics, displayRotation)
)

(sensorOrientation - deviceOrientationDegrees + 360) % 360

(sensorOrientation + deviceOrientationDegrees) % 360

private fun getJpegOrientation(
    characteristics: CameraCharacteristics,
    deviceRotation: Int
): Int {
    val sensorOrientation =
        characteristics.get(CameraCharacteristics.SENSOR_ORIENTATION) ?: 0

    val deviceOrientationDegrees = when (deviceRotation) {
        Surface.ROTATION_90 -> 90
        Surface.ROTATION_180 -> 180
        Surface.ROTATION_270 -> 270
        else -> 0
    }

    val lensFacing = characteristics.get(CameraCharacteristics.LENS_FACING)

    return if (lensFacing == CameraCharacteristics.LENS_FACING_FRONT) {
        (sensorOrientation + deviceOrientationDegrees) % 360
    } else {
        (sensorOrientation - deviceOrientationDegrees + 360) % 360
    }
}

(90 - 270 + 360) % 360 = 180

fusedLocationProviderClient?.lastLocation
    ?.addOnSuccessListener { location: Location? ->
        callback(location)
    }
    ?.addOnFailureListener {
        callback(null)
    }

location?.let { loc ->
    captureRequestBuilder?.set(CaptureRequest.JPEG_GPS_LOCATION, loc)
}