@gmessier/nitro-speech 0.1.2 → 0.2.0

package/lib/typescript/specs/NitroSpeech.nitro.d.ts

@@ -1,17 +1,11 @@
 import { type HybridObject } from 'react-native-nitro-modules';
 interface ParamsAndroid {
-    /**
-     * Default - false
-     *
-     * Min Android 13
-     */
-    androidMaskOffensiveWords?: boolean;
     /**
      * Default - false
      *
      * Prefer quality over latency (may break autofinish timing, depends on engine)
      *
-     * Min Android 13
+     * Android 13+
      */
     androidFormattingPreferQuality?: boolean;
     /**
@@ -37,11 +31,11 @@ interface ParamsIOS {
      *
      * Adds punctuation to speech recognition results
      *
-     * Min iOS 16
+     * iOS 16+
      */
     iosAddPunctuation?: boolean;
 }
-type HapticFeedbackStyle = 'light' | 'medium' | 'heavy';
+type HapticFeedbackStyle = 'light' | 'medium' | 'heavy' | 'none';
 export interface SpeechToTextParams extends ParamsAndroid, ParamsIOS {
     /**
      * Default - "en-US"
@@ -64,17 +58,25 @@ export interface SpeechToTextParams extends ParamsAndroid, ParamsIOS {
      */
     contextualStrings?: string[];
     /**
-     * Default - null
+     * Default - "medium"
      *
      * Haptic feedback style when microphone starts recording.
      */
     startHapticFeedbackStyle?: HapticFeedbackStyle;
     /**
-     * Default - null
+     * Default - "medium"
      *
      * Haptic feedback style when microphone stops recording.
      */
     stopHapticFeedbackStyle?: HapticFeedbackStyle;
+    /**
+     * Default - false
+     *
+     * Android 13+
+     *
+     * iOS 26+ (iOS <26: always `false`)
+     */
+    maskOffensiveWords?: boolean;
 }
 export interface Recognizer extends HybridObject<{
     ios: 'swift';
@@ -111,12 +113,16 @@ export interface Recognizer extends HybridObject<{
      * @param withRefresh - if true, will refresh the auto finish progress.
      */
     updateAutoFinishTime(newTimeMs: number, withRefresh?: boolean): void;
+    /**
+     * Returns true if the speech recognition is active.
+     */
+    getIsActive(): boolean;
     /**
      * The speech recognition has started.
      */
     onReadyForSpeech?: () => void;
     /**
-     * Audio recording has stopped. (may be called multiple times for one recording)
+     * Audio recording has stopped.
      */
     onRecordingStopped?: () => void;
     /**
@@ -139,6 +145,12 @@ export interface Recognizer extends HybridObject<{
      * Permission to record audio has been denied.
      */
     onPermissionDenied?: () => void;
+    /**
+     * Called with arbitrary frequency (many times per second) while audio recording is active.
+     *
+     * Voice input volume normalized to a range of 0 to 1.
+     */
+    onVolumeChange?: (normVolume: number) => void;
 }
 export interface NitroSpeech extends HybridObject<{
     ios: 'swift';

package/lib/typescript/specs/NitroSpeech.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NitroSpeech.nitro.d.ts","sourceRoot":"","sources":["../../../src/specs/NitroSpeech.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D,UAAU,aAAa;IACrB;;;;OAIG;IACH,yBAAyB,CAAC,EAAE,OAAO,CAAA;IACnC;;;;;;OAMG;IACH,8BAA8B,CAAC,EAAE,OAAO,CAAA;IACxC;;;;;;OAMG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAA;IAClC;;;;;;OAMG;IACH,2BAA2B,CAAC,EAAE,OAAO,CAAA;CACtC;AAED,UAAU,SAAS;IACjB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B;AAED,KAAK,mBAAmB,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAA;AAEvD,MAAM,WAAW,kBAAmB,SAAQ,aAAa,EAAE,SAAS;IAClE;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;OAEG;IACH,uBAAuB,CAAC,EAAE,MAAM,CAAA;IAChC;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC5B;;;;OAIG;IACH,wBAAwB,CAAC,EAAE,mBAAmB,CAAA;IAC9C;;;;OAIG;IACH,uBAAuB,CAAC,EAAE,mBAAmB,CAAA;CAC9C;AAED,MAAM,WAAW,UAAW,SAAQ,YAAY,CAAC;IAC/C,GAAG,EAAE,OAAO,CAAA;IACZ,OAAO,EAAE,QAAQ,CAAA;CAClB,CAAC;IACA;;;;OAIG;IACH,cAAc,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI,CAAA;IAChD;;;;;;OAMG;IACH,aAAa,IAAI,IAAI,CAAA;IAErB;;;;;;OAMG;IACH,iBAAiB,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAElD;;;;;;;OAOG;IACH,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;IAEpE;;OAEG;IACH,gBAAgB,CAAC,EAAE,MAAM,IAAI,CAAA;IAC7B;;OAEG;IACH,kBAAkB,CAAC,EAAE,MAAM,IAAI,CAAA;IAC/B;;OAEG;IACH,QAAQ,CAAC,EAAE,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,IAAI,CAAA;IAC5C;;;;;;OAMG;IACH,oBAAoB,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAA;IACnD;;OAEG;IACH,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IACnC;;OAEG;IACH,kBAAkB,CAAC,EAAE,MAAM,IAAI,CAAA;CAChC;AAED,MAAM,WAAW,WAAY,SAAQ,YAAY,CAAC;IAChD,GAAG,EAAE,OAAO,CAAA;IACZ,OAAO,EAAE,QAAQ,CAAA;CAClB,CAAC;IACA,UAAU,EAAE,UAAU,CAAA;CACvB"}
+{"version":3,"file":"NitroSpeech.nitro.d.ts","sourceRoot":"","sources":["../../../src/specs/NitroSpeech.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D,UAAU,aAAa;IACrB;;;;;;OAMG;IACH,8BAA8B,CAAC,EAAE,OAAO,CAAA;IACxC;;;;;;OAMG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAA;IAClC;;;;;;OAMG;IACH,2BAA2B,CAAC,EAAE,OAAO,CAAA;CACtC;AAED,UAAU,SAAS;IACjB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B;AAED,KAAK,mBAAmB,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAA;AAEhE,MAAM,WAAW,kBAAmB,SAAQ,aAAa,EAAE,SAAS;IAClE;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;OAEG;IACH,uBAAuB,CAAC,EAAE,MAAM,CAAA;IAChC;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC5B;;;;OAIG;IACH,wBAAwB,CAAC,EAAE,mBAAmB,CAAA;IAC9C;;;;OAIG;IACH,uBAAuB,CAAC,EAAE,mBAAmB,CAAA;IAC7C;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC7B;AAED,MAAM,WAAW,UAAW,SAAQ,YAAY,CAAC;IAC/C,GAAG,EAAE,OAAO,CAAA;IACZ,OAAO,EAAE,QAAQ,CAAA;CAClB,CAAC;IACA;;;;OAIG;IACH,cAAc,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI,CAAA;IAChD;;;;;;OAMG;IACH,aAAa,IAAI,IAAI,CAAA;IAErB;;;;;;OAMG;IACH,iBAAiB,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAElD;;;;;;;OAOG;IACH,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;IAEpE;;OAEG;IACH,WAAW,IAAI,OAAO,CAAA;IAEtB;;OAEG;IACH,gBAAgB,CAAC,EAAE,MAAM,IAAI,CAAA;IAC7B;;OAEG;IACH,kBAAkB,CAAC,EAAE,MAAM,IAAI,CAAA;IAC/B;;OAEG;IACH,QAAQ,CAAC,EAAE,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,IAAI,CAAA;IAC5C;;;;;;OAMG;IACH,oBAAoB,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAA;IACnD;;OAEG;IACH,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IACnC;;OAEG;IACH,kBAAkB,CAAC,EAAE,MAAM,IAAI,CAAA;IAC/B;;;;OAIG;IACH,cAAc,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAA;CAC9C;AAED,MAAM,WAAW,WAAY,SAAQ,YAAY,CAAC;IAChD,GAAG,EAAE,OAAO,CAAA;IACZ,OAAO,EAAE,QAAQ,CAAA;CAClB,CAAC;IACA,UAAU,EAAE,UAAU,CAAA;CACvB"}

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

@@ -44,6 +44,7 @@ namespace margelo::nitro::nitrospeech {
       static const auto fieldLIGHT = clazz->getStaticField<JHapticFeedbackStyle>("LIGHT");
       static const auto fieldMEDIUM = clazz->getStaticField<JHapticFeedbackStyle>("MEDIUM");
       static const auto fieldHEAVY = clazz->getStaticField<JHapticFeedbackStyle>("HEAVY");
+      static const auto fieldNONE = clazz->getStaticField<JHapticFeedbackStyle>("NONE");
       
       switch (value) {
         case HapticFeedbackStyle::LIGHT:
@@ -52,6 +53,8 @@ namespace margelo::nitro::nitrospeech {
           return clazz->getStaticFieldValue(fieldMEDIUM);
         case HapticFeedbackStyle::HEAVY:
           return clazz->getStaticFieldValue(fieldHEAVY);
+        case HapticFeedbackStyle::NONE:
+          return clazz->getStaticFieldValue(fieldNONE);
         default:
           std::string stringValue = std::to_string(static_cast<int>(value));
           throw std::invalid_argument("Invalid enum value (" + stringValue + "!");

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

@@ -157,6 +157,23 @@ namespace margelo::nitro::nitrospeech {
     static const auto method = 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 = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_double::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 downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_double, void(double)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridRecognizerSpec::setOnVolumeChange(const std::optional<std::function<void(double /* normVolume */)>>& onVolumeChange) {
+    static const auto method = 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);
+  }
 
   // Methods
   void JHybridRecognizerSpec::startListening(const SpeechToTextParams& params) {
@@ -175,5 +192,10 @@ namespace margelo::nitro::nitrospeech {
     static const auto method = javaClassStatic()->getMethod<void(double /* newTimeMs */, jni::alias_ref<jni::JBoolean> /* withRefresh */)>("updateAutoFinishTime");
     method(_javaPart, newTimeMs, withRefresh.has_value() ? jni::JBoolean::valueOf(withRefresh.value()) : nullptr);
   }
+  bool JHybridRecognizerSpec::getIsActive() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("getIsActive");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
 
 } // namespace margelo::nitro::nitrospeech

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

@@ -62,6 +62,8 @@ 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;
 
   public:
     // Methods
@@ -69,6 +71,7 @@ namespace margelo::nitro::nitrospeech {
     void stopListening() override;
     void addAutoFinishTime(std::optional<double> additionalTimeMs) override;
     void updateAutoFinishTime(double newTimeMs, std::optional<bool> withRefresh) override;
+    bool getIsActive() override;
 
   private:
     friend HybridBase;

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

@@ -47,8 +47,8 @@ namespace margelo::nitro::nitrospeech {
       jni::local_ref<JHapticFeedbackStyle> startHapticFeedbackStyle = this->getFieldValue(fieldStartHapticFeedbackStyle);
       static const auto fieldStopHapticFeedbackStyle = clazz->getField<JHapticFeedbackStyle>("stopHapticFeedbackStyle");
       jni::local_ref<JHapticFeedbackStyle> stopHapticFeedbackStyle = this->getFieldValue(fieldStopHapticFeedbackStyle);
-      static const auto fieldAndroidMaskOffensiveWords = clazz->getField<jni::JBoolean>("androidMaskOffensiveWords");
-      jni::local_ref<jni::JBoolean> androidMaskOffensiveWords = this->getFieldValue(fieldAndroidMaskOffensiveWords);
+      static const auto fieldMaskOffensiveWords = clazz->getField<jni::JBoolean>("maskOffensiveWords");
+      jni::local_ref<jni::JBoolean> maskOffensiveWords = this->getFieldValue(fieldMaskOffensiveWords);
       static const auto fieldAndroidFormattingPreferQuality = clazz->getField<jni::JBoolean>("androidFormattingPreferQuality");
       jni::local_ref<jni::JBoolean> androidFormattingPreferQuality = this->getFieldValue(fieldAndroidFormattingPreferQuality);
       static const auto fieldAndroidUseWebSearchModel = clazz->getField<jni::JBoolean>("androidUseWebSearchModel");
@@ -73,7 +73,7 @@ namespace margelo::nitro::nitrospeech {
         }()) : std::nullopt,
         startHapticFeedbackStyle != nullptr ? std::make_optional(startHapticFeedbackStyle->toCpp()) : std::nullopt,
         stopHapticFeedbackStyle != nullptr ? std::make_optional(stopHapticFeedbackStyle->toCpp()) : std::nullopt,
-        androidMaskOffensiveWords != nullptr ? std::make_optional(static_cast<bool>(androidMaskOffensiveWords->value())) : std::nullopt,
+        maskOffensiveWords != nullptr ? std::make_optional(static_cast<bool>(maskOffensiveWords->value())) : std::nullopt,
         androidFormattingPreferQuality != nullptr ? std::make_optional(static_cast<bool>(androidFormattingPreferQuality->value())) : std::nullopt,
         androidUseWebSearchModel != nullptr ? std::make_optional(static_cast<bool>(androidUseWebSearchModel->value())) : std::nullopt,
         androidDisableBatchHandling != nullptr ? std::make_optional(static_cast<bool>(androidDisableBatchHandling->value())) : std::nullopt,
@@ -107,7 +107,7 @@ namespace margelo::nitro::nitrospeech {
         }() : nullptr,
         value.startHapticFeedbackStyle.has_value() ? JHapticFeedbackStyle::fromCpp(value.startHapticFeedbackStyle.value()) : nullptr,
         value.stopHapticFeedbackStyle.has_value() ? JHapticFeedbackStyle::fromCpp(value.stopHapticFeedbackStyle.value()) : nullptr,
-        value.androidMaskOffensiveWords.has_value() ? jni::JBoolean::valueOf(value.androidMaskOffensiveWords.value()) : nullptr,
+        value.maskOffensiveWords.has_value() ? jni::JBoolean::valueOf(value.maskOffensiveWords.value()) : nullptr,
         value.androidFormattingPreferQuality.has_value() ? jni::JBoolean::valueOf(value.androidFormattingPreferQuality.value()) : nullptr,
         value.androidUseWebSearchModel.has_value() ? jni::JBoolean::valueOf(value.androidUseWebSearchModel.value()) : nullptr,
         value.androidDisableBatchHandling.has_value() ? jni::JBoolean::valueOf(value.androidDisableBatchHandling.value()) : nullptr,

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrospeech/HapticFeedbackStyle.kt

@@ -18,5 +18,6 @@ import com.facebook.proguard.annotations.DoNotStrip
 enum class HapticFeedbackStyle(@DoNotStrip @Keep val value: Int) {
   LIGHT(0),
   MEDIUM(1),
-  HEAVY(2);
+  HEAVY(2),
+  NONE(3);
 }

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrospeech/HybridRecognizerSpec.kt

@@ -125,6 +125,20 @@ abstract class HybridRecognizerSpec: HybridObject() {
     set(value) {
       onPermissionDenied = value?.let { it }
     }
+  
+  abstract var onVolumeChange: ((normVolume: Double) -> Unit)?
+  
+  private var onVolumeChange_cxx: Func_void_double?
+    @Keep
+    @DoNotStrip
+    get() {
+      return onVolumeChange?.let { Func_void_double_java(it) }
+    }
+    @Keep
+    @DoNotStrip
+    set(value) {
+      onVolumeChange = value?.let { it }
+    }
 
   // Methods
   @DoNotStrip
@@ -142,6 +156,10 @@ abstract class HybridRecognizerSpec: HybridObject() {
   @DoNotStrip
   @Keep
   abstract fun updateAutoFinishTime(newTimeMs: Double, withRefresh: Boolean?): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getIsActive(): Boolean
 
   private external fun initHybrid(): HybridData
 

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrospeech/SpeechToTextParams.kt

@@ -37,7 +37,7 @@ data class SpeechToTextParams(
   val stopHapticFeedbackStyle: HapticFeedbackStyle?,
   @DoNotStrip
   @Keep
-  val androidMaskOffensiveWords: Boolean?,
+  val maskOffensiveWords: Boolean?,
   @DoNotStrip
   @Keep
   val androidFormattingPreferQuality: Boolean?,
@@ -61,8 +61,8 @@ data class SpeechToTextParams(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(locale: String?, autoFinishRecognitionMs: Double?, disableRepeatingFilter: Boolean?, contextualStrings: Array<String>?, startHapticFeedbackStyle: HapticFeedbackStyle?, stopHapticFeedbackStyle: HapticFeedbackStyle?, androidMaskOffensiveWords: Boolean?, androidFormattingPreferQuality: Boolean?, androidUseWebSearchModel: Boolean?, androidDisableBatchHandling: Boolean?, iosAddPunctuation: Boolean?): SpeechToTextParams {
-      return SpeechToTextParams(locale, autoFinishRecognitionMs, disableRepeatingFilter, contextualStrings, startHapticFeedbackStyle, stopHapticFeedbackStyle, androidMaskOffensiveWords, androidFormattingPreferQuality, androidUseWebSearchModel, androidDisableBatchHandling, iosAddPunctuation)
+    private fun fromCpp(locale: String?, autoFinishRecognitionMs: Double?, disableRepeatingFilter: Boolean?, contextualStrings: Array<String>?, startHapticFeedbackStyle: HapticFeedbackStyle?, stopHapticFeedbackStyle: HapticFeedbackStyle?, maskOffensiveWords: Boolean?, androidFormattingPreferQuality: Boolean?, androidUseWebSearchModel: Boolean?, androidDisableBatchHandling: Boolean?, iosAddPunctuation: Boolean?): SpeechToTextParams {
+      return SpeechToTextParams(locale, autoFinishRecognitionMs, disableRepeatingFilter, contextualStrings, startHapticFeedbackStyle, stopHapticFeedbackStyle, maskOffensiveWords, androidFormattingPreferQuality, androidUseWebSearchModel, androidDisableBatchHandling, iosAddPunctuation)
     }
   }
 }

package/nitrogen/generated/ios/NitroSpeech-Swift-Cxx-Bridge.hpp

@@ -273,6 +273,21 @@ namespace margelo::nitro::nitrospeech::bridge::swift {
     return *optional;
   }
   
+  // pragma MARK: std::optional<std::function<void(double /* normVolume */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(double / * normVolume * /)>>`.
+   */
+  using std__optional_std__function_void_double____normVolume______ = std::optional<std::function<void(double /* normVolume */)>>;
+  inline std::optional<std::function<void(double /* normVolume */)>> create_std__optional_std__function_void_double____normVolume______(const std::function<void(double /* normVolume */)>& value) noexcept {
+    return std::optional<std::function<void(double /* normVolume */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_double____normVolume______(const std::optional<std::function<void(double /* normVolume */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(double /* normVolume */)> get_std__optional_std__function_void_double____normVolume______(const std::optional<std::function<void(double /* normVolume */)>>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::shared_ptr<HybridRecognizerSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridRecognizerSpec>`.
@@ -294,6 +309,15 @@ namespace margelo::nitro::nitrospeech::bridge::swift {
     return Result<void>::withError(error);
   }
   
+  // pragma MARK: Result<bool>
+  using Result_bool_ = Result<bool>;
+  inline Result_bool_ create_Result_bool_(bool value) noexcept {
+    return Result<bool>::withValue(std::move(value));
+  }
+  inline Result_bool_ create_Result_bool_(const std::exception_ptr& error) noexcept {
+    return Result<bool>::withError(error);
+  }
+  
   // pragma MARK: std::shared_ptr<HybridNitroSpeechSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridNitroSpeechSpec>`.

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

@@ -106,6 +106,13 @@ namespace margelo::nitro::nitrospeech {
     inline void setOnPermissionDenied(const std::optional<std::function<void()>>& onPermissionDenied) noexcept override {
       _swiftPart.setOnPermissionDenied(onPermissionDenied);
     }
+    inline std::optional<std::function<void(double /* normVolume */)>> getOnVolumeChange() noexcept override {
+      auto __result = _swiftPart.getOnVolumeChange();
+      return __result;
+    }
+    inline void setOnVolumeChange(const std::optional<std::function<void(double /* normVolume */)>>& onVolumeChange) noexcept override {
+      _swiftPart.setOnVolumeChange(onVolumeChange);
+    }
 
   public:
     // Methods
@@ -133,6 +140,14 @@ namespace margelo::nitro::nitrospeech {
         std::rethrow_exception(__result.error());
       }
     }
+    inline bool getIsActive() override {
+      auto __result = _swiftPart.getIsActive();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
     NitroSpeech::HybridRecognizerSpec_cxx _swiftPart;

package/nitrogen/generated/ios/swift/HapticFeedbackStyle.swift

@@ -23,6 +23,8 @@ public extension HapticFeedbackStyle {
         self = .medium
       case "heavy":
         self = .heavy
+      case "none":
+        self = .none
       default:
         return nil
     }
@@ -39,6 +41,8 @@ public extension HapticFeedbackStyle {
         return "medium"
       case .heavy:
         return "heavy"
+      case .none:
+        return "none"
     }
   }
 }

package/nitrogen/generated/ios/swift/HybridRecognizerSpec.swift

@@ -17,12 +17,14 @@ public protocol HybridRecognizerSpec_protocol: HybridObject {
   var onAutoFinishProgress: ((_ timeLeftMs: Double) -> Void)? { get set }
   var onError: ((_ message: String) -> Void)? { get set }
   var onPermissionDenied: (() -> Void)? { get set }
+  var onVolumeChange: ((_ normVolume: Double) -> Void)? { get set }
 
   // Methods
   func startListening(params: SpeechToTextParams) throws -> Void
   func stopListening() throws -> Void
   func addAutoFinishTime(additionalTimeMs: Double?) throws -> Void
   func updateAutoFinishTime(newTimeMs: Double, withRefresh: Bool?) throws -> Void
+  func getIsActive() throws -> Bool
 }
 
 public extension HybridRecognizerSpec_protocol {

package/nitrogen/generated/ios/swift/HybridRecognizerSpec_cxx.swift

@@ -311,6 +311,38 @@ open class HybridRecognizerSpec_cxx {
       }()
     }
   }
+  
+  public final var onVolumeChange: bridge.std__optional_std__function_void_double____normVolume______ {
+    @inline(__always)
+    get {
+      return { () -> bridge.std__optional_std__function_void_double____normVolume______ in
+        if let __unwrappedValue = self.__implementation.onVolumeChange {
+          return bridge.create_std__optional_std__function_void_double____normVolume______({ () -> bridge.Func_void_double in
+            let __closureWrapper = Func_void_double(__unwrappedValue)
+            return bridge.create_Func_void_double(__closureWrapper.toUnsafe())
+          }())
+        } else {
+          return .init()
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__implementation.onVolumeChange = { () -> ((_ normVolume: Double) -> Void)? in
+        if bridge.has_value_std__optional_std__function_void_double____normVolume______(newValue) {
+          let __unwrapped = bridge.get_std__optional_std__function_void_double____normVolume______(newValue)
+          return { () -> (Double) -> Void in
+            let __wrappedFunction = bridge.wrap_Func_void_double(__unwrapped)
+            return { (__normVolume: Double) -> Void in
+              __wrappedFunction.call(__normVolume)
+            }
+          }()
+        } else {
+          return nil
+        }
+      }()
+    }
+  }
 
   // Methods
   @inline(__always)
@@ -363,4 +395,16 @@ open class HybridRecognizerSpec_cxx {
       return bridge.create_Result_void_(__exceptionPtr)
     }
   }
+  
+  @inline(__always)
+  public final func getIsActive() -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.getIsActive()
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_bool_(__exceptionPtr)
+    }
+  }
 }

package/nitrogen/generated/ios/swift/SpeechToTextParams.swift

@@ -19,7 +19,7 @@ public extension SpeechToTextParams {
   /**
    * Create a new instance of `SpeechToTextParams`.
    */
-  init(locale: String?, autoFinishRecognitionMs: Double?, disableRepeatingFilter: Bool?, contextualStrings: [String]?, startHapticFeedbackStyle: HapticFeedbackStyle?, stopHapticFeedbackStyle: HapticFeedbackStyle?, androidMaskOffensiveWords: Bool?, androidFormattingPreferQuality: Bool?, androidUseWebSearchModel: Bool?, androidDisableBatchHandling: Bool?, iosAddPunctuation: Bool?) {
+  init(locale: String?, autoFinishRecognitionMs: Double?, disableRepeatingFilter: Bool?, contextualStrings: [String]?, startHapticFeedbackStyle: HapticFeedbackStyle?, stopHapticFeedbackStyle: HapticFeedbackStyle?, maskOffensiveWords: Bool?, androidFormattingPreferQuality: Bool?, androidUseWebSearchModel: Bool?, androidDisableBatchHandling: Bool?, iosAddPunctuation: Bool?) {
     self.init({ () -> bridge.std__optional_std__string_ in
       if let __unwrappedValue = locale {
         return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
@@ -63,7 +63,7 @@ public extension SpeechToTextParams {
         return .init()
       }
     }(), { () -> bridge.std__optional_bool_ in
-      if let __unwrappedValue = androidMaskOffensiveWords {
+      if let __unwrappedValue = maskOffensiveWords {
         return bridge.create_std__optional_bool_(__unwrappedValue)
       } else {
         return .init()
@@ -224,12 +224,12 @@ public extension SpeechToTextParams {
     }
   }
   
-  var androidMaskOffensiveWords: Bool? {
+  var maskOffensiveWords: Bool? {
     @inline(__always)
     get {
       return { () -> Bool? in
-        if bridge.has_value_std__optional_bool_(self.__androidMaskOffensiveWords) {
-          let __unwrapped = bridge.get_std__optional_bool_(self.__androidMaskOffensiveWords)
+        if bridge.has_value_std__optional_bool_(self.__maskOffensiveWords) {
+          let __unwrapped = bridge.get_std__optional_bool_(self.__maskOffensiveWords)
           return __unwrapped
         } else {
           return nil
@@ -238,7 +238,7 @@ public extension SpeechToTextParams {
     }
     @inline(__always)
     set {
-      self.__androidMaskOffensiveWords = { () -> bridge.std__optional_bool_ in
+      self.__maskOffensiveWords = { () -> bridge.std__optional_bool_ in
         if let __unwrappedValue = newValue {
           return bridge.create_std__optional_bool_(__unwrappedValue)
         } else {

package/nitrogen/generated/shared/c++/HapticFeedbackStyle.hpp

@@ -32,6 +32,7 @@ namespace margelo::nitro::nitrospeech {
     LIGHT      SWIFT_NAME(light) = 0,
     MEDIUM      SWIFT_NAME(medium) = 1,
     HEAVY      SWIFT_NAME(heavy) = 2,
+    NONE      SWIFT_NAME(none) = 3,
   } CLOSED_ENUM;
 
 } // namespace margelo::nitro::nitrospeech
@@ -47,6 +48,7 @@ namespace margelo::nitro {
         case hashString("light"): return margelo::nitro::nitrospeech::HapticFeedbackStyle::LIGHT;
         case hashString("medium"): return margelo::nitro::nitrospeech::HapticFeedbackStyle::MEDIUM;
         case hashString("heavy"): return margelo::nitro::nitrospeech::HapticFeedbackStyle::HEAVY;
+        case hashString("none"): return margelo::nitro::nitrospeech::HapticFeedbackStyle::NONE;
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum HapticFeedbackStyle - invalid value!");
       }
@@ -56,6 +58,7 @@ namespace margelo::nitro {
         case margelo::nitro::nitrospeech::HapticFeedbackStyle::LIGHT: return JSIConverter<std::string>::toJSI(runtime, "light");
         case margelo::nitro::nitrospeech::HapticFeedbackStyle::MEDIUM: return JSIConverter<std::string>::toJSI(runtime, "medium");
         case margelo::nitro::nitrospeech::HapticFeedbackStyle::HEAVY: return JSIConverter<std::string>::toJSI(runtime, "heavy");
+        case margelo::nitro::nitrospeech::HapticFeedbackStyle::NONE: return JSIConverter<std::string>::toJSI(runtime, "none");
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert HapticFeedbackStyle to JS - invalid value: "
                                     + std::to_string(static_cast<int>(arg)) + "!");
@@ -70,6 +73,7 @@ namespace margelo::nitro {
         case hashString("light"):
         case hashString("medium"):
         case hashString("heavy"):
+        case hashString("none"):
           return true;
         default:
           return false;

package/nitrogen/generated/shared/c++/HybridRecognizerSpec.cpp

@@ -26,10 +26,13 @@ namespace margelo::nitro::nitrospeech {
       prototype.registerHybridSetter("onError", &HybridRecognizerSpec::setOnError);
       prototype.registerHybridGetter("onPermissionDenied", &HybridRecognizerSpec::getOnPermissionDenied);
       prototype.registerHybridSetter("onPermissionDenied", &HybridRecognizerSpec::setOnPermissionDenied);
+      prototype.registerHybridGetter("onVolumeChange", &HybridRecognizerSpec::getOnVolumeChange);
+      prototype.registerHybridSetter("onVolumeChange", &HybridRecognizerSpec::setOnVolumeChange);
       prototype.registerHybridMethod("startListening", &HybridRecognizerSpec::startListening);
       prototype.registerHybridMethod("stopListening", &HybridRecognizerSpec::stopListening);
       prototype.registerHybridMethod("addAutoFinishTime", &HybridRecognizerSpec::addAutoFinishTime);
       prototype.registerHybridMethod("updateAutoFinishTime", &HybridRecognizerSpec::updateAutoFinishTime);
+      prototype.registerHybridMethod("getIsActive", &HybridRecognizerSpec::getIsActive);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridRecognizerSpec.hpp

@@ -61,6 +61,8 @@ namespace margelo::nitro::nitrospeech {
       virtual void setOnError(const std::optional<std::function<void(const std::string& /* message */)>>& onError) = 0;
       virtual std::optional<std::function<void()>> getOnPermissionDenied() = 0;
       virtual void setOnPermissionDenied(const std::optional<std::function<void()>>& onPermissionDenied) = 0;
+      virtual std::optional<std::function<void(double /* normVolume */)>> getOnVolumeChange() = 0;
+      virtual void setOnVolumeChange(const std::optional<std::function<void(double /* normVolume */)>>& onVolumeChange) = 0;
 
     public:
       // Methods
@@ -68,6 +70,7 @@ namespace margelo::nitro::nitrospeech {
       virtual void stopListening() = 0;
       virtual void addAutoFinishTime(std::optional<double> additionalTimeMs) = 0;
       virtual void updateAutoFinishTime(double newTimeMs, std::optional<bool> withRefresh) = 0;
+      virtual bool getIsActive() = 0;
 
     protected:
       // Hybrid Setup

package/nitrogen/generated/shared/c++/SpeechToTextParams.hpp

@@ -44,7 +44,7 @@ namespace margelo::nitro::nitrospeech {
     std::optional<std::vector<std::string>> contextualStrings     SWIFT_PRIVATE;
     std::optional<HapticFeedbackStyle> startHapticFeedbackStyle     SWIFT_PRIVATE;
     std::optional<HapticFeedbackStyle> stopHapticFeedbackStyle     SWIFT_PRIVATE;
-    std::optional<bool> androidMaskOffensiveWords     SWIFT_PRIVATE;
+    std::optional<bool> maskOffensiveWords     SWIFT_PRIVATE;
     std::optional<bool> androidFormattingPreferQuality     SWIFT_PRIVATE;
     std::optional<bool> androidUseWebSearchModel     SWIFT_PRIVATE;
     std::optional<bool> androidDisableBatchHandling     SWIFT_PRIVATE;
@@ -52,7 +52,7 @@ namespace margelo::nitro::nitrospeech {
 
   public:
     SpeechToTextParams() = default;
-    explicit SpeechToTextParams(std::optional<std::string> locale, std::optional<double> autoFinishRecognitionMs, std::optional<bool> disableRepeatingFilter, std::optional<std::vector<std::string>> contextualStrings, std::optional<HapticFeedbackStyle> startHapticFeedbackStyle, std::optional<HapticFeedbackStyle> stopHapticFeedbackStyle, std::optional<bool> androidMaskOffensiveWords, std::optional<bool> androidFormattingPreferQuality, std::optional<bool> androidUseWebSearchModel, std::optional<bool> androidDisableBatchHandling, std::optional<bool> iosAddPunctuation): locale(locale), autoFinishRecognitionMs(autoFinishRecognitionMs), disableRepeatingFilter(disableRepeatingFilter), contextualStrings(contextualStrings), startHapticFeedbackStyle(startHapticFeedbackStyle), stopHapticFeedbackStyle(stopHapticFeedbackStyle), androidMaskOffensiveWords(androidMaskOffensiveWords), androidFormattingPreferQuality(androidFormattingPreferQuality), androidUseWebSearchModel(androidUseWebSearchModel), androidDisableBatchHandling(androidDisableBatchHandling), iosAddPunctuation(iosAddPunctuation) {}
+    explicit SpeechToTextParams(std::optional<std::string> locale, std::optional<double> autoFinishRecognitionMs, std::optional<bool> disableRepeatingFilter, std::optional<std::vector<std::string>> contextualStrings, std::optional<HapticFeedbackStyle> startHapticFeedbackStyle, std::optional<HapticFeedbackStyle> stopHapticFeedbackStyle, std::optional<bool> maskOffensiveWords, std::optional<bool> androidFormattingPreferQuality, std::optional<bool> androidUseWebSearchModel, std::optional<bool> androidDisableBatchHandling, std::optional<bool> iosAddPunctuation): locale(locale), autoFinishRecognitionMs(autoFinishRecognitionMs), disableRepeatingFilter(disableRepeatingFilter), contextualStrings(contextualStrings), startHapticFeedbackStyle(startHapticFeedbackStyle), stopHapticFeedbackStyle(stopHapticFeedbackStyle), maskOffensiveWords(maskOffensiveWords), androidFormattingPreferQuality(androidFormattingPreferQuality), androidUseWebSearchModel(androidUseWebSearchModel), androidDisableBatchHandling(androidDisableBatchHandling), iosAddPunctuation(iosAddPunctuation) {}
   };
 
 } // namespace margelo::nitro::nitrospeech
@@ -71,7 +71,7 @@ namespace margelo::nitro {
         JSIConverter<std::optional<std::vector<std::string>>>::fromJSI(runtime, obj.getProperty(runtime, "contextualStrings")),
         JSIConverter<std::optional<margelo::nitro::nitrospeech::HapticFeedbackStyle>>::fromJSI(runtime, obj.getProperty(runtime, "startHapticFeedbackStyle")),
         JSIConverter<std::optional<margelo::nitro::nitrospeech::HapticFeedbackStyle>>::fromJSI(runtime, obj.getProperty(runtime, "stopHapticFeedbackStyle")),
-        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, "androidMaskOffensiveWords")),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, "maskOffensiveWords")),
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, "androidFormattingPreferQuality")),
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, "androidUseWebSearchModel")),
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, "androidDisableBatchHandling")),
@@ -86,7 +86,7 @@ namespace margelo::nitro {
       obj.setProperty(runtime, "contextualStrings", JSIConverter<std::optional<std::vector<std::string>>>::toJSI(runtime, arg.contextualStrings));
       obj.setProperty(runtime, "startHapticFeedbackStyle", JSIConverter<std::optional<margelo::nitro::nitrospeech::HapticFeedbackStyle>>::toJSI(runtime, arg.startHapticFeedbackStyle));
       obj.setProperty(runtime, "stopHapticFeedbackStyle", JSIConverter<std::optional<margelo::nitro::nitrospeech::HapticFeedbackStyle>>::toJSI(runtime, arg.stopHapticFeedbackStyle));
-      obj.setProperty(runtime, "androidMaskOffensiveWords", JSIConverter<std::optional<bool>>::toJSI(runtime, arg.androidMaskOffensiveWords));
+      obj.setProperty(runtime, "maskOffensiveWords", JSIConverter<std::optional<bool>>::toJSI(runtime, arg.maskOffensiveWords));
       obj.setProperty(runtime, "androidFormattingPreferQuality", JSIConverter<std::optional<bool>>::toJSI(runtime, arg.androidFormattingPreferQuality));
       obj.setProperty(runtime, "androidUseWebSearchModel", JSIConverter<std::optional<bool>>::toJSI(runtime, arg.androidUseWebSearchModel));
       obj.setProperty(runtime, "androidDisableBatchHandling", JSIConverter<std::optional<bool>>::toJSI(runtime, arg.androidDisableBatchHandling));
@@ -107,7 +107,7 @@ namespace margelo::nitro {
       if (!JSIConverter<std::optional<std::vector<std::string>>>::canConvert(runtime, obj.getProperty(runtime, "contextualStrings"))) return false;
       if (!JSIConverter<std::optional<margelo::nitro::nitrospeech::HapticFeedbackStyle>>::canConvert(runtime, obj.getProperty(runtime, "startHapticFeedbackStyle"))) return false;
       if (!JSIConverter<std::optional<margelo::nitro::nitrospeech::HapticFeedbackStyle>>::canConvert(runtime, obj.getProperty(runtime, "stopHapticFeedbackStyle"))) return false;
-      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, "androidMaskOffensiveWords"))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, "maskOffensiveWords"))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, "androidFormattingPreferQuality"))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, "androidUseWebSearchModel"))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, "androidDisableBatchHandling"))) return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gmessier/nitro-speech",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "React Native Speech Recognition Library powered by Nitro Modules",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/module/index.js",
@@ -69,17 +69,17 @@
     "registry": "https://registry.npmjs.org/"
   },
   "devDependencies": {
-    "@react-native/eslint-config": "0.82.0",
-    "@types/react": "^19.1.03",
+    "@react-native/eslint-config": "0.84.1",
+    "@types/react": "19.2.14",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^5.2.1",
     "nitrogen": "*",
     "prettier": "^3.3.3",
-    "react": "^19.2.4",
-    "react-native": "^0.83.1",
-    "react-native-nitro-modules": "^0.33.9",
-    "react-native-builder-bob": "^0.37.0",
+    "react": "19.2.4",
+    "react-native": "0.84.1",
+    "react-native-nitro-modules": "0.34.1",
+    "react-native-builder-bob": "0.37.0",
     "typescript": "^5.8.3"
   },
   "peerDependencies": {