안드로이드 스크린 캡처 및 녹화 기능 추가하기 🎥📱

안녕, 친구들! 오늘은 정말 재밌고 유용한 주제로 찾아왔어. 바로 안드로이드 앱에 스크린 캡처와 녹화 기능을 추가하는 방법에 대해 알아볼 거야. 😎 이 기능들은 요즘 앱에서 정말 핫한 기능이라고 할 수 있지. 특히 게임 앱이나 교육용 앱에서 많이 사용되고 있어.

우리가 이런 기능을 만들면, 사용자들은 자신의 화면을 쉽게 캡처하거나 녹화할 수 있게 돼. 예를 들어, 게임에서 멋진 순간을 포착하거나, 튜토리얼 영상을 만들 때 아주 유용하겠지? 🎮📚

그럼 이제부터 차근차근 알아보자고! 준비됐니? 시작해볼까? 🚀

1. 스크린 캡처 기능 구현하기 📸

먼저 스크린 캡처 기능부터 시작해볼게. 이 기능을 구현하려면 안드로이드의 MediaProjection API를 사용해야 해. 이 API는 안드로이드 5.0(롤리팝) 이상에서 사용할 수 있어.

1.1 권한 설정하기

스크린 캡처를 하려면 먼저 필요한 권한을 설정해야 해. AndroidManifest.xml 파일에 다음 권한을 추가해줘:

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

이 권한들은 캡처한 이미지를 저장하고 읽을 수 있게 해줘. 안드로이드 10 이상에서는 WRITE_EXTERNAL_STORAGE 권한이 필요 없을 수도 있어. 하지만 하위 버전 호환성을 위해 추가해두는 게 좋아.

1.2 MediaProjectionManager 초기화하기

이제 MediaProjectionManager를 초기화해야 해. 이건 스크린 캡처를 위한 시스템 서비스야. 다음과 같이 코드를 작성해봐:

private lateinit var mediaProjectionManager: MediaProjectionManager

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    mediaProjectionManager = getSystemService(Context.MEDIA_PROJECTION_SERVICE) as MediaProjectionManager
}

여기서 mediaProjectionManager를 lateinit으로 선언한 이유는 뭘까? 그건 바로 onCreate() 메서드에서 초기화하기 때문이야. 이렇게 하면 메모리를 효율적으로 사용할 수 있지.

1.3 스크린 캡처 권한 요청하기

사용자에게 스크린 캡처 권한을 요청해야 해. 이건 런타임에 이루어져. 다음과 같이 코드를 작성해봐:

private val REQUEST_MEDIA_PROJECTION = 1

private fun startScreenCapture() {
    val intent = mediaProjectionManager.createScreenCaptureIntent()
    startActivityForResult(intent, REQUEST_MEDIA_PROJECTION)
}

이 코드는 스크린 캡처 권한을 요청하는 인텐트를 생성하고, 그 결과를 기다리는 거야. 사용자가 권한을 허용하면, onActivityResult() 메서드에서 결과를 처리할 수 있어.

1.4 권한 결과 처리하기

사용자가 권한을 허용하면, 다음과 같이 결과를 처리할 수 있어:

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    if (requestCode == REQUEST_MEDIA_PROJECTION) {
        if (resultCode == RESULT_OK) {
            // 권한이 허용됐어!
            val mediaProjection = mediaProjectionManager.getMediaProjection(resultCode, data!!)
            // 여기서 실제 스크린 캡처를 수행해
            captureScreen(mediaProjection)
        } else {
            // 권한이 거부됐어 :(
            Toast.makeText(this, "스크린 캡처 권한이 필요해요!", Toast.LENGTH_SHORT).show()
        }
    }
}

여기서 주의할 점! data가 null이 아니라고 확신할 때만 !! 연산자를 사용해. 그렇지 않으면 NullPointerException이 발생할 수 있어.

1.5 실제 스크린 캡처 수행하기

이제 실제로 스크린을 캡처하는 함수를 만들어보자:

