[refactor] 주석 추가, 수정

Author: miller198

audio_visualizer/src/main/java/com/miller198/audio_visualizer/configs/Configs.kt

@@ -13,24 +13,22 @@ import com.miller198.audio_visualizer.defaultPreProcessFftData
  */
 sealed interface VisualizerConfig {
 
-    // Whether to use waveform (time domain) capture
+    /** Whether to use waveform (time domain) capture */
     val useWaveCapture: Boolean
 
-    // Whether to use FFT (frequency domain) capture
+    /** Whether to use FFT (frequency domain) capture */
     val useFftCapture: Boolean
 
-    // Buffer size for audio capture (e.g., 512, 1024)
+    /** Buffer size for audio capture (e.g., 512, 1024) */
     val captureSize: Int
 
-    // Optional FFT data processing function
+    /** Optional FFT data processing function */
     val processFftData: ((Visualizer, ByteArray, Int) -> List<Float>)?
 
-    // Optional waveform data processing function
+    /** Optional waveform data processing function */
     val processWaveData: ((Visualizer, ByteArray, Int) -> List<Float>)?
 
-    /**
-     * Fully custom configuration defined by the user.
-     */
+    /** Fully custom configuration defined by the user. */
     data class Custom(
         override val useWaveCapture: Boolean,
         override val useFftCapture: Boolean,
@@ -39,9 +37,7 @@ sealed interface VisualizerConfig {
         override val processWaveData: ((Visualizer, ByteArray, Int) -> List<Float>)?
     ) : VisualizerConfig
 
-    /**
-     * FFT-based visualizer configuration.
-     */
+    /** FFT-based visualizer configuration. */
     data class FftCaptureConfig(
         val minFrequency: Int, // Minimum frequency to analyze (Hz)
         val maxFrequency: Int, // Maximum frequency to analyze (Hz)
@@ -61,14 +57,12 @@ sealed interface VisualizerConfig {
             }
         }
 
-        /**
-         * Default FFT configuration.
-         */
+        /** Default FFT configuration. */
         companion object {
             const val DEFAULT_MIN_FREQ = 40
             const val DEFAULT_MAX_FREQ = 4000
             const val DEFAULT_CAPTURE_SIZE = 1024
-            
+
             val Default = FftCaptureConfig(
                 minFrequency = DEFAULT_MIN_FREQ,
                 maxFrequency = DEFAULT_MAX_FREQ,
@@ -92,9 +86,7 @@ sealed interface VisualizerConfig {
         override val useFftCapture: Boolean = false
         override val processFftData: ((Visualizer, ByteArray, Int) -> List<Float>)? = null
 
-        /**
-         * Default waveform configuration.
-         */
+        /** Default waveform configuration. */
         data object Default : WaveCaptureConfig(
             captureSize = 1024,
             processWaveData = { _, byteArray, _ ->
@@ -113,28 +105,22 @@ sealed interface GradientConfig {
     val duration: Int             // Animation duration in milliseconds
     val color: Color              // Base color of the gradient
 
-    /**
-     * Default gradient config (enabled).
-     */
+    /** Default gradient config (enabled). */
     data object Default : GradientConfig {
         override val useGradient: Boolean = true
         override val duration: Int = 2500
         override val color: Color = White
     }
 
-    /**
-     * Enabled gradient config with custom options.
-     */
+    /** Enabled gradient config with custom options. */
     data class Enabled(
         override val duration: Int,
         override val color: Color,
     ) : GradientConfig {
         override val useGradient: Boolean = true
     }
 
-    /**
-     * Disabled gradient config (no animation, transparent color).
-     */
+    /** Disabled gradient config (no animation, transparent color) */
     data object Disabled : GradientConfig {
         override val useGradient: Boolean = false
         override val duration: Int = 0

audio_visualizer/src/main/java/com/miller198/audio_visualizer/soundeffect/DrawSoundBar.kt

@@ -33,19 +33,19 @@ internal fun DrawSoundBar(
     color: Color,
     modifier: Modifier = Modifier,
 ) {
-    // The radius from the center to the start of the bars
+    /** The radius from the center to the start of the bars */
     var adjustedRadius by remember { mutableFloatStateOf(0f) }
 
-    // The maximum possible bar height based on canvas size
+    /** The maximum possible bar height based on canvas size */
     var maxEffectHeight by remember { mutableFloatStateOf(0f) }
 
-    // Animated gradient radius for dynamic glow effects
+    /** Animated gradient radius for dynamic glow effects */
     val animatedGradientRadius = animatedGradientRadius(LinearEasing)
 
-    // Angle between each bar in the 360° circle
+    /** Angle between each bar in the 360° circle */
     val angleStep = 360f / audioData.size
 
-    // Main canvas for drawing the sound bars
+    /** Main canvas for drawing the sound bars */
     Canvas(
         modifier = modifier
             .fillMaxSize()

audio_visualizer/src/main/java/com/miller198/audio_visualizer/soundeffect/DrawSoundWaveFill.kt

@@ -37,25 +37,25 @@ internal fun DrawSoundWaveFill(
     color: Color,
     modifier: Modifier = Modifier,
 ) {
-    // The radius from the center to the start of the bars
+    /** The radius from the center to the start of the bars */
     var adjustedRadius by remember { mutableFloatStateOf(0f) }
 
-    // The maximum possible bar height based on canvas size
+    /**  The maximum possible bar height based on canvas size */
     var maxEffectHeight by remember { mutableFloatStateOf(0f) }
 
-    // Path used to define the circular center hole (to clip out)
+    /** Path used to define the circular center hole (to clip out) */
     var holePath by remember { mutableStateOf(Path()) }
 
-    // Angle between each bar in the 360° circle
+    /** Angle between each bar in the 360° circle */
     val angleStep = 360f / audioData.size
 
-    // The path that represents the full waveform
+    /** The path that represents the full waveform */
     val path = Path()
 
-    // Animated gradient radius for visual effect
+    /** Animated gradient radius for visual effect */
     val animatedGradientRadius = animatedGradientRadius(LinearOutSlowInEasing)
 
-    // Main canvas for drawing the sound wave
+    /** Main canvas for drawing the sound wave */
     Canvas(
         modifier = modifier
             .fillMaxSize()

audio_visualizer/src/main/java/com/miller198/audio_visualizer/soundeffect/DrawSoundWaveStroke.kt

@@ -29,19 +29,19 @@ internal fun DrawSoundWaveStroke(
     color: Color,
     modifier: Modifier = Modifier,
 ) {
-    // The radius from the center to the start of the bars
+    /** The radius from the center to the start of the bars */
     var adjustedRadius by remember { mutableFloatStateOf(0f) }
 
-    // The maximum possible bar height based on canvas size
+    /** The maximum possible bar height based on canvas size */
     var maxEffectHeight by remember { mutableFloatStateOf(0f) }
 
-    // Angle between each bar in the 360° circle
+    /** Angle between each bar in the 360° circle */
     val angleStep = 360f / audioData.size
 
-    // The path that represents the full waveform
+    /** The path that represents the full waveform */
     val path = Path()
 
-    // Main canvas for drawing the sound bars
+    /** Main canvas for drawing the sound bars */
     Canvas(
         modifier = modifier
             .fillMaxSize()

audio_visualizer/src/main/java/com/miller198/audio_visualizer/soundeffect/SoundEffects.kt

@@ -17,28 +17,20 @@ enum class SoundEffects(
         modifier: Modifier,
     ) -> Unit
 ) {
-    /**
-     * No effect. This does not render any audio visualization.
-     */
+    /** No effect. This does not render any audio visualization. */
     NONE({ _, _, _ -> }),
 
-    /**
-     * A vertical bar graph representation of the audio data.
-     */
+    /** A vertical bar graph representation of the audio data. */
     BAR({ audioData, color, modifier ->
         DrawSoundBar(audioData, color, modifier)
     }),
 
-    /**
-     * A waveform rendered using stroke (outline only).
-     */
+    /** A waveform rendered using stroke (outline only). */
     WAVE_STROKE({ audioData, color, modifier ->
         DrawSoundWaveStroke(audioData, color, modifier)
     }),
 
-    /**
-     * A waveform rendered as a filled shape.
-     */
+    /** A waveform rendered as a filled shape. */
     WAVE_FILL({ audioData, color, modifier ->
         DrawSoundWaveFill(audioData, color, modifier)
     })

audio_visualizer/src/main/java/com/miller198/audio_visualizer/ui/CircleVisualizer.kt

@@ -21,44 +21,67 @@ import com.miller198.audio_visualizer.soundeffect.DrawSoundEffectConfigs
 import com.miller198.audio_visualizer.soundeffect.SoundEffects
 import kotlinx.coroutines.launch
 
+/**
+ * Composable that visualizes audio data as a circular sound effect (e.g., wave or bar),
+ * using a provided audio session ID.
+ *
+ * @param audioSessionId The audio session ID from the audio output source (e.g., MediaPlayer).
+ * @param soundEffects Object that defines how to draw the sound effect. use [SoundEffects] (waveform, bars, etc.).
+ * @param visualizerConfig Configuration for how the visualizer captures and processes audio data [VisualizerConfig].
+ * @param modifier Modifier to apply to the visualizer's layout.
+ * @param color The primary color to use for drawing the sound visualization.
+ * @param clippingRadiusConfig Configuration for the inner clipping radius of the circle visualization. Default is [ClippingRadiusConfig.FullClip].
+ * @param gradientConfig Configuration for gradient animation within the visualizer (optional). Default is [GradientConfig.Default] which uses gradient animation.
+ */
 @Composable
 fun CircleVisualizer(
     audioSessionId: Int,
     soundEffects: SoundEffects,
     visualizerConfig: VisualizerConfig,
     modifier: Modifier = Modifier,
     color: Color = White,
-    innerRadiusConfig: ClippingRadiusConfig = ClippingRadiusConfig.FullClip,
+    clippingRadiusConfig: ClippingRadiusConfig = ClippingRadiusConfig.FullClip,
     gradientConfig: GradientConfig = GradientConfig.Default,
 ) {
+    /** Holds the current list of magnitude values */
     val magnitudes = remember { mutableStateOf<List<Float>>(emptyList()) }
+
+    /** Animated version of the magnitudes for smooth transitions in visualization */
     val animateMagnitudes = remember { mutableStateOf<List<Animatable<Float, AnimationVector1D>>>(emptyList()) }
+
     val visualizer = remember { BaseVisualizer() }
 
+    // Set global visual configuration (used in other rendering composable functions)
     DrawSoundEffectConfigs.gradientConfig = gradientConfig
-    DrawSoundEffectConfigs.innerRadiusConfig = innerRadiusConfig
+    DrawSoundEffectConfigs.innerRadiusConfig = clippingRadiusConfig
 
+    // Start the visualizer when the composable is composed with the given audio session ID
     LaunchedEffect(audioSessionId) {
         visualizer.start(
             audioSessionId = audioSessionId,
             captureSize = visualizerConfig.captureSize,
             useWaveCapture = visualizerConfig.useWaveCapture,
             useFftCapture = visualizerConfig.useFftCapture,
             visualizerCallbacks = VisualizerCallbacks(
+                // Callback for waveform audio data (optional processing)
                 onWaveCaptured = { visualizer, bytes, samplingRate ->
                     magnitudes.value = visualizerConfig.processWaveData?.invoke(visualizer, bytes, samplingRate) ?: emptyList()
                 },
+                // Callback for FFT audio data (optional processing)
                 onFftCaptured = { visualizer, bytes, samplingRate ->
                     magnitudes.value = visualizerConfig.processFftData?.invoke(visualizer, bytes, samplingRate) ?: emptyList()
                 },
             )
         )
     }
 
+    // Animate changes in magnitude values for smoother rendering transitions
     LaunchedEffect(magnitudes.value) {
         if (animateMagnitudes.value.isEmpty()) {
+            // Initialize the animatable list if not already done
             animateMagnitudes.value = magnitudes.value.map { Animatable(it) }
         } else {
+            // Animate each value to its new magnitude
             magnitudes.value.forEachIndexed { i, magnitude ->
                 launch {
                     animateMagnitudes.value[i].animateTo(
@@ -73,12 +96,14 @@ fun CircleVisualizer(
         }
     }
 
+    // Release the visualizer when composable leaves the composition
     DisposableEffect(audioSessionId) {
         onDispose {
             visualizer.stop()
         }
     }
 
+    // Draw the sound effect using the provided drawEffect lambda
     soundEffects.drawEffect.invoke(
         animateMagnitudes.value.map { it.value },
         color,