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

package/README.md

@@ -314,32 +314,6 @@ 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,11 +1,19 @@
 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
@@ -247,6 +255,84 @@ 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"
 
@@ -257,6 +343,9 @@ 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/VoiceInputManager.kt

@@ -1,7 +1,5 @@
 package com.margelo.nitro.swe.iternio.reactnativeautoplay
 
-import android.annotation.SuppressLint
-import android.content.Intent
 import android.content.pm.PackageManager
 import android.media.AudioAttributes
 import android.media.AudioFocusRequest
@@ -10,28 +8,18 @@ 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
@@ -39,274 +27,43 @@ import kotlin.math.abs
 
 /**
  * Captures 16-bit PCM audio (16 kHz, mono).
- * 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.
+ * When [carContext] is provided uses CarAudioRecord (Android Auto/Automotive).
+ * When [carContext] is null falls back to standard AudioRecord (phone-only).
  */
 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 pcmContinuation: Continuation<ByteArray>? = null
+    private var continuation: Continuation<ByteArray>? = null
     private val scope = CoroutineScope(Dispatchers.IO)
 
     @Volatile
     private var isRecording = false
 
-    // STT state — only set when SpeechRecognizer owns the mic
-    @Volatile
-    private var activeSpeechRecognizer: SpeechRecognizer? = null
-
+    /**
+     * 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).
+     */
     @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: android.content.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()
-                // Return empty transcription — caller sees null audio and null transcription
-                cont.resume(VoiceInputResult(transcription = null, audio = null))
-            }
-
-            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()
-        }
-
-        try {
-            recordPCM(silenceThresholdMs, maxDurationMs) { chunk ->
-                chunk.audio?.let { ab ->
-                    try {
-                        pipeOut.write(ab.toByteArray())
-                    } catch (_: Exception) {
-                    }
-                }
-            }
-        } finally {
-            try {
-                pipeOut.close()
-            } catch (_: Exception) {
-            }
-            try {
-                readFd.close()
-            } catch (_: Exception) {
-            }
-        }
-
-        return sttDeferred.await()
-    }
-
-    @RequiresApi(Build.VERSION_CODES.TIRAMISU)
-    private suspend fun startSTTWithSource(
-        context: android.content.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.resume(VoiceInputResult(transcription = lastPartial, audio = null))
-            }
-
-            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 ->
-        if (!hasVoiceInputPermission()) {
+        val appContext = NitroModules.applicationContext
+        if (appContext == null || ContextCompat.checkSelfPermission(
+                appContext,
+                android.Manifest.permission.RECORD_AUDIO,
+            ) != PackageManager.PERMISSION_GRANTED
+        ) {
             cont.resumeWithException(SecurityException("RECORD_AUDIO permission not granted"))
             return@suspendCancellableCoroutine
         }
 
-        val appContext = NitroModules.applicationContext ?: run {
-            cont.resumeWithException(SecurityException("Missing application context"))
-            return@suspendCancellableCoroutine
-        }
-
-        pcmContinuation = cont
+        continuation = cont
 
         val audioManager = appContext.getSystemService(AudioManager::class.java)
 
@@ -323,7 +80,7 @@ class VoiceInputManager(
                 }.build()
 
         if (audioManager.requestAudioFocus(focusRequest) != AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
-            pcmContinuation = null
+            continuation = null
             cont.resumeWithException(IllegalStateException("Audio focus request denied"))
             return@suspendCancellableCoroutine
         }
@@ -379,13 +136,6 @@ 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
 
@@ -401,9 +151,7 @@ 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
                             }
 
@@ -422,21 +170,14 @@ class VoiceInputManager(
                 }
             } finally {
                 releaseResources()
-                val captured = pcmContinuation
-                pcmContinuation = null
-                captured?.resume(outputStream.toByteArray())
+                val capturedContinuation = continuation
+                continuation = null
+                capturedContinuation?.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()
@@ -469,12 +210,5 @@ 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, android.Manifest.permission.RECORD_AUDIO
-            ) == PackageManager.PERMISSION_GRANTED
-        }
     }
 }

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

@@ -1,12 +1,19 @@
 package com.margelo.nitro.swe.iternio.reactnativeautoplay.utils
 
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
+import com.facebook.react.bridge.UiThreadUtil
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlin.coroutines.resume
 
 object ThreadUtil {
-    suspend fun <T> postOnUiAndAwait(block: suspend () -> T): Result<T> = runCatching {
-        withContext(Dispatchers.Main) {
-            block()
+    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))
+                }
+            }
         }
-    }
 }

package/ios/hybrid/HybridAutoPlay.swift

@@ -21,7 +21,7 @@ class HybridAutoPlay: HybridAutoPlaySpec {
     private static var listeners = [EventName: [StateListener]]()
     private static var renderStateListeners = [String: [RenderStateListener]]()
     private static var safeAreaInsetsListeners = [String: [SafeAreaListener]]()
-
+    private static var voiceInputManager: VoiceInputManager?
 
     override init() {
         HybridAutoPlay.listeners.removeAll()
@@ -123,10 +123,55 @@ class HybridAutoPlay: HybridAutoPlaySpec {
     func addListenerVoiceInput(
         callback: @escaping (Location?, String?) -> Void
     ) throws -> () -> Void {
-        // iOS does not use the OS-triggered voice input path — use HybridVoice instead.
+        // iOS does not use the OS-triggered voice input path — use startVoiceInput() instead.
         return {}
     }
 
+    func hasVoiceInputPermission() throws -> Bool {
+        return AVAudioSession.sharedInstance().recordPermission == .granted
+    }
+
+    func requestVoiceInputPermission() throws -> Promise<Bool> {
+        return Promise.async {
+            return await withCheckedContinuation { cont in
+                AVAudioSession.sharedInstance().requestRecordPermission { granted in
+                    cont.resume(returning: granted)
+                }
+            }
+        }
+    }
+
+    func startVoiceInput(silenceThresholdMs: Double?, maxDurationMs: Double?, listeningText: String?) throws -> Promise<
+        ArrayBuffer
+    > {
+        return Promise.async {
+            let interfaceController = try? await RootModule.withInterfaceController { $0 }
+
+            let manager = VoiceInputManager()
+            HybridAutoPlay.voiceInputManager = manager
+
+            defer {
+                HybridAutoPlay.voiceInputManager = nil
+            }
+
+            let data = try await manager.start(
+                interfaceController: interfaceController,
+                silenceThresholdMs: silenceThresholdMs ?? 1_500,
+                maxDurationMs: maxDurationMs ?? 10_000,
+                listeningText: listeningText ?? "Listening..."
+            )
+
+            return try ArrayBuffer.copy(data: data)
+        }
+    }
+
+    func stopVoiceInput() throws {
+        Task { @MainActor in
+            let interfaceController = try? await RootModule.withInterfaceController { $0 }
+            HybridAutoPlay.voiceInputManager?.stop(interfaceController: interfaceController)
+        }
+    }
+
     // MARK: set/push/pop templates
     func setRootTemplate(templateId: String) throws -> Promise<Void> {
         return Promise.async {