@gmessier/nitro-speech 0.3.3 → 0.4.0

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

@@ -0,0 +1,95 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+import type { MutableSpeechRecognitionConfig, SpeechRecognitionConfig } from './SpeechRecognitionConfig';
+import type { VolumeChangeEvent } from './VolumeChangeEvent';
+export interface Recognizer extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    /**
+     * Prepare the speech recognition engine and the model for the given parameters.
+     *
+     * Omit the {@linkcode Promise} result if want to run synchronously.
+     * {@linkcode startListening} will start and resolve it automatically.
+     * Only `await` if run beforehand and want to react on the success
+     */
+    prewarm(defaultParams?: SpeechRecognitionConfig): Promise<void>;
+    /**
+     * Try to start the speech recognition.
+     *
+     * Not guaranteed to start the speech recognition.
+     *
+     * On success - {@linkcode onReadyForSpeech} is called
+     *
+     * On failure - {@linkcode onError} is called
+     */
+    startListening(params?: SpeechRecognitionConfig): void;
+    /**
+     * Stops the speech recognition. if not started, does nothing.
+     *
+     * Not a sync operation for android, delay about 250ms to polish the result.
+     *
+     * Use {@linkcode onRecordingStopped} to handle the stop event.
+     */
+    stopListening(): void;
+    /**
+     * Reset the auto finish timer to current {@linkcode SpeechRecognitionConfig.autoFinishRecognitionMs}.
+     */
+    resetAutoFinishTime(): void;
+    /**
+     * Add time to the auto finish timer once without changing the timer threshold.
+     *
+     * @param additionalTimeMs - time in ms to add to the current auto finish timer. If not set, will reset the timer to the original {@linkcode SpeechRecognitionConfig.autoFinishRecognitionMs}.
+     */
+    addAutoFinishTime(additionalTimeMs?: number): void;
+    /**
+     * Applies changes only within the active recognition session.
+     *
+     * @param newConfig - new dynamic params for the speech recognition.
+     * @param resetAutoFinishTime - if true, will reset auto finish time to actual {@linkcode SpeechRecognitionConfig.autoFinishRecognitionMs}.
+     */
+    updateConfig(newConfig?: MutableSpeechRecognitionConfig, resetAutoFinishTime?: boolean): void;
+    /**
+     * Returns true if the speech recognition is active.
+     */
+    getIsActive(): boolean;
+    /**
+     * Returns a list of supported locales.
+     *
+     * @platform iOS only
+     */
+    getSupportedLocalesIOS(): string[];
+    /**
+     * The speech recognition session has started.
+     */
+    onReadyForSpeech?: () => void;
+    /**
+     * The speech recognition session has stopped.
+     */
+    onRecordingStopped?: () => void;
+    /**
+     * Called each time either a new batch has been added or the last batch has been updated.
+     */
+    onResult?: (resultBatches: string[]) => void;
+    /**
+     * Called every {@linkcode SpeechRecognitionConfig.autoFinishProgressIntervalMs} or 1000ms
+     *
+     * Time left in milliseconds until the timer stops.
+     *
+     * @note not implemented for Android yet.
+     */
+    onAutoFinishProgress?: (timeLeftMs: number) => void;
+    /**
+     * Error of the speech recognition.
+     */
+    onError?: (message: string) => void;
+    /**
+     * The permission to use the microphone or recognize speech has been denied.
+     */
+    onPermissionDenied?: () => void;
+    /**
+     * Called with high and arbitrary frequency (many times per second) while audio recording is active.
+     *
+     * @warning overriding it will disable the built-in `useVoiceInputVolume` hook.
+     */
+    onVolumeChange?: (event: VolumeChangeEvent) => void;
+}

package/lib/specs/Recognizer.nitro.js

@@ -0,0 +1 @@
+export {};

package/lib/specs/SpeechRecognitionConfig.d.ts