private fun captureScreen(mediaProjection: MediaProjection) {
    val metrics = resources.displayMetrics
    val density = metrics.densityDpi
    val width = metrics.widthPixels
    val height = metrics.heightPixels

    val imageReader = ImageReader.newInstance(width, height, PixelFormat.RGBA_8888, 2)
    val virtualDisplay = mediaProjection.createVirtualDisplay(
        "ScreenCapture",
        width, height, density,
        DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR,
        imageReader.surface, null, null
    )

    imageReader.setOnImageAvailableListener({ reader ->
        val image = reader.acquireLatestImage()
        if (image != null) {
            val planes = image.planes
            val buffer = planes[0].buffer
            val pixelStride = planes[0].pixelStride
            val rowStride = planes[0].rowStride
            val rowPadding = rowStride - pixelStride * width

            val bitmap = Bitmap.createBitmap(
                width + rowPadding / pixelStride, height,
                Bitmap.Config.ARGB_8888
            )
            bitmap.copyPixelsFromBuffer(buffer)

            // 비트맵을 저장하거나 사용해
            saveBitmap(bitmap)

            image.close()
        }
        virtualDisplay.release()
        mediaProjection.stop()
    }, null)

    // 캡처 시작
    mediaProjection.registerCallback(object : MediaProjection.Callback() {
        override fun onStop() {
            imageReader.setOnImageAvailableListener(null, null)
        }
    }, null)
}

우와, 코드가 좀 길지? 하나씩 설명해줄게:

먼저 화면의 크기와 밀도 정보를 가져와.
ImageReader를 생성해서 이미지를 받을 준비를 해.
VirtualDisplay를 만들어서 화면을 캡처해.
이미지가 사용 가능해지면, 비트맵으로 변환해.
변환된 비트맵을 저장하거나 사용해.
사용이 끝나면 리소스를 해제해.

이 과정에서 메모리 누수가 발생하지 않도록 주의해야 해. 특히 image.close()와 virtualDisplay.release(), mediaProjection.stop()을 꼭 호출해줘야 해.

1.6 비트맵 저장하기

마지막으로, 캡처한 비트맵을 저장하는 함수를 만들어보자:

private fun saveBitmap(bitmap: Bitmap) {
    val filename = "screenshot_${System.currentTimeMillis()}.png"
    val contentValues = ContentValues().apply {
        put(MediaStore.Images.Media.DISPLAY_NAME, filename)
        put(MediaStore.Images.Media.MIME_TYPE, "image/png")
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            put(MediaStore.Images.Media.RELATIVE_PATH, Environment.DIRECTORY_PICTURES)
        }
    }

    val resolver = contentResolver
    var uri: Uri? = null
    try {
        uri = resolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, contentValues)
        uri?.let { 
            resolver.openOutputStream(it)?.use { outputStream ->
                bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream)
            }
        }
        Toast.makeText(this, "스크린샷이 저장되었어요!", Toast.LENGTH_SHORT).show()
    } catch (e: Exception) {
        Toast.makeText(this, "스크린샷 저장 실패 :(", Toast.LENGTH_SHORT).show()
        uri?.let { resolver.delete(it, null, null) }
    }
}

이 함수는 다음과 같은 일을 해:

파일 이름을 생성해 (현재 시간을 이용해서 유니크한 이름을 만들어)
ContentValues를 사용해서 파일 정보를 설정해
ContentResolver를 사용해서 파일을 저장해
저장이 성공하면 토스트 메시지로 알려줘
실패하면 에러 메시지를 보여주고, 만들어진 URI를 삭제해

안드로이드 10(Q) 이상에서는 RELATIVE_PATH를 사용해서 저장 위치를 지정할 수 있어. 이전 버전에서는 DCIM이나 Pictures 폴더에 직접 저장해야 했지.

여기까지가 스크린 캡처 기능의 기본적인 구현이야. 이제 사용자가 버튼을 누르면 startScreenCapture() 함수를 호출하도록 설정하면 돼. 예를 들어:

captureButton.setOnClickListener {
    startScreenCapture()
}

이렇게 하면 사용자가 버튼을 누를 때마다 스크린 캡처가 시작되고, 결과물이 저장될 거야.

🔍 알아두면 좋은 팁!

스크린 캡처 기능을 구현할 때는 사용자 경험을 고려해야 해. 예를 들어:

캡처 버튼을 눌렀을 때 시각적/청각적 피드백을 주는 것이 좋아.
캡처된 이미지를 바로 볼 수 있는 옵션을 제공하면 사용자 편의성이 높아질 거야.
연속 캡처 기능이나 타이머 기능을 추가하면 더 다양한 상황에서 사용할 수 있어.

