@siteed/expo-audio-stream 2.0.1 → 2.2.0

package/android/src/main/java/net/siteed/audiostream/FFT.kt

@@ -1,99 +0,0 @@
-// packages/expo-audio-stream/android/src/main/java/net/siteed/audiostream/FFT.kt
-package net.siteed.audiostream
-
-import kotlin.math.PI
-import kotlin.math.cos
-import kotlin.math.sin
-import kotlin.math.sqrt
-
-class FFT(private val n: Int) {
-    private val cosTable = FloatArray(n / 2)
-    private val sinTable = FloatArray(n / 2)
-    private val hannWindow = FloatArray(n)
-
-    init {
-        // Precompute trig tables
-        for (i in 0 until n / 2) {
-            cosTable[i] = cos(2.0 * PI * i / n).toFloat()
-            sinTable[i] = sin(2.0 * PI * i / n).toFloat()
-        }
-        
-        // Precompute normalized Hann window to match vDSP
-        val normalizationFactor = sqrt(2.0f / n)  // Match vDSP normalization
-        for (i in hannWindow.indices) {
-            hannWindow[i] = normalizationFactor * 0.5f * (1 - cos(2.0 * PI * i / (n - 1))).toFloat()
-        }
-    }
-
-    fun processSegment(segment: FloatArray): FloatArray {
-        // Pad or truncate input to match FFT length
-        val paddedSegment = if (segment.size < n) {
-            segment + FloatArray(n - segment.size)
-        } else {
-            segment.copyOf(n)
-        }
-
-        // Apply normalized Hann window
-        for (i in paddedSegment.indices) {
-            paddedSegment[i] *= hannWindow[i]
-        }
-
-        // Perform FFT
-        realForward(paddedSegment)
-
-        return paddedSegment
-    }
-
-    fun realForward(data: FloatArray) {
-        realForwardRecursive(data)
-    }
-
-    private fun realForwardRecursive(data: FloatArray) {
-        val n = data.size
-        if (n <= 1) return
-
-        val even = FloatArray(n / 2)
-        val odd = FloatArray(n / 2)
-
-        for (i in 0 until n / 2) {
-            even[i] = data[2 * i]
-            odd[i] = data[2 * i + 1]
-        }
-
-        realForwardRecursive(even)
-        realForwardRecursive(odd)
-
-        for (i in 0 until n / 2) {
-            val t = cosTable[i] * odd[i] - sinTable[i] * even[i]
-            val u = sinTable[i] * odd[i] + cosTable[i] * even[i]
-            data[i] = even[i] + t
-            data[i + n / 2] = even[i] - t
-        }
-    }
-
-    fun realInverse(powerSpectrum: FloatArray, output: FloatArray) {
-        // Copy power spectrum to complex format for inverse FFT
-        val complexData = FloatArray(n * 2)
-        for (i in 0 until n/2 + 1) {
-            complexData[2 * i] = powerSpectrum[i]
-            if (2 * i + 1 < complexData.size) {
-                complexData[2 * i + 1] = 0f
-            }
-        }
-
-        // Conjugate for inverse FFT
-        for (i in 0 until n) {
-            if (2 * i + 1 < complexData.size) {
-                complexData[2 * i + 1] = -complexData[2 * i + 1]
-            }
-        }
-
-        // Perform forward FFT (which is inverse when input is conjugated)
-        realForward(complexData)
-
-        // Copy real part to output and conjugate again
-        for (i in 0 until n) {
-            output[i] = complexData[2 * i] / n
-        }
-    }
-}

package/android/src/main/java/net/siteed/audiostream/Features.kt

