@iternio/react-native-auto-play 0.4.11 → 0.5.0

package/README.md

@@ -314,6 +314,32 @@ The library does **not** bundle any icon font — the consuming app must provide
 
    For cross-platform compatibility use **lowercase names with underscores only** (e.g. `material_symbols`).
 
+**or**
+
+1. use expo-font
+    ```js
+    [
+      'expo-font',
+      {
+        android: {
+          fonts: [
+            {
+              fontFamily: 'MaterialSymbols',
+              fontDefinitions: [
+                {
+                  path: './assets/fonts/material_symbols.ttf',
+                  weight: 800,
+                },
+              ],
+            },
+          ],
+        },
+        ios: ['./assets/fonts/material_symbols.ttf'],
+      },
+    ],
+    ```
+    For cross-platform compatibility use **lowercase names with underscores only** (e.g. `material_symbols`).
+
 2. Register the font and an optional glyph map at startup:
 
    ```ts

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridAutoPlay.kt

@@ -1,19 +1,11 @@
 package com.margelo.nitro.swe.iternio.reactnativeautoplay
 
-import android.content.pm.PackageManager
 import android.os.Build
-import androidx.core.content.ContextCompat
 import com.facebook.react.bridge.UiThreadUtil
-import com.facebook.react.modules.core.PermissionAwareActivity
-import com.facebook.react.modules.core.PermissionListener
-import com.margelo.nitro.NitroModules
-import com.margelo.nitro.core.ArrayBuffer
 import com.margelo.nitro.core.Promise
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.AndroidAutoTemplate
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.template.MessageTemplate
 import com.margelo.nitro.swe.iternio.reactnativeautoplay.utils.ThreadUtil
-import kotlinx.coroutines.suspendCancellableCoroutine
-import java.nio.ByteBuffer
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.CopyOnWriteArrayList
 import kotlin.coroutines.resume
@@ -255,84 +247,6 @@ class HybridAutoPlay : HybridAutoPlaySpec() {
         }
     }
 
-    override fun hasVoiceInputPermission(): Boolean {
-        val context = NitroModules.applicationContext ?: return false
-        return ContextCompat.checkSelfPermission(
-            context, android.Manifest.permission.RECORD_AUDIO
-        ) == PackageManager.PERMISSION_GRANTED
-    }
-
-    override fun requestVoiceInputPermission(): Promise<Boolean> {
-        return Promise.async {
-            if (hasVoiceInputPermission()) {
-                return@async true
-            }
-
-            val carContext = AndroidAutoSession.getRootContext()
-
-            if (carContext != null) {
-                suspendCancellableCoroutine {
-                    carContext.requestPermissions(listOf(android.Manifest.permission.RECORD_AUDIO)) { approved, _ ->
-                        it.resume(approved.contains(android.Manifest.permission.RECORD_AUDIO))
-                    }
-                }
-            } else {
-                val context = NitroModules.applicationContext ?: return@async false
-                val activity =
-                    context.currentActivity as? PermissionAwareActivity ?: return@async false
-                val code = (Math.random() * 10000).toInt()
-
-                suspendCancellableCoroutine {
-                    activity.requestPermissions(
-                        arrayOf(android.Manifest.permission.RECORD_AUDIO),
-                        code,
-                        PermissionListener { requestCode, _, grantResults ->
-                            if (requestCode != code) {
-                                return@PermissionListener false
-                            }
-
-                            val granted =
-                                grantResults.isNotEmpty() && grantResults.first() == PackageManager.PERMISSION_GRANTED
-
-                            it.resume(granted)
-
-                            return@PermissionListener true
-                        })
-                }
-            }
-        }
-    }
-
-    override fun startVoiceInput(
-        silenceThresholdMs: Double?, maxDurationMs: Double?, listeningText: String?
-    ): Promise<ArrayBuffer> {
-        return Promise.async {
-            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
-                throw UnsupportedOperationException("startVoiceInput requires at least API level ${Build.VERSION_CODES.O}")
-            }
-
-            val manager = VoiceInputManager(AndroidAutoSession.getRootContext())
-            voiceInputManager = manager
-
-            try {
-                val pcmBytes = manager.start(
-                    silenceThresholdMs = silenceThresholdMs?.toLong() ?: 1_500L,
-                    maxDurationMs = maxDurationMs?.toLong() ?: 10_000L,
-                )
-                val directBuffer =
-                    ByteBuffer.allocateDirect(pcmBytes.size).put(pcmBytes).rewind() as ByteBuffer
-                ArrayBuffer.wrap(directBuffer)
-            } finally {
-                voiceInputManager = null
-                manager.dispose()
-            }
-        }
-    }
-
-    override fun stopVoiceInput() {
-        voiceInputManager?.stop()
-    }
-
     companion object {
         const val TAG = "HybridAutoPlay"
 
@@ -343,9 +257,6 @@ class HybridAutoPlay : HybridAutoPlaySpec() {
 
         private val voiceInputListeners = CopyOnWriteArrayList<(Location?, String?) -> Unit>()
 
-        @Volatile
-        private var voiceInputManager: VoiceInputManager? = null
-
         private val safeAreaInsetsListeners =
             ConcurrentHashMap<String, CopyOnWriteArrayList<(SafeAreaInsets) -> Unit>>()
 

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridVoice.kt

@@ -0,0 +1,97 @@
+package com.margelo.nitro.swe.iternio.reactnativeautoplay
+
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.content.ContextCompat
+import com.facebook.react.modules.core.PermissionAwareActivity
+import com.facebook.react.modules.core.PermissionListener
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlin.coroutines.resume
+
+class HybridVoice : HybridVoiceSpec() {
+    @Volatile
+    private var voiceInputManager: VoiceInputManager? = null
+
+    override fun hasVoiceInputPermission(): Boolean {
+        return VoiceInputManager.hasVoiceInputPermission()
+    }
+
+    override fun requestVoiceInputPermission(): Promise<Boolean> {
+        return Promise.async {
+            if (hasVoiceInputPermission()) {
+                return@async true
+            }
+
+            val carContext = AndroidAutoSession.getRootContext()
+
+            if (carContext != null) {
+                suspendCancellableCoroutine { cont ->
+                    carContext.requestPermissions(
+                        listOf(android.Manifest.permission.RECORD_AUDIO)
+                    ) { approved, _ ->
+                        cont.resume(approved.contains(android.Manifest.permission.RECORD_AUDIO))
+                    }
+                }
+            } else {
+                val context = NitroModules.applicationContext ?: return@async false
+                val activity =
+                    context.currentActivity as? PermissionAwareActivity ?: return@async false
+                val code = (Math.random() * 10000).toInt()
+
+                suspendCancellableCoroutine { cont ->
+                    activity.requestPermissions(
+                        arrayOf(android.Manifest.permission.RECORD_AUDIO),
+                        code,
+                        PermissionListener { requestCode, _, grantResults ->
+                            if (requestCode != code) {
+                                return@PermissionListener false
+                            }
+                            cont.resume(
+                                grantResults.isNotEmpty() &&
+                                    grantResults.first() == PackageManager.PERMISSION_GRANTED
+                            )
+                            true
+                        }
+                    )
+                }
+            }
+        }
+    }
+
+    override fun startVoiceInput(
+        silenceThresholdMs: Double?,
+        maxDurationMs: Double?,
+        listeningText: String?,
+        preferSpeechToText: Boolean?,
+        onChunk: ((chunk: VoiceInputChunk) -> Unit)?,
+        language: String?
+    ): Promise<VoiceInputResult> {
+        return Promise.async {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+                throw UnsupportedOperationException("startVoiceInput requires at least API level ${Build.VERSION_CODES.O}")
+            }
+
+            val manager = VoiceInputManager(AndroidAutoSession.getRootContext())
+            voiceInputManager = manager
+
+            try {
+                manager.start(
+                    silenceThresholdMs = silenceThresholdMs?.toLong() ?: 1_500L,
+                    maxDurationMs = maxDurationMs?.toLong() ?: 10_000L,
+                    preferSpeechToText = preferSpeechToText ?: false,
+                    onChunk = onChunk,
+                    language = language
+                )
+            } finally {
+                voiceInputManager = null
+                manager.dispose()
+            }
+        }
+    }
+
+    override fun stopVoiceInput() {
+        voiceInputManager?.stop()
+    }
+}

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/VoiceInputManager.kt

@@ -1,5 +1,9 @@
 package com.margelo.nitro.swe.iternio.reactnativeautoplay
 
+import android.Manifest
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.Intent
 import android.content.pm.PackageManager
 import android.media.AudioAttributes
 import android.media.AudioFocusRequest
@@ -8,18 +12,28 @@ import android.media.AudioManager
 import android.media.AudioRecord
 import android.media.MediaRecorder
 import android.os.Build
+import android.os.Bundle
+import android.os.ParcelFileDescriptor
+import android.speech.RecognitionListener
+import android.speech.RecognizerIntent
+import android.speech.SpeechRecognizer
 import androidx.annotation.RequiresApi
 import androidx.car.app.CarContext
 import androidx.car.app.media.CarAudioRecord
 import androidx.core.content.ContextCompat
+import com.facebook.react.bridge.UiThreadUtil
 import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.ArrayBuffer
+import com.margelo.nitro.swe.iternio.reactnativeautoplay.utils.ThreadUtil
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
+import kotlinx.coroutines.async
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.suspendCancellableCoroutine
 import java.io.ByteArrayOutputStream
+import java.nio.ByteBuffer
 import kotlin.coroutines.Continuation
 import kotlin.coroutines.resume
 import kotlin.coroutines.resumeWithException
@@ -27,43 +41,280 @@ import kotlin.math.abs
 
 /**
  * Captures 16-bit PCM audio (16 kHz, mono).
- * When [carContext] is provided uses CarAudioRecord (Android Auto/Automotive).
- * When [carContext] is null falls back to standard AudioRecord (phone-only).
+ * When [carContext] is provided uses CarAudioRecord (Android Auto/Automotive),
+ * otherwise falls back to standard AudioRecord.
+ *
+ * When preferSpeechToText is true and SpeechRecognizer is available, it owns
+ * the microphone and streams partial results; the PCM path is not used.
+ * When SpeechRecognizer is unavailable the manager falls back to PCM recording.
  */
 class VoiceInputManager(
     private val carContext: CarContext?,
 ) {
+    // PCM recording state
     private var carAudioRecord: CarAudioRecord? = null
     private var audioRecord: AudioRecord? = null
     private var audioFocusRequest: AudioFocusRequest? = null
     private var recordingJob: Job? = null
-    private var continuation: Continuation<ByteArray>? = null
+    private var pcmContinuation: Continuation<ByteArray>? = null
     private val scope = CoroutineScope(Dispatchers.IO)
 
     @Volatile
     private var isRecording = false
 
-    /**
-     * Acquires audio focus, starts recording, and suspends until stopped.
-     * Stops automatically after [silenceThresholdMs] of silence or [maxDurationMs] total.
-     * Returns the complete raw PCM buffer (Int16 LE, 16 kHz, mono).
-     */
+    // STT state — only set when SpeechRecognizer owns the mic
+    @Volatile
+    private var activeSpeechRecognizer: SpeechRecognizer? = null
+
     @RequiresApi(Build.VERSION_CODES.O)
     suspend fun start(
         silenceThresholdMs: Long = 1_500,
         maxDurationMs: Long = 10_000,
+        preferSpeechToText: Boolean = false,
+        onChunk: ((chunk: VoiceInputChunk) -> Unit)? = null,
+        language: String? = null
+    ): VoiceInputResult {
+        if (preferSpeechToText) {
+            val context = NitroModules.applicationContext ?: throw IllegalArgumentException()
+            if (SpeechRecognizer.isRecognitionAvailable(context)) {
+                if (carContext != null) {
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                        return startSTTFromCarAudio(silenceThresholdMs, maxDurationMs, onChunk, language)
+                    }
+                    // Car connected but API < 33: EXTRA_AUDIO_SOURCE unavailable, fall back to PCM
+                    return startPCM(silenceThresholdMs, maxDurationMs, onChunk)
+                }
+                return ThreadUtil.postOnUiAndAwait { startSTT(context, onChunk, language) }.getOrThrow()
+            }
+        }
+        return startPCM(silenceThresholdMs, maxDurationMs, onChunk)
+    }
+
+    // MARK: - STT path (SpeechRecognizer owns the mic)
+
+    private suspend fun startSTT(
+        context: Context,
+        onChunk: ((chunk: VoiceInputChunk) -> Unit)?,
+        language: String?
+    ): VoiceInputResult = suspendCancellableCoroutine { cont ->
+        val recognizer = SpeechRecognizer.createSpeechRecognizer(context)
+        activeSpeechRecognizer = recognizer
+
+        recognizer.setRecognitionListener(object : RecognitionListener {
+            override fun onResults(results: Bundle?) {
+                activeSpeechRecognizer = null
+                recognizer.destroy()
+                val text =
+                    results?.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION)?.firstOrNull()
+                cont.resume(VoiceInputResult(transcription = text, audio = null))
+            }
+
+            override fun onError(error: Int) {
+                activeSpeechRecognizer = null
+                recognizer.destroy()
+                cont.resumeWithException(RuntimeException("SpeechRecognizer error $error"))
+            }
+
+            override fun onPartialResults(partialResults: Bundle?) {
+                val text = partialResults?.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION)
+                    ?.firstOrNull()
+                if (!text.isNullOrEmpty()) {
+                    onChunk?.invoke(VoiceInputChunk(partial = text, audio = null))
+                }
+            }
+
+            override fun onReadyForSpeech(params: Bundle?) {}
+            override fun onBeginningOfSpeech() {}
+            override fun onRmsChanged(rmsdB: Float) {}
+            override fun onBufferReceived(buffer: ByteArray?) {}
+            override fun onEndOfSpeech() {}
+            override fun onEvent(eventType: Int, params: Bundle?) {}
+        })
+
+        val intent = Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH).apply {
+            putExtra(
+                RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM
+            )
+            putExtra(RecognizerIntent.EXTRA_PARTIAL_RESULTS, true)
+            putExtra(RecognizerIntent.EXTRA_MAX_RESULTS, 1)
+            language?.let {
+                putExtra(RecognizerIntent.EXTRA_LANGUAGE, it)
+            }
+        }
+
+        recognizer.startListening(intent)
+
+        cont.invokeOnCancellation {
+            activeSpeechRecognizer = null
+            recognizer.destroy()
+        }
+    }
+
+    // MARK: - STT path fed from CarAudioRecord via a pipe (API 33+)
+    @SuppressLint("MissingPermission")
+    @RequiresApi(Build.VERSION_CODES.TIRAMISU)
+    private suspend fun startSTTFromCarAudio(
+        silenceThresholdMs: Long,
+        maxDurationMs: Long,
+        onChunk: ((chunk: VoiceInputChunk) -> Unit)?,
+        language: String?
+    ): VoiceInputResult {
+        if (!hasVoiceInputPermission()) {
+            throw SecurityException("RECORD_AUDIO permission not granted")
+        }
+
+        val appContext = NitroModules.applicationContext ?: throw IllegalArgumentException()
+        val pipes = ParcelFileDescriptor.createPipe()
+        val readFd = pipes[0]
+        val pipeOut = ParcelFileDescriptor.AutoCloseOutputStream(pipes[1])
+
+        val sttDeferred = scope.async {
+            ThreadUtil.postOnUiAndAwait {
+                startSTTWithSource(appContext, readFd, silenceThresholdMs, onChunk, language)
+            }.getOrThrow()
+        }
+
+        var pcmBytes: ByteArray
+        try {
+            pcmBytes = recordPCM(silenceThresholdMs, maxDurationMs) { chunk ->
+                chunk.audio?.let { ab ->
+                    try {
+                        pipeOut.write(ab.toByteArray())
+                    } catch (_: Exception) {
+                        isRecording = false
+                    }
+                }
+            }
+        } finally {
+            try {
+                pipeOut.close()
+            } catch (_: Exception) {
+            }
+            try {
+                readFd.close()
+            } catch (_: Exception) {
+            }
+        }
+
+        return try {
+            sttDeferred.await()
+        } catch (_: Exception) {
+            val directBuffer = ByteBuffer.allocateDirect(pcmBytes.size).put(pcmBytes).rewind() as ByteBuffer
+            VoiceInputResult(transcription = null, audio = ArrayBuffer.wrap(directBuffer))
+        }
+    }
+
+    @RequiresApi(Build.VERSION_CODES.TIRAMISU)
+    private suspend fun startSTTWithSource(
+        context: Context,
+        audioSource: ParcelFileDescriptor,
+        silenceThresholdMs: Long,
+        onChunk: ((chunk: VoiceInputChunk) -> Unit)?,
+        language: String?
+    ): VoiceInputResult = suspendCancellableCoroutine { cont ->
+        val recognizer = SpeechRecognizer.createSpeechRecognizer(context)
+        activeSpeechRecognizer = recognizer
+        // When EXTRA_AUDIO_SOURCE is used, onResults always returns an empty list — the actual
+        // transcription only arrives via onPartialResults. Track the last partial here.
+        var lastPartial: String? = null
+
+        recognizer.setRecognitionListener(object : RecognitionListener {
+            override fun onResults(results: Bundle?) {
+                activeSpeechRecognizer = null
+                recognizer.destroy()
+                val text =
+                    results?.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION)?.firstOrNull()
+                        ?: lastPartial
+                cont.resume(VoiceInputResult(transcription = text, audio = null))
+            }
+
+            override fun onError(error: Int) {
+                activeSpeechRecognizer = null
+                recognizer.destroy()
+                cont.resumeWithException(RuntimeException("SpeechRecognizer error $error"))
+            }
+
+            override fun onPartialResults(partialResults: Bundle?) {
+                val text = partialResults?.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION)
+                    ?.firstOrNull()
+                if (!text.isNullOrEmpty()) {
+                    lastPartial = text
+                    onChunk?.invoke(VoiceInputChunk(partial = text, audio = null))
+                }
+            }
+
+            override fun onReadyForSpeech(params: Bundle?) {}
+            override fun onBeginningOfSpeech() {}
+            override fun onRmsChanged(rmsdB: Float) {}
+            override fun onBufferReceived(buffer: ByteArray?) {}
+            override fun onEndOfSpeech() {}
+            override fun onEvent(eventType: Int, params: Bundle?) {}
+        })
+
+        val intent = Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH).apply {
+            putExtra(
+                RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM
+            )
+            putExtra(RecognizerIntent.EXTRA_PARTIAL_RESULTS, true)
+            putExtra(RecognizerIntent.EXTRA_MAX_RESULTS, 1)
+            language?.let {
+                putExtra(RecognizerIntent.EXTRA_LANGUAGE, it)
+            }
+            putExtra(RecognizerIntent.EXTRA_AUDIO_SOURCE, audioSource)
+            putExtra(RecognizerIntent.EXTRA_AUDIO_SOURCE_CHANNEL_COUNT, 1)
+            putExtra(RecognizerIntent.EXTRA_AUDIO_SOURCE_ENCODING, AudioFormat.ENCODING_PCM_16BIT)
+            putExtra(RecognizerIntent.EXTRA_AUDIO_SOURCE_SAMPLING_RATE, SAMPLE_RATE)
+            putExtra(RecognizerIntent.EXTRA_SPEECH_INPUT_MINIMUM_LENGTH_MILLIS, WARMUP_MS)
+            putExtra(
+                RecognizerIntent.EXTRA_SPEECH_INPUT_COMPLETE_SILENCE_LENGTH_MILLIS,
+                silenceThresholdMs
+            )
+            putExtra(
+                RecognizerIntent.EXTRA_SPEECH_INPUT_POSSIBLY_COMPLETE_SILENCE_LENGTH_MILLIS,
+                silenceThresholdMs / 2,
+            )
+        }
+
+        recognizer.startListening(intent)
+
+        cont.invokeOnCancellation {
+            activeSpeechRecognizer = null
+            recognizer.destroy()
+        }
+    }
+
+    // MARK: - PCM path
+
+    @RequiresApi(Build.VERSION_CODES.O)
+    private suspend fun startPCM(
+        silenceThresholdMs: Long,
+        maxDurationMs: Long,
+        onChunk: ((chunk: VoiceInputChunk) -> Unit)?,
+    ): VoiceInputResult {
+        val pcmBytes = recordPCM(silenceThresholdMs, maxDurationMs, onChunk)
+        val directBuffer =
+            ByteBuffer.allocateDirect(pcmBytes.size).put(pcmBytes).rewind() as ByteBuffer
+        return VoiceInputResult(transcription = null, audio = ArrayBuffer.wrap(directBuffer))
+    }
+
+    @SuppressLint("MissingPermission")
+    @RequiresApi(Build.VERSION_CODES.O)
+    private suspend fun recordPCM(
+        silenceThresholdMs: Long,
+        maxDurationMs: Long,
+        onChunk: ((chunk: VoiceInputChunk) -> Unit)?,
     ): ByteArray = suspendCancellableCoroutine { cont ->
-        val appContext = NitroModules.applicationContext
-        if (appContext == null || ContextCompat.checkSelfPermission(
-                appContext,
-                android.Manifest.permission.RECORD_AUDIO,
-            ) != PackageManager.PERMISSION_GRANTED
-        ) {
+        if (!hasVoiceInputPermission()) {
             cont.resumeWithException(SecurityException("RECORD_AUDIO permission not granted"))
             return@suspendCancellableCoroutine
         }
 
-        continuation = cont
+        val appContext = NitroModules.applicationContext ?: run {
+            cont.resumeWithException(SecurityException("Missing application context"))
+            return@suspendCancellableCoroutine
+        }
+
+        pcmContinuation = cont
 
         val audioManager = appContext.getSystemService(AudioManager::class.java)
 
@@ -80,7 +331,7 @@ class VoiceInputManager(
                 }.build()
 
         if (audioManager.requestAudioFocus(focusRequest) != AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
-            continuation = null
+            pcmContinuation = null
             cont.resumeWithException(IllegalStateException("Audio focus request denied"))
             return@suspendCancellableCoroutine
         }
@@ -136,6 +387,13 @@ class VoiceInputManager(
                     if (read > 0) {
                         outputStream.write(buffer, 0, read)
 
+                        onChunk?.let { cb ->
+                            val chunk = ByteArray(read) { buffer[it] }
+                            val direct =
+                                ByteBuffer.allocateDirect(read).put(chunk).rewind() as ByteBuffer
+                            cb(VoiceInputChunk(partial = null, audio = ArrayBuffer.wrap(direct)))
+                        }
+
                         val now = System.currentTimeMillis()
                         val elapsedMs = now - recordingStart
 
@@ -151,7 +409,9 @@ class VoiceInputManager(
                                 val sample =
                                     (buffer[i].toInt() and 0xFF) or (buffer[i + 1].toInt() shl 8)
                                 val absSample = abs(sample.toShort().toInt())
-                                if (absSample > peak) peak = absSample
+                                if (absSample > peak) {
+                                    peak = absSample
+                                }
                                 i += 2
                             }
 
@@ -170,14 +430,21 @@ class VoiceInputManager(
                 }
             } finally {
                 releaseResources()
-                val capturedContinuation = continuation
-                continuation = null
-                capturedContinuation?.resume(outputStream.toByteArray())
+                val captured = pcmContinuation
+                pcmContinuation = null
+                captured?.resume(outputStream.toByteArray())
             }
         }
     }
 
     fun stop() {
+        // STT path: stopListening() triggers onResults/onError which resolves the continuation
+        activeSpeechRecognizer?.let { recognizer ->
+            UiThreadUtil.runOnUiThread {
+                recognizer.stopListening()
+            }
+        }
+        // PCM path and car-audio STT pump
         isRecording = false
         carAudioRecord?.stopRecording()
         audioRecord?.stop()
@@ -210,5 +477,12 @@ class VoiceInputManager(
         private const val WARMUP_MS = 500L
         private const val SAMPLE_RATE = 16_000
         private const val PHONE_BUFFER_SIZE = 3_200 // ~100ms at 16kHz/16-bit/mono
+
+        fun hasVoiceInputPermission(): Boolean {
+            val context = NitroModules.applicationContext ?: return false
+            return ContextCompat.checkSelfPermission(
+                context, Manifest.permission.RECORD_AUDIO
+            ) == PackageManager.PERMISSION_GRANTED
+        }
     }
 }

package/android/src/main/java/com/margelo/nitro/swe/iternio/reactnativeautoplay/utils/ThreadUtil.kt

@@ -1,19 +1,12 @@
 package com.margelo.nitro.swe.iternio.reactnativeautoplay.utils
 
-import com.facebook.react.bridge.UiThreadUtil
-import kotlinx.coroutines.suspendCancellableCoroutine
-import kotlin.coroutines.resume
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
 
 object ThreadUtil {
-    suspend fun <T> postOnUiAndAwait(block: () -> T): Result<T> =
-        suspendCancellableCoroutine { cont ->
-            UiThreadUtil.runOnUiThread {
-                try {
-                    val result = block()
-                    cont.resume(Result.success(result))
-                } catch (e: Exception) {
-                    cont.resume(Result.failure(e))
-                }
-            }
+    suspend fun <T> postOnUiAndAwait(block: suspend () -> T): Result<T> = runCatching {
+        withContext(Dispatchers.Main) {
+            block()
         }
+    }
 }