자, 여기까지가 스크린 캡처 기능 구현의 기본이야. 이제 녹화 기능으로 넘어가볼까? 🎬

2. 스크린 녹화 기능 구현하기 🎥

이제 스크린 녹화 기능을 구현해볼 거야. 이 기능도 MediaProjection API를 사용하지만, 캡처와는 조금 다른 방식으로 동작해. 준비됐니? 시작해보자!

2.1 추가 권한 설정하기

스크린 녹화를 위해서는 추가적인 권한이 필요해. AndroidManifest.xml 파일에 다음 권한을 추가해줘:

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

RECORD_AUDIO 권한은 스크린 녹화 시 내부 오디오를 녹음하기 위해 필요해. 만약 오디오 녹음이 필요 없다면 이 권한은 생략해도 돼.

2.2 MediaRecorder 초기화하기

스크린 녹화를 위해서는 MediaRecorder를 사용할 거야. 다음과 같이 초기화해줘:

private lateinit var mediaRecorder: MediaRecorder

private fun initMediaRecorder() {
    mediaRecorder = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
        MediaRecorder(this)
    } else {
        @Suppress("DEPRECATION")
        MediaRecorder()
    }

    val filename = "screen_record_${System.currentTimeMillis()}.mp4"
    val contentValues = ContentValues().apply {
        put(MediaStore.Video.Media.DISPLAY_NAME, filename)
        put(MediaStore.Video.Media.MIME_TYPE, "video/mp4")
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            put(MediaStore.Video.Media.RELATIVE_PATH, Environment.DIRECTORY_MOVIES)
        }
    }

    val resolver = contentResolver
    val uri = resolver.insert(MediaStore.Video.Media.EXTERNAL_CONTENT_URI, contentValues)

    mediaRecorder.apply {
        setAudioSource(MediaRecorder.AudioSource.MIC)
        setVideoSource(MediaRecorder.VideoSource.SURFACE)
        setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)
        setVideoEncoder(MediaRecorder.VideoEncoder.H264)
        setAudioEncoder(MediaRecorder.AudioEncoder.AAC)
        setVideoEncodingBitRate(512 * 1000)
        setVideoFrameRate(30)
        setOutputFile(resolver.openFileDescriptor(uri!!, "w")?.fileDescriptor)
    }
}

이 코드는 다음과 같은 일을 해:

MediaRecorder 객체를 생성해 (안드로이드 버전에 따라 다르게 생성해)
녹화할 파일의 이름과 저장 위치를 설정해
MediaRecorder의 각종 설정을 해 (오디오 소스, 비디오 소스, 출력 포맷, 인코더 등)

여기서 setVideoSource를 SURFACE로 설정한 이유는 뭘까? 그건 바로 화면을 직접 캡처하기 위해서야. 카메라가 아닌 화면 자체를 녹화하려면 이렇게 설정해야 해.

2.3 VirtualDisplay 생성하기

이제 VirtualDisplay를 생성해서 화면을 캡처할 준비를 해야 해:

private var virtualDisplay: VirtualDisplay? = null

private fun createVirtualDisplay(mediaProjection: MediaProjection) {
    val metrics = resources.displayMetrics
    val screenDensity = metrics.densityDpi
    val screenWidth = metrics.widthPixels
    val screenHeight = metrics.heightPixels

    virtualDisplay = mediaProjection.createVirtualDisplay(
        "ScreenRecorder",
        screenWidth, screenHeight, screenDensity,
        DisplayManager.VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR,
        mediaRecorder.surface, null, null
    )
}

이 함수는 MediaProjection을 사용해서 VirtualDisplay를 생성해. 이 VirtualDisplay는 화면의 내용을 MediaRecorder로 전달하는 역할을 해.

2.4 녹화 시작하기

이제 실제로 녹화를 시작하는 함수를 만들어보자:

private var isRecording = false

private fun startRecording() {
    if (isRecording) return

    try {
        initMediaRecorder()
        mediaRecorder.prepare()

        val intent = mediaProjectionManager.createScreenCaptureIntent()
        startActivityForResult(intent, REQUEST_MEDIA_PROJECTION)
    } catch (e: Exception) {
        e.printStackTrace()
        Toast.makeText(this, "녹화 시작 실패 :(", Toast.LENGTH_SHORT).show()
    }
}

