@siteed/audio-studio 3.1.0 → 3.2.0-beta.1

package/android/src/main/java/net/siteed/audiostudio/AudioStudioModule.kt

@@ -21,14 +21,17 @@ import kotlinx.coroutines.cancelChildren
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 
-class AudioStudioModule : Module(), EventSender {
+class AudioStudioModule : Module(), EventSender, AudioStreamDecoderDelegate {
     companion object {
         private const val CLASS_NAME = "AudioStudioModule"
     }
-    
+
     private lateinit var audioRecorderManager: AudioRecorderManager
     private lateinit var audioProcessor: AudioProcessor
     private lateinit var audioDeviceManager: AudioDeviceManager
+
+    private val streamDecoders = mutableMapOf<String, AudioStreamDecoder>()
+    private val streamDecodersLock = Object()
     private var enablePhoneStateHandling: Boolean = false // Default to false until we check manifest
     private var enableNotificationHandling: Boolean = false // Default to false until we check manifest
     private var enableBackgroundAudio: Boolean = false // Default to false until we check manifest
@@ -88,7 +91,11 @@ class AudioStudioModule : Module(), EventSender {
             Constants.AUDIO_ANALYSIS_EVENT_NAME,
             Constants.RECORDING_INTERRUPTED_EVENT_NAME,
             Constants.TRIM_PROGRESS_EVENT,
-            Constants.DEVICE_CHANGED_EVENT // Add device changed event name
+            Constants.DEVICE_CHANGED_EVENT, // Add device changed event name
+            Constants.AUDIO_STREAM_CHUNK_EVENT,
+            Constants.AUDIO_STREAM_PROGRESS_EVENT,
+            Constants.AUDIO_STREAM_COMPLETE_EVENT,
+            Constants.AUDIO_STREAM_ERROR_EVENT
         )
 
         // Initialize Managers
@@ -520,7 +527,7 @@ class AudioStudioModule : Module(), EventSender {
                     """.trimIndent())
 
                     // Handle decoding options
-                    val decodingOptions = options["decodingOptions"] as? Map<String, Any>
+                    val decodingOptions = options["decodingOptions"] as? Map<*, *>
                     LogUtils.d(CLASS_NAME, "Decoding options: $decodingOptions")
                 
                     val config = decodingOptions?.let {
@@ -676,6 +683,48 @@ class AudioStudioModule : Module(), EventSender {
         }
 
 
+        AsyncFunction("extractPreviewBars") { options: Map<String, Any>, promise: Promise ->
+            coroutineScope.launch(Dispatchers.IO) {
+                try {
+                    val fileUri = requireNotNull(options["fileUri"] as? String) { "fileUri is required" }
+                    val numberOfBars = (options["numberOfBars"] as? Number)?.toInt() ?: 100
+                    val startTimeMs = options["startTimeMs"] as? Number
+                    val endTimeMs = options["endTimeMs"] as? Number
+
+                    val defaultConfig = DecodingConfig(
+                        targetSampleRate = null,
+                        targetChannels = 1,
+                        targetBitDepth = 16,
+                        normalizeAudio = false
+                    )
+                    val decodingOptionsMap = options["decodingOptions"] as? Map<*, *>
+                    val config = decodingOptionsMap?.let {
+                        DecodingConfig(
+                            targetSampleRate = (it["targetSampleRate"] as? Number)?.toInt(),
+                            targetChannels = (it["targetChannels"] as? Number)?.toInt(),
+                            targetBitDepth = (it["targetBitDepth"] as? Number)?.toInt() ?: 16,
+                            normalizeAudio = (it["normalizeAudio"] as? Boolean) ?: false
+                        )
+                    } ?: defaultConfig
+                    val silenceRmsThreshold = ((decodingOptionsMap?.get("silenceRmsThreshold") as? Number)?.toFloat()) ?: 0.01f
+
+                    val audioData = audioProcessor.loadAudioFromAnyFormat(fileUri, config)
+                        ?: throw IllegalStateException("Failed to load audio data")
+                    val result = audioProcessor.generatePreviewBars(
+                        audioData = audioData,
+                        numberOfBars = numberOfBars,
+                        startTimeMs = startTimeMs?.toLong(),
+                        endTimeMs = endTimeMs?.toLong(),
+                        silenceRmsThreshold = silenceRmsThreshold
+                    )
+                    promise.resolve(result)
+                } catch (e: Exception) {
+                    LogUtils.e(CLASS_NAME, "Failed to extract preview bars: ${e.message}", e)
+                    promise.reject("PROCESSING_ERROR", e.message ?: "Unknown error", e)
+                }
+            }
+        }
+
         AsyncFunction("extractAudioAnalysis") { options: Map<String, Any>, promise: Promise ->
             // Off the shared executor so other JS calls don't block during
             // multi-second analysis on large files.
@@ -707,12 +756,13 @@ class AudioStudioModule : Module(), EventSender {
                         normalizeAudio = false
                     )
                 
-                    val config = (options["decodingOptions"] as? Map<String, Any>)?.let { decodingOptionsMap ->
+                    val decodingOptionsMap = options["decodingOptions"] as? Map<*, *>
+                    val config = decodingOptionsMap?.let {
                         DecodingConfig(
-                            targetSampleRate = decodingOptionsMap["targetSampleRate"] as? Int,
-                            targetChannels = decodingOptionsMap["targetChannels"] as? Int,
-                            targetBitDepth = (decodingOptionsMap["targetBitDepth"] as? Int) ?: 16,
-                            normalizeAudio = (decodingOptionsMap["normalizeAudio"] as? Boolean) ?: false
+                            targetSampleRate = (it["targetSampleRate"] as? Number)?.toInt(),
+                            targetChannels = (it["targetChannels"] as? Number)?.toInt(),
+                            targetBitDepth = (it["targetBitDepth"] as? Number)?.toInt() ?: 16,
+                            normalizeAudio = (it["normalizeAudio"] as? Boolean) ?: false
                         )
                     } ?: defaultConfig
 
@@ -802,12 +852,12 @@ class AudioStudioModule : Module(), EventSender {
                     }
                 
                     // Get decoding options
-                    val decodingOptionsMap = options["decodingOptions"] as? Map<String, Any>
+                    val decodingOptionsMap = options["decodingOptions"] as? Map<*, *>
                     val decodingConfig = if (decodingOptionsMap != null) {
                         DecodingConfig(
-                            targetSampleRate = decodingOptionsMap["targetSampleRate"] as? Int,
-                            targetChannels = decodingOptionsMap["targetChannels"] as? Int,
-                            targetBitDepth = (decodingOptionsMap["targetBitDepth"] as? Int) ?: 16,
+                            targetSampleRate = (decodingOptionsMap["targetSampleRate"] as? Number)?.toInt(),
+                            targetChannels = (decodingOptionsMap["targetChannels"] as? Number)?.toInt(),
+                            targetBitDepth = (decodingOptionsMap["targetBitDepth"] as? Number)?.toInt() ?: 16,
                             normalizeAudio = (decodingOptionsMap["normalizeAudio"] as? Boolean) ?: false
                         ).also {
                             LogUtils.d(CLASS_NAME, """
@@ -951,6 +1001,130 @@ class AudioStudioModule : Module(), EventSender {
                 }
             }
         }
+
+        AsyncFunction("streamAudioData") { options: Map<String, Any?>, promise: Promise ->
+            try {
+                val requestId = options["requestId"] as? String
+                    ?: throw IllegalArgumentException("requestId is required")
+                val fileUri = options["fileUri"] as? String
+                    ?: throw IllegalArgumentException("fileUri is required")
+                val streamFormat = (options["streamFormat"] as? String) ?: "float32"
+                if (streamFormat != "float32") {
+                    promise.reject(
+                        "ERR_AUDIO_STREAM_UNSUPPORTED_FORMAT",
+                        "Only streamFormat='float32' is supported",
+                        null
+                    )
+                    return@AsyncFunction
+                }
+
+                val context = appContext.reactContext
+                    ?: throw IllegalStateException("React context not available")
+
+                val decoderOptions = AudioStreamDecoder.Options(
+                    requestId = requestId,
+                    fileUri = fileUri,
+                    startTimeMs = (options["startTimeMs"] as? Number)?.toLong(),
+                    endTimeMs = (options["endTimeMs"] as? Number)?.toLong(),
+                    targetSampleRate = (options["targetSampleRate"] as? Number)?.toInt()
+                        ?: (options["sampleRate"] as? Number)?.toInt(),
+                    channels = (options["channels"] as? Number)?.toInt(),
+                    normalizeAudio = (options["normalizeAudio"] as? Boolean) ?: true,
+                    chunkDurationMs = ((options["chunkDurationMs"] as? Number)?.toInt() ?: 1000)
+                        .coerceIn(10, 60000),
+                    maxChunkBytes = (options["maxChunkBytes"] as? Number)?.toInt(),
+                    maxBufferedChunks = ((options["maxBufferedChunks"] as? Number)?.toInt() ?: 4)
+                        .coerceAtLeast(1),
+                )
+
+                val decoder = AudioStreamDecoder(context, decoderOptions, this@AudioStudioModule)
+                synchronized(streamDecodersLock) {
+                    if (streamDecoders.containsKey(requestId)) {
+                        promise.reject(
+                            "ERR_AUDIO_STREAM_BUSY",
+                            "requestId already in use",
+                            null
+                        )
+                        return@AsyncFunction
+                    }
+                    streamDecoders[requestId] = decoder
+                }
+                decoder.start()
+                promise.resolve(bundleOf("requestId" to requestId))
+            } catch (e: Exception) {
+                LogUtils.e(CLASS_NAME, "streamAudioData failed: ${e.message}", e)
+                promise.reject(
+                    "ERR_AUDIO_STREAM_DECODE_FAILED",
+                    e.message ?: "streamAudioData failed",
+                    e
+                )
+            }
+        }
+
+        AsyncFunction("cancelStreamAudioData") { requestId: String, promise: Promise ->
+            val decoder = synchronized(streamDecodersLock) {
+                streamDecoders[requestId]
+            }
+            decoder?.cancel()
+            promise.resolve(bundleOf(
+                "requestId" to requestId,
+                "cancelled" to (decoder != null)
+            ))
+        }
+
+        Function("acknowledgeStreamAudioChunk") { requestId: String, chunkIndex: Int ->
+            val decoder = synchronized(streamDecodersLock) {
+                streamDecoders[requestId]
+            }
+            decoder?.acknowledgeChunk(chunkIndex)
+        }
+
+        AsyncFunction("getAudioDecodeCapabilities") { promise: Promise ->
+            promise.resolve(bundleOf(
+                "platform" to "android",
+                "supportedInputFormats" to listOf(
+                    "audio/wav",
+                    "audio/mpeg",
+                    "audio/mp4",
+                    "audio/aac",
+                    "audio/ogg",
+                    "audio/opus",
+                    "audio/webm",
+                    "audio/flac",
+                    "audio/amr-wb",
+                ),
+                "supportedOutputFormats" to listOf("float32"),
+                "supportsCancellation" to true,
+                "supportsBackpressure" to true,
+                "supportsTimeRange" to true,
+                "supportsTargetSampleRate" to true,
+                "supportsChannelMixing" to true,
+                "knownLimitations" to listOf(
+                    "MediaCodec output rate may differ from extractor metadata for some encoders; output is resampled via linear interpolation."
+                )
+            ))
+        }
+    }
+
+    private fun releaseStreamDecoder(requestId: String) {
+        synchronized(streamDecodersLock) {
+            streamDecoders.remove(requestId)
+        }
+    }
+
+    override fun streamDecoderEmit(eventName: String, payload: Bundle) {
+        when (eventName) {
+            Constants.AUDIO_STREAM_COMPLETE_EVENT -> {
+                (payload.getString("requestId"))?.let { releaseStreamDecoder(it) }
+            }
+            Constants.AUDIO_STREAM_ERROR_EVENT -> {
+                val code = payload.getString("code") ?: ""
+                if (code != "ERR_AUDIO_STREAM_CANCELLED") {
+                    payload.getString("requestId")?.let { releaseStreamDecoder(it) }
+                }
+            }
+        }
+        safeSendEvent(eventName, payload)
     }
 
     private fun initializeManager() {