@siteed/expo-audio-studio 2.8.6 → 2.10.0

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

@@ -552,8 +552,8 @@ class AudioRecorderManager(
 
                 if (!initializeAudioRecord(promise)) return
 
-                if (recordingConfig.enableCompressedOutput && !initializeCompressedRecorder(
-                    if (recordingConfig.compressedFormat == "aac") "aac" else "opus",
+                if (recordingConfig.output.compressed.enabled && !initializeCompressedRecorder(
+                    if (recordingConfig.output.compressed.format == "aac") "aac" else "opus",
                     promise
                 )) return
 
@@ -593,9 +593,9 @@ class AudioRecorderManager(
                 "sampleRate" to recordingConfig.sampleRate,
                 "mimeType" to mimeType,
                 "compression" to if (compressedFile != null) bundleOf(
-                    "mimeType" to if (recordingConfig.compressedFormat == "aac") "audio/aac" else "audio/opus",
-                    "bitrate" to recordingConfig.compressedBitRate,
-                    "format" to recordingConfig.compressedFormat,
+                    "mimeType" to if (recordingConfig.output.compressed.format == "aac") "audio/aac" else "audio/opus",
+                    "bitrate" to recordingConfig.output.compressed.bitrate,
+                    "format" to recordingConfig.output.compressed.format,
                     "size" to 0,
                     "compressedFileUri" to compressedFile?.toURI().toString()
                 ) else null
@@ -712,11 +712,25 @@ class AudioRecorderManager(
                 AudioFormat.CHANNEL_IN_STEREO
             }
 
-            bufferSizeInBytes = AudioRecord.getMinBufferSize(
+            val minBufferSize = AudioRecord.getMinBufferSize(
                 recordingConfig.sampleRate,
                 channelConfig,
                 audioFormat
             )
+            
+            // Calculate buffer size based on bufferDurationSeconds if provided
+            bufferSizeInBytes = recordingConfig.bufferDurationSeconds?.let { bufferDuration ->
+                val bytesPerSample = when (recordingConfig.encoding) {
+                    "pcm_8bit" -> 1
+                    "pcm_16bit" -> 2
+                    "pcm_32bit" -> 4
+                    else -> 2
+                }
+                val requestedSize = (bufferDuration * recordingConfig.sampleRate * 
+                                   bytesPerSample * recordingConfig.channels).toInt()
+                // Use the larger of requested size or minimum buffer size
+                maxOf(requestedSize, minBufferSize)
+            } ?: minBufferSize
 
             when {
                 bufferSizeInBytes == AudioRecord.ERROR -> {
@@ -818,16 +832,24 @@ class AudioRecorderManager(
     private fun initializeRecordingResources(fileExtension: String, promise: Promise): Boolean {
         try {
             streamUuid = java.util.UUID.randomUUID().toString()
-            audioFile = createRecordingFile(recordingConfig)
             totalDataSize = 0
-
-            FileOutputStream(audioFile, true).use { fos ->
-                audioFileHandler.writeWavHeader(
-                    fos,
-                    recordingConfig.sampleRate,
-                    recordingConfig.channels,
-                    AudioFormatUtils.getBitDepth(recordingConfig.encoding)
-                )
+            
+            // Only create file if primary output is enabled
+            if (recordingConfig.output.primary.enabled) {
+                audioFile = createRecordingFile(recordingConfig)
+                
+                FileOutputStream(audioFile, true).use { fos ->
+                    audioFileHandler.writeWavHeader(
+                        fos,
+                        recordingConfig.sampleRate,
+                        recordingConfig.channels,
+                        AudioFormatUtils.getBitDepth(recordingConfig.encoding)
+                    )
+                }
+            } else {
+                // Set audioFile to null when primary output is disabled
+                audioFile = null
+                LogUtils.d(CLASS_NAME, "Skipping primary file creation - primary output is disabled")
             }
 
             if (recordingConfig.showNotification) {
@@ -860,16 +882,18 @@ class AudioRecorderManager(
                 - Sample Rate: ${recordingConfig.sampleRate} Hz
                 - Channels: ${recordingConfig.channels}
                 - Encoding: ${recordingConfig.encoding}
+                - Buffer Duration: ${recordingConfig.bufferDurationSeconds?.let { "${it}s" } ?: "default"}
+                - Primary Output: ${recordingConfig.output.primary.enabled}
                 - Data Emission Interval: ${recordingConfig.interval}ms
                 - Analysis Interval: ${recordingConfig.intervalAnalysis}ms
                 - Processing Enabled: ${recordingConfig.enableProcessing}
                 - Keep Awake: ${recordingConfig.keepAwake}
                 - Show Notification: ${recordingConfig.showNotification}
                 - Show Waveform: ${recordingConfig.showWaveformInNotification}
-                - Compressed Output: ${recordingConfig.enableCompressedOutput}
-                ${if (recordingConfig.enableCompressedOutput) """
-                    - Compressed Format: ${recordingConfig.compressedFormat}
-                    - Compressed Bitrate: ${recordingConfig.compressedBitRate}
+                - Compressed Output: ${recordingConfig.output.compressed.enabled}
+                ${if (recordingConfig.output.compressed.enabled) """
+                    - Compressed Format: ${recordingConfig.output.compressed.format}
+                    - Compressed Bitrate: ${recordingConfig.output.compressed.bitrate}
                 """.trimIndent() else ""}
                 - Auto Resume: ${recordingConfig.autoResumeAfterInterruption}
                 - Output Directory: ${recordingConfig.outputDirectory ?: "default"}
@@ -974,29 +998,45 @@ class AudioRecorderManager(
                 compressedRecorder = null
 
                 // Log compressed file status if enabled
-                if (recordingConfig.enableCompressedOutput) {
+                if (recordingConfig.output.compressed.enabled) {
                     val compressedSize = compressedFile?.length() ?: 0
                     LogUtils.d(CLASS_NAME, "Compressed File validation - Size: $compressedSize bytes, Path: ${compressedFile?.absolutePath}")
                 }
 
-                val result = bundleOf(
-                    "fileUri" to audioFile?.toURI().toString(),
-                    "filename" to audioFile?.name,
-                    "durationMs" to duration,
-                    "channels" to recordingConfig.channels,
-                    "bitDepth" to AudioFormatUtils.getBitDepth(recordingConfig.encoding),
-                    "sampleRate" to recordingConfig.sampleRate,
-                    "size" to fileSize,
-                    "mimeType" to mimeType,
-                    "createdAt" to System.currentTimeMillis(),
-                    "compression" to if (compressedFile != null) bundleOf(
-                        "size" to compressedFile?.length(),
-                        "mimeType" to if (recordingConfig.compressedFormat == "aac") "audio/aac" else "audio/opus",
-                        "bitrate" to recordingConfig.compressedBitRate,
-                        "format" to recordingConfig.compressedFormat,
-                        "compressedFileUri" to compressedFile?.toURI().toString()
-                    ) else null
-                )
+                val result = if (!recordingConfig.output.primary.enabled) {
+                    // When primary output is disabled, return minimal info
+                    bundleOf(
+                        "fileUri" to "",
+                        "filename" to "stream-only",
+                        "durationMs" to duration,
+                        "channels" to recordingConfig.channels,
+                        "bitDepth" to AudioFormatUtils.getBitDepth(recordingConfig.encoding),
+                        "sampleRate" to recordingConfig.sampleRate,
+                        "size" to totalDataSize,
+                        "mimeType" to mimeType,
+                        "createdAt" to System.currentTimeMillis(),
+                        "compression" to null
+                    )
+                } else {
+                    bundleOf(
+                        "fileUri" to audioFile?.toURI().toString(),
+                        "filename" to audioFile?.name,
+                        "durationMs" to duration,
+                        "channels" to recordingConfig.channels,
+                        "bitDepth" to AudioFormatUtils.getBitDepth(recordingConfig.encoding),
+                        "sampleRate" to recordingConfig.sampleRate,
+                        "size" to fileSize,
+                        "mimeType" to mimeType,
+                        "createdAt" to System.currentTimeMillis(),
+                        "compression" to if (compressedFile != null) bundleOf(
+                            "size" to compressedFile?.length(),
+                            "mimeType" to if (recordingConfig.output.compressed.format == "aac") "audio/aac" else "audio/opus",
+                            "bitrate" to recordingConfig.output.compressed.bitrate,
+                            "format" to recordingConfig.output.compressed.format,
+                            "compressedFileUri" to compressedFile?.toURI().toString()
+                        ) else null
+                    )
+                }
                 promise.resolve(result)
 
                 // Reset the timing variables
@@ -1155,12 +1195,12 @@ class AudioRecorderManager(
                 else -> totalRecordedTime
             }
 
-            val compressionBundle = if (recordingConfig.enableCompressedOutput) {
+            val compressionBundle = if (recordingConfig.output.compressed.enabled) {
                 bundleOf(
                     "size" to (compressedFile?.length() ?: 0),
-                    "mimeType" to if (recordingConfig.compressedFormat == "aac") "audio/aac" else "audio/opus",
-                    "bitrate" to recordingConfig.compressedBitRate,
-                    "format" to recordingConfig.compressedFormat
+                    "mimeType" to if (recordingConfig.output.compressed.format == "aac") "audio/aac" else "audio/opus",
+                    "bitrate" to recordingConfig.output.compressed.bitrate,
+                    "format" to recordingConfig.output.compressed.format
                 )
             } else null
 
@@ -1257,8 +1297,16 @@ class AudioRecorderManager(
     private fun recordingProcess() {
         try {
             LogUtils.i(CLASS_NAME, "Starting recording process...")
-            FileOutputStream(audioFile, true).use { fos ->
-                // Write audio data directly to the file
+            
+            // Only use FileOutputStream if primary output is enabled
+            val fos = if (recordingConfig.output.primary.enabled && audioFile != null) {
+                FileOutputStream(audioFile, true)
+            } else {
+                null
+            }
+            
+            try {
+                // Write audio data directly to the file (if not skipping)
                 val audioData = ByteArray(bufferSizeInBytes)
                 LogUtils.d(CLASS_NAME, "Entering recording loop")
                 
@@ -1318,7 +1366,10 @@ class AudioRecorderManager(
                     }
 
                     if (bytesRead > 0) {
-                        fos.write(audioData, 0, bytesRead)
+                        // Only write to file if primary output is enabled
+                        if (fos != null) {
+                            fos.write(audioData, 0, bytesRead)
+                        }
                         totalDataSize += bytesRead
                         
                         accumulatedAudioData.write(audioData, 0, bytesRead)
@@ -1377,10 +1428,16 @@ class AudioRecorderManager(
                         }
                     }
                 }
+            } finally {
+                // Close the file output stream if it was opened
+                fos?.close()
             }
-            // Update the WAV header to reflect the actual data size
-            audioFile?.let { file ->
-                audioFileHandler.updateWavHeader(file)
+            
+            // Update the WAV header to reflect the actual data size (only if file was created)
+            if (recordingConfig.output.primary.enabled) {
+                audioFile?.let { file ->
+                    audioFileHandler.updateWavHeader(file)
+                }
             }
 
         } catch (e: Exception) {
@@ -1403,7 +1460,7 @@ class AudioRecorderManager(
         val positionInMs =
             (from * 1000) / (recordingConfig.sampleRate * recordingConfig.channels * (if (recordingConfig.encoding == "pcm_8bit") 8 else 16) / 8)
 
-        val compressionBundle = if (recordingConfig.enableCompressedOutput) {
+        val compressionBundle = if (recordingConfig.output.compressed.enabled) {
             val compressedSize = compressedFile?.length() ?: 0
             val eventDataSize = compressedSize - lastEmittedCompressedSize
             
@@ -1563,6 +1620,12 @@ class AudioRecorderManager(
 
     @RequiresApi(Build.VERSION_CODES.Q)
     private fun initializeCompressedRecorder(fileExtension: String, promise: Promise): Boolean {
+        // Skip compressed recording if compressed output is not enabled
+        if (!recordingConfig.output.compressed.enabled) {
+            LogUtils.d(CLASS_NAME, "Skipping compressed recorder initialization - compressed output is disabled")
+            return true
+        }
+        
         try {
             // Pass true to indicate this is a compressed file
             compressedFile = createRecordingFile(recordingConfig, isCompressed = true)
@@ -1576,15 +1639,15 @@ class AudioRecorderManager(
 
             compressedRecorder?.apply {
                 setAudioSource(MediaRecorder.AudioSource.MIC)
-                setOutputFormat(if (recordingConfig.compressedFormat == "aac") 
+                setOutputFormat(if (recordingConfig.output.compressed.format == "aac") 
                     MediaRecorder.OutputFormat.AAC_ADTS 
                     else MediaRecorder.OutputFormat.OGG)
-                setAudioEncoder(if (recordingConfig.compressedFormat == "aac") 
+                setAudioEncoder(if (recordingConfig.output.compressed.format == "aac") 
                     MediaRecorder.AudioEncoder.AAC 
                     else MediaRecorder.AudioEncoder.OPUS)
                 setAudioChannels(recordingConfig.channels)
                 setAudioSamplingRate(recordingConfig.sampleRate)
-                setAudioEncodingBitRate(recordingConfig.compressedBitRate)
+                setAudioEncodingBitRate(recordingConfig.output.compressed.bitrate)
                 setOutputFile(compressedFile?.absolutePath)
                 prepare()
             }
@@ -1687,7 +1750,7 @@ class AudioRecorderManager(
         
         // Choose extension based on whether this is a compressed file
         val extension = if (isCompressed) {
-            config.compressedFormat.lowercase()
+            config.output.compressed.format.lowercase()
         } else {
             "wav"
         }
@@ -1752,8 +1815,8 @@ class AudioRecorderManager(
             if (!initializeBufferSize(dummyPromise)) return false
             if (!initializeAudioRecord(dummyPromise)) return false
             
-            if (recordingConfig.enableCompressedOutput && !initializeCompressedRecorder(
-                if (recordingConfig.compressedFormat == "aac") "aac" else "opus",
+            if (recordingConfig.output.compressed.enabled && !initializeCompressedRecorder(
+                if (recordingConfig.output.compressed.format == "aac") "aac" else "opus",
                 dummyPromise
             )) return false
 

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

@@ -10,6 +10,16 @@ object LogUtils {
     // Format: [ExpoAudioStudio:ClassName]
     private const val TAG_PREFIX = "ExpoAudioStudio"
     
+    // Check if we're running in a test environment
+    private val isInTest: Boolean by lazy {
+        try {
+            Class.forName("org.junit.Test")
+            true
+        } catch (e: ClassNotFoundException) {
+            false
+        }
+    }
+    
     /**
      * Logs a debug message with a consistent format.
      * 
@@ -17,7 +27,11 @@ object LogUtils {
      * @param message The message to log
      */
     fun d(className: String, message: String) {
-        Log.d("$TAG_PREFIX:$className", message)
+        if (isInTest) {
+            println("D/$TAG_PREFIX:$className: $message")
+        } else {
+            Log.d("$TAG_PREFIX:$className", message)
+        }
     }
     
     /**
@@ -28,7 +42,12 @@ object LogUtils {
      * @param throwable Optional throwable to include in the log
      */
     fun e(className: String, message: String, throwable: Throwable? = null) {
-        Log.e("$TAG_PREFIX:$className", message, throwable)
+        if (isInTest) {
+            println("E/$TAG_PREFIX:$className: $message")
+            throwable?.printStackTrace()
+        } else {
+            Log.e("$TAG_PREFIX:$className", message, throwable)
+        }
     }
     
     /**
@@ -39,7 +58,12 @@ object LogUtils {
      * @param throwable Optional throwable to include in the log
      */
     fun w(className: String, message: String, throwable: Throwable? = null) {
-        Log.w("$TAG_PREFIX:$className", message, throwable)
+        if (isInTest) {
+            println("W/$TAG_PREFIX:$className: $message")
+            throwable?.printStackTrace()
+        } else {
+            Log.w("$TAG_PREFIX:$className", message, throwable)
+        }
     }
     
     /**
@@ -49,7 +73,11 @@ object LogUtils {
      * @param message The message to log
      */
     fun i(className: String, message: String) {
-        Log.i("$TAG_PREFIX:$className", message)
+        if (isInTest) {
+            println("I/$TAG_PREFIX:$className: $message")
+        } else {
+            Log.i("$TAG_PREFIX:$className", message)
+        }
     }
     
     /**

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

@@ -4,6 +4,45 @@ import android.media.AudioFormat
 import android.os.Build
 import java.io.File
 
+// New output configuration structure
+data class OutputConfig(
+    val primary: PrimaryOutput = PrimaryOutput(),
+    val compressed: CompressedOutput = CompressedOutput()
+) {
+    data class PrimaryOutput(
+        val enabled: Boolean = true,
+        val format: String = "wav"
+    )
+    
+    data class CompressedOutput(
+        val enabled: Boolean = false,
+        val format: String = "aac",
+        val bitrate: Int = 128000
+    )
+    
+    companion object {
+        fun fromMap(map: Map<String, Any?>?): OutputConfig {
+            if (map == null) return OutputConfig()
+            
+            val primaryMap = map.getTypedMap<Any?>("primary") { true }
+            val compressedMap = map.getTypedMap<Any?>("compressed") { true }
+            
+            val primary = PrimaryOutput(
+                enabled = primaryMap.getBooleanOrDefault("enabled", true),
+                format = primaryMap.getStringOrDefault("format", "wav")
+            )
+            
+            val compressed = CompressedOutput(
+                enabled = compressedMap.getBooleanOrDefault("enabled", false),
+                format = compressedMap.getStringOrDefault("format", "aac").lowercase(),
+                bitrate = compressedMap.getNumberOrDefault("bitrate", 128000)
+            )
+            
+            return OutputConfig(primary = primary, compressed = compressed)
+        }
+    }
+}
+
 data class RecordingConfig(
     val sampleRate: Int = Constants.DEFAULT_SAMPLE_RATE,
     val channels: Int = 1,
@@ -17,14 +56,13 @@ data class RecordingConfig(
     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 output: OutputConfig = OutputConfig(),
     val autoResumeAfterInterruption: Boolean = false,
     val outputDirectory: String? = null,
     val filename: String? = null,
     val deviceId: String? = null,
     val deviceDisconnectionBehavior: String? = null,
+    val bufferDurationSeconds: Double? = null,
 ) {
     companion object {
         fun fromMap(options: Map<String, Any?>?): Result<Pair<RecordingConfig, AudioFormatInfo>> {
@@ -45,19 +83,17 @@ data class RecordingConfig(
             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
+            // Parse output config
+            val outputMap = options.getTypedMap<Any?>("output") { true }
+            val outputConfig = OutputConfig.fromMap(outputMap)
 
             // Validate bitrate if compression is enabled
-            if (enableCompressedOutput) {
+            if (outputConfig.compressed.enabled) {
                 when {
-                    compressedBitRate < 8000 -> return Result.failure(
+                    outputConfig.compressed.bitrate < 8000 -> return Result.failure(
                         IllegalArgumentException("Bitrate must be at least 8000 bps")
                     )
-                    compressedBitRate > 960000 -> return Result.failure(
+                    outputConfig.compressed.bitrate > 960000 -> return Result.failure(
                         IllegalArgumentException("Bitrate cannot exceed 960000 bps")
                     )
                 }
@@ -102,9 +138,7 @@ data class RecordingConfig(
                 showWaveformInNotification = options.getBooleanOrDefault("showWaveformInNotification", false),
                 notification = notificationConfig,
                 features = features,
-                enableCompressedOutput = enableCompressedOutput,
-                compressedFormat = compressedFormat,
-                compressedBitRate = compressedBitRate,
+                output = outputConfig,
                 autoResumeAfterInterruption = options.getBooleanOrDefault("autoResumeAfterInterruption", false),
                 outputDirectory = outputDirectory?.let {
                     it.replace(Regex("^file://"), "")
@@ -113,7 +147,8 @@ data class RecordingConfig(
                 },
                 filename = options["filename"] as? String,
                 deviceId = deviceId,
-                deviceDisconnectionBehavior = deviceDisconnectionBehavior
+                deviceDisconnectionBehavior = deviceDisconnectionBehavior,
+                bufferDurationSeconds = (options["bufferDurationSeconds"] as? Number)?.toDouble(),
             )
 
             // Validate sample rate and channels