이 함수는 다음과 같은 일을 해:

이미 녹화 중이면 아무것도 하지 않아
MediaRecorder를 초기화하고 준비해
스크린 캡처 권한을 요청해

여기서 주의할 점! mediaRecorder.prepare()를 호출하기 전에 모든 설정이 완료되어야 해. 그렇지 않으면 IllegalStateException이 발생할 수 있어.

2.5 권한 결과 처리하기

권한 요청의 결과를 처리하는 함수를 업데이트해야 해:

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    super.onActivityResult(requestCode, resultCode, data)
    if (requestCode == REQUEST_MEDIA_PROJECTION) {
        if (resultCode == RESULT_OK) {
            val mediaProjection = mediaProjectionManager.getMediaProjection(resultCode, data!!)
            createVirtualDisplay(mediaProjection)
            mediaRecorder.start()
            isRecording = true
            Toast.makeText(this, "녹화가 시작되었어요!", Toast.LENGTH_SHORT).show()
        } else {
            Toast.makeText(this, "스크린 녹화 권한이 필요해요!", Toast.LENGTH_SHORT).show()
        }
    }
}

이 함수는 권한이 허용되면 VirtualDisplay를 생성하고 녹화를 시작해. 권한이 거부되면 사용자에게 알려줘.

2.6 녹화 중지하기

녹화를 중지하는 함수도 필요해:

private fun stopRecording() {
    if (!isRecording) return

    try {
        mediaRecorder.stop()
        mediaRecorder.reset()
        virtualDisplay?.release()
        isRecording = false
        Toast.makeText(this, "녹화가 저장되었어요!", Toast.LENGTH_SHORT).show()
    } catch (e: Exception) {
        e.printStackTrace()
        Toast.makeText(this, "녹화 중지 실패 :(", Toast.LENGTH_SHORT).show()
    }
}

이 함수는 다음과 같은 일을 해:

녹화 중이 아니면 아무것도 하지 않아
MediaRecorder를 중지하고 리셋해
VirtualDisplay를 해제해
녹화 상태를 false로 변경해

주의할 점! mediaRecorder.stop()을 호출할 때 예외가 발생할 수 있어. 특히 녹화 시간이 너무 짧으면 발생할 수 있지. 이를 방지하기 위해 try-catch 블록을 사용했어.

2.7 UI 구성하기

이제 사용자가 녹화를 시작하고 중지할 수 있는 UI를 만들어보자:

<Button
    android:id="@+id/btnStartRecording"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="녹화 시작" />

<Button
    android:id="@+id/btnStopRecording"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="녹화 중지" />

그리고 이 버튼들에 클릭 리스너를 설정해:

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)

    findViewById<Button>(R.id.btnStartRecording).setOnClickListener {
        startRecording()
    }

    findViewById<Button>(R.id.btnStopRecording).setOnClickListener {
        stopRecording()
    }
}

이렇게 하면 사용자가 버튼을 눌러 녹화를 시작하고 중지할 수 있어.

🔍 알아두면 좋은 팁!

스크린 녹화 기능을 구현할 때 고려해야 할 몇 가지 사항이 있어:

녹화 중임을 사용자에게 알려주는 것이 좋아. 상태바에 알림을 표시하거나, 화면에 작은 아이콘을 띄우는 방법 등이 있지.
녹화 시간을 제한하는 것도 좋아. 너무 긴 녹화는 저장 공간을 많이 차지할 수 있거든.
녹화 품질 설정을 사용자가 선택할 수 있게 하면 더 좋아. 고화질, 중화질, 저화질 등의 옵션을 제공할 수 있어.
배터리 소모가 큰 기능이니, 배터리 상태를 체크하고 사용자에게 알려주는 것도 좋아.

자, 여기까지가 스크린 녹화 기능의 기본적인 구현이야. 이제 우리 앱은 스크린 캡처와 녹화 기능을 모두 가지게 됐어! 🎉

