Fix: guard double-resume in AudioPlaybackManager playPcmData (#453)

* fix: guard double-resume in AudioPlaybackManager playPcmData

* fix: make audioTrack volatile for cross-thread visibility

* fix: fix AudioPlaybackManager bit depth rejection and stop() completion path

* fix: address AudioPlaybackManager race condition and malformed WAV header loop

Author: TamKungZ

sdk/runanywhere-kotlin/src/androidMain/kotlin/com/runanywhere/sdk/features/tts/AudioPlaybackManager.kt

@@ -7,20 +7,27 @@ import com.runanywhere.sdk.foundation.SDKLogger
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlinx.coroutines.withContext
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicInteger
 import kotlin.coroutines.resume
 import kotlin.coroutines.resumeWithException
 
 /**
  * Manages audio playback for TTS services on Android.
- * Plays WAV audio data (16-bit PCM format) generated by TTS synthesis.
+ * Plays WAV audio data (8-bit or 16-bit PCM format) generated by TTS synthesis.
  *
  * Matches iOS AudioPlaybackManager behavior.
  */
 class AudioPlaybackManager {
     private val logger = SDKLogger.tts
+    private val playbackIdGenerator = AtomicInteger(0)
 
+    @Volatile
     private var audioTrack: AudioTrack? = null
 
+    @Volatile
+    private var interruptPlayback: (() -> Unit)? = null
+
     @Volatile
     var isPlaying: Boolean = false
         private set
@@ -36,72 +43,90 @@ class AudioPlaybackManager {
             throw AudioPlaybackException.EmptyAudioData
         }
 
+        val playbackId = playbackIdGenerator.incrementAndGet()
+        logger.debug("[playbackId=$playbackId] play() start: totalBytes=${audioData.size}")
+
         withContext(Dispatchers.IO) {
             try {
-                // Parse WAV header to get audio parameters
                 val wavInfo = parseWavHeader(audioData)
-                logger.info("Playing audio: ${audioData.size} bytes, ${wavInfo.sampleRate}Hz, ${wavInfo.channels}ch")
+                logger.info("[playbackId=$playbackId] Playing audio: ${audioData.size} bytes, ${wavInfo.sampleRate}Hz, ${wavInfo.channels}ch, ${wavInfo.bitsPerSample}bit")
 
-                // Get PCM data (skip WAV header)
                 val pcmData = audioData.copyOfRange(wavInfo.dataOffset, audioData.size)
 
-                playPcmData(pcmData, wavInfo.sampleRate, wavInfo.channels, wavInfo.bitsPerSample)
+                playPcmData(playbackId, pcmData, wavInfo.sampleRate, wavInfo.channels, wavInfo.bitsPerSample)
 
-                logger.info("Playback completed")
+                logger.info("[playbackId=$playbackId] play() completed")
             } catch (e: Exception) {
-                logger.error("Playback failed: ${e.message}")
+                logger.error("[playbackId=$playbackId] play() failed: ${e.message}")
                 throw if (e is AudioPlaybackException) e else AudioPlaybackException.PlaybackFailed(e.message)
             }
         }
     }
 
     /**
-     * Stop current playback.
+     * Stop current playback. If play() is suspended, it will resume with PlaybackInterrupted.
      */
     fun stop() {
-        if (!isPlaying) return
-
-        try {
-            audioTrack?.stop()
-            audioTrack?.release()
-            audioTrack = null
-        } catch (e: Exception) {
-            logger.error("Error stopping playback: ${e.message}")
-        }
-
-        isPlaying = false
-        logger.info("Playback stopped")
+        logger.debug("stop() called: isPlaying=$isPlaying, hasTrack=${audioTrack != null}")
+        interruptPlayback?.invoke()
     }
 
     private suspend fun playPcmData(
+        playbackId: Int,
         pcmData: ByteArray,
         sampleRate: Int,
         channels: Int,
         bitsPerSample: Int,
     ) = suspendCancellableCoroutine { continuation ->
+        val resumed = AtomicBoolean(false)
+
+        fun cleanup(track: AudioTrack?) {
+            isPlaying = false
+            try { track?.stop() } catch (_: Exception) {}
+            try { track?.release() } catch (_: Exception) {}
+            if (audioTrack === track) audioTrack = null
+            interruptPlayback = null
+        }
+
+        fun succeed(track: AudioTrack?) {
+            val casWon = resumed.compareAndSet(false, true)
+            logger.debug("[playbackId=$playbackId] completion path=success casWon=$casWon")
+            if (casWon) {
+                cleanup(track)
+                continuation.resume(Unit)
+            }
+        }
+
+        fun fail(track: AudioTrack?, throwable: Throwable) {
+            val casWon = resumed.compareAndSet(false, true)
+            logger.debug("[playbackId=$playbackId] completion path=${throwable::class.simpleName} casWon=$casWon")
+            if (casWon) {
+                cleanup(track)
+                continuation.resumeWithException(throwable)
+            }
+        }
+
         try {
+            logger.debug("[playbackId=$playbackId] playPcmData() enter: pcmBytes=${pcmData.size}, sampleRate=$sampleRate, channels=$channels, bitsPerSample=$bitsPerSample")
+
             val channelConfig =
-                if (channels == 1) {
-                    AudioFormat.CHANNEL_OUT_MONO
-                } else {
-                    AudioFormat.CHANNEL_OUT_STEREO
-                }
+                if (channels == 1) AudioFormat.CHANNEL_OUT_MONO else AudioFormat.CHANNEL_OUT_STEREO
 
             val audioFormat =
-                if (bitsPerSample == 16) {
-                    AudioFormat.ENCODING_PCM_16BIT
-                } else {
-                    AudioFormat.ENCODING_PCM_8BIT
+                when (bitsPerSample) {
+                    8 -> AudioFormat.ENCODING_PCM_8BIT
+                    16 -> AudioFormat.ENCODING_PCM_16BIT
+                    else -> {
+                        logger.debug("[playbackId=$playbackId] completion path=unsupported_bit_depth bitsPerSample=$bitsPerSample")
+                        continuation.resumeWithException(AudioPlaybackException.InvalidAudioFormat)
+                        return@suspendCancellableCoroutine
+                    }
                 }
 
-            val minBufferSize =
-                AudioTrack.getMinBufferSize(
-                    sampleRate,
-                    channelConfig,
-                    audioFormat,
-                )
+            val minBufferSize = AudioTrack.getMinBufferSize(sampleRate, channelConfig, audioFormat)
 
             if (minBufferSize == AudioTrack.ERROR || minBufferSize == AudioTrack.ERROR_BAD_VALUE) {
+                logger.warn("[playbackId=$playbackId] Invalid minBufferSize=$minBufferSize")
                 continuation.resumeWithException(AudioPlaybackException.InvalidAudioFormat)
                 return@suspendCancellableCoroutine
             }
@@ -128,70 +153,57 @@ class AudioPlaybackManager {
                     .setTransferMode(AudioTrack.MODE_STATIC)
                     .build()
 
+            interruptPlayback = { fail(track, AudioPlaybackException.PlaybackInterrupted) }
             audioTrack = track
             isPlaying = true
 
-            // Write all data
             val bytesWritten = track.write(pcmData, 0, pcmData.size)
             if (bytesWritten < 0) {
-                track.release()
-                audioTrack = null
-                isPlaying = false
-                continuation.resumeWithException(AudioPlaybackException.PlaybackFailed("Write failed: $bytesWritten"))
+                logger.debug("[playbackId=$playbackId] completion path=write_error bytesWritten=$bytesWritten")
+                fail(track, AudioPlaybackException.PlaybackFailed("Write failed: $bytesWritten"))
+                return@suspendCancellableCoroutine
+            }
+
+            val bytesPerSample = bitsPerSample / 8
+            val frameSize = bytesPerSample * channels
+            if (frameSize <= 0 || bytesWritten % frameSize != 0) {
+                logger.debug("[playbackId=$playbackId] completion path=invalid_frame frameSize=$frameSize bytesWritten=$bytesWritten")
+                fail(track, AudioPlaybackException.InvalidAudioFormat)
                 return@suspendCancellableCoroutine
             }
 
-            // Set notification marker at end
-            track.notificationMarkerPosition = pcmData.size / (bitsPerSample / 8 * channels)
+            track.notificationMarkerPosition = bytesWritten / frameSize
             track.setPlaybackPositionUpdateListener(
                 object : AudioTrack.OnPlaybackPositionUpdateListener {
                     override fun onMarkerReached(track: AudioTrack?) {
-                        isPlaying = false
-                        track?.stop()
-                        track?.release()
-                        audioTrack = null
-                        continuation.resume(Unit)
+                        succeed(track)
                     }
 
                     override fun onPeriodicNotification(track: AudioTrack?) {
-                        // Not used
                     }
                 },
             )
 
-            // Handle cancellation
             continuation.invokeOnCancellation {
-                stop()
+                fail(track, AudioPlaybackException.PlaybackInterrupted)
             }
 
-            // Start playback
+            logger.debug("[playbackId=$playbackId] track.play()")
             track.play()
         } catch (e: Exception) {
-            isPlaying = false
-            audioTrack?.release()
-            audioTrack = null
-            continuation.resumeWithException(e)
+            fail(audioTrack, e)
         }
     }
 
     private fun parseWavHeader(data: ByteArray): WavInfo {
-        if (data.size < 44) {
-            throw AudioPlaybackException.InvalidAudioFormat
-        }
+        if (data.size < 44) throw AudioPlaybackException.InvalidAudioFormat
 
-        // Check RIFF header
         val riff = String(data.copyOfRange(0, 4))
-        if (riff != "RIFF") {
-            throw AudioPlaybackException.InvalidAudioFormat
-        }
+        if (riff != "RIFF") throw AudioPlaybackException.InvalidAudioFormat
 
-        // Check WAVE format
         val wave = String(data.copyOfRange(8, 12))
-        if (wave != "WAVE") {
-            throw AudioPlaybackException.InvalidAudioFormat
-        }
+        if (wave != "WAVE") throw AudioPlaybackException.InvalidAudioFormat
 
-        // Parse fmt chunk
         val channels = (data[22].toInt() and 0xFF) or ((data[23].toInt() and 0xFF) shl 8)
         val sampleRate =
             (data[24].toInt() and 0xFF) or
@@ -200,7 +212,10 @@ class AudioPlaybackManager {
                 ((data[27].toInt() and 0xFF) shl 24)
         val bitsPerSample = (data[34].toInt() and 0xFF) or ((data[35].toInt() and 0xFF) shl 8)
 
-        // Find data chunk (usually at offset 44 but can vary)
+        if (channels !in 1..2) throw AudioPlaybackException.InvalidAudioFormat
+        if (sampleRate <= 0) throw AudioPlaybackException.InvalidAudioFormat
+        if (bitsPerSample !in setOf(8, 16)) throw AudioPlaybackException.InvalidAudioFormat
+
         var dataOffset = 12
         while (dataOffset < data.size - 8) {
             val chunkId = String(data.copyOfRange(dataOffset, dataOffset + 4))
@@ -211,13 +226,21 @@ class AudioPlaybackManager {
                     ((data[dataOffset + 7].toInt() and 0xFF) shl 24)
 
             if (chunkId == "data") {
-                dataOffset += 8 // Skip chunk header
+                dataOffset += 8
                 break
             }
 
-            dataOffset += 8 + chunkSize
+            if (chunkSize < 0) throw AudioPlaybackException.InvalidAudioFormat
+            val paddedChunkSize = chunkSize + (chunkSize and 1)
+            val nextOffset = dataOffset.toLong() + 8L + paddedChunkSize.toLong()
+            if (nextOffset <= dataOffset.toLong() || nextOffset > data.size.toLong()) {
+                throw AudioPlaybackException.InvalidAudioFormat
+            }
+            dataOffset = nextOffset.toInt()
         }
 
+        if (dataOffset >= data.size) throw AudioPlaybackException.InvalidAudioFormat
+
         return WavInfo(
             sampleRate = sampleRate,
             channels = channels,
@@ -262,4 +285,4 @@ sealed class AudioPlaybackException : Exception() {
 
         override val message: String = "Invalid audio format"
     }
-}
+}