@@ -1,98 +0,0 @@
-package net.siteed.audiostream
-
-import android.os.Bundle
-import androidx.core.os.bundleOf
-
-data class Features(
-    val energy: Float = 0f,
-    val mfcc: List<Float> = emptyList(),
-    val rms: Float = 0f,
-    val minAmplitude: Float = 0f,
-    val maxAmplitude: Float = 0f,
-    val zcr: Float = 0f,
-    val spectralCentroid: Float = 0f,
-    val spectralFlatness: Float = 0f,
-    val spectralRollOff: Float = 0f,
-    val spectralBandwidth: Float = 0f,
-    val tempo: Float = 0f,
-    val hnr: Float = 0f,
-    val melSpectrogram: List<Float> = emptyList(),
-    val chromagram: List<Float> = emptyList(),
-    val spectralContrast: List<Float> = emptyList(),
-    val tonnetz: List<Float> = emptyList(),
-    val pitch: Float = 0f,
-    val crc32: Long? = null
-) {
-    fun toDictionary(): Map<String, Any> {
-        val baseMap = mapOf(
-            "energy" to energy,
-            "mfcc" to mfcc,
-            "rms" to rms,
-            "minAmplitude" to minAmplitude,
-            "maxAmplitude" to maxAmplitude,
-            "zcr" to zcr,
-            "spectralCentroid" to spectralCentroid,
-            "spectralFlatness" to spectralFlatness,
-            "spectralRollOff" to spectralRollOff,
-            "spectralBandwidth" to spectralBandwidth,
-            "tempo" to tempo,
-            "hnr" to hnr,
-            "melSpectrogram" to melSpectrogram,
-            "chromagram" to chromagram,
-            "spectralContrast" to spectralContrast,
-            "tonnetz" to tonnetz,
-            "pitch" to pitch,
-            "crc32" to (crc32 ?: 0)
-        )
-        return baseMap.filterValues { it != null }
-    }
-
-    fun toBundle(): Bundle {
-        return bundleOf(
-            "energy" to energy,
-            "mfcc" to mfcc,
-            "rms" to rms,
-            "minAmplitude" to minAmplitude,
-            "maxAmplitude" to maxAmplitude,
-            "zcr" to zcr,
-            "spectralCentroid" to spectralCentroid,
-            "spectralFlatness" to spectralFlatness,
-            "spectralRollOff" to spectralRollOff,
-            "spectralBandwidth" to spectralBandwidth,
-            "tempo" to tempo,
-            "hnr" to hnr,
-            "melSpectrogram" to melSpectrogram,
-            "chromagram" to chromagram,
-            "spectralContrast" to spectralContrast,
-            "tonnetz" to tonnetz,
-            "pitch" to pitch,
-            "crc32" to (crc32 ?: 0)
-        )
-    }
-
-    companion object {
-        fun parseFeatureOptions(options: Map<*, *>?): Map<String, Boolean> {
-            return options?.let { map ->
-                mapOf(
-                    "energy" to (map["energy"] as? Boolean ?: false),
-                    "mfcc" to (map["mfcc"] as? Boolean ?: false),
-                    "rms" to (map["rms"] as? Boolean ?: false),
-                    "zcr" to (map["zcr"] as? Boolean ?: false),
-                    "dB" to (map["dB"] as? Boolean ?: false),
-                    "spectralCentroid" to (map["spectralCentroid"] as? Boolean ?: false),
-                    "spectralFlatness" to (map["spectralFlatness"] as? Boolean ?: false),
-                    "spectralRollOff" to (map["spectralRollOff"] as? Boolean ?: false),
-                    "spectralBandwidth" to (map["spectralBandwidth"] as? Boolean ?: false),
-                    "chromagram" to (map["chromagram"] as? Boolean ?: false),
-                    "tempo" to (map["tempo"] as? Boolean ?: false),
-                    "hnr" to (map["hnr"] as? Boolean ?: false),
-                    "melSpectrogram" to (map["melSpectrogram"] as? Boolean ?: false),
-                    "spectralContrast" to (map["spectralContrast"] as? Boolean ?: false),
-                    "tonnetz" to (map["tonnetz"] as? Boolean ?: false),
-                    "pitch" to (map["pitch"] as? Boolean ?: false),
-                    "crc32" to (map["crc32"] as? Boolean ?: false)
-                )
-            } ?: emptyMap()
-        }
-    }
-}

package/android/src/main/java/net/siteed/audiostream/NotificationConfig.kt

