@iternio/react-native-auto-play 0.5.3 → 0.5.5

package/ios/utils/VoiceInputManager.swift

@@ -3,6 +3,31 @@ import CarPlay
 import NitroModules
 import Speech
 
+/// Keeps itself and the player alive until playback finishes.
+/// Needed because AVAudioPlayer.delegate is weak, so without an external strong
+/// reference the delegate (and player) would be released immediately after play().
+private final class AudioPlayerDelegate: NSObject, AVAudioPlayerDelegate, @unchecked Sendable {
+    private let onFinish: () -> Void
+    private var keepAlive: AudioPlayerDelegate?
+    private var player: AVAudioPlayer?
+
+    init(player: AVAudioPlayer, _ onFinish: @escaping () -> Void) {
+        self.onFinish = onFinish
+        self.player = player
+        super.init()
+        keepAlive = self
+    }
+
+    private func finish() {
+        player = nil
+        keepAlive = nil
+        onFinish()
+    }
+
+    func audioPlayerDidFinishPlaying(_: AVAudioPlayer, successfully _: Bool) { finish() }
+    func audioPlayerDecodeErrorDidOccur(_: AVAudioPlayer, error _: Error?) { finish() }
+}
+
 /// 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 {
@@ -36,6 +61,8 @@ class VoiceInputManager {
     private var resultBox: ResultBox?
     private var samples: [Int16] = []
     private var isStopping = false
+    private var cancelledByUser = false
+    private var isIgnoringSamples = false
     private let stopLock = NSLock()
 
     // STT
@@ -65,11 +92,19 @@ class VoiceInputManager {
         silenceThresholdMs: Double,
         maxDurationMs: Double,
         listeningText: String,
+        listeningImage: Variant_GlyphImage_AssetImage_RemoteImage?,
+        listeningImageRepeats: Bool?,
         preferSpeechToText: Bool,
         onChunk: ((_ chunk: VoiceInputChunk) -> Void)?,
-        language: String?
+        language: String?,
+        startSoundUri: String?,
+        endSoundUri: String?
     ) async throws -> VoiceInputResult {
-        return try await withCheckedThrowingContinuation { cont in
+        stopLock.withLock {
+            cancelledByUser = false
+        }
+
+        let result = try await withCheckedThrowingContinuation { cont in
             let box = ResultBox(cont)
             self.resultBox = box
             self.samples = []
@@ -81,7 +116,6 @@ class VoiceInputManager {
                     interfaceController: interfaceController,
                     silenceThresholdMs: silenceThresholdMs,
                     maxDurationMs: maxDurationMs,
-                    listeningText: listeningText,
                     preferSpeechToText: preferSpeechToText,
                     onChunk: onChunk,
                     box: box,
@@ -91,8 +125,68 @@ class VoiceInputManager {
             catch {
                 self.cleanup(interfaceController: interfaceController)
                 box.resume(throwing: error)
+                return
+            }
+
+            // Mic is open — present template then play start sound.
+            // isIgnoringSamples discards tap buffers during the sound so it isn't recorded.
+            // recordingStart is set after the sound so silence/max-duration timers are accurate.
+            self.stopLock.withLock { self.isIgnoringSamples = startSoundUri != nil }
+            Task {
+                if let interfaceController = interfaceController {
+                    await self.presentVoiceTemplate(
+                        interfaceController: interfaceController,
+                        listeningText: listeningText,
+                        listeningImage: listeningImage,
+                        listeningImageRepeats: listeningImageRepeats
+                    )
+                }
+                if let uri = startSoundUri {
+                    await self.playSound(uri: uri, setupSession: false)
+                }
+                self.stopLock.withLock {
+                    self.isIgnoringSamples = false
+                    self.recordingStart = Date()
+                }
             }
         }
+
+        if let uri = endSoundUri {
+            await playSound(uri: uri)
+        }
+
+        return result
+    }
+
+    private func playSound(uri: String, setupSession: Bool = true) async {
+        guard let url = URL(string: uri) else { return }
+        do {
+            let session = AVAudioSession.sharedInstance()
+            if setupSession {
+                try session.setCategory(.playback, mode: .default)
+                try session.setActive(true)
+            }
+            // URLSession handles both http:// (Metro dev server) and file:// (release bundle)
+            let (data, _) = try await URLSession.shared.data(from: url)
+            await withCheckedContinuation { (cont: CheckedContinuation<Void, Never>) in
+                DispatchQueue.main.async {
+                    do {
+                        let player = try AVAudioPlayer(data: data)
+                        let delegate = AudioPlayerDelegate(player: player) { cont.resume() }
+                        player.delegate = delegate
+                        player.prepareToPlay()
+                        player.play()
+                    }
+                    catch {
+                        cont.resume()
+                    }
+                }
+            }
+        }
+        catch {
+            print(error)
+            // fail silently — a broken sound file must not block voice input
+        }
     }
 
     func stop(interfaceController: AutoPlayInterfaceController? = nil) {
@@ -102,6 +196,7 @@ class VoiceInputManager {
             return
         }
         isStopping = true
+        let wasCancelled = cancelledByUser
         let wasSTTMode = isSTTMode
         let capturedRequest = recognitionRequest
         let box = resultBox
@@ -117,7 +212,12 @@ class VoiceInputManager {
         }
         else {
             cleanup(interfaceController: interfaceController)
-            box?.resume(returning: makePCMResult(from: capturedSamples))
+            if wasCancelled {
+                box?.resume(throwing: AutoPlayError.voiceInputCancelled)
+            }
+            else {
+                box?.resume(returning: makePCMResult(from: capturedSamples))
+            }
         }
     }
 
@@ -127,7 +227,6 @@ class VoiceInputManager {
         interfaceController: AutoPlayInterfaceController?,
         silenceThresholdMs: Double,
         maxDurationMs: Double,
-        listeningText: String,
         preferSpeechToText: Bool,
         onChunk: ((_ chunk: VoiceInputChunk) -> Void)?,
         box: ResultBox,
@@ -141,14 +240,12 @@ class VoiceInputManager {
         try session.setCategory(.playAndRecord, mode: .measurement, options: [])
         try session.setActive(true)
 
-        if let interfaceController {
-            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),
+            let recognizer = language != nil
+                ? SFSpeechRecognizer(locale: Locale(identifier: language!))
+                : SFSpeechRecognizer(locale: Locale.current),
             recognizer.isAvailable
         {
             let request = SFSpeechAudioBufferRecognitionRequest()
@@ -163,12 +260,18 @@ class VoiceInputManager {
                     // STT failed — fall back to whatever PCM was accumulated
                     self.stopLock.lock()
                     self.isStopping = true
+                    let wasCancelled = self.cancelledByUser
                     let capturedSamples = self.samples
                     self.samples = []
                     self.stopLock.unlock()
 
                     self.cleanup(interfaceController: interfaceController)
-                    box.resume(returning: self.makePCMResult(from: capturedSamples))
+                    if wasCancelled {
+                        box.resume(throwing: AutoPlayError.voiceInputCancelled)
+                    }
+                    else {
+                        box.resume(returning: self.makePCMResult(from: capturedSamples))
+                    }
                     return
                 }
 
@@ -177,16 +280,22 @@ class VoiceInputManager {
                 if result.isFinal {
                     self.stopLock.lock()
                     self.isStopping = true
+                    let wasCancelled = self.cancelledByUser
                     self.samples = []
                     self.stopLock.unlock()
 
                     self.cleanup(interfaceController: interfaceController)
-                    box.resume(
-                        returning: VoiceInputResult(
-                            transcription: result.bestTranscription.formattedString,
-                            audio: nil
+                    if wasCancelled {
+                        box.resume(throwing: AutoPlayError.voiceInputCancelled)
+                    }
+                    else {
+                        box.resume(
+                            returning: VoiceInputResult(
+                                transcription: result.bestTranscription.formattedString,
+                                audio: nil
+                            )
                         )
-                    )
+                    }
                 }
                 else {
                     onChunk?(VoiceInputChunk(partial: result.bestTranscription.formattedString, audio: nil))
@@ -202,15 +311,24 @@ class VoiceInputManager {
             throw VoiceInputError.converterUnavailable
         }
 
-        recordingStart = Date()
+        recordingStart = nil
         silenceStart = nil
+        isIgnoringSamples = false
 
         inputNode.installTap(
             onBus: 0,
             bufferSize: VoiceInputManager.tapBufferSize,
             format: nativeFormat
         ) { [weak self] buffer, _ in
-            guard let self, !self.isStopping else { return }
+            guard let self else { return }
+
+            self.stopLock.lock()
+            let stopping = self.isStopping
+            let ignoringSamples = self.isIgnoringSamples
+            let recordingStartSnapshot = self.recordingStart
+            self.stopLock.unlock()
+
+            guard !stopping, !ignoringSamples else { return }
 
             // Feed STT if active
             activeRecognitionRequest?.append(buffer)
@@ -253,7 +371,7 @@ class VoiceInputManager {
             let now = Date()
 
             // Max duration — applies in both modes
-            if let start = self.recordingStart,
+            if let start = recordingStartSnapshot,
                 now.timeIntervalSince(start) * 1000 >= maxDurationMs
             {
                 self.triggerAutoStop(interfaceController: interfaceController)
@@ -262,7 +380,7 @@ class VoiceInputManager {
 
             // Silence detection — skip during warm-up so the pipeline has time
             // to stabilise before we start measuring amplitude
-            if let start = self.recordingStart,
+            if let start = recordingStartSnapshot,
                 now.timeIntervalSince(start) * 1000 >= VoiceInputManager.warmupMs
             {
                 let peak = newSamples.reduce(0) { max($0, abs(Int($1))) }
@@ -311,21 +429,98 @@ class VoiceInputManager {
         return VoiceInputResult(transcription: nil, audio: buffer)
     }
 
-    private func presentVoiceTemplate(interfaceController: AutoPlayInterfaceController, listeningText: String) {
+    // CPVoiceControlState enforces a maximum image size of 150x150 points.
+    private static let voiceImageMaxSize = CGSize(width: 150, height: 150)
+
+    // CPVoiceControlState also enforces a 0.3s–5s animation cycle; the 0.3s floor is applied
+    // by the system regardless of what we pass, so we only need to clamp our own ceiling.
+    private static let maxVoiceImageCycleDuration: TimeInterval = 5.0
+
+    // Bypasses RCTConvert for asset images: it collapses animated UIImages to a single frame
+    // via CGImage during scale adjustment. Parser.decodeImage preserves animation frames by
+    // walking every frame in the source via ImageIO — UIImage(data:) never builds a multi-frame
+    // .images array itself, for GIF, APNG, or WebP. Tinting is skipped for animated images since
+    // frames cannot be tinted individually.
+    private func loadVoiceImage(image: Variant_GlyphImage_AssetImage_RemoteImage?, traitCollection: UITraitCollection)
+        -> UIImage?
+    {
+        guard let image else { return nil }
+
+        if let assetImage = image.assetImage {
+            guard let url = URL(string: assetImage.uri),
+                let data = try? Data(contentsOf: url),
+                let uiImage = Parser.decodeImage(
+                    data: data,
+                    scale: CGFloat(assetImage.scale),
+                    maxDuration: VoiceInputManager.maxVoiceImageCycleDuration
+                )
+            else { return nil }
+
+            if uiImage.images != nil {
+                return Parser.resizeAnimated(uiImage, max: VoiceInputManager.voiceImageMaxSize)
+            }
+
+            if assetImage.color == nil {
+                return Parser.resize(uiImage, max: VoiceInputManager.voiceImageMaxSize)
+            }
+
+            guard let tinted = Parser.parseAssetImage(assetImage: assetImage, traitCollection: traitCollection) else {
+                return nil
+            }
+            return Parser.resize(tinted, max: VoiceInputManager.voiceImageMaxSize)
+        }
+
+        if let glyphImage = image.glyphImage {
+            return
+                SymbolFont
+                .imageFromGlyph(
+                    glyphImage: glyphImage,
+                    size: 150,  // according to docs on CPVoiceControlState.image
+                    foregroundColor: glyphImage.color,
+                    backgroundColor: glyphImage.backgroundColor,
+                    fontScale: glyphImage.fontScale ?? 1.0,
+                    traitCollection: traitCollection
+                )
+        }
+
+        return nil
+    }
+
+    @MainActor
+    private func presentVoiceTemplate(
+        interfaceController: AutoPlayInterfaceController,
+        listeningText: String,
+        listeningImage: Variant_GlyphImage_AssetImage_RemoteImage?,
+        listeningImageRepeats: Bool?
+    ) async {
+        let traitCollection = SceneStore.getRootTraitCollection() ?? UITraitCollection.current
+        let image = loadVoiceImage(
+            image: listeningImage,
+            traitCollection: traitCollection
+        )
+
+        let repeats = listeningImageRepeats ?? (image?.images != nil)
         let listeningState = CPVoiceControlState(
             identifier: "listening",
             titleVariants: [listeningText],
-            image: nil,
-            repeats: true
+            image: image,
+            repeats: repeats
         )
-        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")
+        let voiceTemplate = VoiceInputTemplate(
+            voiceControlStates: [listeningState],
+            id: "voice-input"
+        ) { [weak self] in
+            guard let self else { return }
+            self.stopLock.withLock {
+                if !self.isStopping { self.cancelledByUser = true }
+            }
+            self.stop()
         }
+
+        voiceControlTemplate = voiceTemplate.template
+        try? await interfaceController.presentTemplate(voiceTemplate.template, animated: true)
+        voiceTemplate.template.activateVoiceControlState(withIdentifier: "listening")
     }
 
     private func dismissVoiceTemplate(interfaceController: AutoPlayInterfaceController) {

package/lib/hybrid/HybridVoice.js

@@ -1,8 +1,13 @@
+import { Image } from 'react-native';
 import { NitroModules } from 'react-native-nitro-modules';
+import { NitroImageUtil } from '../utils/NitroImage';
 const _native = NitroModules.createHybridObject('Voice');
 const startVoiceInput = async (options) => {
-    const { onChunk, silenceThresholdMs, maxDurationMs, listeningText, preferSpeechToText, language, } = options ?? {};
-    return await _native.startVoiceInput(silenceThresholdMs, maxDurationMs, listeningText, preferSpeechToText, onChunk, language);
+    const { onChunk, silenceThresholdMs, maxDurationMs, listeningText, listeningImage, preferSpeechToText, language, startSound, endSound, } = options ?? {};
+    const listeningImageRepeats = listeningImage?.type === 'asset' ? listeningImage.repeats : undefined;
+    const startSoundUri = startSound != null ? Image.resolveAssetSource(startSound).uri : undefined;
+    const endSoundUri = endSound != null ? Image.resolveAssetSource(endSound).uri : undefined;
+    return await _native.startVoiceInput(silenceThresholdMs, maxDurationMs, listeningText, NitroImageUtil.convert(listeningImage), listeningImageRepeats, preferSpeechToText, onChunk, language, startSoundUri, endSoundUri);
 };
 export const HybridVoice = {
     /**

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

@@ -1,11 +1,12 @@
 import type { HybridObject } from 'react-native-nitro-modules';
 import type { VoiceInputChunk, VoiceInputResult } from '../types/Voice';
+import type { NitroImage } from '../utils/NitroImage';
 export interface Voice extends HybridObject<{
     android: 'kotlin';
     ios: 'swift';
 }> {
     hasVoiceInputPermission(): boolean;
     requestVoiceInputPermission(): Promise<boolean>;
-    startVoiceInput(silenceThresholdMs?: number, maxDurationMs?: number, listeningText?: string, preferSpeechToText?: boolean, onChunk?: (chunk: VoiceInputChunk) => void, language?: string): Promise<VoiceInputResult>;
+    startVoiceInput(silenceThresholdMs?: number, maxDurationMs?: number, listeningText?: string, listeningImage?: NitroImage, listeningImageRepeats?: boolean, preferSpeechToText?: boolean, onChunk?: (chunk: VoiceInputChunk) => void, language?: string, startSoundUri?: string, endSoundUri?: string): Promise<VoiceInputResult>;
     stopVoiceInput(): void;
 }

package/lib/templates/Template.d.ts

@@ -4,7 +4,7 @@ import type { NitroMapButton } from '../utils/NitroMapButton';
 export type ActionButton<T> = ActionButtonAndroid<T> | ActionButtonIos<T>;
 export type HeaderActionsIos<T> = {
     /**
-     * @platform iOS - the back button can not be hidden or disabled, if you don't define it iOS will provide a default back button popping the template
+     * @namespace iOS - the back button can not be hidden or disabled, if you don't define it iOS will provide a default back button popping the template
      */
     backButton?: BackButton<T>;
     leadingNavigationBarButtons?: [ActionButtonIos<T>, ActionButtonIos<T>] | [ActionButtonIos<T>];

package/lib/types/Image.d.ts

@@ -66,4 +66,20 @@ export type AutoImage = AutoGlyph | {
     timeoutMs?: number;
     type: 'remote';
 };
+/**
+ * Image for the CarPlay voice control overlay. Animated GIF, APNG, and WebP all animate.
+ * `color` is ignored for animated assets — frames cannot be tinted individually. Static
+ * assets and glyphs are resized/capped to fit within 150×150pt (`fontScale` controls a
+ * glyph's relative size). CarPlay enforces a 0.3s–5s animation cycle duration: shorter
+ * source animations are stretched to 0.3s by the system, longer ones are capped to 5s.
+ * @namespace ios
+ */
+export type VoiceInputImage = AutoGlyph | {
+    type: 'asset';
+    image: ImageSourcePropType;
+    /** Tints the image. Ignored for animated assets — frames cannot be tinted individually. */
+    color?: ThemedColor | string;
+    /** Whether the animation loops. Defaults to `true` for animated images, `false` for static. */
+    repeats?: boolean;
+};
 export {};

package/lib/types/Voice.d.ts

@@ -1,3 +1,4 @@
+import type { VoiceInputImage } from './Image';
 export interface VoiceInputChunk {
     partial?: string;
     audio?: ArrayBuffer;
@@ -10,7 +11,15 @@ export interface VoiceInputOptions {
     silenceThresholdMs?: number;
     maxDurationMs?: number;
     listeningText?: string;
+    /** Image displayed in the CarPlay voice control overlay. See {@link VoiceInputImage}.
+     * @namespace ios
+     */
+    listeningImage?: VoiceInputImage;
     preferSpeechToText?: boolean;
     onChunk?: (chunk: VoiceInputChunk) => void;
     language?: string;
+    /** Sound played just before recording starts. Pass a Metro asset: `require('./beep_start.wav')`. */
+    startSound?: number;
+    /** Sound played just after recording stops. Pass a Metro asset: `require('./beep_end.wav')`. */
+    endSound?: number;
 }

package/lib/utils/ErrorUtil.d.ts

@@ -1,3 +1,4 @@
 export declare const ErrorUtil: {
     isTemplateNotFoundError: (error: unknown) => error is Error;
+    isVoiceInputCanceledError: (error: unknown) => error is Error;
 };

package/lib/utils/ErrorUtil.js

@@ -1,4 +1,4 @@
-const isTemplateNotFoundError = (error) => {
+const isError = (error) => {
     if (error == null) {
         return false;
     }
@@ -14,6 +14,18 @@ const isTemplateNotFoundError = (error) => {
     if (typeof error.message !== 'string') {
         return false;
     }
-    return error.message.startsWith('templateNotFound');
+    return true;
+};
+const isTemplateNotFoundError = (error) => {
+    if (isError(error)) {
+        return error.message.startsWith('templateNotFound');
+    }
+    return false;
+};
+const isVoiceInputCanceledError = (error) => {
+    if (isError(error)) {
+        return error.message.startsWith('voiceInputCancelled');
+    }
+    return false;
 };
-export const ErrorUtil = { isTemplateNotFoundError };
+export const ErrorUtil = { isTemplateNotFoundError, isVoiceInputCanceledError };

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

@@ -9,6 +9,14 @@
 
 // Forward declaration of `VoiceInputResult` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct VoiceInputResult; }
+// Forward declaration of `GlyphImage` to properly resolve imports.
+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 `VoiceInputChunk` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct VoiceInputChunk; }
 
@@ -20,6 +28,16 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct VoiceInputC
 #include <optional>
 #include <NitroModules/ArrayBuffer.hpp>
 #include <NitroModules/JArrayBuffer.hpp>
+#include "GlyphImage.hpp"
+#include "AssetImage.hpp"
+#include "RemoteImage.hpp"
+#include <variant>
+#include "JVariant_GlyphImage_AssetImage_RemoteImage.hpp"
+#include "JGlyphImage.hpp"
+#include "NitroColor.hpp"
+#include "JNitroColor.hpp"
+#include "JAssetImage.hpp"
+#include "JRemoteImage.hpp"
 #include "VoiceInputChunk.hpp"
 #include <functional>
 #include "JFunc_void_VoiceInputChunk.hpp"
@@ -80,9 +98,9 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       return __promise;
     }();
   }
-  std::shared_ptr<Promise<VoiceInputResult>> JHybridVoiceSpec::startVoiceInput(std::optional<double> silenceThresholdMs, std::optional<double> maxDurationMs, const std::optional<std::string>& listeningText, std::optional<bool> preferSpeechToText, const std::optional<std::function<void(const VoiceInputChunk& /* chunk */)>>& onChunk, const std::optional<std::string>& language) {
-    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 */, jni::alias_ref<jni::JBoolean> /* preferSpeechToText */, jni::alias_ref<JFunc_void_VoiceInputChunk::javaobject> /* onChunk */, jni::alias_ref<jni::JString> /* language */)>("startVoiceInput_cxx");
-    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, preferSpeechToText.has_value() ? jni::JBoolean::valueOf(preferSpeechToText.value()) : nullptr, onChunk.has_value() ? JFunc_void_VoiceInputChunk_cxx::fromCpp(onChunk.value()) : nullptr, language.has_value() ? jni::make_jstring(language.value()) : nullptr);
+  std::shared_ptr<Promise<VoiceInputResult>> JHybridVoiceSpec::startVoiceInput(std::optional<double> silenceThresholdMs, std::optional<double> maxDurationMs, const std::optional<std::string>& listeningText, const std::optional<std::variant<GlyphImage, AssetImage, RemoteImage>>& listeningImage, std::optional<bool> listeningImageRepeats, std::optional<bool> preferSpeechToText, const std::optional<std::function<void(const VoiceInputChunk& /* chunk */)>>& onChunk, const std::optional<std::string>& language, const std::optional<std::string>& startSoundUri, const std::optional<std::string>& endSoundUri) {
+    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 */, jni::alias_ref<JVariant_GlyphImage_AssetImage_RemoteImage> /* listeningImage */, jni::alias_ref<jni::JBoolean> /* listeningImageRepeats */, jni::alias_ref<jni::JBoolean> /* preferSpeechToText */, jni::alias_ref<JFunc_void_VoiceInputChunk::javaobject> /* onChunk */, jni::alias_ref<jni::JString> /* language */, jni::alias_ref<jni::JString> /* startSoundUri */, jni::alias_ref<jni::JString> /* endSoundUri */)>("startVoiceInput_cxx");
+    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, listeningImage.has_value() ? JVariant_GlyphImage_AssetImage_RemoteImage::fromCpp(listeningImage.value()) : nullptr, listeningImageRepeats.has_value() ? jni::JBoolean::valueOf(listeningImageRepeats.value()) : nullptr, preferSpeechToText.has_value() ? jni::JBoolean::valueOf(preferSpeechToText.value()) : nullptr, onChunk.has_value() ? JFunc_void_VoiceInputChunk_cxx::fromCpp(onChunk.value()) : nullptr, language.has_value() ? jni::make_jstring(language.value()) : nullptr, startSoundUri.has_value() ? jni::make_jstring(startSoundUri.value()) : nullptr, endSoundUri.has_value() ? jni::make_jstring(endSoundUri.value()) : nullptr);
     return [&]() {
       auto __promise = Promise<VoiceInputResult>::create();
       __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {

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

@@ -56,7 +56,7 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
     // Methods
     bool hasVoiceInputPermission() override;
     std::shared_ptr<Promise<bool>> requestVoiceInputPermission() override;
-    std::shared_ptr<Promise<VoiceInputResult>> startVoiceInput(std::optional<double> silenceThresholdMs, std::optional<double> maxDurationMs, const std::optional<std::string>& listeningText, std::optional<bool> preferSpeechToText, const std::optional<std::function<void(const VoiceInputChunk& /* chunk */)>>& onChunk, const std::optional<std::string>& language) override;
+    std::shared_ptr<Promise<VoiceInputResult>> startVoiceInput(std::optional<double> silenceThresholdMs, std::optional<double> maxDurationMs, const std::optional<std::string>& listeningText, const std::optional<std::variant<GlyphImage, AssetImage, RemoteImage>>& listeningImage, std::optional<bool> listeningImageRepeats, std::optional<bool> preferSpeechToText, const std::optional<std::function<void(const VoiceInputChunk& /* chunk */)>>& onChunk, const std::optional<std::string>& language, const std::optional<std::string>& startSoundUri, const std::optional<std::string>& endSoundUri) override;
     void stopVoiceInput() override;
 
   private:

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

@@ -37,12 +37,12 @@ abstract class HybridVoiceSpec: HybridObject() {
   @Keep
   abstract fun requestVoiceInputPermission(): Promise<Boolean>
   
-  abstract fun startVoiceInput(silenceThresholdMs: Double?, maxDurationMs: Double?, listeningText: String?, preferSpeechToText: Boolean?, onChunk: ((chunk: VoiceInputChunk) -> Unit)?, language: String?): Promise<VoiceInputResult>
+  abstract fun startVoiceInput(silenceThresholdMs: Double?, maxDurationMs: Double?, listeningText: String?, listeningImage: Variant_GlyphImage_AssetImage_RemoteImage?, listeningImageRepeats: Boolean?, preferSpeechToText: Boolean?, onChunk: ((chunk: VoiceInputChunk) -> Unit)?, language: String?, startSoundUri: String?, endSoundUri: String?): Promise<VoiceInputResult>
   
   @DoNotStrip
   @Keep
-  private fun startVoiceInput_cxx(silenceThresholdMs: Double?, maxDurationMs: Double?, listeningText: String?, preferSpeechToText: Boolean?, onChunk: Func_void_VoiceInputChunk?, language: String?): Promise<VoiceInputResult> {
-    val __result = startVoiceInput(silenceThresholdMs, maxDurationMs, listeningText, preferSpeechToText, onChunk?.let { it }, language)
+  private fun startVoiceInput_cxx(silenceThresholdMs: Double?, maxDurationMs: Double?, listeningText: String?, listeningImage: Variant_GlyphImage_AssetImage_RemoteImage?, listeningImageRepeats: Boolean?, preferSpeechToText: Boolean?, onChunk: Func_void_VoiceInputChunk?, language: String?, startSoundUri: String?, endSoundUri: String?): Promise<VoiceInputResult> {
+    val __result = startVoiceInput(silenceThresholdMs, maxDurationMs, listeningText, listeningImage, listeningImageRepeats, preferSpeechToText, onChunk?.let { it }, language, startSoundUri, endSoundUri)
     return __result
   }
   

package/nitrogen/generated/ios/c++/HybridVoiceSpecSwift.hpp

@@ -16,6 +16,14 @@ namespace ReactNativeAutoPlay { class HybridVoiceSpec_cxx; }
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct VoiceInputResult; }
 // Forward declaration of `ArrayBufferHolder` to properly resolve imports.
 namespace NitroModules { class ArrayBufferHolder; }
+// Forward declaration of `GlyphImage` to properly resolve imports.
+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 `VoiceInputChunk` to properly resolve imports.
 namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct VoiceInputChunk; }
 
@@ -25,6 +33,11 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay { struct VoiceInputC
 #include <optional>
 #include <NitroModules/ArrayBuffer.hpp>
 #include <NitroModules/ArrayBufferHolder.hpp>
+#include "GlyphImage.hpp"
+#include "AssetImage.hpp"
+#include "RemoteImage.hpp"
+#include <variant>
+#include "NitroColor.hpp"
 #include "VoiceInputChunk.hpp"
 #include <functional>
 
@@ -94,8 +107,8 @@ namespace margelo::nitro::swe::iternio::reactnativeautoplay {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::shared_ptr<Promise<VoiceInputResult>> startVoiceInput(std::optional<double> silenceThresholdMs, std::optional<double> maxDurationMs, const std::optional<std::string>& listeningText, std::optional<bool> preferSpeechToText, const std::optional<std::function<void(const VoiceInputChunk& /* chunk */)>>& onChunk, const std::optional<std::string>& language) override {
-      auto __result = _swiftPart.startVoiceInput(silenceThresholdMs, maxDurationMs, listeningText, preferSpeechToText, onChunk, language);
+    inline std::shared_ptr<Promise<VoiceInputResult>> startVoiceInput(std::optional<double> silenceThresholdMs, std::optional<double> maxDurationMs, const std::optional<std::string>& listeningText, const std::optional<std::variant<GlyphImage, AssetImage, RemoteImage>>& listeningImage, std::optional<bool> listeningImageRepeats, std::optional<bool> preferSpeechToText, const std::optional<std::function<void(const VoiceInputChunk& /* chunk */)>>& onChunk, const std::optional<std::string>& language, const std::optional<std::string>& startSoundUri, const std::optional<std::string>& endSoundUri) override {
+      auto __result = _swiftPart.startVoiceInput(silenceThresholdMs, maxDurationMs, listeningText, listeningImage, listeningImageRepeats, preferSpeechToText, onChunk, language, startSoundUri, endSoundUri);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }

package/nitrogen/generated/ios/swift/HybridVoiceSpec.swift

@@ -15,7 +15,7 @@ public protocol HybridVoiceSpec_protocol: HybridObject {
   // Methods
   func hasVoiceInputPermission() throws -> Bool
   func requestVoiceInputPermission() throws -> Promise<Bool>
-  func startVoiceInput(silenceThresholdMs: Double?, maxDurationMs: Double?, listeningText: String?, preferSpeechToText: Bool?, onChunk: ((_ chunk: VoiceInputChunk) -> Void)?, language: String?) throws -> Promise<VoiceInputResult>
+  func startVoiceInput(silenceThresholdMs: Double?, maxDurationMs: Double?, listeningText: String?, listeningImage: Variant_GlyphImage_AssetImage_RemoteImage?, listeningImageRepeats: Bool?, preferSpeechToText: Bool?, onChunk: ((_ chunk: VoiceInputChunk) -> Void)?, language: String?, startSoundUri: String?, endSoundUri: String?) throws -> Promise<VoiceInputResult>
   func stopVoiceInput() throws -> Void
 }