@siteed/expo-audio-studio 2.11.0 → 2.12.0

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()
@@ -1687,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,
@@ -1709,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?) {
@@ -1750,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 ->

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

@@ -64,6 +64,7 @@ data class RecordingConfig(
     val filename: String? = null,
     val deviceId: String? = null,
     val deviceDisconnectionBehavior: String? = null,
+    val audioFocusStrategy: String? = null,
     val bufferDurationSeconds: Double? = null,
 ) {
     companion object {
@@ -125,6 +126,10 @@ data class RecordingConfig(
             // Get device-related settings
             val deviceId = options["deviceId"] as? String
             val deviceDisconnectionBehavior = options["deviceDisconnectionBehavior"] as? String
+            
+            // Get Android-specific settings
+            val androidConfig = options["android"] as? Map<String, Any>
+            val audioFocusStrategy = androidConfig?.get("audioFocusStrategy") as? String
 
             // Initialize the recording configuration with cleaned directory path
             val tempRecordingConfig = RecordingConfig(
@@ -151,6 +156,7 @@ data class RecordingConfig(
                 filename = options["filename"] as? String,
                 deviceId = deviceId,
                 deviceDisconnectionBehavior = deviceDisconnectionBehavior,
+                audioFocusStrategy = audioFocusStrategy,
                 bufferDurationSeconds = (options["bufferDurationSeconds"] as? Number)?.toDouble(),
             )
 

package/android/src/test/java/net/siteed/audiostream/AudioFocusStrategyTest.kt

@@ -0,0 +1,249 @@
+package net.siteed.audiostream
+
+import org.junit.Test
+import org.junit.Assert.*
+
+/**
+ * Unit tests for audio focus strategy configuration and logic.
+ * These tests verify that the RecordingConfig correctly handles audioFocusStrategy
+ * parameter and that the smart defaults work as expected.
+ */
+class AudioFocusStrategyTest {
+
+    @Test
+    fun testRecordingConfigWithExplicitBackgroundStrategy() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "android" to mapOf(
+                "audioFocusStrategy" to "background"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertEquals("Audio focus strategy should be background", "background", config.audioFocusStrategy)
+    }
+
+    @Test
+    fun testRecordingConfigWithExplicitInteractiveStrategy() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "android" to mapOf(
+                "audioFocusStrategy" to "interactive"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertEquals("Audio focus strategy should be interactive", "interactive", config.audioFocusStrategy)
+    }
+
+    @Test
+    fun testRecordingConfigWithExplicitCommunicationStrategy() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "android" to mapOf(
+                "audioFocusStrategy" to "communication"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertEquals("Audio focus strategy should be communication", "communication", config.audioFocusStrategy)
+    }
+
+    @Test
+    fun testRecordingConfigWithExplicitNoneStrategy() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "android" to mapOf(
+                "audioFocusStrategy" to "none"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertEquals("Audio focus strategy should be none", "none", config.audioFocusStrategy)
+    }
+
+    @Test
+    fun testRecordingConfigWithoutAudioFocusStrategy() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit"
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertNull("Audio focus strategy should be null when not specified", config.audioFocusStrategy)
+    }
+
+    @Test
+    fun testRecordingConfigWithInvalidAudioFocusStrategy() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "android" to mapOf(
+                "audioFocusStrategy" to "invalid_strategy"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed even with invalid strategy", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertEquals("Invalid audio focus strategy should be preserved", "invalid_strategy", config.audioFocusStrategy)
+    }
+
+    @Test
+    fun testRecordingConfigWithNullAudioFocusStrategy() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "android" to mapOf(
+                "audioFocusStrategy" to null
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertNull("Audio focus strategy should be null", config.audioFocusStrategy)
+    }
+
+    @Test
+    fun testRecordingConfigKeepAwakeAndBackgroundStrategy() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "keepAwake" to true,
+            "android" to mapOf(
+                "audioFocusStrategy" to "background"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertTrue("keepAwake should be true", config.keepAwake)
+        assertEquals("Audio focus strategy should be background", "background", config.audioFocusStrategy)
+    }
+
+    @Test
+    fun testRecordingConfigKeepAwakeFalseAndInteractiveStrategy() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "keepAwake" to false,
+            "android" to mapOf(
+                "audioFocusStrategy" to "interactive"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertFalse("keepAwake should be false", config.keepAwake)
+        assertEquals("Audio focus strategy should be interactive", "interactive", config.audioFocusStrategy)
+    }
+
+    @Test
+    fun testRecordingConfigWithAutoResumeAndBackgroundStrategy() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "autoResumeAfterInterruption" to true,
+            "android" to mapOf(
+                "audioFocusStrategy" to "background"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertEquals("Audio focus strategy should be background", "background", config.audioFocusStrategy)
+        assertTrue("autoResumeAfterInterruption should be true", config.autoResumeAfterInterruption)
+    }
+
+    @Test
+    fun testRecordingConfigWithCommunicationStrategyAndSpeechSampleRate() {
+        val options = mapOf(
+            "sampleRate" to 16000, // Common speech sample rate
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "android" to mapOf(
+                "audioFocusStrategy" to "communication"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertEquals("Sample rate should be 16000", 16000, config.sampleRate)
+        assertEquals("Audio focus strategy should be communication", "communication", config.audioFocusStrategy)
+    }
+
+    @Test
+    fun testDefaultRecordingConfigValues() {
+        val result = RecordingConfig.fromMap(null)
+        assertTrue("Config creation should succeed with null input", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertNull("Default audio focus strategy should be null", config.audioFocusStrategy)
+        assertTrue("Default keepAwake should be true", config.keepAwake)
+        assertFalse("Default autoResumeAfterInterruption should be false", config.autoResumeAfterInterruption)
+    }
+
+    @Test
+    fun testRecordingConfigCompleteAudioFocusConfiguration() {
+        val options = mapOf(
+            "sampleRate" to 44100,
+            "channels" to 1,
+            "encoding" to "pcm_16bit",
+            "keepAwake" to true,
+            "autoResumeAfterInterruption" to true,
+            "showNotification" to true,
+            "android" to mapOf(
+                "audioFocusStrategy" to "background"
+            )
+        )
+
+        val result = RecordingConfig.fromMap(options)
+        assertTrue("Config creation should succeed", result.isSuccess)
+
+        val (config, _) = result.getOrThrow()
+        assertEquals("Audio focus strategy should be background", "background", config.audioFocusStrategy)
+        assertTrue("keepAwake should be true", config.keepAwake)
+        assertTrue("autoResumeAfterInterruption should be true", config.autoResumeAfterInterruption)
+        assertTrue("showNotification should be true", config.showNotification)
+    }
+}