@@ -1,70 +0,0 @@
-package net.siteed.audiostream
-
-data class NotificationConfig(
-    val title: String = "Recording...",
-    val text: String = "",
-    val icon: String? = null,
-    val channelId: String = "audio_recording_channel",
-    val notificationId: Int = 1,
-    val actions: List<NotificationAction> = emptyList(),
-    val channelName: String = "Audio Recording",
-    val channelDescription: String = "Shows audio recording status",
-    val waveform: WaveformConfig? = null,
-    val lightColor: String = "#FF0000",
-    val priority: String = "high",
-    val accentColor: String? = null
-) {
-    companion object {
-        fun fromMap(map: Map<String, Any?>?): NotificationConfig {
-            if (map == null) return NotificationConfig()
-
-            val androidMap = map["android"] as? Map<String, Any?> ?: emptyMap()
-
-            return NotificationConfig(
-                title = map["title"] as? String ?: "Recording...",
-                text = map["text"] as? String ?: "",
-                icon = map["icon"] as? String,
-                channelId = androidMap["channelId"] as? String ?: "audio_recording_channel",
-                notificationId = (androidMap["notificationId"] as? Number)?.toInt() ?: 1,
-                actions = parseNotificationActions(androidMap["actions"] as? List<Map<String, Any?>>),
-                channelName = androidMap["channelName"] as? String ?: "Audio Recording",
-                channelDescription = androidMap["channelDescription"] as? String ?: "Shows audio recording status",
-                waveform = parseWaveformConfig(androidMap["waveform"] as? Map<String, Any?>),
-                lightColor = androidMap["lightColor"] as? String ?: "#FF0000",
-                priority = androidMap["priority"] as? String ?: "high",
-                accentColor = androidMap["accentColor"] as? String
-            )
-        }
-
-        private fun parseNotificationActions(actionsList: List<Map<String, Any?>>?): List<NotificationAction> {
-            return actionsList?.mapNotNull { actionMap ->
-                if (actionMap["title"] != null && actionMap["identifier"] != null) {
-                    NotificationAction(
-                        title = actionMap["title"] as String,
-                        icon = actionMap["icon"] as? String,
-                        intentAction = actionMap["identifier"] as String
-                    )
-                } else null
-            } ?: emptyList()
-        }
-
-        private fun parseWaveformConfig(waveformMap: Map<String, Any?>?): WaveformConfig? {
-            if (waveformMap == null) return null
-
-            return WaveformConfig(
-                color = waveformMap["color"] as? String ?: "#FFFFFF",
-                opacity = (waveformMap["opacity"] as? Number)?.toFloat() ?: 1.0f,
-                strokeWidth = (waveformMap["strokeWidth"] as? Number)?.toFloat() ?: 1.5f,
-                style = waveformMap["style"] as? String ?: "stroke",
-                mirror = waveformMap["mirror"] as? Boolean ?: true,
-                height = (waveformMap["height"] as? Number)?.toInt() ?: 64
-            )
-        }
-    }
-}
-
-data class NotificationAction(
-    val title: String,
-    val icon: String? = null,
-    val intentAction: String
-)

package/android/src/main/java/net/siteed/audiostream/PermissionUtils.kt

@@ -1,59 +0,0 @@
-package net.siteed.audiostream
-
-import android.content.Context
-import android.content.pm.PackageManager
-import android.os.Build
-import androidx.core.content.ContextCompat
-import android.Manifest
-import android.util.Log
-
-class PermissionUtils(private val context: Context) {
-    fun checkRecordingPermission(): Boolean {
-        val hasRecordPermission = ContextCompat.checkSelfPermission(
-            context,
-            Manifest.permission.RECORD_AUDIO
-        ) == PackageManager.PERMISSION_GRANTED
-
-        Log.d(Constants.TAG, "RECORD_AUDIO permission: $hasRecordPermission")
-
-        // Check for foreground service permission on Android 14+
-        val hasForegroundService = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-            val result = ContextCompat.checkSelfPermission(
-                context,
-                Manifest.permission.FOREGROUND_SERVICE_MICROPHONE
-            ) == PackageManager.PERMISSION_GRANTED
-            Log.d(Constants.TAG, "FOREGROUND_SERVICE_MICROPHONE permission: $result (Android 14+)")
-            result
-        } else {
-            Log.d(Constants.TAG, "FOREGROUND_SERVICE_MICROPHONE not required (Android < 14)")
-            true
-        }
-
-        val result = hasRecordPermission && hasForegroundService
-        Log.d(Constants.TAG, "Final recording permission result: $result")
-        return result
-    }
-
-    fun checkNotificationPermission(): Boolean {
-        val result = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-            val hasPermission = ContextCompat.checkSelfPermission(
-                context,
-                Manifest.permission.POST_NOTIFICATIONS
-            ) == PackageManager.PERMISSION_GRANTED
-            Log.d(Constants.TAG, "POST_NOTIFICATIONS permission: $hasPermission (Android 13+)")
-            hasPermission
-        } else {
-            Log.d(Constants.TAG, "POST_NOTIFICATIONS not required (Android < 13)")
-            true
-        }
-        return result
-    }
-
-    fun checkPhoneStatePermission(): Boolean {
-        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-            context.checkSelfPermission(android.Manifest.permission.READ_PHONE_STATE) == PackageManager.PERMISSION_GRANTED
-        } else {
-            true
-        }
-    }
-}

