연습 녹음 화면 구현

Prezel/app/build.gradle.kts

@@ -42,15 +42,15 @@ dependencies {
     implementation(projects.featureSplashImpl)
     implementation(projects.featureLoginApi)
     implementation(projects.featureLoginImpl)
-    implementation(projects.featureTermsApi)
-    implementation(projects.featureTermsImpl)
     implementation(projects.featureHomeApi)
     implementation(projects.featureHomeImpl)
     implementation(projects.featureHistoryApi)
     implementation(projects.featureHistoryImpl)
     implementation(projects.featureMyApi)
     implementation(projects.featureMyImpl)
-    implementation(projects.featureSettingApi)
+
+    implementation(projects.featureTermsImpl)
+    implementation(projects.featurePracticeImpl)
     implementation(projects.featureSettingImpl)
     implementation(projects.featureProfileImpl)
 

Prezel/app/src/main/AndroidManifest.xml

@@ -2,6 +2,7 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
 
     <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
 
     <application
         android:name=".PrezelApplication"

Prezel/core/audio/build.gradle.kts

@@ -0,0 +1,14 @@
+plugins {
+    alias(libs.plugins.prezel.android.library)
+    alias(libs.plugins.prezel.hilt)
+}
+
+android {
+    namespace = "com.team.prezel.core.audio"
+}
+
+dependencies {
+    implementation(platform(libs.androidx.compose.bom))
+    implementation(libs.androidx.compose.runtime)
+    implementation(libs.kotlinx.coroutines.core)
+}

Prezel/core/audio/src/main/java/com/team/prezel/core/audio/AudioPlayerSession.kt

@@ -0,0 +1,13 @@
+package com.team.prezel.core.audio
+
+internal interface AudioPlayerSession {
+    fun start(
+        source: AudioSource,
+        startPositionSeconds: Int,
+        onCompleted: () -> Unit,
+    ): Result<Int>
+
+    fun currentPositionSeconds(): Int
+
+    fun release()
+}

Prezel/core/audio/src/main/java/com/team/prezel/core/audio/AudioRecorderSession.kt

@@ -0,0 +1,9 @@
+package com.team.prezel.core.audio
+
+internal interface AudioRecorderSession {
+    fun start(): Result<Unit>
+
+    fun stop(elapsedSeconds: Int): Result<RecordedAudio>
+
+    fun reset()
+}

Prezel/core/audio/src/main/java/com/team/prezel/core/audio/AudioSessionEffect.kt

@@ -0,0 +1,9 @@
+package com.team.prezel.core.audio
+
+sealed interface AudioSessionEffect {
+    data object RecordingStartFailed : AudioSessionEffect
+
+    data object RecordingStopFailed : AudioSessionEffect
+
+    data object PlaybackStartFailed : AudioSessionEffect
+}

Prezel/core/audio/src/main/java/com/team/prezel/core/audio/AudioSessionState.kt

@@ -0,0 +1,33 @@
+package com.team.prezel.core.audio
+
+import androidx.compose.runtime.Immutable
+
+@Immutable
+sealed interface AudioSessionState {
+    data object Idle : AudioSessionState
+
+    data class Recording(
+        val elapsedSeconds: Int,
+    ) : AudioSessionState
+
+    data class ReadyToPlay(
+        val source: AudioSource,
+        val positionSeconds: Int = 0,
+        val durationSeconds: Int,
+    ) : AudioSessionState
+
+    data class Playing(
+        val source: AudioSource,
+        val positionSeconds: Int,
+        val durationSeconds: Int,
+    ) : AudioSessionState
+}
+
+@Immutable
+sealed interface AudioSource {
+    val filePath: String
+
+    data class RecordedFile(
+        override val filePath: String,
+    ) : AudioSource
+}

Prezel/core/audio/src/main/java/com/team/prezel/core/audio/MediaPlayerSession.kt

@@ -0,0 +1,56 @@
+package com.team.prezel.core.audio
+
+import android.media.MediaPlayer
+import javax.inject.Inject
+
+internal class MediaPlayerSession @Inject constructor() : AudioPlayerSession {
+    private var player: MediaPlayer? = null
+
+    override fun start(
+        source: AudioSource,
+        startPositionSeconds: Int,
+        onCompleted: () -> Unit,
+    ): Result<Int> =
+        runCatching {
+            release()
+
+            var pendingPlayer: MediaPlayer? = null
+            val newPlayer = runCatching {
+                MediaPlayer().also { pendingPlayer = it }.apply {
+                    setDataSource(source.filePath)
+                    prepare()
+                    seekToStartPosition(startPositionSeconds)
+                    setOnCompletionListener { onCompleted() }
+                    start()
+                }
+            }.getOrElse { throwable ->
+                pendingPlayer?.release()
+                throw throwable
+            }
+
+            player = newPlayer
+            newPlayer.duration
+        }.onFailure {
+            release()
+        }
+
+    override fun currentPositionSeconds(): Int = player?.currentPosition?.toSeconds() ?: 0
+
+    override fun release() {
+        player?.runCatching { stop() }
+        player?.release()
+        player = null
+    }
+
+    private fun MediaPlayer.seekToStartPosition(startPositionSeconds: Int) {
+        if (startPositionSeconds > 0) {
+            seekTo(startPositionSeconds * MILLIS_PER_SECOND)
+        }
+    }
+
+    private companion object {
+        const val MILLIS_PER_SECOND = 1_000
+    }
+}
+
+internal fun Int.toSeconds(): Int = this / 1_000

Prezel/core/audio/src/main/java/com/team/prezel/core/audio/MediaRecorderSession.kt

@@ -0,0 +1,81 @@
+package com.team.prezel.core.audio
+
+import android.content.Context
+import android.media.MediaRecorder
+import android.os.Build
+import dagger.hilt.android.qualifiers.ApplicationContext
+import java.io.File
+import javax.inject.Inject
+import kotlin.math.max
+
+internal class MediaRecorderSession @Inject constructor(
+    @param:ApplicationContext private val context: Context,
+) : AudioRecorderSession {
+    private var recorder: MediaRecorder? = null
+    private var currentAudioFile: File? = null
+
+    override fun start(): Result<Unit> =
+        runCatching {
+            reset()
+
+            val file = File.createTempFile("recording_", ".m4a", context.cacheDir)
+            var pendingRecorder: MediaRecorder? = null
+            val newRecorder = runCatching {
+                createMediaRecorder(context = context).also { pendingRecorder = it }.apply {
+                    setAudioSource(MediaRecorder.AudioSource.MIC)
+                    setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)
+                    setAudioEncoder(MediaRecorder.AudioEncoder.AAC)
+                    setOutputFile(file.absolutePath)
+                    prepare()
+                    start()
+                }
+            }.getOrElse { throwable ->
+                pendingRecorder?.release()
+                file.delete()
+                throw throwable
+            }
+
+            recorder = newRecorder
+            currentAudioFile = file
+        }.onFailure {
+            reset()
+        }
+
+    override fun stop(elapsedSeconds: Int): Result<RecordedAudio> =
+        runCatching {
+            val file = currentAudioFile!!
+            recorder!!.stop()
+            RecordedAudio(
+                source = AudioSource.RecordedFile(filePath = file.absolutePath),
+                durationSeconds = max(elapsedSeconds, 0),
+            )
+        }.onSuccess {
+            releaseRecorder()
+        }.onFailure {
+            reset()
+        }
+
+    override fun reset() {
+        releaseRecorder()
+        currentAudioFile?.delete()
+        currentAudioFile = null
+    }
+
+    private fun releaseRecorder() {
+        recorder?.release()
+        recorder = null
+    }
+}
+
+internal data class RecordedAudio(
+    val source: AudioSource.RecordedFile,
+    val durationSeconds: Int,
+)
+
+@Suppress("DEPRECATION")
+private fun createMediaRecorder(context: Context): MediaRecorder =
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+        MediaRecorder(context)
+    } else {
+        MediaRecorder()
+    }