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

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,35 +33,30 @@ class VoiceInputManager {
         interfaceController: AutoPlayInterfaceController?,
         silenceThresholdMs: Double,
         maxDurationMs: Double,
-        listeningText: String,
-        preferSpeechToText: Bool,
-        onChunk: ((_ chunk: VoiceInputChunk) -> Void)?,
-        language: String?
-    ) 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,
-                    language: language
+                    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) {
@@ -102,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
@@ -126,16 +82,13 @@ class VoiceInputManager {
         interfaceController: AutoPlayInterfaceController?,
         silenceThresholdMs: Double,
         maxDurationMs: Double,
-        listeningText: String,
-        preferSpeechToText: Bool,
-        onChunk: ((_ chunk: VoiceInputChunk) -> Void)?,
-        box: ResultBox,
-        language: String?
+        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)
@@ -144,59 +97,12 @@ class VoiceInputManager {
             presentVoiceTemplate(interfaceController: interfaceController, listeningText: listeningText)
         }
 
-        var activeRecognitionRequest: SFSpeechAudioBufferRecognitionRequest? = nil
-
-        if preferSpeechToText, SFSpeechRecognizer.authorizationStatus() == .authorized,
-            let recognizer = language != nil ? SFSpeechRecognizer(locale: Locale(identifier: language!)) : 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
         }
 
@@ -210,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
             {
@@ -261,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
                     {
@@ -286,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)
@@ -299,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",
@@ -328,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++/JActiveCarUxRestrictions.hpp

@@ -45,16 +45,16 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
         maxContentDepth,
         maxCumulativeContentItems,
         maxRestrictedStringLength,
-        [&]() {
-          size_t __size = activeRestrictions->size();
+        [&](auto&& __input) {
+          size_t __size = __input->size();
           std::vector<CarUxRestrictions> __vector;
           __vector.reserve(__size);
           for (size_t __i = 0; __i < __size; __i++) {
-            auto __element = activeRestrictions->getElement(__i);
+            auto __element = __input->getElement(__i);
             __vector.push_back(__element->toCpp());
           }
           return __vector;
-        }()
+        }(activeRestrictions)
       );
     }
 
@@ -72,16 +72,16 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
         value.maxContentDepth,
         value.maxCumulativeContentItems,
         value.maxRestrictedStringLength,
-        [&]() {
-          size_t __size = value.activeRestrictions.size();
+        [&](auto&& __input) {
+          size_t __size = __input.size();
           jni::local_ref<jni::JArrayClass<JCarUxRestrictions>> __array = jni::JArrayClass<JCarUxRestrictions>::newArray(__size);
           for (size_t __i = 0; __i < __size; __i++) {
-            const auto& __element = value.activeRestrictions[__i];
+            const auto& __element = __input[__i];
             auto __elementJni = JCarUxRestrictions::fromCpp(__element);
             __array->setElement(__i, *__elementJni);
           }
           return __array;
-        }()
+        }(value.activeRestrictions)
       );
     }
   };

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

@@ -141,27 +141,27 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
           }
         }()) : std::nullopt,
         autoDismissMs != nullptr ? std::make_optional(autoDismissMs->value()) : std::nullopt,
-        headerActions != nullptr ? std::make_optional([&]() {
-          size_t __size = headerActions->size();
+        headerActions != nullptr ? std::make_optional([&](auto&& __input) {
+          size_t __size = __input->size();
           std::vector<NitroAction> __vector;
           __vector.reserve(__size);
           for (size_t __i = 0; __i < __size; __i++) {
-            auto __element = headerActions->getElement(__i);
+            auto __element = __input->getElement(__i);
             __vector.push_back(__element->toCpp());
           }
           return __vector;
-        }()) : std::nullopt,
+        }(headerActions)) : std::nullopt,
         title->toCpp(),