package/android/src/main/java/net/siteed/audiostream/RecordingActionReceiver.kt

@@ -1,59 +0,0 @@
-package net.siteed.audiostream
-
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import android.util.Log
-import expo.modules.kotlin.Promise
-import java.util.concurrent.atomic.AtomicBoolean
-
-class RecordingActionReceiver : BroadcastReceiver() {
-    companion object {
-        const val ACTION_PAUSE_RECORDING = "net.siteed.audiostream.PAUSE_RECORDING"
-        const val ACTION_RESUME_RECORDING = "net.siteed.audiostream.RESUME_RECORDING"
-        private val isProcessingAction = AtomicBoolean(false)
-    }
-
-    override fun onReceive(context: Context, intent: Intent) {
-        when (intent.action) {
-            ACTION_PAUSE_RECORDING, ACTION_RESUME_RECORDING -> handleRecordingAction(intent.action)
-            else -> Log.w("RecordingActionReceiver", "Unknown action: ${intent.action}")
-        }
-    }
-
-    private fun handleRecordingAction(action: String?) {
-        if (!isProcessingAction.compareAndSet(false, true)) {
-            Log.d("RecordingActionReceiver", "Action already in progress, skipping")
-            return
-        }
-
-        try {
-            val audioRecorderManager = AudioRecorderManager.getInstance()
-            if (audioRecorderManager == null) {
-                Log.e("RecordingActionReceiver", "AudioRecorderManager instance is null")
-                isProcessingAction.set(false)
-                return
-            }
-
-            val notificationPromise = object : Promise {
-                override fun resolve(value: Any?) {
-                    Log.d("RecordingActionReceiver", "$action completed successfully")
-                    isProcessingAction.set(false)
-                }
-
-                override fun reject(code: String, message: String?, cause: Throwable?) {
-                    Log.e("RecordingActionReceiver", "$action failed: $message", cause)
-                    isProcessingAction.set(false)
-                }
-            }
-
-            when (action) {
-                ACTION_PAUSE_RECORDING -> audioRecorderManager.pauseRecording(notificationPromise)
-                ACTION_RESUME_RECORDING -> audioRecorderManager.resumeRecording(notificationPromise)
-            }
-        } catch (e: Exception) {
-            Log.e("RecordingActionReceiver", "Error processing $action", e)
-            isProcessingAction.set(false)
-        }
-    }
-}

package/android/src/main/java/net/siteed/audiostream/RecordingConfig.kt

