@siteed/expo-audio-studio 2.10.6 → 2.12.0

package/android/src/androidTest/java/net/siteed/audiostream/integration/PcmStreamingDurationTest.kt

@@ -0,0 +1,252 @@
+package net.siteed.audiostream.integration
+
+import android.os.Bundle
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.Assert.*
+import java.io.File
+
+/**
+ * Integration test for Issue #263: PCM streaming bugs
+ * Tests that durationMs is positive (not -1) in streaming-only mode
+ */
+@RunWith(AndroidJUnit4::class)
+class PcmStreamingDurationTest {
+
+    private val context = InstrumentationRegistry.getInstrumentation().targetContext
+
+    @Test
+    fun testStreamingOnlyMode_returnsPositiveDuration() {
+        println("🧪 Test: Issue #263 - Positive duration in streaming-only mode")
+        println("==============================================================")
+
+        // Configuration for streaming-only mode (no file output)
+        val config = Bundle().apply {
+            putInt("sampleRate", 16000)
+            putInt("channels", 1)
+            putString("encoding", "pcm_16bit")
+            putInt("interval", 100)
+            putInt("intervalAnalysis", 50)
+            
+            // Disable all file outputs - streaming only
+            val outputBundle = Bundle().apply {
+                val primaryBundle = Bundle().apply {
+                    putBoolean("enabled", false)
+                }
+                val compressedBundle = Bundle().apply {
+                    putBoolean("enabled", false)
+                }
+                putBundle("primary", primaryBundle)
+                putBundle("compressed", compressedBundle)
+            }
+            putBundle("output", outputBundle)
+        }
+
+        // Simulate recording result for streaming-only mode
+        val result = simulateStreamingOnlyRecording(config, recordingDurationMs = 1000)
+
+        println("📊 Simulated Recording Results:")
+        println("===============================")
+        
+        val durationMs = result.getLong("durationMs", -1)
+        val fileUri = result.getString("fileUri", "")
+        val filename = result.getString("filename", "")
+        val size = result.getLong("size", 0)
+        
+        println("Duration: ${durationMs}ms")
+        println("FileUri: '$fileUri'")
+        println("Filename: '$filename'")
+        println("Size: $size bytes")
+
+        // Issue #263 Bug Check: durationMs should be positive, not -1
+        assertTrue(
+            "Issue #263: durationMs should be positive in streaming-only mode, but got: $durationMs",
+            durationMs > 0
+        )
+
+        // Duration should match expected recording time
+        assertEquals(
+            "Duration should match simulated recording time",
+            1000L,
+            durationMs
+        )
+
+        // In streaming-only mode, fileUri should be empty or indicate streaming
+        assertTrue(
+            "FileUri should indicate streaming-only mode",
+            fileUri.isEmpty() || fileUri.contains("stream") || filename == "stream-only"
+        )
+
+        // Size should reflect actual data streamed, not file size
+        assertTrue(
+            "Size should be positive (representing streamed data)",
+            size > 0
+        )
+
+        println("\n✅ Issue #263 Validation:")
+        println("- durationMs is positive: ${durationMs}ms ✓")
+        println("- Duration matches recording time: ✓")
+        println("- No file created (streaming-only): '$fileUri' ✓")
+        println("- Size represents streamed data: $size bytes ✓")
+        println()
+    }
+
+    @Test
+    fun testIntervalAnalysisVsInterval_configuration() {
+        println("🧪 Test: intervalAnalysis vs interval configuration")
+        println("==================================================")
+
+        // Test that different intervals can be configured
+        val config = Bundle().apply {
+            putInt("interval", 200) // 200ms for data
+            putInt("intervalAnalysis", 100) // 100ms for analysis
+            putInt("sampleRate", 16000)
+            putInt("channels", 1)
+            putString("encoding", "pcm_16bit")
+            
+            // Disable file outputs
+            val outputBundle = Bundle().apply {
+                val primaryBundle = Bundle().apply { putBoolean("enabled", false) }
+                val compressedBundle = Bundle().apply { putBoolean("enabled", false) }
+                putBundle("primary", primaryBundle)
+                putBundle("compressed", compressedBundle)
+            }
+            putBundle("output", outputBundle)
+        }
+
+        val result = simulateStreamingOnlyRecording(config, recordingDurationMs = 1000)
+
+        // Verify configuration was respected
+        val durationMs = result.getLong("durationMs", -1)
+        assertTrue("Duration should be positive", durationMs > 0)
+        assertEquals("Duration should match recording time", 1000L, durationMs)
+
+        // Calculate expected data points based on intervals
+        val expectedDataPoints = 1000 / 200 // ~5 data emissions
+        val expectedAnalysisPoints = 1000 / 100 // ~10 analysis emissions
+
+        println("Expected data emissions: $expectedDataPoints (200ms intervals)")
+        println("Expected analysis emissions: $expectedAnalysisPoints (100ms intervals)")
+        println("Duration: ${durationMs}ms")
+
+        println("\n✅ Interval Configuration Tests:")
+        println("- Different intervals configured: ✓")
+        println("- Positive duration: ${durationMs}ms ✓")
+        println("- Analysis twice as frequent as data: ✓")
+        println()
+    }
+
+    @Test
+    fun testBugScenario_beforeFix() {
+        println("🧪 Test: Issue #263 Bug Scenario (Before Fix)")
+        println("=============================================")
+
+        // This test documents what the bug would have produced
+        // before the fix was implemented
+        val config = Bundle().apply {
+            putInt("sampleRate", 16000)
+            putInt("channels", 1)
+            putString("encoding", "pcm_16bit")
+            
+            val outputBundle = Bundle().apply {
+                val primaryBundle = Bundle().apply { putBoolean("enabled", false) }
+                val compressedBundle = Bundle().apply { putBoolean("enabled", false) }
+                putBundle("primary", primaryBundle)
+                putBundle("compressed", compressedBundle)
+            }
+            putBundle("output", outputBundle)
+        }
+
+        // Simulate what the old buggy behavior would have returned
+        val buggyResult = simulateBuggyStreamingOnlyRecording(config)
+        val fixedResult = simulateStreamingOnlyRecording(config, recordingDurationMs = 1000)
+
+        println("Buggy behavior (before fix):")
+        println("- durationMs: ${buggyResult.getLong("durationMs", -999)}")
+        println("- Calculated from file size: 0 - 44 = -44 bytes")
+        
+        println("\nFixed behavior (after fix):")
+        println("- durationMs: ${fixedResult.getLong("durationMs", -999)}")
+        println("- Calculated from actual recording time")
+
+        // Verify the fix resolves the issue
+        assertTrue(
+            "Before fix: duration would be <= 0",
+            buggyResult.getLong("durationMs", -999) <= 0
+        )
+        
+        assertTrue(
+            "After fix: duration should be positive",
+            fixedResult.getLong("durationMs", -999) > 0
+        )
+
+        println("\n✅ Bug Fix Validation:")
+        println("- Old behavior produced negative/zero duration ✓")
+        println("- New behavior produces positive duration ✓")
+        println("- Issue #263 resolved ✓")
+        println()
+    }
+
+    /**
+     * Simulates the current (fixed) behavior for streaming-only recording
+     */
+    private fun simulateStreamingOnlyRecording(config: Bundle, recordingDurationMs: Long): Bundle {
+        // Simulate the fixed duration calculation logic
+        val primaryEnabled = config.getBundle("output")?.getBundle("primary")?.getBoolean("enabled", true) ?: true
+        val compressedEnabled = config.getBundle("output")?.getBundle("compressed")?.getBoolean("enabled", false) ?: false
+        
+        // Simulate total data size for a recording (16-bit PCM, 1 channel, 16kHz)
+        val sampleRate = config.getInt("sampleRate", 16000)
+        val channels = config.getInt("channels", 1)
+        val bytesPerSample = 2 // 16-bit
+        val totalDataSize = (recordingDurationMs * sampleRate * channels * bytesPerSample) / 1000
+        
+        return Bundle().apply {
+            if (!primaryEnabled) {
+                // Fixed behavior: use actual recording time for duration
+                putLong("durationMs", recordingDurationMs)
+                putString("fileUri", "")
+                putString("filename", "stream-only")
+                putLong("size", totalDataSize)
+                putString("mimeType", "audio/wav")
+            } else {
+                // File-based recording would use file size calculation
+                putLong("durationMs", recordingDurationMs)
+                putString("fileUri", "file:///mock/recording.wav")
+                putString("filename", "recording.wav")
+                putLong("size", totalDataSize + 44) // Include WAV header
+                putString("mimeType", "audio/wav")
+            }
+            putInt("channels", channels)
+            putInt("sampleRate", sampleRate)
+            putLong("createdAt", System.currentTimeMillis())
+        }
+    }
+
+    /**
+     * Simulates the old buggy behavior that calculated duration from file size
+     */
+    private fun simulateBuggyStreamingOnlyRecording(config: Bundle): Bundle {
+        // Simulate the old buggy calculation
+        val fileSize = 0L // No file in streaming mode
+        val dataFileSize = fileSize - 44 // Would be negative!
+        val sampleRate = config.getInt("sampleRate", 16000)
+        val channels = config.getInt("channels", 1)
+        val bytesPerSample = 2
+        val byteRate = sampleRate * channels * bytesPerSample
+        val duration = if (byteRate > 0) (dataFileSize * 1000 / byteRate) else 0
+        
+        return Bundle().apply {
+            putLong("durationMs", duration) // This would be negative or zero!
+            putString("fileUri", "")
+            putString("filename", "stream-only")
+            putLong("size", 0)
+            putString("mimeType", "audio/wav")
+            putInt("channels", channels)
+            putInt("sampleRate", sampleRate)
+            putLong("createdAt", System.currentTimeMillis())
+        }
+    }
+}

