@iternio/react-native-auto-play 0.4.5 → 0.4.6

package/ios/utils/VoiceInputManager.swift

@@ -1,47 +1,16 @@
 import AVFoundation
 import CarPlay
-import NitroModules
-import Speech
 
-/// Wraps CheckedContinuation so it can only be resumed once even when
-/// shared between a stop() call and an async recognition task callback.
-private final class ResultBox: @unchecked Sendable {
-    private var continuation: CheckedContinuation<VoiceInputResult, Error>?
-    private let lock = NSLock()
-
-    init(_ continuation: CheckedContinuation<VoiceInputResult, Error>) {
-        self.continuation = continuation
-    }
-
-    func resume(returning result: VoiceInputResult) {
-        lock.lock()
-        defer { lock.unlock() }
-        continuation?.resume(returning: result)
-        continuation = nil
-    }
-
-    func resume(throwing error: Error) {
-        lock.lock()
-        defer { lock.unlock() }
-        continuation?.resume(throwing: error)
-        continuation = nil
-    }
-}
-
-/// Captures audio from the car microphone and buffers raw 16 kHz / 16-bit / mono PCM,
-/// or transcribes it via SFSpeechRecognizer when preferSpeechToText is true.
+/// Captures audio from the car microphone and buffers raw 16 kHz / 16-bit / mono PCM.
+/// Recording stops automatically when silence is detected or the max duration is reached.
 class VoiceInputManager {
     private var audioEngine: AVAudioEngine?
     private var voiceControlTemplate: CPVoiceControlTemplate?
-    private var resultBox: ResultBox?
+    private var continuation: CheckedContinuation<[Int16], Error>?
     private var samples: [Int16] = []
     private var isStopping = false
     private let stopLock = NSLock()
 
-    // STT
-    private var recognitionRequest: SFSpeechAudioBufferRecognitionRequest?
-    private var isSTTMode = false
-
     // Timing
     private var recordingStart: Date?
     private var silenceStart: Date?
@@ -64,33 +33,30 @@ class VoiceInputManager {
         interfaceController: AutoPlayInterfaceController?,
         silenceThresholdMs: Double,
         maxDurationMs: Double,
-        listeningText: String,
-        preferSpeechToText: Bool,
-        onChunk: ((_ chunk: VoiceInputChunk) -> Void)?
-    ) async throws -> VoiceInputResult {
-        return try await withCheckedThrowingContinuation { cont in
-            let box = ResultBox(cont)
-            self.resultBox = box
+        listeningText: String
+    ) async throws -> Data {
+        let samples = try await withCheckedThrowingContinuation {
+            (cont: CheckedContinuation<[Int16], Error>) in
+            self.continuation = cont
             self.samples = []
             self.isStopping = false
-            self.isSTTMode = preferSpeechToText
 
             do {
                 try self.startCapture(
                     interfaceController: interfaceController,
                     silenceThresholdMs: silenceThresholdMs,
                     maxDurationMs: maxDurationMs,
-                    listeningText: listeningText,
-                    preferSpeechToText: preferSpeechToText,
-                    onChunk: onChunk,
-                    box: box
+                    listeningText: listeningText
                 )
             }
             catch {
-                self.cleanup(interfaceController: interfaceController)
-                box.resume(throwing: error)
+                self.stopCapture(interfaceController: interfaceController)
+                self.continuation = nil
+                cont.resume(throwing: error)
             }
         }
+
+        return samplesAsData(samples)
     }
 
     func stop(interfaceController: AutoPlayInterfaceController? = nil) {
@@ -100,22 +66,14 @@ class VoiceInputManager {
             return
         }
         isStopping = true
-        let wasSTTMode = isSTTMode
-        let box = resultBox
+        let capturedContinuation = continuation
         let capturedSamples = samples
-        resultBox = nil
+        continuation = nil
         samples = []
         stopLock.unlock()
 
-        if wasSTTMode {
-            // endAudio() causes the recognition task to fire its final result,
-            // which resumes the box. Engine teardown happens there too.
-            recognitionRequest?.endAudio()
-        }
-        else {
-            cleanup(interfaceController: interfaceController)
-            box?.resume(returning: makePCMResult(from: capturedSamples))
-        }
+        stopCapture(interfaceController: interfaceController)
+        capturedContinuation?.resume(returning: capturedSamples)
     }
 
     // MARK: - Private
@@ -124,15 +82,13 @@ class VoiceInputManager {
         interfaceController: AutoPlayInterfaceController?,
         silenceThresholdMs: Double,
         maxDurationMs: Double,
-        listeningText: String,
-        preferSpeechToText: Bool,
-        onChunk: ((_ chunk: VoiceInputChunk) -> Void)?,
-        box: ResultBox
+        listeningText: String
     ) throws {
         guard AVAudioSession.sharedInstance().recordPermission == .granted else {
             throw VoiceInputError.microphonePermissionDenied
         }
 
+        // Activate the session first so inputNode reports the correct hardware format
         let session = AVAudioSession.sharedInstance()
         try session.setCategory(.playAndRecord, mode: .measurement, options: [])
         try session.setActive(true)
@@ -141,59 +97,12 @@ class VoiceInputManager {
             presentVoiceTemplate(interfaceController: interfaceController, listeningText: listeningText)
         }
 
-        var activeRecognitionRequest: SFSpeechAudioBufferRecognitionRequest? = nil
-
-        if preferSpeechToText, SFSpeechRecognizer.authorizationStatus() == .authorized,
-            let recognizer = SFSpeechRecognizer(locale: Locale.current),
-            recognizer.isAvailable
-        {
-            let request = SFSpeechAudioBufferRecognitionRequest()
-            request.shouldReportPartialResults = true
-            recognitionRequest = request
-            activeRecognitionRequest = request
-
-            recognizer.recognitionTask(with: request) { [weak self] result, error in
-                guard let self else { return }
-
-                if error != nil {
-                    // STT failed — fall back to whatever PCM was accumulated
-                    self.stopLock.lock()
-                    let capturedSamples = self.samples
-                    self.samples = []
-                    self.stopLock.unlock()
-
-                    self.cleanup(interfaceController: interfaceController)
-                    box.resume(returning: self.makePCMResult(from: capturedSamples))
-                    return
-                }
-
-                guard let result else { return }
-
-                if result.isFinal {
-                    self.stopLock.lock()
-                    self.isStopping = true
-                    self.samples = []
-                    self.stopLock.unlock()
-
-                    self.cleanup(interfaceController: interfaceController)
-                    box.resume(
-                        returning: VoiceInputResult(
-                            transcription: result.bestTranscription.formattedString,
-                            audio: nil
-                        )
-                    )
-                }
-                else {
-                    onChunk?(VoiceInputChunk(partial: result.bestTranscription.formattedString, audio: nil))
-                }
-            }
-        }
-
         let engine = AVAudioEngine()
         let inputNode = engine.inputNode
         let nativeFormat = inputNode.outputFormat(forBus: 0)
 
-        guard let converter = AVAudioConverter(from: nativeFormat, to: VoiceInputManager.targetFormat) else {
+        let targetFormat = VoiceInputManager.targetFormat
+        guard let converter = AVAudioConverter(from: nativeFormat, to: targetFormat) else {
             throw VoiceInputError.converterUnavailable
         }
 
@@ -207,43 +116,36 @@ class VoiceInputManager {
         ) { [weak self] buffer, _ in
             guard let self, !self.isStopping else { return }
 
-            // Feed STT if active
-            activeRecognitionRequest?.append(buffer)
-
-            // Convert to 16kHz int16 for accumulation and PCM chunks
             let outputFrameCapacity = AVAudioFrameCount(
-                Double(buffer.frameLength) * VoiceInputManager.sampleRate / nativeFormat.sampleRate
+                Double(buffer.frameLength)
+                    * VoiceInputManager.sampleRate
+                    / nativeFormat.sampleRate
             )
+
             guard
                 let outputBuffer = AVAudioPCMBuffer(
-                    pcmFormat: VoiceInputManager.targetFormat,
+                    pcmFormat: targetFormat,
                     frameCapacity: outputFrameCapacity
                 )
             else { return }
 
             var conversionError: NSError?
-            let status = converter.convert(to: outputBuffer, error: &conversionError) { _, outStatus in
+            let status = converter.convert(to: outputBuffer, error: &conversionError) {
+                _,
+                outStatus in
                 outStatus.pointee = .haveData
                 return buffer
             }
+
             guard status != .error, let int16Data = outputBuffer.int16ChannelData else { return }
 
             let frameCount = Int(outputBuffer.frameLength)
             let newSamples = Array(UnsafeBufferPointer(start: int16Data[0], count: frameCount))
             self.samples.append(contentsOf: newSamples)
 
-            // PCM chunk callback
-            if activeRecognitionRequest == nil, let onChunk {
-                if let chunkBuffer = try? ArrayBuffer.copy(
-                    data: newSamples.withUnsafeBufferPointer { Data(buffer: $0) }
-                ) {
-                    onChunk(VoiceInputChunk(partial: nil, audio: chunkBuffer))
-                }
-            }
-
             let now = Date()
 
-            // Max duration — applies in both modes
+            // Max duration check
             if let start = self.recordingStart,
                 now.timeIntervalSince(start) * 1000 >= maxDurationMs
             {
@@ -258,9 +160,7 @@ class VoiceInputManager {
             {
                 let peak = newSamples.reduce(0) { max($0, abs(Int($1))) }
                 if peak < VoiceInputManager.silenceAmplitudeThreshold {
-                    if self.silenceStart == nil {
-                        self.silenceStart = now
-                    }
+                    if self.silenceStart == nil { self.silenceStart = now }
                     if let silenceBegin = self.silenceStart,
                         now.timeIntervalSince(silenceBegin) * 1000 >= silenceThresholdMs
                     {
@@ -283,11 +183,10 @@ class VoiceInputManager {
         }
     }
 
-    private func cleanup(interfaceController: AutoPlayInterfaceController?) {
+    private func stopCapture(interfaceController: AutoPlayInterfaceController?) {
         audioEngine?.inputNode.removeTap(onBus: 0)
         audioEngine?.stop()
         audioEngine = nil
-        recognitionRequest = nil
         recordingStart = nil
         silenceStart = nil
         try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
@@ -296,12 +195,6 @@ class VoiceInputManager {
         }
     }
 
-    private func makePCMResult(from samples: [Int16]) -> VoiceInputResult {
-        let data = samples.withUnsafeBufferPointer { Data(buffer: $0) }
-        let buffer = try? ArrayBuffer.copy(data: data)
-        return VoiceInputResult(transcription: nil, audio: buffer)
-    }
-
     private func presentVoiceTemplate(interfaceController: AutoPlayInterfaceController, listeningText: String) {
         let listeningState = CPVoiceControlState(
             identifier: "listening",
@@ -325,6 +218,12 @@ class VoiceInputManager {
         }
         voiceControlTemplate = nil
     }
+
+    private func samplesAsData(_ samples: [Int16]) -> Data {
+        samples.withUnsafeBufferPointer { ptr in
+            Data(buffer: ptr)
+        }
+    }
 }
 
 enum VoiceInputError: Error {

package/lib/index.d.ts

@@ -1,8 +1,7 @@
 import { HybridAndroidAutoTelemetry } from './hybrid/HybridAndroidAutoTelemetry';
 import { HybridAutoPlay } from './hybrid/HybridAutoPlay';
-import { HybridVoice } from './hybrid/HybridVoice';
 import type { AndroidAutomotive } from './specs/AndroidAutomotive.nitro';
-export { HybridAndroidAutoTelemetry, HybridAutoPlay, HybridVoice };
+export { HybridAndroidAutoTelemetry, HybridAutoPlay };
 export declare const HybridAndroidAutomotive: AndroidAutomotive | null;
 /**
  * These are the static module names for the app running on the mobile device, head unit screen and the CarPlay dashboard.
@@ -40,7 +39,6 @@ export * from './types/SignInMethod';
 export * from './types/Telemetry';
 export * from './types/Text';
 export * from './types/Trip';
-export type { VoiceInputChunk, VoiceInputOptions, VoiceInputResult } from './types/Voice';
 export type { AlertPriority, NavigationAlert as Alert, NavigationAlertAction as AlertAction, } from './utils/NitroAlert';
 export type { ThemedColor } from './utils/NitroColor';
 export type { GridButton } from './utils/NitroGrid';

package/lib/index.js

@@ -3,9 +3,8 @@ import { NitroModules } from 'react-native-nitro-modules';
 import AutoPlayHeadlessJsTask from './AutoPlayHeadlessJsTask';
 import { HybridAndroidAutoTelemetry } from './hybrid/HybridAndroidAutoTelemetry';
 import { HybridAutoPlay } from './hybrid/HybridAutoPlay';
-import { HybridVoice } from './hybrid/HybridVoice';
 AutoPlayHeadlessJsTask.registerHeadlessTask(HybridAutoPlay);
-export { HybridAndroidAutoTelemetry, HybridAutoPlay, HybridVoice };
+export { HybridAndroidAutoTelemetry, HybridAutoPlay };
 export const HybridAndroidAutomotive = Platform.OS === 'android'
     ? NitroModules.createHybridObject('AndroidAutomotive')
     : null;

package/lib/specs/AutoPlay.nitro.d.ts

@@ -31,6 +31,35 @@ export interface AutoPlay extends HybridObject<{
      * @namespace Android
      */
     addListenerVoiceInput(callback: (coordinates: Location | undefined, query: string | undefined) => void): CleanupCallback;
+    /**
+     * Returns true if microphone permission has already been granted.
+     */
+    hasVoiceInputPermission(): boolean;
+    /**
+     * Request microphone permission from the user.
+     * On Android: uses the car context when Android Auto is connected, otherwise
+     * falls back to the React Native application context.
+     * On iOS: uses AVAudioApplication (iOS 17+) or AVAudioSession (iOS 15–16).
+     * Returns true if permission was granted, false if denied.
+     */
+    requestVoiceInputPermission(): Promise<boolean>;
+    /**
+     * Start an in-app voice recording session.
+     * On Android: acquires audio focus and captures via CarAudioRecord when
+     * Android Auto is connected, otherwise uses standard AudioRecord.
+     * On iOS: presents CPVoiceControlTemplate (when a car is connected) and
+     * captures audio via AVAudioEngine.
+     * Resolves with the complete raw PCM buffer (16 kHz, 16-bit, mono) when
+     * silence is detected, the max duration is reached, or stopVoiceInput() is called.
+     * Rejects if microphone permission has not been granted or recording fails to start.
+     */
+    startVoiceInput(silenceThresholdMs?: number, maxDurationMs?: number, listeningText?: string): Promise<ArrayBuffer>;
+    /**
+     * Stop the active voice recording session early. Causes the Promise returned
+     * by startVoiceInput() to resolve with the audio captured so far.
+     * No-op if no recording is in progress.
+     */
+    stopVoiceInput(): void;
     /**
      * sets the specified template as root template, initializes a new stack
      * Promise might contain an error message in case setting root template failed

package/nitro.json

@@ -9,16 +9,6 @@
     "androidCxxLibName": "ReactNativeAutoPlay"
   },
   "autolinking": {
-    "Voice": {
-      "android": {
-        "implementationClassName": "HybridVoice",
-        "language": "kotlin"
-      },
-      "ios": {
-        "implementationClassName": "HybridVoice",
-        "language": "swift"
-      }
-    },
     "AutoPlay": {
       "android": {
         "implementationClassName": "HybridAutoPlay",

package/nitrogen/generated/android/ReactNativeAutoPlay+autolinking.cmake

@@ -45,7 +45,6 @@ target_sources(
   ../nitrogen/generated/shared/c++/HybridMessageTemplateSpec.cpp
   ../nitrogen/generated/shared/c++/HybridSearchTemplateSpec.cpp
   ../nitrogen/generated/shared/c++/HybridSignInTemplateSpec.cpp
-  ../nitrogen/generated/shared/c++/HybridVoiceSpec.cpp
   # Android-specific Nitrogen C++ sources
   ../nitrogen/generated/android/c++/JHybridAndroidAutomotiveSpec.cpp
   ../nitrogen/generated/android/c++/JHybridAndroidAutoTelemetrySpec.cpp
@@ -63,7 +62,6 @@ target_sources(
   ../nitrogen/generated/android/c++/JHybridSearchTemplateSpec.cpp
   ../nitrogen/generated/android/c++/JHybridSignInTemplateSpec.cpp
   ../nitrogen/generated/android/c++/JVariant_QrSignIn_PinSignIn_InputSignIn_GoogleSignIn.cpp
-  ../nitrogen/generated/android/c++/JHybridVoiceSpec.cpp
 )
 
 # From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake

package/nitrogen/generated/android/ReactNativeAutoPlayOnLoad.cpp

@@ -46,8 +46,6 @@
 #include "JHybridSearchTemplateSpec.hpp"
 #include "JHybridSignInTemplateSpec.hpp"
 #include "JFunc_void_std__optional_std__string__std__optional_GoogleSignInAccount_.hpp"
-#include "JHybridVoiceSpec.hpp"
-#include "JFunc_void_VoiceInputChunk.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
 
 namespace margelo::nitro::swe::iternio::reactnativeautoplay {
@@ -58,14 +56,6 @@ int initialize(JavaVM* vm) {
   });
 }
 
-struct JHybridVoiceSpecImpl: public jni::JavaClass<JHybridVoiceSpecImpl, JHybridVoiceSpec::JavaPart> {
-  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/HybridVoice;";
-  static std::shared_ptr<JHybridVoiceSpec> create() {
-    static const auto constructorFn = javaClassStatic()->getConstructor<JHybridVoiceSpecImpl::javaobject()>();
-    jni::local_ref<JHybridVoiceSpec::JavaPart> javaPart = javaClassStatic()->newObject(constructorFn);
-    return javaPart->getJHybridVoiceSpec();
-  }
-};
 struct JHybridAutoPlaySpecImpl: public jni::JavaClass<JHybridAutoPlaySpecImpl, JHybridAutoPlaySpec::JavaPart> {
   static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/swe/iternio/reactnativeautoplay/HybridAutoPlay;";
   static std::shared_ptr<JHybridAutoPlaySpec> create() {
@@ -191,16 +181,8 @@ void registerAllNatives() {
   margelo::nitro::swe::iternio::reactnativeautoplay::JHybridSearchTemplateSpec::CxxPart::registerNatives();
   margelo::nitro::swe::iternio::reactnativeautoplay::JHybridSignInTemplateSpec::CxxPart::registerNatives();
   margelo::nitro::swe::iternio::reactnativeautoplay::JFunc_void_std__optional_std__string__std__optional_GoogleSignInAccount__cxx::registerNatives();
-  margelo::nitro::swe::iternio::reactnativeautoplay::JHybridVoiceSpec::CxxPart::registerNatives();
-  margelo::nitro::swe::iternio::reactnativeautoplay::JFunc_void_VoiceInputChunk_cxx::registerNatives();
 
   // Register Nitro Hybrid Objects
-  HybridObjectRegistry::registerHybridObjectConstructor(
-    "Voice",
-    []() -> std::shared_ptr<HybridObject> {
-      return JHybridVoiceSpecImpl::create();
-    }
-  );
   HybridObjectRegistry::registerHybridObjectConstructor(
     "AutoPlay",
     []() -> std::shared_ptr<HybridObject> {

package/nitrogen/generated/android/c++/JHybridAutoPlaySpec.cpp

@@ -37,6 +37,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroBu
 #include <NitroModules/JNICallable.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/JPromise.hpp>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
 #include <NitroModules/JUnit.hpp>
 #include "EventName.hpp"
 #include "JEventName.hpp"
@@ -143,6 +145,47 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       }
     }();
   }
+  bool JHybridAutoPlaySpec::hasVoiceInputPermission() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("hasVoiceInputPermission");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  std::shared_ptr<Promise<bool>> JHybridAutoPlaySpec::requestVoiceInputPermission() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("requestVoiceInputPermission");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<bool>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
+        __promise->resolve(static_cast<bool>(__result->value()));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> JHybridAutoPlaySpec::startVoiceInput(std::optional<double> silenceThresholdMs, std::optional<double> maxDurationMs, const std::optional<std::string>& listeningText) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JDouble> /* silenceThresholdMs */, jni::alias_ref<jni::JDouble> /* maxDurationMs */, jni::alias_ref<jni::JString> /* listeningText */)>("startVoiceInput");
+    auto __result = method(_javaPart, silenceThresholdMs.has_value() ? jni::JDouble::valueOf(silenceThresholdMs.value()) : nullptr, maxDurationMs.has_value() ? jni::JDouble::valueOf(maxDurationMs.value()) : nullptr, listeningText.has_value() ? jni::make_jstring(listeningText.value()) : nullptr);
+    return [&]() {
+      auto __promise = Promise<std::shared_ptr<ArrayBuffer>>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JArrayBuffer::javaobject>(__boxedResult);
+        __promise->resolve(__result->cthis()->getArrayBuffer());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  void JHybridAutoPlaySpec::stopVoiceInput() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("stopVoiceInput");
+    method(_javaPart);
+  }
   std::shared_ptr<Promise<void>> JHybridAutoPlaySpec::setRootTemplate(const std::string& templateId) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* templateId */)>("setRootTemplate");
     auto __result = method(_javaPart, jni::make_jstring(templateId));

package/nitrogen/generated/android/c++/JHybridAutoPlaySpec.hpp

@@ -57,6 +57,10 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
     std::function<void()> addListener(EventName eventType, const std::function<void()>& callback) override;
     std::function<void()> addListenerRenderState(const std::string& moduleName, const std::function<void(VisibilityState /* payload */)>& callback) override;
     std::function<void()> addListenerVoiceInput(const std::function<void(const std::optional<Location>& /* coordinates */, const std::optional<std::string>& /* query */)>& callback) override;
+    bool hasVoiceInputPermission() override;
+    std::shared_ptr<Promise<bool>> requestVoiceInputPermission() override;
+    std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> startVoiceInput(std::optional<double> silenceThresholdMs, std::optional<double> maxDurationMs, const std::optional<std::string>& listeningText) override;
+    void stopVoiceInput() override;
     std::shared_ptr<Promise<void>> setRootTemplate(const std::string& templateId) override;
     std::shared_ptr<Promise<void>> pushTemplate(const std::string& templateId) override;
     std::shared_ptr<Promise<void>> popTemplate(std::optional<bool> animate) override;

package/nitrogen/generated/android/kotlin/com/margelo/nitro/swe/iternio/reactnativeautoplay/HybridAutoPlaySpec.kt

@@ -11,6 +11,7 @@ import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
 import com.margelo.nitro.core.Promise
+import com.margelo.nitro.core.ArrayBuffer
 import com.margelo.nitro.core.HybridObject
 
 /**
@@ -56,6 +57,22 @@ abstract class HybridAutoPlaySpec: HybridObject() {
     return Func_void_java(__result)
   }
   
+  @DoNotStrip
+  @Keep
+  abstract fun hasVoiceInputPermission(): Boolean
+  
+  @DoNotStrip
+  @Keep
+  abstract fun requestVoiceInputPermission(): Promise<Boolean>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun startVoiceInput(silenceThresholdMs: Double?, maxDurationMs: Double?, listeningText: String?): Promise<ArrayBuffer>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun stopVoiceInput(): Unit
+  
   @DoNotStrip
   @Keep
   abstract fun setRootTemplate(templateId: String): Promise<Unit>

package/nitrogen/generated/ios/ReactNativeAutoPlay-Swift-Cxx-Bridge.cpp

@@ -17,7 +17,6 @@
 #include "HybridMapTemplateSpecSwift.hpp"
 #include "HybridMessageTemplateSpecSwift.hpp"
 #include "HybridSearchTemplateSpecSwift.hpp"
-#include "HybridVoiceSpecSwift.hpp"
 #include "ReactNativeAutoPlay-Swift-Cxx-Umbrella.hpp"
 #include <NitroModules/NitroDefines.hpp>
 
@@ -47,6 +46,14 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void(bool /* result */)>
+  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = ReactNativeAutoPlay::Func_void_bool::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](bool result) mutable -> void {
+      swiftClosure.call(result);
+    };
+  }
+  
   // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
   Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeAutoPlay::Func_void_std__exception_ptr::fromUnsafe(swiftClosureWrapper);
@@ -55,6 +62,14 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void(const std::shared_ptr<ArrayBuffer>& /* result */)>
+  Func_void_std__shared_ptr_ArrayBuffer_ create_Func_void_std__shared_ptr_ArrayBuffer_(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = ReactNativeAutoPlay::Func_void_std__shared_ptr_ArrayBuffer_::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::shared_ptr<ArrayBuffer>& result) mutable -> void {
+      swiftClosure.call(ArrayBufferHolder(result));
+    };
+  }
+  
   // pragma MARK: std::function<void(const SafeAreaInsets& /* insets */)>
   Func_void_SafeAreaInsets create_Func_void_SafeAreaInsets(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = ReactNativeAutoPlay::Func_void_SafeAreaInsets::fromUnsafe(swiftClosureWrapper);
@@ -159,14 +174,6 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift {
     };
   }
   
-  // pragma MARK: std::function<void(bool /* isPanningInterfaceVisible */)>
-  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept {
-    auto swiftClosure = ReactNativeAutoPlay::Func_void_bool::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](bool isPanningInterfaceVisible) mutable -> void {
-      swiftClosure.call(isPanningInterfaceVisible);
-    };
-  }
-  
   // pragma MARK: std::shared_ptr<HybridGridTemplateSpec>
   std::shared_ptr<HybridGridTemplateSpec> create_std__shared_ptr_HybridGridTemplateSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     ReactNativeAutoPlay::HybridGridTemplateSpec_cxx swiftPart = ReactNativeAutoPlay::HybridGridTemplateSpec_cxx::fromUnsafe(swiftUnsafePointer);
@@ -302,37 +309,5 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift {
     ReactNativeAutoPlay::HybridSearchTemplateSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
     return swiftPart.toUnsafe();
   }
-  
-  // pragma MARK: std::function<void(const VoiceInputResult& /* result */)>
-  Func_void_VoiceInputResult create_Func_void_VoiceInputResult(void* NON_NULL swiftClosureWrapper) noexcept {
-    auto swiftClosure = ReactNativeAutoPlay::Func_void_VoiceInputResult::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const VoiceInputResult& result) mutable -> void {
-      swiftClosure.call(result);
-    };
-  }
-  
-  // pragma MARK: std::function<void(const VoiceInputChunk& /* chunk */)>
-  Func_void_VoiceInputChunk create_Func_void_VoiceInputChunk(void* NON_NULL swiftClosureWrapper) noexcept {
-    auto swiftClosure = ReactNativeAutoPlay::Func_void_VoiceInputChunk::fromUnsafe(swiftClosureWrapper);
-    return [swiftClosure = std::move(swiftClosure)](const VoiceInputChunk& chunk) mutable -> void {
-      swiftClosure.call(chunk);
-    };
-  }
-  
-  // pragma MARK: std::shared_ptr<HybridVoiceSpec>
-  std::shared_ptr<HybridVoiceSpec> create_std__shared_ptr_HybridVoiceSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
-    ReactNativeAutoPlay::HybridVoiceSpec_cxx swiftPart = ReactNativeAutoPlay::HybridVoiceSpec_cxx::fromUnsafe(swiftUnsafePointer);
-    return std::make_shared<margelo::nitro::swe::iternio::reactnativeautoplay::HybridVoiceSpecSwift>(swiftPart);
-  }
-  void* NON_NULL get_std__shared_ptr_HybridVoiceSpec_(std__shared_ptr_HybridVoiceSpec_ cppType) {
-    std::shared_ptr<margelo::nitro::swe::iternio::reactnativeautoplay::HybridVoiceSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::swe::iternio::reactnativeautoplay::HybridVoiceSpecSwift>(cppType);
-    #ifdef NITRO_DEBUG
-    if (swiftWrapper == nullptr) [[unlikely]] {
-      throw std::runtime_error("Class \"HybridVoiceSpec\" is not implemented in Swift!");
-    }
-    #endif
-    ReactNativeAutoPlay::HybridVoiceSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
-    return swiftPart.toUnsafe();
-  }
 
 } // namespace margelo::nitro::swe::iternio::reactnativeautoplay::bridge::swift