@@ -1,205 +0,0 @@
-package net.siteed.audiostream
-
-import android.media.AudioFormat
-import android.os.Build
-import java.io.File
-
-data class RecordingConfig(
-    val sampleRate: Int = Constants.DEFAULT_SAMPLE_RATE,
-    val channels: Int = 1,
-    val encoding: String = "pcm_16bit",
-    val keepAwake: Boolean = true,
-    val interval: Long = Constants.DEFAULT_INTERVAL,
-    val intervalAnalysis: Long = Constants.DEFAULT_INTERVAL_ANALYSIS,
-    val enableProcessing: Boolean = false,
-    val segmentDurationMs: Int = 100,
-    val showNotification: Boolean = false,
-    val showWaveformInNotification: Boolean = false,
-    val notification: NotificationConfig = NotificationConfig(),
-    val features: Map<String, Boolean> = emptyMap(),
-    val enableCompressedOutput: Boolean = false,
-    val compressedFormat: String = "opus",
-    val compressedBitRate: Int = 24000,
-    val autoResumeAfterInterruption: Boolean = false,
-    val outputDirectory: String? = null,
-    val filename: String? = null,
-) {
-    companion object {
-        fun fromMap(options: Map<String, Any?>?): Result<Pair<RecordingConfig, AudioFormatInfo>> {
-            if (options == null) {
-                val defaultConfig = RecordingConfig()
-                val defaultFormat = AudioFormatInfo(
-                    format = AudioFormat.ENCODING_PCM_16BIT,
-                    mimeType = "audio/wav",
-                    fileExtension = "wav"
-                )
-                return Result.success(Pair(defaultConfig, defaultFormat))
-            }
-
-            // Extract features using type-safe helper
-            val features = options.getTypedMap<Boolean>("features") { it is Boolean }
-
-            // Parse notification config using type-safe helper
-            val notificationMap = options.getTypedMap<Any?>("notification") { true }
-            val notificationConfig = NotificationConfig.fromMap(notificationMap)
-
-            // Parse compression config
-            val compressionMap = options.getTypedMap<Any?>("compression") { true }
-            val enableCompressedOutput = compressionMap["enabled"] as? Boolean ?: false
-            val compressedFormat = (compressionMap["format"] as? String)?.lowercase() ?: "aac"
-            val compressedBitRate = (compressionMap["bitrate"] as? Number)?.toInt() ?: 128000
-
-            // Validate bitrate if compression is enabled
-            if (enableCompressedOutput) {
-                when {
-                    compressedBitRate < 8000 -> return Result.failure(
-                        IllegalArgumentException("Bitrate must be at least 8000 bps")
-                    )
-                    compressedBitRate > 960000 -> return Result.failure(
-                        IllegalArgumentException("Bitrate cannot exceed 960000 bps")
-                    )
-                }
-            }
-
-            // Only validate directory if it's provided
-            val outputDirectory = options["outputDirectory"] as? String
-            if (outputDirectory != null) {
-                // Clean up the directory path by removing file:// protocol and normalizing
-                val cleanDirectory = outputDirectory
-                    .replace(Regex("^file://"), "")
-                    .trim('/')
-                    .replace("//", "/")
-
-                val directory = File(cleanDirectory)
-                if (!directory.exists()) {
-                    return Result.failure(IllegalArgumentException("Directory does not exist: $cleanDirectory"))
-                }
-                if (!directory.isDirectory) {
-                    return Result.failure(IllegalArgumentException("Path is not a directory: $cleanDirectory"))
-                }
-                if (!directory.canWrite()) {
-                    return Result.failure(IllegalArgumentException("Directory is not writable: $cleanDirectory"))
-                }
-            }
-
-            // Initialize the recording configuration with cleaned directory path
-            val tempRecordingConfig = RecordingConfig(
-                sampleRate = options.getNumberOrDefault("sampleRate", Constants.DEFAULT_SAMPLE_RATE),
-                channels = options.getNumberOrDefault("channels", 1),
-                encoding = options.getStringOrDefault("encoding", "pcm_16bit"),
-                keepAwake = options.getBooleanOrDefault("keepAwake", true),
-                interval = options.getNumberOrDefault("interval", Constants.DEFAULT_INTERVAL),
-                intervalAnalysis = options.getNumberOrDefault("intervalAnalysis", Constants.DEFAULT_INTERVAL_ANALYSIS),
-                enableProcessing = options.getBooleanOrDefault("enableProcessing", false),
-                segmentDurationMs = options.getNumberOrDefault("segmentDurationMs", 100),
-                showNotification = options.getBooleanOrDefault("showNotification", false),
-                showWaveformInNotification = options.getBooleanOrDefault("showWaveformInNotification", false),
-                notification = notificationConfig,
-                features = features,
-                enableCompressedOutput = enableCompressedOutput,
-                compressedFormat = compressedFormat,
-                compressedBitRate = compressedBitRate,
-                autoResumeAfterInterruption = options.getBooleanOrDefault("autoResumeAfterInterruption", false),
-                outputDirectory = outputDirectory?.let {
-                    it.replace(Regex("^file://"), "")
-                        .trim('/')
-                        .replace("//", "/")
-                },
-                filename = options["filename"] as? String
-            )
-
-            // Validate sample rate and channels
-            if (tempRecordingConfig.sampleRate !in listOf(16000, 44100, 48000)) {
-                return Result.failure(
-                    IllegalArgumentException("Sample rate must be one of 16000, 44100, or 48000 Hz")
-                )
-            }
-            if (tempRecordingConfig.channels !in 1..2) {
-                return Result.failure(
-                    IllegalArgumentException("Channels must be either 1 (Mono) or 2 (Stereo)")
-                )
-            }
-
-            // Set encoding and file extension
-            val audioFormatInfo = when (tempRecordingConfig.encoding) {
-                "pcm_8bit" -> AudioFormatInfo(
-                    format = AudioFormat.ENCODING_PCM_8BIT,
-                    mimeType = "audio/wav",
-                    fileExtension = "wav"
-                )
-                "pcm_16bit" -> AudioFormatInfo(
-                    format = AudioFormat.ENCODING_PCM_16BIT,
-                    mimeType = "audio/wav",
-                    fileExtension = "wav"
-                )
-                "pcm_32bit" -> AudioFormatInfo(
-                    format = AudioFormat.ENCODING_PCM_FLOAT,
-                    mimeType = "audio/wav",
-                    fileExtension = "wav"
-                )
-                "opus" -> {
-                    if (Build.VERSION.SDK_INT < 29) {
-                        return Result.failure(
-                            IllegalArgumentException("Opus encoding not supported on this Android version.")
-                        )
-                    }
-                    AudioFormatInfo(
-                        format = if (Build.VERSION.SDK_INT >= 29) 20 else AudioFormat.ENCODING_DEFAULT, // 20 is ENCODING_OPUS
-                        mimeType = "audio/opus",
-                        fileExtension = "opus"
-                    )
-                }
-                "aac_lc" -> AudioFormatInfo(
-                    format = AudioFormat.ENCODING_AAC_LC,
-                    mimeType = "audio/aac",
-                    fileExtension = "aac"
-                )
-                else -> AudioFormatInfo(
-                    format = AudioFormat.ENCODING_DEFAULT,
-                    mimeType = "audio/wav",
-                    fileExtension = "wav"
-                )
-            }
-
-            return Result.success(Pair(tempRecordingConfig, audioFormatInfo))
-        }
-    }
-}
-
-// Extension functions for type-safe map access
-private inline fun <reified T> Map<String, Any?>.getTypedMap(
-    key: String,
-    predicate: (Any?) -> Boolean
-): Map<String, T> {
-    return (this[key] as? Map<*, *>)?.mapNotNull { (k, v) ->
-        if (k is String && predicate(v)) {
-            k to (v as T)
-        } else null
-    }?.toMap() ?: emptyMap()
-}
-
-private fun Map<String, Any?>.getStringOrDefault(key: String, default: String): String {
-    return this[key] as? String ?: default
-}
-
-private fun Map<String, Any?>.getBooleanOrDefault(key: String, default: Boolean): Boolean {
-    return this[key] as? Boolean ?: default
-}
-
-private fun Map<String, Any?>.getNumberOrDefault(key: String, default: Int): Int {
-    return (this[key] as? Number)?.toInt() ?: default
-}
-
-private fun Map<String, Any?>.getNumberOrDefault(key: String, default: Long): Long {
-    return (this[key] as? Number)?.toLong() ?: default
-}
-
-private fun Map<String, Any?>.getNumberOrDefault(key: String, default: Double): Double {
-    return (this[key] as? Number)?.toDouble() ?: default
-}
-
-data class AudioFormatInfo(
-    val format: Int,
-    val mimeType: String,
-    val fileExtension: String
-)

package/android/src/main/java/net/siteed/audiostream/WaveformConfig.kt

@@ -1,19 +0,0 @@
-package net.siteed.audiostream
-
-/**
- * Configuration for the notification waveform visualization
- * @property color The color of the waveform (e.g., "#FFFFFF" for white)
- * @property opacity Opacity of the waveform (0.0-1.0)
- * @property strokeWidth Width of the waveform line (default: 1.5f)
- * @property style Drawing style: "stroke" for outline, "fill" for solid
- * @property mirror Whether to mirror the waveform (symmetrical display)
- * @property height Height of the waveform view in dp (default: 64)
- */
-data class WaveformConfig(
-    val color: String = "#FFFFFF",
-    val opacity: Float = 1.0f,
-    val strokeWidth: Float = 1.5f,
-    val style: String = "stroke", // "stroke" or "fill"
-    val mirror: Boolean = true,
-    val height: Int = 64
-)