package/android/src/androidTest/java/net/siteed/audiostream/integration/run_integration_tests.sh

@@ -29,6 +29,11 @@ echo "📱 Running Compressed-Only Output Test (Issue #244)..."
 echo "-----------------------------------------------------"
 ./gradlew :siteed-expo-audio-studio:connectedAndroidTest --tests "*.CompressedOnlyOutputTest"
 
+echo ""
+echo "📱 Running Audio Focus Strategy Integration Test..."
+echo "--------------------------------------------------"
+./gradlew :siteed-expo-audio-studio:connectedAndroidTest --tests "*.AudioFocusStrategyIntegrationTest"
+
 echo ""
 echo "📊 Test Results Summary"
 echo "======================"

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

@@ -903,43 +903,55 @@ class AudioProcessor(private val filesDir: File) {
     }
 
     private fun decodeAudioToPCM(extractor: MediaExtractor, format: MediaFormat): ByteArray {
-        val decoder = MediaCodec.createDecoderByType(format.getString(MediaFormat.KEY_MIME)!!)
-        decoder.configure(format, null, null, 0)
-        decoder.start()
-
-        val info = MediaCodec.BufferInfo()
-        val pcmData = mutableListOf<Byte>()
-
-        var isEOS = false
-        while (!isEOS) {
-            val inputBufferId = decoder.dequeueInputBuffer(10000)
-            if (inputBufferId >= 0) {
-                val inputBuffer = decoder.getInputBuffer(inputBufferId)!!
-                val sampleSize = extractor.readSampleData(inputBuffer, 0)
-
-                if (sampleSize < 0) {
-                    decoder.queueInputBuffer(inputBufferId, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM)
-                    isEOS = true
-                } else {
-                    decoder.queueInputBuffer(inputBufferId, 0, sampleSize, extractor.sampleTime, 0)
-                    extractor.advance()
+        var decoder: MediaCodec? = null
+        
+        try {
+            decoder = MediaCodec.createDecoderByType(format.getString(MediaFormat.KEY_MIME)!!)
+            decoder.configure(format, null, null, 0)
+            decoder.start()
+
+            val info = MediaCodec.BufferInfo()
+            val pcmData = mutableListOf<Byte>()
+
+            var isEOS = false
+            while (!isEOS) {
+                val inputBufferId = decoder.dequeueInputBuffer(10000)
+                if (inputBufferId >= 0) {
+                    val inputBuffer = decoder.getInputBuffer(inputBufferId)!!
+                    val sampleSize = extractor.readSampleData(inputBuffer, 0)
+
+                    if (sampleSize < 0) {
+                        decoder.queueInputBuffer(inputBufferId, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM)
+                        isEOS = true
+                    } else {
+                        decoder.queueInputBuffer(inputBufferId, 0, sampleSize, extractor.sampleTime, 0)
+                        extractor.advance()
+                    }
+                }
+
+                val outputBufferId = decoder.dequeueOutputBuffer(info, 10000)
+                if (outputBufferId >= 0) {
+                    val outputBuffer = decoder.getOutputBuffer(outputBufferId)!!
+                    val chunk = ByteArray(info.size)
+                    outputBuffer.get(chunk)
+                    pcmData.addAll(chunk.toList())
+                    decoder.releaseOutputBuffer(outputBufferId, false)
                 }
             }
 
-            val outputBufferId = decoder.dequeueOutputBuffer(info, 10000)
-            if (outputBufferId >= 0) {
-                val outputBuffer = decoder.getOutputBuffer(outputBufferId)!!
-                val chunk = ByteArray(info.size)
-                outputBuffer.get(chunk)
-                pcmData.addAll(chunk.toList())
-                decoder.releaseOutputBuffer(outputBufferId, false)
+            return pcmData.toByteArray()
+        } finally {
+            try {
+                decoder?.stop()
+            } catch (e: Exception) {
+                LogUtils.w(CLASS_NAME, "Error stopping decoder: ${e.message}")
+            }
+            try {
+                decoder?.release()
+            } catch (e: Exception) {
+                LogUtils.w(CLASS_NAME, "Error releasing decoder: ${e.message}")
             }
         }
-
-        decoder.stop()
-        decoder.release()
-
-        return pcmData.toByteArray()
     }
 
     private fun resampleAudio(

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

@@ -114,8 +114,17 @@ class AudioRecorderManager(
     private var telephonyManager: TelephonyManager? = null
         get() {
             if (field == null) {
-                field = context.getSystemService(Context.TELEPHONY_SERVICE) as? TelephonyManager
-                LogUtils.d(CLASS_NAME, "TelephonyManager initialization: ${if (field != null) "successful" else "failed"}")
+                try {
+                    field = context.getSystemService(Context.TELEPHONY_SERVICE) as? TelephonyManager
+                    if (field == null) {
+                        LogUtils.w(CLASS_NAME, "TelephonyManager is null - device may not have telephony service (tablet/emulator)")
+                    } else {
+                        LogUtils.d(CLASS_NAME, "TelephonyManager initialization: successful")
+                    }
+                } catch (e: Exception) {
+                    LogUtils.w(CLASS_NAME, "Failed to initialize TelephonyManager: ${e.message}")
+                    field = null
+                }
             }
             return field
         }
@@ -409,8 +418,9 @@ class AudioRecorderManager(
                             }
                             TelephonyManager.CALL_STATE_IDLE -> {
                                 if (_isRecording.get() && isPaused.get()) {
-                                    LogUtils.d(CLASS_NAME, "Call ended, handling auto-resume (enabled: ${recordingConfig.autoResumeAfterInterruption})")
-                                    if (recordingConfig.autoResumeAfterInterruption) {
+                                    val autoResume = if (::recordingConfig.isInitialized) recordingConfig.autoResumeAfterInterruption else false
+                                    LogUtils.d(CLASS_NAME, "Call ended, handling auto-resume (enabled: $autoResume)")
+                                    if (autoResume) {
                                         mainHandler.post {
                                             resumeRecording(object : Promise {
                                                 override fun resolve(value: Any?) {
@@ -438,15 +448,18 @@ class AudioRecorderManager(
                     }
                 }
 
-                if (telephonyManager != null) {
+                val localTelephonyManager = telephonyManager
+                if (localTelephonyManager != null) {
                     try {
-                        telephonyManager?.listen(phoneStateListener, PhoneStateListener.LISTEN_CALL_STATE)
+                        localTelephonyManager.listen(phoneStateListener, PhoneStateListener.LISTEN_CALL_STATE)
                         LogUtils.d(CLASS_NAME, "Successfully registered phone state listener")
+                    } catch (e: SecurityException) {
+                        LogUtils.w(CLASS_NAME, "Missing permission for phone state listener: ${e.message}")
                     } catch (e: Exception) {
                         LogUtils.e(CLASS_NAME, "Failed to register phone state listener", e)
                     }
                 } else {
-                    LogUtils.e(CLASS_NAME, "TelephonyManager is null, cannot register phone state listener")
+                    LogUtils.w(CLASS_NAME, "TelephonyManager is null, phone call interruption handling disabled (device may not have telephony service)")
                 }
             } else {
                 LogUtils.w(CLASS_NAME, "READ_PHONE_STATE permission not granted, phone call interruption handling disabled")
@@ -479,7 +492,8 @@ class AudioRecorderManager(
                     }
                 }
                 AudioManager.AUDIOFOCUS_GAIN -> {
-                    if (_isRecording.get() && isPaused.get() && recordingConfig.autoResumeAfterInterruption) {
+                    val autoResume = if (::recordingConfig.isInitialized) recordingConfig.autoResumeAfterInterruption else false
+                    if (_isRecording.get() && isPaused.get() && autoResume) {
                         mainHandler.post {
                             resumeRecording(object : Promise {
                                 override fun resolve(value: Any?) {
@@ -608,7 +622,11 @@ class AudioRecorderManager(
 
         } catch (e: Exception) {
             releaseAudioFocus()
-            telephonyManager?.listen(phoneStateListener, PhoneStateListener.LISTEN_NONE)
+            try {
+                telephonyManager?.listen(phoneStateListener, PhoneStateListener.LISTEN_NONE)
+            } catch (e: Exception) {
+                LogUtils.w(CLASS_NAME, "Failed to unregister phone state listener: ${e.message}")
+            }
             promise.reject("UNEXPECTED_ERROR", "Unexpected error: ${e.message}", e)
         }
     }
@@ -985,15 +1003,30 @@ class AudioRecorderManager(
                 val fileSize = audioFile?.length() ?: 0
                 LogUtils.d(CLASS_NAME, "WAV File validation - Size: $fileSize bytes, Path: ${audioFile?.absolutePath}")
                 
-                val dataFileSize = fileSize - 44  // Subtract header size
-                val byteRate =
-                    recordingConfig.sampleRate * recordingConfig.channels * when (recordingConfig.encoding) {
-                        "pcm_8bit" -> 1
-                        "pcm_16bit" -> 2
-                        "pcm_32bit" -> 4
-                        else -> 2 // Default to 2 bytes per sample if the encoding is not recognized
+                // Calculate duration based on context - use actual recording time for streaming-only mode
+                val duration = if (!recordingConfig.output.primary.enabled) {
+                    // For streaming-only mode, calculate duration from actual recording time
+                    val actualRecordingTime = if (recordingStartTime > 0) {
+                        System.currentTimeMillis() - recordingStartTime - pausedDuration
+                    } else {
+                        0L
                     }
-                val duration = if (byteRate > 0) (dataFileSize * 1000 / byteRate) else 0
+                    LogUtils.d(CLASS_NAME, "Streaming-only mode: Using actual recording time: ${actualRecordingTime}ms")
+                    actualRecordingTime
+                } else {
+                    // For file-based recording, calculate duration from file size
+                    val dataFileSize = fileSize - 44  // Subtract header size
+                    val byteRate =
+                        recordingConfig.sampleRate * recordingConfig.channels * when (recordingConfig.encoding) {
+                            "pcm_8bit" -> 1
+                            "pcm_16bit" -> 2
+                            "pcm_32bit" -> 4
+                            else -> 2 // Default to 2 bytes per sample if the encoding is not recognized
+                        }
+                    val fileDuration = if (byteRate > 0) (dataFileSize * 1000 / byteRate) else 0
+                    LogUtils.d(CLASS_NAME, "File-based mode: Using file size duration: ${fileDuration}ms")
+                    fileDuration
+                }
 
                 compressedRecorder?.apply {
                     stop()
@@ -1654,9 +1687,20 @@ class AudioRecorderManager(
 
             compressedRecorder?.apply {
                 setAudioSource(MediaRecorder.AudioSource.MIC)
-                setOutputFormat(if (recordingConfig.output.compressed.format == "aac") 
-                    MediaRecorder.OutputFormat.AAC_ADTS 
-                    else MediaRecorder.OutputFormat.OGG)
+                
+                // Choose output format based on codec and preferRawStream flag
+                val outputFormat = when (recordingConfig.output.compressed.format) {
+                    "aac" -> {
+                        if (recordingConfig.output.compressed.preferRawStream) {
+                            MediaRecorder.OutputFormat.AAC_ADTS  // Raw AAC stream
+                        } else {
+                            MediaRecorder.OutputFormat.MPEG_4    // M4A container (new default)
+                        }
+                    }
+                    else -> MediaRecorder.OutputFormat.OGG       // Opus uses OGG container
+                }
+                setOutputFormat(outputFormat)
+                
                 setAudioEncoder(if (recordingConfig.output.compressed.format == "aac") 
                     MediaRecorder.AudioEncoder.AAC 
                     else MediaRecorder.AudioEncoder.OPUS)
@@ -1676,6 +1720,55 @@ class AudioRecorderManager(
 
     @SuppressLint("NewApi")
     private fun requestAudioFocus(): Boolean {
+        val strategy = getAudioFocusStrategy()
+        
+        when (strategy) {
+            "none" -> {
+                LogUtils.d(CLASS_NAME, "Skipping audio focus request (strategy: none)")
+                return true
+            }
+            
+            "background" -> {
+                LogUtils.d(CLASS_NAME, "Background recording - minimal audio focus")
+                // For true background recording, we don't request audio focus
+                // This allows recording to continue uninterrupted when users switch apps
+                return true
+            }
+            
+            "communication" -> {
+                return requestCommunicationAudioFocus()
+            }
+            
+            "interactive" -> {
+                return requestInteractiveAudioFocus()
+            }
+            
+            else -> {
+                LogUtils.w(CLASS_NAME, "Unknown audio focus strategy: $strategy, using interactive")
+                return requestInteractiveAudioFocus()
+            }
+        }
+    }
+
+    private fun getAudioFocusStrategy(): String {
+        // Use explicit strategy if provided
+        if (::recordingConfig.isInitialized) {
+            recordingConfig.audioFocusStrategy?.let { return it }
+            
+            // Smart defaults based on other config
+            return if (recordingConfig.keepAwake && enableBackgroundAudio) {
+                "background"
+            } else {
+                "interactive"
+            }
+        }
+        
+        // Default strategy if recordingConfig is not initialized
+        return "interactive"
+    }
+
+    @SuppressLint("NewApi")
+    private fun requestInteractiveAudioFocus(): Boolean {
         audioFocusChangeListener = AudioManager.OnAudioFocusChangeListener { focusChange ->
             when (focusChange) {
                 AudioManager.AUDIOFOCUS_LOSS,
@@ -1698,7 +1791,8 @@ class AudioRecorderManager(
                     }
                 }
                 AudioManager.AUDIOFOCUS_GAIN -> {
-                    if (_isRecording.get() && isPaused.get() && recordingConfig.autoResumeAfterInterruption) {
+                    val autoResume = if (::recordingConfig.isInitialized) recordingConfig.autoResumeAfterInterruption else false
+                    if (_isRecording.get() && isPaused.get() && autoResume) {
                         mainHandler.post {
                             resumeRecording(object : Promise {
                                 override fun resolve(value: Any?) {
@@ -1739,6 +1833,78 @@ class AudioRecorderManager(
         return result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED
     }
 
+    @SuppressLint("NewApi")
+    private fun requestCommunicationAudioFocus(): Boolean {
+        audioFocusChangeListener = AudioManager.OnAudioFocusChangeListener { focusChange ->
+            when (focusChange) {
+                AudioManager.AUDIOFOCUS_LOSS -> {
+                    // Only pause for permanent focus loss (like phone calls)
+                    if (_isRecording.get() && !isPaused.get()) {
+                        mainHandler.post {
+                            pauseRecording(object : Promise {
+                                override fun resolve(value: Any?) {
+                                    isPaused.set(true)
+                                    eventSender.sendExpoEvent(Constants.RECORDING_INTERRUPTED_EVENT_NAME, bundleOf(
+                                        "reason" to "audioFocusLoss",
+                                        "isPaused" to true
+                                    ))
+                                }
+                                override fun reject(code: String, message: String?, cause: Throwable?) {
+                                    LogUtils.e(CLASS_NAME, "Failed to pause recording on audio focus loss")
+                                }
+                            })
+                        }
+                    }
+                }
+                AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
+                    // Don't pause for temporary loss in communication mode
+                    LogUtils.d(CLASS_NAME, "Ignoring transient audio focus loss in communication mode")
+                }
+                AudioManager.AUDIOFOCUS_GAIN -> {
+                    val autoResume = if (::recordingConfig.isInitialized) recordingConfig.autoResumeAfterInterruption else false
+                    if (_isRecording.get() && isPaused.get() && autoResume) {
+                        mainHandler.post {
+                            resumeRecording(object : Promise {
+                                override fun resolve(value: Any?) {
+                                    eventSender.sendExpoEvent(Constants.RECORDING_INTERRUPTED_EVENT_NAME, bundleOf(
+                                        "reason" to "audioFocusGain",
+                                        "isPaused" to false
+                                    ))
+                                }
+                                override fun reject(code: String, message: String?, cause: Throwable?) {
+                                    LogUtils.e(CLASS_NAME, "Failed to resume recording on audio focus gain")
+                                }
+                            })
+                        }
+                    }
+                }
+            }
+        }
+
+        val result = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val focusRequest = AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN)
+                .setAudioAttributes(AudioAttributes.Builder()
+                    .setUsage(AudioAttributes.USAGE_VOICE_COMMUNICATION)
+                    .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
+                    .build())
+                .setAcceptsDelayedFocusGain(false)
+                .setWillPauseWhenDucked(false)
+                .setOnAudioFocusChangeListener(audioFocusChangeListener!!)
+                .build()
+            audioFocusRequest = focusRequest
+            audioManager.requestAudioFocus(focusRequest)
+        } else {
+            @Suppress("DEPRECATION")
+            audioManager.requestAudioFocus(
+                audioFocusChangeListener,
+                AudioManager.STREAM_VOICE_CALL,
+                AudioManager.AUDIOFOCUS_GAIN
+            )
+        }
+        
+        return result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED
+    }
+
     private fun releaseAudioFocus() {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
             (audioFocusRequest as? AudioFocusRequest)?.let { request ->
@@ -1765,7 +1931,17 @@ class AudioRecorderManager(
         
         // Choose extension based on whether this is a compressed file
         val extension = if (isCompressed) {
-            config.output.compressed.format.lowercase()
+            when (config.output.compressed.format.lowercase()) {
+                "aac" -> {
+                    if (config.output.compressed.preferRawStream) {
+                        "aac"  // Raw AAC stream
+                    } else {
+                        "m4a"  // M4A container (new default)
+                    }
+                }
+                "opus" -> "opus"  // Opus in OGG container
+                else -> config.output.compressed.format.lowercase()
+            }
         } else {
             "wav"
         }