@iternio/react-native-auto-play 0.3.10 → 0.3.12

package/ios/utils/VoiceInputManager.swift

@@ -0,0 +1,233 @@
+import AVFoundation
+import CarPlay
+
+/// 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 continuation: CheckedContinuation<[Int16], Error>?
+    private var samples: [Int16] = []
+    private var isStopping = false
+    private let stopLock = NSLock()
+
+    // Timing
+    private var recordingStart: Date?
+    private var silenceStart: Date?
+
+    private static let sampleRate: Double = 16_000
+    private static let tapBufferSize: AVAudioFrameCount = 4_096
+    private static let silenceAmplitudeThreshold = 500
+    private static let warmupMs: Double = 500
+
+    private static let targetFormat = AVAudioFormat(
+        commonFormat: .pcmFormatInt16,
+        sampleRate: sampleRate,
+        channels: 1,
+        interleaved: true
+    )!
+
+    // MARK: - Public
+
+    func start(
+        interfaceController: AutoPlayInterfaceController?,
+        silenceThresholdMs: Double,
+        maxDurationMs: Double,
+        listeningText: String
+    ) async throws -> Data {
+        let samples = try await withCheckedThrowingContinuation {
+            (cont: CheckedContinuation<[Int16], Error>) in
+            self.continuation = cont
+            self.samples = []
+            self.isStopping = false
+
+            do {
+                try self.startCapture(
+                    interfaceController: interfaceController,
+                    silenceThresholdMs: silenceThresholdMs,
+                    maxDurationMs: maxDurationMs,
+                    listeningText: listeningText
+                )
+            }
+            catch {
+                self.stopCapture(interfaceController: interfaceController)
+                self.continuation = nil
+                cont.resume(throwing: error)
+            }
+        }
+
+        return samplesAsData(samples)
+    }
+
+    func stop(interfaceController: AutoPlayInterfaceController? = nil) {
+        stopLock.lock()
+        guard !isStopping else {
+            stopLock.unlock()
+            return
+        }
+        isStopping = true
+        let capturedContinuation = continuation
+        let capturedSamples = samples
+        continuation = nil
+        samples = []
+        stopLock.unlock()
+
+        stopCapture(interfaceController: interfaceController)
+        capturedContinuation?.resume(returning: capturedSamples)
+    }
+
+    // MARK: - Private
+
+    private func startCapture(
+        interfaceController: AutoPlayInterfaceController?,
+        silenceThresholdMs: Double,
+        maxDurationMs: Double,
+        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: [.mixWithOthers])
+        try session.setActive(true)
+
+        if let interfaceController {
+            presentVoiceTemplate(interfaceController: interfaceController, listeningText: listeningText)
+        }
+
+        let engine = AVAudioEngine()
+        let inputNode = engine.inputNode
+        let nativeFormat = inputNode.outputFormat(forBus: 0)
+
+        let targetFormat = VoiceInputManager.targetFormat
+        guard let converter = AVAudioConverter(from: nativeFormat, to: targetFormat) else {
+            throw VoiceInputError.converterUnavailable
+        }
+
+        recordingStart = Date()
+        silenceStart = nil
+
+        inputNode.installTap(
+            onBus: 0,
+            bufferSize: VoiceInputManager.tapBufferSize,
+            format: nativeFormat
+        ) { [weak self] buffer, _ in
+            guard let self, !self.isStopping else { return }
+
+            let outputFrameCapacity = AVAudioFrameCount(
+                Double(buffer.frameLength)
+                    * VoiceInputManager.sampleRate
+                    / nativeFormat.sampleRate
+            )
+
+            guard
+                let outputBuffer = AVAudioPCMBuffer(
+                    pcmFormat: targetFormat,
+                    frameCapacity: outputFrameCapacity
+                )
+            else { return }
+
+            var conversionError: NSError?
+            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)
+
+            let now = Date()
+
+            // Max duration check
+            if let start = self.recordingStart,
+                now.timeIntervalSince(start) * 1000 >= maxDurationMs
+            {
+                self.triggerAutoStop(interfaceController: interfaceController)
+                return
+            }
+
+            // Silence detection — skip during warm-up so the pipeline has time
+            // to stabilise before we start measuring amplitude
+            if let start = self.recordingStart,
+                now.timeIntervalSince(start) * 1000 >= VoiceInputManager.warmupMs
+            {
+                let peak = newSamples.reduce(0) { max($0, abs(Int($1))) }
+                if peak < VoiceInputManager.silenceAmplitudeThreshold {
+                    if self.silenceStart == nil { self.silenceStart = now }
+                    if let silenceBegin = self.silenceStart,
+                        now.timeIntervalSince(silenceBegin) * 1000 >= silenceThresholdMs
+                    {
+                        self.triggerAutoStop(interfaceController: interfaceController)
+                    }
+                }
+                else {
+                    self.silenceStart = nil
+                }
+            }
+        }
+
+        try engine.start()
+        audioEngine = engine
+    }
+
+    private func triggerAutoStop(interfaceController: AutoPlayInterfaceController?) {
+        DispatchQueue.global(qos: .userInitiated).async {
+            self.stop(interfaceController: interfaceController)
+        }
+    }
+
+    private func stopCapture(interfaceController: AutoPlayInterfaceController?) {
+        audioEngine?.inputNode.removeTap(onBus: 0)
+        audioEngine?.stop()
+        audioEngine = nil
+        recordingStart = nil
+        silenceStart = nil
+        try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
+        if let interfaceController {
+            dismissVoiceTemplate(interfaceController: interfaceController)
+        }
+    }
+
+    private func presentVoiceTemplate(interfaceController: AutoPlayInterfaceController, listeningText: String) {
+        let listeningState = CPVoiceControlState(
+            identifier: "listening",
+            titleVariants: [listeningText],
+            image: nil,
+            repeats: true
+        )
+        let template = CPVoiceControlTemplate(voiceControlStates: [listeningState])
+        initTemplate(template: template, id: "voice-input")
+        voiceControlTemplate = template
+
+        Task { @MainActor in
+            try? await interfaceController.presentTemplate(template, animated: true)
+            template.activateVoiceControlState(withIdentifier: "listening")
+        }
+    }
+
+    private func dismissVoiceTemplate(interfaceController: AutoPlayInterfaceController) {
+        Task { @MainActor in
+            try? await interfaceController.dismissTemplate(animated: true)
+        }
+        voiceControlTemplate = nil
+    }
+
+    private func samplesAsData(_ samples: [Int16]) -> Data {
+        samples.withUnsafeBufferPointer { ptr in
+            Data(buffer: ptr)
+        }
+    }
+}
+
+enum VoiceInputError: Error {
+    case microphonePermissionDenied
+    case converterUnavailable
+    case noActiveSession
+}

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