@@ -0,0 +1,162 @@
+interface ParamsAndroid {
+    /**
+     * Prefer quality over latency (may break autofinish, depends on device)
+     *
+     * @since Android 13+
+     *
+     * @default false
+     */
+    androidFormattingPreferQuality?: boolean;
+    /**
+     * Language model based on web search terms. (may not work on some devices)
+     *
+     * Free form model by default
+     *
+     * @default false
+     */
+    androidUseWebSearchModel?: boolean;
+    /**
+     * Without batch handling the result will contain empty or same content batches.
+     *
+     * @default false
+     */
+    androidDisableBatchHandling?: boolean;
+}
+type IosPreset = 'shortform' | 'general';
+interface ParamsIOS {
+    /**
+     * Add punctuation to speech recognition results
+     *
+     * @since iOS 16.0+
+     *
+     * @default true
+     */
+    iosAddPunctuation?: boolean;
+    /**
+     * `"shortForm"` - for a short phrase or sentence, also disables punctuation
+     *
+     * `"general"` - for longer speeches, more accurate but delayed response
+     *
+     * @since iOS 26.0+
+     *
+     * @default "general"
+     */
+    iosPreset?: IosPreset;
+    /**
+     * A processing hint indicating that the audio is from a speaker with a heavy accent, lisp, or other confounding factor.
+     *
+     * @since iOS 26.0+
+     *
+     * @default false
+     */
+    iosAtypicalSpeech?: boolean;
+}
+type HapticFeedbackStyle = 'light' | 'medium' | 'heavy' | 'none';
+export interface MutableSpeechRecognitionConfig {
+    /**
+     * Silence timer duration with no voice detected
+     *
+     * for Android - undefined behavior for > 300_000ms (5 minutes)
+     *
+     * @default 8000
+     */
+    autoFinishRecognitionMs?: number;
+    /**
+     * The interval at which `onAutoFinishProgress` will be triggered.
+     *
+     * min: 50ms,
+     *
+     * max: {@link autoFinishRecognitionMs}
+     *
+     * @default 1000
+     */
+    autoFinishProgressIntervalMs?: number;
+    /**
+     * The voice detector sensitivity to reset the auto finish timer.
+     *
+     * Adjust for your expected environment.
+     *
+     * `0.00` - `1.00`
+     *
+     * `0.10` - Quiet room level
+     *
+     * `0.40` - Default, street, medium restaurant background, office level
+     *
+     * `0.60` - Loud restaurants, noisy office, party, highly crowded places level
+     *
+     * `1` - Use to disable volume-based reset of the auto finish timer
+     *
+     * @default 0.40
+     */
+    resetAutoFinishVoiceSensitivity?: number;
+    /**
+     * Lots of repeating words in a row can be annoying
+     *
+     * @default false
+     */
+    disableRepeatingFilter?: boolean;
+    /**
+     * Haptic feedback level when microphone starts recording.
+     *
+     * Use `"none"` to disable.
+     *
+     * @default "medium"
+     */
+    startHapticFeedbackStyle?: HapticFeedbackStyle;
+    /**
+     * Haptic feedback level when microphone stops recording.
+     *
+     * Use `"none"` to disable.
+     *
+     * @default "medium"
+     */
+    stopHapticFeedbackStyle?: HapticFeedbackStyle;
+}
+/**
+ * @note Configuration for android and ios may behave differently
+ * for the same properties, test both platforms
+ *
+ * Use `Plarform.select()` to match expectations
+ */
+export interface SpeechRecognitionConfig extends MutableSpeechRecognitionConfig, ParamsAndroid, ParamsIOS {
+    /**
+     * @default "en-US"
+     *
+     * @example
+     * "fr-FR"
+     * "pt-PT"
+     * "pt-BR"
+     *
+     */
+    locale?: string;
+    /**
+     * An array of strings that should be recognized, even if they are not in the system vocabulary.
+     *
+     * Use this property to specify short custom phrases that are unique to your app.
+     *
+     * You might include phrases with the names of characters, products, or places that are specific to your app.
+     *
+     * You might also include domain-specific terminology or unusual or made-up words.
+     *
+     * Assigning custom phrases to this property improves the likelihood of those phrases being recognized.
+     *
+     * Keep phrases relatively brief, limiting them to one or two words whenever possible.
+     * Lengthy phrases are less likely to be recognized.
+     * In addition, try to limit each phrase to something the user can say without pausing.
+     *
+     * Limit the total number of phrases to no more than 100.
+     *
+     * @default []
+     */
+    contextualStrings?: string[];
+    /**
+     * Mask offensive words with asterisks.
+     *
+     * @since Android 13+
+     * @since iOS 26+ (iOS <26: always `false`)
+     *
+     * @default false
+     */
+    maskOffensiveWords?: boolean;
+}
+export {};

