@siteed/audio-studio 3.0.5 → 3.1.1

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

@@ -118,6 +118,7 @@ class AudioRecorderManager(
     private var audioFocusRequest: Any? = null  // Type Any to handle both old and new APIs
     private var phoneStateListener: PhoneStateListener? = null
     private var telephonyCallback: Any? = null  // TelephonyCallback for API 31+, typed as Any to avoid class verification issues on older APIs
+    private val pausedBySystemInterruption = AtomicBoolean(false)
     private var telephonyManager: TelephonyManager? = null
         get() {
             if (field == null) {
@@ -408,7 +409,7 @@ class AudioRecorderManager(
                 if (_isRecording.get() && !isPaused.get()) {
                     LogUtils.d(CLASS_NAME, "Pausing recording due to incoming/ongoing call")
                     mainHandler.post {
-                        pauseRecording(object : Promise {
+                        pauseRecordingForSystemInterruption(object : Promise {
                             override fun resolve(value: Any?) {
                                 LogUtils.d(CLASS_NAME, "Successfully paused recording due to call")
                                 eventSender.sendExpoEvent(Constants.RECORDING_INTERRUPTED_EVENT_NAME, bundleOf(
@@ -426,8 +427,14 @@ class AudioRecorderManager(
             TelephonyManager.CALL_STATE_IDLE -> {
                 if (_isRecording.get() && isPaused.get()) {
                     val autoResume = if (::recordingConfig.isInitialized) recordingConfig.autoResumeAfterInterruption else false
-                    LogUtils.d(CLASS_NAME, "Call ended, handling auto-resume (enabled: $autoResume)")
-                    if (autoResume) {
+                    val shouldAutoResume = InterruptionAutoResumePolicy.shouldAutoResume(
+                        autoResumeAfterInterruption = autoResume,
+                        isRecording = _isRecording.get(),
+                        isPaused = isPaused.get(),
+                        pausedBySystemInterruption = pausedBySystemInterruption.get()
+                    )
+                    LogUtils.d(CLASS_NAME, "Call ended, handling auto-resume (enabled: $autoResume, pausedBySystemInterruption: ${pausedBySystemInterruption.get()})")
+                    if (shouldAutoResume) {
                         mainHandler.post {
                             resumeRecording(object : Promise {
                                 override fun resolve(value: Any?) {
@@ -443,7 +450,7 @@ class AudioRecorderManager(
                             })
                         }
                     } else {
-                        LogUtils.d(CLASS_NAME, "Auto-resume disabled, staying paused")
+                        LogUtils.d(CLASS_NAME, "Auto-resume not permitted, staying paused")
                         eventSender.sendExpoEvent(Constants.RECORDING_INTERRUPTED_EVENT_NAME, bundleOf(
                             "reason" to "phoneCallEnded",
                             "isPaused" to true
@@ -954,6 +961,7 @@ class AudioRecorderManager(
 
             audioRecord?.startRecording()
             isPaused.set(false)
+            pausedBySystemInterruption.set(false)
             isFirstChunk = true
             recordingStartTime = System.currentTimeMillis()
 
@@ -1174,6 +1182,7 @@ class AudioRecorderManager(
                 // Reset the timing variables
                 _isRecording.set(false)
                 isPaused.set(false)
+                pausedBySystemInterruption.set(false)
                 totalRecordedTime = 0
                 pausedDuration = 0
             } catch (e: Exception) {
@@ -1258,6 +1267,7 @@ class AudioRecorderManager(
             }
             
             LogUtils.d(CLASS_NAME, "⏺️ Recording resumed successfully")
+            pausedBySystemInterruption.set(false)
             promise.resolve("Recording resumed")
         } catch (e: Exception) {
             LogUtils.e(CLASS_NAME, "⏺️ Failed to resume recording: ${e.message}", e)
@@ -1267,12 +1277,21 @@ class AudioRecorderManager(
     }
 
     fun pauseRecording(promise: Promise) {
+        pauseRecording(promise, isSystemInterruption = false)
+    }
+
+    private fun pauseRecordingForSystemInterruption(promise: Promise) {
+        pauseRecording(promise, isSystemInterruption = true)
+    }
+
+    private fun pauseRecording(promise: Promise, isSystemInterruption: Boolean) {
         if (_isRecording.get() && !isPaused.get()) {
             audioRecord?.stop()
             compressedRecorder?.pause()
             
             lastPauseTime = System.currentTimeMillis()
             isPaused.set(true)
+            pausedBySystemInterruption.set(isSystemInterruption)
 
             if (recordingConfig.showNotification) {
                 notificationManager.pauseUpdates()
@@ -1417,17 +1436,7 @@ class AudioRecorderManager(
                        "audioManager.mode=${audioManager.mode}, " +
                        "audioManager.isBluetoothScoOn=${audioManager.isBluetoothScoOn}")
             
-            // Trust phone state more than audio manager state
-            if (callState == TelephonyManager.CALL_STATE_RINGING || 
-                callState == TelephonyManager.CALL_STATE_OFFHOOK) {
-                return true
-            }
-            
-            // Only check audio manager mode as secondary indicator
-            return audioManager.mode == AudioManager.MODE_IN_CALL || 
-                   audioManager.mode == AudioManager.MODE_IN_COMMUNICATION
-            
-            // Remove audioManager.isBluetoothScoOn check as it can be erroneously true after disconnection
+            return AndroidCallState.isOngoingCall(callState, audioManager.mode)
         } catch (e: Exception) {
             LogUtils.e(CLASS_NAME, "Error checking call state: ${e.message}")
             return false
@@ -1757,6 +1766,7 @@ class AudioRecorderManager(
                 
                 _isRecording.set(false)
                 isPaused.set(false)
+                pausedBySystemInterruption.set(false)
                 isPrepared = false  // Reset prepared state
                 
                 if (::recordingConfig.isInitialized && recordingConfig.showNotification) {
@@ -1919,9 +1929,8 @@ class AudioRecorderManager(
                 AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
                     if (_isRecording.get() && !isPaused.get()) {
                         mainHandler.post {
-                            pauseRecording(object : Promise {
+                            pauseRecordingForSystemInterruption(object : Promise {
                                 override fun resolve(value: Any?) {
-                                    isPaused.set(true)
                                     eventSender.sendExpoEvent(Constants.RECORDING_INTERRUPTED_EVENT_NAME, bundleOf(
                                         "reason" to "audioFocusLoss",
                                         "isPaused" to true
@@ -1936,7 +1945,12 @@ class AudioRecorderManager(
                 }
                 AudioManager.AUDIOFOCUS_GAIN -> {
                     val autoResume = if (::recordingConfig.isInitialized) recordingConfig.autoResumeAfterInterruption else false
-                    if (_isRecording.get() && isPaused.get() && autoResume) {
+                    if (InterruptionAutoResumePolicy.shouldAutoResume(
+                            autoResumeAfterInterruption = autoResume,
+                            isRecording = _isRecording.get(),
+                            isPaused = isPaused.get(),
+                            pausedBySystemInterruption = pausedBySystemInterruption.get()
+                        )) {
                         mainHandler.post {
                             resumeRecording(object : Promise {
                                 override fun resolve(value: Any?) {
@@ -1985,9 +1999,8 @@ class AudioRecorderManager(
                     // Only pause for permanent focus loss (like phone calls)
                     if (_isRecording.get() && !isPaused.get()) {
                         mainHandler.post {
-                            pauseRecording(object : Promise {
+                            pauseRecordingForSystemInterruption(object : Promise {
                                 override fun resolve(value: Any?) {
-                                    isPaused.set(true)
                                     eventSender.sendExpoEvent(Constants.RECORDING_INTERRUPTED_EVENT_NAME, bundleOf(
                                         "reason" to "audioFocusLoss",
                                         "isPaused" to true
@@ -2006,7 +2019,12 @@ class AudioRecorderManager(
                 }
                 AudioManager.AUDIOFOCUS_GAIN -> {
                     val autoResume = if (::recordingConfig.isInitialized) recordingConfig.autoResumeAfterInterruption else false
-                    if (_isRecording.get() && isPaused.get() && autoResume) {
+                    if (InterruptionAutoResumePolicy.shouldAutoResume(
+                            autoResumeAfterInterruption = autoResume,
+                            isRecording = _isRecording.get(),
+                            isPaused = isPaused.get(),
+                            pausedBySystemInterruption = pausedBySystemInterruption.get()
+                        )) {
                         mainHandler.post {
                             resumeRecording(object : Promise {
                                 override fun resolve(value: Any?) {
@@ -2168,4 +2186,38 @@ class AudioRecorderManager(
             return false
         }
     }
-}
+}
+
+internal object AndroidCallState {
+    /**
+     * Telephony call state wins when known. AudioManager mode is only a fallback
+     * for unknown state because some Android devices leave it stale after calls.
+     */
+    fun isOngoingCall(callState: Int?, audioMode: Int): Boolean {
+        return when (callState) {
+            TelephonyManager.CALL_STATE_RINGING,
+            TelephonyManager.CALL_STATE_OFFHOOK -> true
+            TelephonyManager.CALL_STATE_IDLE -> false
+            else -> audioMode == AudioManager.MODE_IN_CALL ||
+                audioMode == AudioManager.MODE_IN_COMMUNICATION
+        }
+    }
+}
+
+internal object InterruptionAutoResumePolicy {
+    /**
+     * Auto-resume is only allowed when the pause was caused by a system interruption.
+     * User-initiated pauses must stay paused even after phone/audio focus interruptions end.
+     */
+    fun shouldAutoResume(
+        autoResumeAfterInterruption: Boolean,
+        isRecording: Boolean,
+        isPaused: Boolean,
+        pausedBySystemInterruption: Boolean
+    ): Boolean {
+        return autoResumeAfterInterruption &&
+            isRecording &&
+            isPaused &&
+            pausedBySystemInterruption
+    }
+}

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

@@ -413,7 +413,7 @@ class AudioStudioModule : Module(), EventSender {
 
                     val progressListener = object : AudioTrimmer.ProgressListener {
                         override fun onProgress(progress: Float, bytesProcessed: Long, totalBytes: Long) {
-                            sendEvent(Constants.TRIM_PROGRESS_EVENT, mapOf(
+                            safeSendEvent(Constants.TRIM_PROGRESS_EVENT, mapOf(
                                 "progress" to progress,
                                 "bytesProcessed" to bytesProcessed,
                                 "totalBytes" to totalBytes
@@ -520,7 +520,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 +676,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 +749,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 +845,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, """
@@ -989,7 +1032,7 @@ class AudioStudioModule : Module(), EventSender {
                         }
                         
                         // Notify JS about the disconnection
-                        sendEvent(Constants.DEVICE_CHANGED_EVENT, bundleOf(
+                        safeSendEvent(Constants.DEVICE_CHANGED_EVENT, bundleOf(
                             "type" to "deviceDisconnected",
                             "deviceId" to deviceId
                         ))
@@ -1004,7 +1047,7 @@ class AudioStudioModule : Module(), EventSender {
         audioDeviceManager.onDeviceConnected = { deviceId ->
             LogUtils.d(CLASS_NAME, "📱 Device connected: $deviceId")
             // Notify JS about the connection
-            sendEvent(Constants.DEVICE_CHANGED_EVENT, bundleOf(
+            safeSendEvent(Constants.DEVICE_CHANGED_EVENT, bundleOf(
                 "type" to "deviceConnected",
                 "deviceId" to deviceId
             ))
@@ -1014,7 +1057,7 @@ class AudioStudioModule : Module(), EventSender {
         audioDeviceManager.onDeviceDisconnected = { deviceId ->
             LogUtils.d(CLASS_NAME, "📱 Device disconnected: $deviceId")
             // Notify JS about the disconnection
-            sendEvent(Constants.DEVICE_CHANGED_EVENT, bundleOf(
+            safeSendEvent(Constants.DEVICE_CHANGED_EVENT, bundleOf(
                 "type" to "deviceDisconnected",
                 "deviceId" to deviceId
             ))
@@ -1023,6 +1066,18 @@ class AudioStudioModule : Module(), EventSender {
         audioProcessor = AudioProcessor(filesDir)
     }
     
+    private fun safeSendEvent(eventName: String, params: Bundle) {
+        AndroidEventEmitter.safeSend(CLASS_NAME, eventName) {
+            sendEvent(eventName, params)
+        }
+    }
+
+    private fun safeSendEvent(eventName: String, params: Map<String, Any?>) {
+        AndroidEventEmitter.safeSend(CLASS_NAME, eventName) {
+            sendEvent(eventName, params)
+        }
+    }
+
     /**
      * Handles audio device disconnection based on the recording configuration
      */
@@ -1055,7 +1110,7 @@ class AudioStudioModule : Module(), EventSender {
                         
                         // Notify JS about fallback
                         LogUtils.d(CLASS_NAME, "📱 Sending deviceFallback event to JS")
-                        sendEvent(Constants.RECORDING_INTERRUPTED_EVENT_NAME, bundleOf(
+                        safeSendEvent(Constants.RECORDING_INTERRUPTED_EVENT_NAME, bundleOf(
                             "reason" to "deviceFallback",
                             "isPaused" to false,
                             "deviceId" to deviceId
@@ -1070,7 +1125,7 @@ class AudioStudioModule : Module(), EventSender {
                                 // Notify AudioRecorderManager to handle device change while paused
                                 audioRecorderManager.handleDeviceChange()
                                 
-                                sendEvent(Constants.RECORDING_INTERRUPTED_EVENT_NAME, bundleOf(
+                                safeSendEvent(Constants.RECORDING_INTERRUPTED_EVENT_NAME, bundleOf(
                                     "reason" to "deviceSwitchFailed",
                                     "isPaused" to true
                                 ))
@@ -1090,7 +1145,7 @@ class AudioStudioModule : Module(), EventSender {
                             // Notify AudioRecorderManager to handle device change while paused
                             audioRecorderManager.handleDeviceChange()
                             
-                            sendEvent(Constants.RECORDING_INTERRUPTED_EVENT_NAME, bundleOf(
+                            safeSendEvent(Constants.RECORDING_INTERRUPTED_EVENT_NAME, bundleOf(
                                 "reason" to "deviceDisconnected",
                                 "isPaused" to true
                             ))
@@ -1112,7 +1167,7 @@ class AudioStudioModule : Module(), EventSender {
                         // Notify AudioRecorderManager to handle device change while paused
                         audioRecorderManager.handleDeviceChange()
                         
-                        sendEvent(Constants.RECORDING_INTERRUPTED_EVENT_NAME, bundleOf(
+                        safeSendEvent(Constants.RECORDING_INTERRUPTED_EVENT_NAME, bundleOf(
                             "reason" to "deviceDisconnected",
                             "isPaused" to true
                         ))
@@ -1128,6 +1183,18 @@ class AudioStudioModule : Module(), EventSender {
 
     override fun sendExpoEvent(eventName: String, params: Bundle) {
         LogUtils.d(CLASS_NAME, "Sending event: $eventName")
-        this@AudioStudioModule.sendEvent(eventName, params)
+        safeSendEvent(eventName, params)
+    }
+}
+
+internal object AndroidEventEmitter {
+    fun safeSend(className: String, eventName: String, send: () -> Unit): Boolean {
+        return try {
+            send()
+            true
+        } catch (e: Exception) {
+            LogUtils.e(className, "Failed to send event $eventName: ${e.message}", e)
+            false
+        }
     }
 }