@@ -24,12 +24,42 @@ export interface AutoPlay extends HybridObject<{
      */
     addListenerRenderState(moduleName: string, callback: (payload: VisibilityState) => void): CleanupCallback;
     /**
-     * Adds a listener for voice input events. Not implemented on iOS.
+     * Adds a listener for voice input events fired by the OS (Android Auto only).
+     * On iOS this is a no-op — use startVoiceInput instead.
      * @param callback the callback to receive the voice input
      * @returns callback to remove the listener
      * @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/lib/templates/MapTemplate.d.ts

@@ -6,6 +6,7 @@ import type { ColorScheme, RootComponentInitialProps } from '../types/RootCompon
 import type { TripConfig, TripPoint, TripPreviewTextConfiguration, TripsConfig } from '../types/Trip';
 import { type NitroAction } from '../utils/NitroAction';
 import { type NavigationAlert } from '../utils/NitroAlert';
+import { type NitroColor, type ThemedColor } from '../utils/NitroColor';
 import { NitroMapButton } from '../utils/NitroMapButton';
 import { type HeaderActionsIos, type NitroBaseMapTemplateConfig, Template, type TemplateConfig } from './Template';
 export type Point = {
@@ -53,6 +54,7 @@ export interface NitroMapTemplateConfig extends TemplateConfig, NitroBaseMapTemp
     onAutoDriveEnabled?: () => void;
     mapButtons?: Array<NitroMapButton>;
     headerActions?: Array<NitroAction>;
+    defaultGuidanceBackgroundColor?: NitroColor;
     /**
      * specify the percentage of screen height/width the pan button should scroll
      * @namespace iOS
@@ -78,7 +80,7 @@ export type BaseMapTemplateConfig<T> = {
      */
     headerActions?: MapHeaderActions<T>;
 };