이런 기능들은 다양한 앱에서 유용하게 사용될 수 있어. 예를 들어, 재능넷(https://www.jaenung.net)같은 재능 공유 플랫폼에서 사용자들이 자신의 재능을 보여주는 튜토리얼 영상을 만들 때 아주 유용할 거야. 화면을 녹화하면서 자신의 기술을 설명하는 영상을 쉽게 만들 수 있으니까.

그럼 이제 우리 앱의 기능을 좀 더 발전시켜볼까? 🚀

3. 고급 기능 추가하기 🔧

기본적인 스크린 캡처와 녹화 기능을 구현했으니, 이제 좀 더 고급 기능들을 추가해볼 거야. 이런 기능들은 사용자 경험을 크게 향상시킬 수 있어. 어떤 기능들이 있는지 살펴볼까?

3.1 녹화 중 상태 표시하기

사용자가 녹화 중임을 알 수 있도록 상태바에 알림을 표시해보자:

private var notificationManager: NotificationManager? = null
private val NOTIFICATION_ID = 1
private val CHANNEL_ID = "ScreenRecordChannel"

private fun showRecordingNotification() {
    notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
        val channel = NotificationChannel(CHANNEL_ID, "Screen Record", NotificationManager.IMPORTANCE_DEFAULT)
        notificationManager?.createNotificationChannel(channel)
    }

    val notification = NotificationCompat.Builder(this, CHANNEL_ID)
        .setContentTitle("화면 녹화 중")
        .setContentText("탭하여 앱으로 돌아가기")
        .setSmallIcon(R.drawable.ic_record)
        .setOngoing(true)
        .build()

    notificationManager?.notify(NOTIFICATION_ID, notification)
}

private fun hideRecordingNotification() {
    notificationManager?.cancel(NOTIFICATION_ID)
}

이 코드를 startRecording()과 stopRecording() 함수에 각각 추가해주면 돼:

private fun startRecording() {
    // ... 기존 코드 ...
    showRecordingNotification()
}

private fun stopRecording() {
    // ... 기존 코드 ...
    hideRecordingNotification()
}

이렇게 하면 사용자는 녹화 중임을 항상 인지할 수 있어. 특히 다른 앱을 사용하다가도 녹화 중임을 알 수 있지.

3.2 녹화 시간 제한 및 표시

녹화 시간을 제한하고 현재 녹화 시간을 표시하는 기능을 추가해보자:

private var recordingTimer: CountDownTimer? = null
private val MAX_RECORDING_TIME = 5 * 60 * 1000L // 5분

private fun startRecordingTimer() {
    recordingTimer = object : CountDownTimer(MAX_RECORDING_TIME, 1000) {
        override fun onTick(millisUntilFinished: Long) {
            val seconds = (MAX_RECORDING_TIME - millisUntilFinished) / 1000
            updateRecordingTime(seconds)
        }

        override fun onFinish() {
            stopRecording()
        }
    }.start()
}

private fun updateRecordingTime(seconds: Long) {
    val minutes = seconds / 60
    val remainingSeconds = seconds % 60
    runOnUiThread {
        findViewById<TextView>(R.id.tvRecordingTime).text = 
            String.format("%02d:%02d", minutes, remainingSeconds)
    }
}

private fun stopRecordingTimer() {
    recordingTimer?.cancel()
    recordingTimer = null
}

이 코드를 startRecording()과 stopRecording() 함수에 추가해:

private fun startRecording() {
    // ... 기존 코드 ...
    startRecordingTimer()
}

private fun stopRecording() {
    // ... 기존 코드 ...
    stopRecordingTimer()
}

이렇게 하면 녹화 시간이 5분으로 제한되고, 사용자는 현재 녹화 시간을 볼 수 있어. 필요하다면 MAX_RECORDING_TIME 값을 조절해서 녹화 시간을 변경할 수 있어.

3.3 녹화 품질 설정

사용자가 녹화 품질을 선택할 수 있게 해보자:

enum class RecordingQuality {
    LOW, MEDIUM, HIGH
}

private fun setRecordingQuality(quality: RecordingQuality) {
    when (quality) {
        RecordingQuality.LOW -> {
            mediaRecorder.setVideoEncodingBitRate(1 * 1000 * 1000)
            mediaRecorder.setVideoFrameRate(24)
        }
        RecordingQuality.MEDIUM -> {
            mediaRecorder.setVideoEncodingBitRate(5 * 1000 * 1000)
            mediaRecorder.setVideoFrameRate(30)
        }
        RecordingQuality.HIGH -> {
            mediaRecorder.setVideoEncodingBitRate(10 * 1000 * 1000)
            mediaRecorder.setVideoFrameRate(60)
        }
    }
}