package/lib/specs/SpeechRecognitionConfig.js

@@ -0,0 +1 @@
+export {};

package/lib/specs/VolumeChangeEvent.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Contains data about each audio buffer volume.
+ *
+ * Emits with high frequency.
+ */
+export interface VolumeChangeEvent {
+    /**
+     * Smoothed voice input volume
+     *
+     * Normalized to a range of 0 to 1.
+     *
+     * Best choice for UI animations.
+     */
+    smoothedVolume: number;
+    /**
+     * Raw voice input volume
+     *
+     * Normalized to a range of 0 to 1.
+     *
+     * Appropriate for internal logic, quick reactions, not UI.
+     */
+    rawVolume: number;
+    /**
+     * Audio buffer volume in decibels.
+     *
+     * May vary on different devices and audio engines.
+     *
+     * db 0 is still a sound, undefined is no sound.
+     */
+    db?: number;
+}

package/lib/specs/VolumeChangeEvent.js

@@ -0,0 +1 @@
+export {};

package/nitro.json

@@ -1,15 +1,11 @@
 {
   "$schema": "https://nitro.margelo.com/nitro.schema.json",
   "cxxNamespace": ["nitrospeech"],
-
-
   "ios": {
     "iosModuleName": "NitroSpeech"
   },
   "android": {
     "androidNamespace": ["nitrospeech"],
-
-
     "androidCxxLibName": "NitroSpeech"
   },
   "autolinking": {

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

@@ -33,11 +33,11 @@ target_sources(
   # Autolinking Setup
   ../nitrogen/generated/android/NitroSpeechOnLoad.cpp
   # Shared Nitrogen C++ sources
-  ../nitrogen/generated/shared/c++/HybridRecognizerSpec.cpp
   ../nitrogen/generated/shared/c++/HybridNitroSpeechSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridRecognizerSpec.cpp
   # Android-specific Nitrogen C++ sources
-  ../nitrogen/generated/android/c++/JHybridRecognizerSpec.cpp
   ../nitrogen/generated/android/c++/JHybridNitroSpeechSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridRecognizerSpec.cpp
 )
 
 # From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake

package/nitrogen/generated/android/NitroSpeechOnLoad.cpp

@@ -15,12 +15,13 @@
 #include <fbjni/fbjni.h>
 #include <NitroModules/HybridObjectRegistry.hpp>
 
+#include "JHybridNitroSpeechSpec.hpp"
 #include "JHybridRecognizerSpec.hpp"
 #include "JFunc_void.hpp"
 #include "JFunc_void_std__vector_std__string_.hpp"
 #include "JFunc_void_double.hpp"
 #include "JFunc_void_std__string.hpp"
-#include "JHybridNitroSpeechSpec.hpp"
+#include "JFunc_void_VolumeChangeEvent.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
 
 namespace margelo::nitro::nitrospeech {
@@ -45,12 +46,13 @@ void registerAllNatives() {
   using namespace margelo::nitro::nitrospeech;
 
   // Register native JNI methods
+  margelo::nitro::nitrospeech::JHybridNitroSpeechSpec::CxxPart::registerNatives();
   margelo::nitro::nitrospeech::JHybridRecognizerSpec::CxxPart::registerNatives();
   margelo::nitro::nitrospeech::JFunc_void_cxx::registerNatives();
   margelo::nitro::nitrospeech::JFunc_void_std__vector_std__string__cxx::registerNatives();
   margelo::nitro::nitrospeech::JFunc_void_double_cxx::registerNatives();
   margelo::nitro::nitrospeech::JFunc_void_std__string_cxx::registerNatives();
-  margelo::nitro::nitrospeech::JHybridNitroSpeechSpec::CxxPart::registerNatives();
+  margelo::nitro::nitrospeech::JFunc_void_VolumeChangeEvent_cxx::registerNatives();
 
   // Register Nitro Hybrid Objects
   HybridObjectRegistry::registerHybridObjectConstructor(

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

@@ -0,0 +1,78 @@
+///
+/// JFunc_void_VolumeChangeEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "VolumeChangeEvent.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JVolumeChangeEvent.hpp"
+#include <optional>
+
+namespace margelo::nitro::nitrospeech {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(event: VolumeChangeEvent) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_VolumeChangeEvent: public jni::JavaClass<JFunc_void_VolumeChangeEvent> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrospeech/Func_void_VolumeChangeEvent;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_VolumeChangeEvent` instance holds through JNI.
+     */
+    void invoke(const VolumeChangeEvent& event) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JVolumeChangeEvent> /* event */)>("invoke");
+      method(self(), JVolumeChangeEvent::fromCpp(event));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_VolumeChangeEvent that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_VolumeChangeEvent_cxx final: public jni::HybridClass<JFunc_void_VolumeChangeEvent_cxx, JFunc_void_VolumeChangeEvent> {
+  public:
+    static jni::local_ref<JFunc_void_VolumeChangeEvent::javaobject> fromCpp(const std::function<void(const VolumeChangeEvent& /* event */)>& func) {
+      return JFunc_void_VolumeChangeEvent_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_VolumeChangeEvent_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JVolumeChangeEvent> event) {
+      _func(event->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const VolumeChangeEvent& /* event */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrospeech/Func_void_VolumeChangeEvent_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_VolumeChangeEvent_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_VolumeChangeEvent_cxx(const std::function<void(const VolumeChangeEvent& /* event */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const VolumeChangeEvent& /* event */)> _func;
+  };
+
+} // namespace margelo::nitro::nitrospeech

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

@@ -33,16 +33,16 @@ namespace margelo::nitro::nitrospeech {
      */
     void invoke(const std::vector<std::string>& resultBatches) const {
       static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<jni::JString>> /* resultBatches */)>("invoke");
-      method(self(), [&]() {
-        size_t __size = resultBatches.size();
+      method(self(), [&](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 = resultBatches[__i];
+          const auto& __element = __input[__i];
           auto __elementJni = jni::make_jstring(__element);
           __array->setElement(__i, *__elementJni);
         }
         return __array;
-      }());
+      }(resultBatches));
     }
   };
 
@@ -60,16 +60,16 @@ namespace margelo::nitro::nitrospeech {
      * Invokes the C++ `std::function<...>` this `JFunc_void_std__vector_std__string__cxx` instance holds.
      */
     void invoke_cxx(jni::alias_ref<jni::JArrayClass<jni::JString>> resultBatches) {
-      _func([&]() {
-              size_t __size = resultBatches->size();
-              std::vector<std::string> __vector;
-              __vector.reserve(__size);
-              for (size_t __i = 0; __i < __size; __i++) {
-                auto __element = resultBatches->getElement(__i);
-                __vector.push_back(__element->toStdString());
-              }
-              return __vector;
-            }());
+      _func([&](auto&& __input) {
+        size_t __size = __input->size();
+        std::vector<std::string> __vector;
+        __vector.reserve(__size);
+        for (size_t __i = 0; __i < __size; __i++) {
+          auto __element = __input->getElement(__i);
+          __vector.push_back(__element->toStdString());
+        }
+        return __vector;
+      }(resultBatches));
     }
 
   public:

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

@@ -7,10 +7,16 @@
 
 #include "JHybridRecognizerSpec.hpp"
 
-// Forward declaration of `SpeechToTextParams` to properly resolve imports.
-namespace margelo::nitro::nitrospeech { struct SpeechToTextParams; }
+// Forward declaration of `VolumeChangeEvent` to properly resolve imports.
+namespace margelo::nitro::nitrospeech { struct VolumeChangeEvent; }
+// Forward declaration of `SpeechRecognitionConfig` to properly resolve imports.
+namespace margelo::nitro::nitrospeech { struct SpeechRecognitionConfig; }
 // Forward declaration of `HapticFeedbackStyle` to properly resolve imports.
 namespace margelo::nitro::nitrospeech { enum class HapticFeedbackStyle; }
+// Forward declaration of `IosPreset` to properly resolve imports.
+namespace margelo::nitro::nitrospeech { enum class IosPreset; }
+// Forward declaration of `MutableSpeechRecognitionConfig` to properly resolve imports.
+namespace margelo::nitro::nitrospeech { struct MutableSpeechRecognitionConfig; }
 
 #include <functional>
 #include <optional>
@@ -21,10 +27,20 @@ namespace margelo::nitro::nitrospeech { enum class HapticFeedbackStyle; }
 #include "JFunc_void_std__vector_std__string_.hpp"
 #include "JFunc_void_double.hpp"
 #include "JFunc_void_std__string.hpp"
-#include "SpeechToTextParams.hpp"
-#include "JSpeechToTextParams.hpp"
+#include "VolumeChangeEvent.hpp"
+#include "JFunc_void_VolumeChangeEvent.hpp"
+#include "JVolumeChangeEvent.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include <NitroModules/JUnit.hpp>
+#include "SpeechRecognitionConfig.hpp"
+#include "JSpeechRecognitionConfig.hpp"
 #include "HapticFeedbackStyle.hpp"
 #include "JHapticFeedbackStyle.hpp"
+#include "IosPreset.hpp"
+#include "JIosPreset.hpp"
+#include "MutableSpeechRecognitionConfig.hpp"
+#include "JMutableSpeechRecognitionConfig.hpp"
 
 namespace margelo::nitro::nitrospeech {
 
@@ -158,45 +174,78 @@ namespace margelo::nitro::nitrospeech {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* onPermissionDenied */)>("setOnPermissionDenied_cxx");
     method(_javaPart, onPermissionDenied.has_value() ? JFunc_void_cxx::fromCpp(onPermissionDenied.value()) : nullptr);
   }
-  std::optional<std::function<void(double /* normVolume */)>> JHybridRecognizerSpec::getOnVolumeChange() {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void_double::javaobject>()>("getOnVolumeChange_cxx");
+  std::optional<std::function<void(const VolumeChangeEvent& /* event */)>> JHybridRecognizerSpec::getOnVolumeChange() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void_VolumeChangeEvent::javaobject>()>("getOnVolumeChange_cxx");
     auto __result = method(_javaPart);
-    return __result != nullptr ? std::make_optional([&]() -> std::function<void(double /* normVolume */)> {
-      if (__result->isInstanceOf(JFunc_void_double_cxx::javaClassStatic())) [[likely]] {
-        auto downcast = jni::static_ref_cast<JFunc_void_double_cxx::javaobject>(__result);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const VolumeChangeEvent& /* event */)> {
+      if (__result->isInstanceOf(JFunc_void_VolumeChangeEvent_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_VolumeChangeEvent_cxx::javaobject>(__result);
         return downcast->cthis()->getFunction();
       } else {
         auto __resultRef = jni::make_global(__result);
-        return JNICallable<JFunc_void_double, void(double)>(std::move(__resultRef));
+        return JNICallable<JFunc_void_VolumeChangeEvent, void(VolumeChangeEvent)>(std::move(__resultRef));
       }
     }()) : std::nullopt;
   }
-  void JHybridRecognizerSpec::setOnVolumeChange(const std::optional<std::function<void(double /* normVolume */)>>& onVolumeChange) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_double::javaobject> /* onVolumeChange */)>("setOnVolumeChange_cxx");
-    method(_javaPart, onVolumeChange.has_value() ? JFunc_void_double_cxx::fromCpp(onVolumeChange.value()) : nullptr);
+  void JHybridRecognizerSpec::setOnVolumeChange(const std::optional<std::function<void(const VolumeChangeEvent& /* event */)>>& onVolumeChange) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_VolumeChangeEvent::javaobject> /* onVolumeChange */)>("setOnVolumeChange_cxx");
+    method(_javaPart, onVolumeChange.has_value() ? JFunc_void_VolumeChangeEvent_cxx::fromCpp(onVolumeChange.value()) : nullptr);
   }
 
   // Methods
-  void JHybridRecognizerSpec::startListening(const SpeechToTextParams& params) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JSpeechToTextParams> /* params */)>("startListening");
-    method(_javaPart, JSpeechToTextParams::fromCpp(params));
+  std::shared_ptr<Promise<void>> JHybridRecognizerSpec::prewarm(const std::optional<SpeechRecognitionConfig>& defaultParams) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JSpeechRecognitionConfig> /* defaultParams */)>("prewarm");
+    auto __result = method(_javaPart, defaultParams.has_value() ? JSpeechRecognitionConfig::fromCpp(defaultParams.value()) : nullptr);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  void JHybridRecognizerSpec::startListening(const std::optional<SpeechRecognitionConfig>& params) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JSpeechRecognitionConfig> /* params */)>("startListening");
+    method(_javaPart, params.has_value() ? JSpeechRecognitionConfig::fromCpp(params.value()) : nullptr);
   }
   void JHybridRecognizerSpec::stopListening() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("stopListening");
     method(_javaPart);
   }
+  void JHybridRecognizerSpec::resetAutoFinishTime() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("resetAutoFinishTime");
+    method(_javaPart);
+  }
   void JHybridRecognizerSpec::addAutoFinishTime(std::optional<double> additionalTimeMs) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* additionalTimeMs */)>("addAutoFinishTime");
     method(_javaPart, additionalTimeMs.has_value() ? jni::JDouble::valueOf(additionalTimeMs.value()) : nullptr);
   }
-  void JHybridRecognizerSpec::updateAutoFinishTime(double newTimeMs, std::optional<bool> withRefresh) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void(double /* newTimeMs */, jni::alias_ref<jni::JBoolean> /* withRefresh */)>("updateAutoFinishTime");
-    method(_javaPart, newTimeMs, withRefresh.has_value() ? jni::JBoolean::valueOf(withRefresh.value()) : nullptr);
+  void JHybridRecognizerSpec::updateConfig(const std::optional<MutableSpeechRecognitionConfig>& newConfig, std::optional<bool> resetAutoFinishTime) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JMutableSpeechRecognitionConfig> /* newConfig */, jni::alias_ref<jni::JBoolean> /* resetAutoFinishTime */)>("updateConfig");
+    method(_javaPart, newConfig.has_value() ? JMutableSpeechRecognitionConfig::fromCpp(newConfig.value()) : nullptr, resetAutoFinishTime.has_value() ? jni::JBoolean::valueOf(resetAutoFinishTime.value()) : nullptr);
   }
   bool JHybridRecognizerSpec::getIsActive() {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getIsActive");
     auto __result = method(_javaPart);
     return static_cast<bool>(__result);
   }
+  std::vector<std::string> JHybridRecognizerSpec::getSupportedLocalesIOS() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<jni::JString>>()>("getSupportedLocalesIOS");
+    auto __result = method(_javaPart);
+    return [&](auto&& __input) {
+      size_t __size = __input->size();
+      std::vector<std::string> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __input->getElement(__i);
+        __vector.push_back(__element->toStdString());
+      }
+      return __vector;
+    }(__result);
+  }
 
 } // namespace margelo::nitro::nitrospeech

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

@@ -62,16 +62,19 @@ namespace margelo::nitro::nitrospeech {
     void setOnError(const std::optional<std::function<void(const std::string& /* message */)>>& onError) override;
     std::optional<std::function<void()>> getOnPermissionDenied() override;
     void setOnPermissionDenied(const std::optional<std::function<void()>>& onPermissionDenied) override;
-    std::optional<std::function<void(double /* normVolume */)>> getOnVolumeChange() override;
-    void setOnVolumeChange(const std::optional<std::function<void(double /* normVolume */)>>& onVolumeChange) override;
+    std::optional<std::function<void(const VolumeChangeEvent& /* event */)>> getOnVolumeChange() override;
+    void setOnVolumeChange(const std::optional<std::function<void(const VolumeChangeEvent& /* event */)>>& onVolumeChange) override;
 
   public:
     // Methods
-    void startListening(const SpeechToTextParams& params) override;
+    std::shared_ptr<Promise<void>> prewarm(const std::optional<SpeechRecognitionConfig>& defaultParams) override;
+    void startListening(const std::optional<SpeechRecognitionConfig>& params) override;
     void stopListening() override;
+    void resetAutoFinishTime() override;
     void addAutoFinishTime(std::optional<double> additionalTimeMs) override;
-    void updateAutoFinishTime(double newTimeMs, std::optional<bool> withRefresh) override;
+    void updateConfig(const std::optional<MutableSpeechRecognitionConfig>& newConfig, std::optional<bool> resetAutoFinishTime) override;
     bool getIsActive() override;
+    std::vector<std::string> getSupportedLocalesIOS() override;
 
   private:
     jni::global_ref<JHybridRecognizerSpec::JavaPart> _javaPart;