add flushAudio

Author: truemagic-coder

README.md

@@ -172,6 +172,37 @@ subscription?.remove();
 playbackSubscription?.remove();
 ```
 
+### Stopping Audio Playback
+
+```typescript
+import { ExpoStreamer } from 'expo-streamer';
+
+// Graceful stop - allows buffered audio to finish
+await ExpoStreamer.stopAudio();
+
+// Immediate flush - clears buffer and stops mid-stream
+await ExpoStreamer.flushAudio();
+```
+
+**When to use `stopAudio()` vs `flushAudio()`:**
+
+- **`stopAudio()`**: Use when you want to gracefully stop playback, allowing any buffered audio to finish playing. Good for natural conversation endings.
+  
+- **`flushAudio()`**: Use when you need to immediately stop all audio output, such as when the user interrupts or cancels playback. This clears all scheduled audio buffers without waiting for them to drain.
+
+```typescript
+// Example: User interruption handling
+async function handleUserInterrupt() {
+  // Immediately stop all audio
+  await ExpoStreamer.flushAudio();
+  
+  // Clear the turn queue
+  await ExpoStreamer.clearSoundQueueByTurnId(currentTurnId);
+  
+  console.log('Audio interrupted and flushed');
+}
+```
+
 ## 📋 API Reference
 
 ### Core Types
@@ -243,6 +274,7 @@ const EncodingTypes = {
 | `playAudio(data: string, turnId: string, encoding?: Encoding)` | `Promise<void>` | Play base64 audio data |
 | `pauseAudio()` | `Promise<void>` | Pause current playback |
 | `stopAudio()` | `Promise<void>` | Stop all audio playback |
+| `flushAudio()` | `Promise<void>` | Immediately flush audio buffer and stop mid-stream |
 | `clearPlaybackQueueByTurnId(turnId: string)` | `Promise<void>` | Clear queue for specific turn |
 
 ### Configuration Methods

android/src/main/java/expo/modules/audiostream/AudioPlaybackManager.kt

@@ -287,6 +287,66 @@ class AudioPlaybackManager(private val eventSender: EventSender? = null) {
         }
     }
 
+    fun flushAudio(promise: Promise? = null) {
+        Log.d("ExpoPlayStreamModule", "Flushing audio buffer")
+        isPlaying = false
+        coroutineScope.launch {
+            try {
+                // Immediately stop and flush audio track
+                Log.d("ExpoPlayStreamModule", "Flushing audioTrack")
+                if (::audioTrack.isInitialized && audioTrack.state != AudioTrack.STATE_UNINITIALIZED) {
+                    try {
+                        audioTrack.pause()
+                        audioTrack.flush()
+                        audioTrack.stop()
+                    } catch (e: Exception) {
+                        Log.e("ExpoPlayStreamModule", "Error flushing AudioTrack: ${e.message}", e)
+                    }
+                }
+                
+                // Cancel jobs immediately
+                if (currentPlaybackJob != null) {
+                    Log.d("ExpoPlayStreamModule", "Cancelling currentPlaybackJob")
+                    currentPlaybackJob?.cancelAndJoin()
+                    currentPlaybackJob = null
+                }
+
+                if (processingJob != null) {
+                    Log.d("ExpoPlayStreamModule", "Cancelling processingJob")
+                    processingJob?.cancelAndJoin()
+                    processingJob = null
+                }
+
+                // Clear all pending chunks
+                Log.d("ExpoPlayStreamModule", "Clearing all pending chunks")
+                for (chunk in playbackChannel) {
+                    if (!chunk.isPromiseSettled) {
+                        chunk.isPromiseSettled = true
+                        chunk.promise.resolve(null)
+                    }
+                }
+
+                // Close channels
+                if (!processingChannel.isClosedForSend) {
+                    processingChannel.close()
+                }
+                if (!playbackChannel.isClosedForSend) {
+                    playbackChannel.close()
+                }
+
+                // Reset state
+                hasSentSoundStartedEvent = false
+                segmentsLeftToPlay = 0
+
+                Log.d("ExpoPlayStreamModule", "Audio buffer flushed")
+                promise?.resolve(null)
+            } catch (e: Exception) {
+                Log.e("ExpoPlayStreamModule", "Error in flushAudio: ${e.message}", e)
+                promise?.reject("ERR_FLUSH_AUDIO", e.message, e)
+            }
+        }
+    }
+
     fun stopPlayback(promise: Promise? = null) {
         Log.d("ExpoPlayStreamModule", "Stopping playback")
         if (!isPlaying || playbackChannel.isEmpty ) {

android/src/main/java/expo/modules/audiostream/ExpoPlayAudioStreamModule.kt

@@ -179,6 +179,8 @@ class ExpoPlayAudioStreamModule : Module(), EventSender {
 
         AsyncFunction("stopAudio") { promise: Promise -> audioPlaybackManager.stopPlayback(promise) }
 
+        AsyncFunction("flushAudio") { promise: Promise -> audioPlaybackManager.flushAudio(promise) }
+
         AsyncFunction("clearAudioFiles") { promise: Promise ->
             audioRecorderManager.clearAudioStorage(promise)
         }

ios/ExpoPlayAudioStreamModule.swift

@@ -210,6 +210,14 @@ public class ExpoPlayAudioStreamModule: Module, AudioStreamManagerDelegate, Micr
             }
         }
 
+        AsyncFunction("flushAudio") { (promise: Promise) in
+            if case .success(let soundPlayer) = componentManager.getSoundPlayer() {
+                soundPlayer.flushAudio(promise)
+            } else {
+                promise.reject("SOUND_PLAYER_UNAVAILABLE", "Sound player is not available")
+            }
+        }
+        
         AsyncFunction("listAudioFiles") { (promise: Promise) in
             let result = listAudioFiles()
             promise.resolve(result)

ios/SoundPlayer.swift

@@ -371,6 +371,45 @@ class SoundPlayer: SoundPlayerManaging {
         promise.resolve(nil)
     }
 
+    /// Immediately flushes the audio buffer and stops playback mid-stream
+    /// - Parameter promise: Promise to resolve when flushed
+    func flushAudio(_ promise: Promise) {
+        Logger.debug("[SoundPlayer] Flushing Audio Buffer")
+        
+        // Thread-safe queue clearing
+        bufferAccessQueue.sync {
+            if !self.audioQueue.isEmpty {
+                Logger.debug("[SoundPlayer] Queue is not empty, clearing \(self.audioQueue.count) items")
+                self.audioQueue.removeAll()
+            }
+        }
+        
+        // Immediately stop the audio player node and reset it
+        if let playerNode = self.audioPlayerNode {
+            if playerNode.isPlaying {
+                Logger.debug("[SoundPlayer] Player is playing, stopping and resetting")
+                playerNode.stop()
+                // Reset the player node to clear any scheduled buffers
+                playerNode.reset()
+            }
+        }
+        
+        // Stop the engine and disable voice processing if in voice processing mode
+        if config.playbackMode == .voiceProcessing {
+            if let engine = self.audioEngine, engine.isRunning {
+                engine.stop()
+                try? self.disableVoiceProcessing()
+                self.isAudioEngineIsSetup = false
+            }
+        }
+        
+        self.segmentsLeftToPlay = 0
+        self.isPlaying = false
+        
+        Logger.debug("[SoundPlayer] Audio buffer flushed")
+        promise.resolve(nil)
+    }
+    
     /// Interrupts audio playback
     /// - Parameter promise: Promise to resolve when interrupted
     func interrupt(_ promise: Promise) {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-streamer",
-  "version": "1.0.7",
+  "version": "1.1.0",
   "description": "Realtime Audio Streaming for Expo",
   "main": "build/index.js",
   "types": "build/index.d.ts",

src/index.ts

@@ -199,6 +199,21 @@ export class ExpoPlayAudioStream {
     }
   }
 
+  /**
+   * Immediately flushes the audio buffer and stops playback mid-stream.
+   * Unlike stopAudio(), this method doesn't wait for the buffer to drain.
+   * @returns {Promise<void>}
+   * @throws {Error} If the audio buffer fails to flush.
+   */
+  static async flushAudio(): Promise<void> {
+    try {
+      return await ExpoPlayAudioStreamModule.flushAudio();
+    } catch (error) {
+      console.error(error);
+      throw new Error(`Failed to flush audio: ${error}`);
+    }
+  }
+
   /**
    * Clears the playback queue by turn ID.
    * @param {string} turnId - The turn ID.