이 함수를 initMediaRecorder() 함수 내에서 호출해:

private fun initMediaRecorder() {
    // ... 기존 코드 ...
    setRecordingQuality(RecordingQuality.MEDIUM) // 기본값으로 중간 품질 설정
}

이제 사용자가 녹화 전에 품질을 선택할 수 있게 UI를 추가하면 돼. 예를 들어, 라디오 버튼 그룹을 사용해서 품질을 선택하게 할 수 있어.

3.4 배터리 상태 체크

녹화 시작 전 배터리 상태를 체크하고 사용자에게 알려주는 기능을 추가해보자:

private fun checkBatteryStatus(): Boolean {
    val batteryStatus: Intent? = IntentFilter(Intent.ACTION_BATTERY_CHANGED).let { ifilter ->
        applicationContext.registerReceiver(null, ifilter)
    }
    
    val batteryPct: Float? = batteryStatus?.let { intent ->
        val level: Int = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1)
        val scale: Int = intent.getIntExtra(BatteryManager.EXTRA_SCALE, -1)
        level * 100 / scale.toFloat()
    }

    return if (batteryPct != null && batteryPct <= 15f) {
        Toast.makeText(this, "배터리가 15% 이하입니다. 녹화를 시작하기 전에 충전하는 것이 좋아요.", Toast.LENGTH_LONG).show()
        false
    } else {
        true
    }
}

이 함수를 startRecording() 함수 시작 부분에 추가해:

private fun startRecording() {
    if (!checkBatteryStatus()) return
    // ... 기존 코드 ...
}

이렇게 하면 배터리가 15% 이하일 때 사용자에게 경고를 주고 녹화를 시작하지 않아. 배터리 소모가 큰 기능이니까 이런 체크는 꼭 필요해.

3.5 녹화 파일 관리

마지막으로, 녹화된 파일을 관리하는 기능을 추가해보자:

private fun getRecordedVideos(): List<File> {
    val directory = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_MOVIES)
    return directory.listFiles { file ->
        file.isFile && file.name.startsWith("screen_record_")
    }?.toList() ?: emptyList()
}

private fun deleteRecordedVideo(file: File) {
    if (file.exists()) {
        if (file.delete()) {
            Toast.makeText(this, "파일이 삭제되었습니다.", Toast.LENGTH_SHORT).show()
        } else {
            Toast.makeText(this, "파일 삭제에 실패했습니다.", Toast.LENGTH_SHORT).show()
        }
    }
}

private fun shareRecordedVideo(file: File) {
    val uri = FileProvider.getUriForFile(this, "${packageName}.fileprovider", file)
    val intent = Intent(Intent.ACTION_SEND).apply {
        type = "video/mp4"
        putExtra(Intent.EXTRA_STREAM, uri)
        addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
    }
    startActivity(Intent.createChooser(intent, "비디오 공유"))
}

이 함수들을 사용해서 녹화된 비디오 목록을 표시하고, 삭제하거나 공유할 수 있는 UI를 만들 수 있어.

🔍 알아두면 좋은 팁!

이런 고급 기능들을 추가할 때 주의할 점이 있어:

사용자 경험을 항상 최우선으로 생각해야 해. 너무 복잡한 기능은 오히려 사용성을 떨어뜨릴 수 있어.
성능 최적화를 잊지 마. 특히 녹화 중에는 다른 작업들이 원활하게 수행되어야 해.
보안과 프라이버시를 고려해야 해. 녹화된 파일은 안전하게 저장되고 관리되어야 해.
다양한 기기와 안드로이드 버전에서 테스트해봐야 해. 호환성 문제가 없는지 꼭 확인해야 해.

자, 이제 우리 앱은 정말 강력한 스크린 캡처와 녹화 기능을 가지게 됐어! 🎉 이런 기능들은 사용자들에게 큰 가치를 제공할 거야. 예를 들어, 재능넷(https://www.jaenung.net) 같은 플랫폼에서 사용자들이 자신의 재능을 더 효과적으로 보여줄 수 있게 될 거야. 화면을 녹화하면서 자신의 기술을 설명하는 고품질 튜토리얼 비디오를 쉽게 만들 수 있으니까.

이런 기능들을 잘 활용하면, 우리 앱은 사용자들에게 정말 유용한 도구가 될 수 있어. 화이팅! 👍