-export type MapTemplateConfig = Omit<NitroMapTemplateConfig, 'mapButtons' | 'headerActions' | 'onStopNavigation' | 'onAutoDriveEnabled'> & BaseMapTemplateConfig<MapTemplate> & {
+export type MapTemplateConfig = Omit<NitroMapTemplateConfig, 'mapButtons' | 'headerActions' | 'onStopNavigation' | 'onAutoDriveEnabled' | 'defaultGuidanceBackgroundColor'> & BaseMapTemplateConfig<MapTemplate> & {
     /**
      * react component that is rendered
      */
@@ -93,6 +95,10 @@ export type MapTemplateConfig = Omit<NitroMapTemplateConfig, 'mapButtons' | 'hea
      * @namespace Android
      */
     onAutoDriveEnabled?: (template: MapTemplate) => void;
+    /**
+     * Initial navigation maneuver background color. Mainly useful, when in CarPlay the default loading maneuver does not have the right color.
+     */
+    defaultGuidanceBackgroundColor?: ThemedColor | string;
 };
 export interface TripSelectorCallback {
     setSelectedTrip: (id: string) => void;

package/lib/templates/MapTemplate.js

@@ -7,6 +7,7 @@ import { SafeAreaInsetsProvider } from '../components/SafeAreaInsetsContext';
 import { HybridAutoPlay } from '../hybrid/HybridAutoPlay';
 import { NitroActionUtil } from '../utils/NitroAction';
 import { NitroAlertUtil } from '../utils/NitroAlert';
+import { NitroColorUtil } from '../utils/NitroColor';
 import { NitroManeuverUtil } from '../utils/NitroManeuver';
 import { NitroMapButton } from '../utils/NitroMapButton';
 import { Template, } from './Template';
@@ -16,7 +17,7 @@ export class MapTemplate extends Template {
     template = this;
     constructor(config) {
         super(config);
-        const { component, mapButtons, headerActions, onStopNavigation, onAutoDriveEnabled, ...baseConfig } = config;
+        const { component, mapButtons, headerActions, onStopNavigation, onAutoDriveEnabled, defaultGuidanceBackgroundColor, ...baseConfig } = config;
         AppRegistry.registerComponent(this.id, () => (props) => React.createElement(MapTemplateProvider, {
             mapTemplate: this.template,
             // biome-ignore lint/correctness/noChildrenProp: there is no other way in a ts file
@@ -37,6 +38,9 @@ export class MapTemplate extends Template {
             mapButtons: NitroMapButton.convert(this.template, mapButtons),
             onStopNavigation: () => onStopNavigation(this.template),
             onAutoDriveEnabled: onAutoDriveEnabled ? () => onAutoDriveEnabled(this.template) : undefined,
+            defaultGuidanceBackgroundColor: defaultGuidanceBackgroundColor != null
+                ? NitroColorUtil.convert(defaultGuidanceBackgroundColor)
+                : undefined,
         };
         HybridMapTemplate.createMapTemplate(nitroConfig);
     }
@@ -111,7 +115,11 @@ export class MapTemplate extends Template {
             return;
         }
         if (maneuvers.type === 'loading') {
-            HybridMapTemplate.updateManeuvers(this.id, { isLoading: true });
+            HybridMapTemplate.updateManeuvers(this.id, {
+                isLoading: true,
+                cardBackgroundColor: NitroColorUtil.convert(maneuvers.cardBackgroundColor),
+                text: maneuvers.text != null ? maneuvers.text : undefined,
+            });
             return;
         }
         const messageManeuver = NitroManeuverUtil.convert(maneuvers);

package/lib/types/Image.d.ts

@@ -24,4 +24,17 @@ export type AutoImage = {
      */
     color?: ThemedColor | string;
     type: 'asset';
+} | {
+    /** HTTPS URL to a remote image. HTTP is not supported (blocked by App Transport Security). */
+    uri: string;
+    /**
+     * if specified the image gets tinted, if not it will just use the original image
+     */
+    color?: ThemedColor | string;
+    /**
+     * Network timeout in milliseconds before the remote fetch is abandoned and `null` is returned.
+     * Defaults to 500ms when not specified.
+     */
+    timeoutMs?: number;
+    type: 'remote';
 };

package/lib/types/Maneuver.d.ts

@@ -210,6 +210,12 @@ export type MessageManeuver = {
 };
 export type LoadingManeuver = {
     type: 'loading';
+    cardBackgroundColor: ThemedColor | string;
+    /**
+     * @namespace iOS CarPlay — shows text on the loading maneuver card
+     * @namespace Android Auto — not supported
+     */
+    text?: string;
 };
 export type AutoManeuver = (Array<RoutingManeuver> & {
     length: 0 | 1 | 2;

package/lib/utils/NitroImage.d.ts

@@ -11,11 +11,16 @@ interface GlyphImage {
     backgroundColor: NitroColor;
     fontScale?: number;
 }
+interface RemoteImage {
+    uri: string;
+    color?: NitroColor;
+    timeoutMs?: number;
+}
 /**
  * we need to map the ButtonImage.name from GlyphName to
  * the actual numeric value so we need a nitro specific type
  */
-export type NitroImage = GlyphImage | AssetImage;
+export type NitroImage = GlyphImage | AssetImage | RemoteImage;
 declare function convert(image: AutoImage): NitroImage;
 declare function convert(image?: AutoImage): NitroImage | undefined;
 export declare const NitroImageUtil: {

package/lib/utils/NitroImage.js

@@ -14,6 +14,13 @@ function convert(image) {
             fontScale,
         };
     }
+    if (image.type === 'remote') {
+        return {
+            uri: image.uri,
+            color: NitroColorUtil.convert(image.color),
+            timeoutMs: image.timeoutMs,
+        };
+    }
     // Image.resolveAssetSource is pretty terrible, it will simply return whatever object you pass it is not a number [require(...)]
     // so the input allows all optional parameters which are returned as is even though
     // the return type claims to not have any optional parameters...

package/lib/utils/NitroManeuver.d.ts

@@ -35,6 +35,8 @@ export interface NitroMessageManeuver {
 }
 interface NitroLoadingManeuver {
     isLoading: true;
+    cardBackgroundColor: NitroColor;
+    text?: string;
 }
 export type NitroManeuver = Array<NitroRoutingManeuver> | NitroMessageManeuver | NitroLoadingManeuver;
 declare function convert(autoManeuver: MessageManeuver): NitroMessageManeuver;

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

@@ -49,7 +49,7 @@ target_sources(
   ../nitrogen/generated/android/c++/JHybridAndroidAutomotiveSpec.cpp
   ../nitrogen/generated/android/c++/JHybridAndroidAutoTelemetrySpec.cpp
   ../nitrogen/generated/android/c++/JHybridAutoPlaySpec.cpp
-  ../nitrogen/generated/android/c++/JVariant_GlyphImage_AssetImage.cpp
+  ../nitrogen/generated/android/c++/JVariant_GlyphImage_AssetImage_RemoteImage.cpp
   ../nitrogen/generated/android/c++/JHybridClusterSpec.cpp
   ../nitrogen/generated/android/c++/JNitroImage.cpp
   ../nitrogen/generated/android/c++/JHybridGridTemplateSpec.cpp

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

@@ -33,7 +33,8 @@
 #include "JNitroImage.hpp"
 #include "JNitroMapButton.hpp"
 #include "JNitroMapButtonType.hpp"
-#include "JVariant_GlyphImage_AssetImage.hpp"
+#include "JRemoteImage.hpp"
+#include "JVariant_GlyphImage_AssetImage_RemoteImage.hpp"
 #include "NitroAction.hpp"
 #include "NitroActionType.hpp"
 #include "NitroAlignment.hpp"
@@ -43,6 +44,7 @@
 #include "NitroGridButton.hpp"
 #include "NitroMapButton.hpp"
 #include "NitroMapButtonType.hpp"
+#include "RemoteImage.hpp"
 #include <NitroModules/JNICallable.hpp>
 #include <functional>
 #include <optional>

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

@@ -21,6 +21,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroAction
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct GlyphImage; }
 // Forward declaration of `AssetImage` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct AssetImage; }
+// Forward declaration of `RemoteImage` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct RemoteImage; }
 // Forward declaration of `NitroColor` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroColor; }
 // Forward declaration of `NitroActionType` to properly resolve imports.
@@ -35,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"
@@ -54,12 +58,14 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroBu
 #include "JNitroAction.hpp"
 #include "GlyphImage.hpp"
 #include "AssetImage.hpp"
+#include "RemoteImage.hpp"
 #include <variant>
-#include "JVariant_GlyphImage_AssetImage.hpp"
+#include "JVariant_GlyphImage_AssetImage_RemoteImage.hpp"
 #include "JGlyphImage.hpp"
 #include "NitroColor.hpp"
 #include "JNitroColor.hpp"
 #include "JAssetImage.hpp"
+#include "JRemoteImage.hpp"
 #include "NitroActionType.hpp"
 #include "JNitroActionType.hpp"
 #include "NitroAlignment.hpp"
@@ -139,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/c++/JHybridClusterSpec.cpp

@@ -17,6 +17,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroAttrib
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct GlyphImage; }
 // Forward declaration of `AssetImage` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct AssetImage; }
+// Forward declaration of `RemoteImage` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct RemoteImage; }
 // Forward declaration of `NitroColor` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroColor; }
 // Forward declaration of `ColorScheme` to properly resolve imports.
@@ -42,12 +44,14 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class ZoomEve
 #include "JNitroAttributedStringImage.hpp"
 #include "GlyphImage.hpp"
 #include "AssetImage.hpp"
+#include "RemoteImage.hpp"
 #include <variant>
 #include "JNitroImage.hpp"
 #include "JGlyphImage.hpp"
 #include "NitroColor.hpp"
 #include "JNitroColor.hpp"
 #include "JAssetImage.hpp"
+#include "JRemoteImage.hpp"
 #include "ColorScheme.hpp"
 #include "JFunc_void_std__string_ColorScheme.hpp"
 #include "JColorScheme.hpp"

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

@@ -15,6 +15,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroAction
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct GlyphImage; }
 // Forward declaration of `AssetImage` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct AssetImage; }
+// Forward declaration of `RemoteImage` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct RemoteImage; }
 // Forward declaration of `NitroColor` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroColor; }
 // Forward declaration of `NitroActionType` to properly resolve imports.
@@ -54,12 +56,14 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroMa
 #include "JNitroAction.hpp"
 #include "GlyphImage.hpp"
 #include "AssetImage.hpp"
+#include "RemoteImage.hpp"
 #include <variant>
-#include "JVariant_GlyphImage_AssetImage.hpp"
+#include "JVariant_GlyphImage_AssetImage_RemoteImage.hpp"
 #include "JGlyphImage.hpp"
 #include "NitroColor.hpp"
 #include "JNitroColor.hpp"
 #include "JAssetImage.hpp"
+#include "JRemoteImage.hpp"
 #include "NitroActionType.hpp"
 #include "JNitroActionType.hpp"
 #include "NitroAlignment.hpp"

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

@@ -15,6 +15,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroAction
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct GlyphImage; }
 // Forward declaration of `AssetImage` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct AssetImage; }
+// Forward declaration of `RemoteImage` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct RemoteImage; }
 // Forward declaration of `NitroColor` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroColor; }
 // Forward declaration of `NitroActionType` to properly resolve imports.
@@ -58,12 +60,14 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroMa
 #include "JNitroAction.hpp"
 #include "GlyphImage.hpp"
 #include "AssetImage.hpp"
+#include "RemoteImage.hpp"
 #include <variant>
-#include "JVariant_GlyphImage_AssetImage.hpp"
+#include "JVariant_GlyphImage_AssetImage_RemoteImage.hpp"
 #include "JGlyphImage.hpp"
 #include "NitroColor.hpp"
 #include "JNitroColor.hpp"
 #include "JAssetImage.hpp"
+#include "JRemoteImage.hpp"
 #include "NitroActionType.hpp"
 #include "JNitroActionType.hpp"
 #include "NitroAlignment.hpp"

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

@@ -15,6 +15,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroAction
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct GlyphImage; }
 // Forward declaration of `AssetImage` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct AssetImage; }
+// Forward declaration of `RemoteImage` to properly resolve imports.
+namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct RemoteImage; }
 // Forward declaration of `NitroColor` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct NitroColor; }
 // Forward declaration of `NitroActionType` to properly resolve imports.
@@ -58,12 +60,14 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { enum class NitroMa
 #include "JNitroAction.hpp"
 #include "GlyphImage.hpp"
 #include "AssetImage.hpp"
+#include "RemoteImage.hpp"
 #include <variant>
-#include "JVariant_GlyphImage_AssetImage.hpp"
+#include "JVariant_GlyphImage_AssetImage_RemoteImage.hpp"
 #include "JGlyphImage.hpp"
 #include "NitroColor.hpp"
 #include "JNitroColor.hpp"
 #include "JAssetImage.hpp"
+#include "JRemoteImage.hpp"
 #include "NitroActionType.hpp"
 #include "JNitroActionType.hpp"
 #include "NitroAlignment.hpp"