-        [&]() {
-          size_t __size = buttons->size();
+        [&](auto&& __input) {
+          size_t __size = __input->size();
           std::vector<NitroGridButton> __vector;
           __vector.reserve(__size);
           for (size_t __i = 0; __i < __size; __i++) {
-            auto __element = buttons->getElement(__i);
+            auto __element = __input->getElement(__i);
             __vector.push_back(__element->toCpp());
           }
           return __vector;
-        }(),
+        }(buttons),
         mapConfig != nullptr ? std::make_optional(mapConfig->toCpp()) : std::nullopt
       );
     }
@@ -184,27 +184,27 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
         value.onDidDisappear.has_value() ? JFunc_void_std__optional_bool__cxx::fromCpp(value.onDidDisappear.value()) : nullptr,
         value.onPopped.has_value() ? JFunc_void_cxx::fromCpp(value.onPopped.value()) : nullptr,
         value.autoDismissMs.has_value() ? jni::JDouble::valueOf(value.autoDismissMs.value()) : nullptr,
-        value.headerActions.has_value() ? [&]() {
-          size_t __size = value.headerActions.value().size();
+        value.headerActions.has_value() ? [&](auto&& __input) {
+          size_t __size = __input.size();
           jni::local_ref<jni::JArrayClass<JNitroAction>> __array = jni::JArrayClass<JNitroAction>::newArray(__size);
           for (size_t __i = 0; __i < __size; __i++) {
-            const auto& __element = value.headerActions.value()[__i];
+            const auto& __element = __input[__i];
             auto __elementJni = JNitroAction::fromCpp(__element);
             __array->setElement(__i, *__elementJni);
           }
           return __array;
-        }() : nullptr,
+        }(value.headerActions.value()) : nullptr,
         JAutoText::fromCpp(value.title),
-        [&]() {
-          size_t __size = value.buttons.size();
+        [&](auto&& __input) {
+          size_t __size = __input.size();
           jni::local_ref<jni::JArrayClass<JNitroGridButton>> __array = jni::JArrayClass<JNitroGridButton>::newArray(__size);
           for (size_t __i = 0; __i < __size; __i++) {
-            const auto& __element = value.buttons[__i];
+            const auto& __element = __input[__i];
             auto __elementJni = JNitroGridButton::fromCpp(__element);
             __array->setElement(__i, *__elementJni);
           }
           return __array;
-        }(),
+        }(value.buttons),
         value.mapConfig.has_value() ? JNitroBaseMapTemplateConfig::fromCpp(value.mapConfig.value()) : nullptr
       );
     }

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

@@ -90,16 +90,16 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
   }
   std::shared_ptr<Promise<PermissionRequestResult>> JHybridAndroidAutoTelemetrySpec::requestAutomotivePermissions(const std::vector<std::string>& permissions, const std::string& message, const std::string& grantButtonText, const std::optional<std::string>& cancelButtonText) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JArrayClass<jni::JString>> /* permissions */, jni::alias_ref<jni::JString> /* message */, jni::alias_ref<jni::JString> /* grantButtonText */, jni::alias_ref<jni::JString> /* cancelButtonText */)>("requestAutomotivePermissions");
-    auto __result = method(_javaPart, [&]() {
-      size_t __size = permissions.size();
+    auto __result = method(_javaPart, [&](auto&& __input) {
+      size_t __size = __input.size();
       jni::local_ref<jni::JArrayClass<jni::JString>> __array = jni::JArrayClass<jni::JString>::newArray(__size);
       for (size_t __i = 0; __i < __size; __i++) {
-        const auto& __element = permissions[__i];
+        const auto& __element = __input[__i];
         auto __elementJni = jni::make_jstring(__element);
         __array->setElement(__i, *__elementJni);
       }
       return __array;
-    }(), jni::make_jstring(message), jni::make_jstring(grantButtonText), cancelButtonText.has_value() ? jni::make_jstring(cancelButtonText.value()) : nullptr);
+    }(permissions), jni::make_jstring(message), jni::make_jstring(grantButtonText), cancelButtonText.has_value() ? jni::make_jstring(cancelButtonText.value()) : nullptr);
     return [&]() {
       auto __promise = Promise<PermissionRequestResult>::create();
       __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {