@gmessier/nitro-speech 0.0.1

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

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

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

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

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

@@ -0,0 +1,95 @@
+///
+/// JFunc_void_std__vector_std__string_.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <string>
+#include <vector>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::nitrospeech {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(resultBatches: Array<String>) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__vector_std__string_: public jni::JavaClass<JFunc_void_std__vector_std__string_> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrospeech/Func_void_std__vector_std__string_;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__vector_std__string_` instance holds through JNI.
+     */
+    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();
+        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];
+          auto __elementJni = jni::make_jstring(__element);
+          __array->setElement(__i, *__elementJni);
+        }
+        return __array;
+      }());
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__vector_std__string_ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__vector_std__string__cxx final: public jni::HybridClass<JFunc_void_std__vector_std__string__cxx, JFunc_void_std__vector_std__string_> {
+  public:
+    static jni::local_ref<JFunc_void_std__vector_std__string_::javaobject> fromCpp(const std::function<void(const std::vector<std::string>& /* resultBatches */)>& func) {
+      return JFunc_void_std__vector_std__string__cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * 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;
+            }());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::vector<std::string>& /* resultBatches */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrospeech/Func_void_std__vector_std__string__cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__vector_std__string__cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__vector_std__string__cxx(const std::function<void(const std::vector<std::string>& /* resultBatches */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::vector<std::string>& /* resultBatches */)> _func;
+  };
+
+} // namespace margelo::nitro::nitrospeech

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

@@ -0,0 +1,59 @@
+///
+/// JHybridNitroSpeechSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridNitroSpeechSpec.hpp"
+
+// Forward declaration of `HybridRecognizerSpec` to properly resolve imports.
+namespace margelo::nitro::nitrospeech { class HybridRecognizerSpec; }
+
+#include <memory>
+#include "HybridRecognizerSpec.hpp"
+#include "JHybridRecognizerSpec.hpp"
+
+namespace margelo::nitro::nitrospeech {
+
+  jni::local_ref<JHybridNitroSpeechSpec::jhybriddata> JHybridNitroSpeechSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridNitroSpeechSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridNitroSpeechSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridNitroSpeechSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridNitroSpeechSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridNitroSpeechSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  std::shared_ptr<HybridRecognizerSpec> JHybridNitroSpeechSpec::getRecognizer() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JHybridRecognizerSpec::javaobject>()>("getRecognizer");
+    auto __result = method(_javaPart);
+    return __result->cthis()->shared_cast<JHybridRecognizerSpec>();
+  }
+  void JHybridNitroSpeechSpec::setRecognizer(const std::shared_ptr<HybridRecognizerSpec>& recognizer) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JHybridRecognizerSpec::javaobject> /* recognizer */)>("setRecognizer");
+    method(_javaPart, std::dynamic_pointer_cast<JHybridRecognizerSpec>(recognizer)->getJavaPart());
+  }
+
+  // Methods
+  
+
+} // namespace margelo::nitro::nitrospeech

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

@@ -0,0 +1,66 @@
+///
+/// HybridNitroSpeechSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridNitroSpeechSpec.hpp"
+
+
+
+
+namespace margelo::nitro::nitrospeech {
+
+  using namespace facebook;
+
+  class JHybridNitroSpeechSpec: public jni::HybridClass<JHybridNitroSpeechSpec, JHybridObject>,
+                                public virtual HybridNitroSpeechSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrospeech/HybridNitroSpeechSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridNitroSpeechSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridNitroSpeechSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridNitroSpeechSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridNitroSpeechSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::shared_ptr<HybridRecognizerSpec> getRecognizer() override;
+    void setRecognizer(const std::shared_ptr<HybridRecognizerSpec>& recognizer) override;
+
+  public:
+    // Methods
+    
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridNitroSpeechSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::nitrospeech

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

@@ -0,0 +1,167 @@
+///
+/// JHybridRecognizerSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridRecognizerSpec.hpp"
+
+// Forward declaration of `SpeechToTextParams` to properly resolve imports.
+namespace margelo::nitro::nitrospeech { struct SpeechToTextParams; }
+
+#include <functional>
+#include <optional>
+#include "JFunc_void.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include <string>
+#include <vector>
+#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"
+
+namespace margelo::nitro::nitrospeech {
+
+  jni::local_ref<JHybridRecognizerSpec::jhybriddata> JHybridRecognizerSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridRecognizerSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridRecognizerSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridRecognizerSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridRecognizerSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridRecognizerSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  std::optional<std::function<void()>> JHybridRecognizerSpec::getOnReadyForSpeech() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>()>("getOnReadyForSpeech_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void()> {
+      if (__result->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridRecognizerSpec::setOnReadyForSpeech(const std::optional<std::function<void()>>& onReadyForSpeech) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* onReadyForSpeech */)>("setOnReadyForSpeech_cxx");
+    method(_javaPart, onReadyForSpeech.has_value() ? JFunc_void_cxx::fromCpp(onReadyForSpeech.value()) : nullptr);
+  }
+  std::optional<std::function<void()>> JHybridRecognizerSpec::getOnRecordingStopped() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>()>("getOnRecordingStopped_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void()> {
+      if (__result->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridRecognizerSpec::setOnRecordingStopped(const std::optional<std::function<void()>>& onRecordingStopped) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* onRecordingStopped */)>("setOnRecordingStopped_cxx");
+    method(_javaPart, onRecordingStopped.has_value() ? JFunc_void_cxx::fromCpp(onRecordingStopped.value()) : nullptr);
+  }
+  std::optional<std::function<void(const std::vector<std::string>& /* resultBatches */)>> JHybridRecognizerSpec::getOnResult() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_std__vector_std__string_::javaobject>()>("getOnResult_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const std::vector<std::string>& /* resultBatches */)> {
+      if (__result->isInstanceOf(JFunc_void_std__vector_std__string__cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_std__vector_std__string__cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_std__vector_std__string_, void(std::vector<std::string>)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridRecognizerSpec::setOnResult(const std::optional<std::function<void(const std::vector<std::string>& /* resultBatches */)>>& onResult) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__vector_std__string_::javaobject> /* onResult */)>("setOnResult_cxx");
+    method(_javaPart, onResult.has_value() ? JFunc_void_std__vector_std__string__cxx::fromCpp(onResult.value()) : nullptr);
+  }
+  std::optional<std::function<void(double /* timeLeftMs */)>> JHybridRecognizerSpec::getOnAutoFinishProgress() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_double::javaobject>()>("getOnAutoFinishProgress_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(double /* timeLeftMs */)> {
+      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::setOnAutoFinishProgress(const std::optional<std::function<void(double /* timeLeftMs */)>>& onAutoFinishProgress) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_double::javaobject> /* onAutoFinishProgress */)>("setOnAutoFinishProgress_cxx");
+    method(_javaPart, onAutoFinishProgress.has_value() ? JFunc_void_double_cxx::fromCpp(onAutoFinishProgress.value()) : nullptr);
+  }
+  std::optional<std::function<void(const std::string& /* message */)>> JHybridRecognizerSpec::getOnError() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_std__string::javaobject>()>("getOnError_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(const std::string& /* message */)> {
+      if (__result->isInstanceOf(JFunc_void_std__string_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_std__string_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_std__string, void(std::string)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridRecognizerSpec::setOnError(const std::optional<std::function<void(const std::string& /* message */)>>& onError) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__string::javaobject> /* onError */)>("setOnError_cxx");
+    method(_javaPart, onError.has_value() ? JFunc_void_std__string_cxx::fromCpp(onError.value()) : nullptr);
+  }
+  std::optional<std::function<void()>> JHybridRecognizerSpec::getOnPermissionDenied() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>()>("getOnPermissionDenied_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void()> {
+      if (__result->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridRecognizerSpec::setOnPermissionDenied(const std::optional<std::function<void()>>& onPermissionDenied) {
+    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);
+  }
+
+  // Methods
+  void JHybridRecognizerSpec::startListening(const SpeechToTextParams& params) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JSpeechToTextParams> /* params */)>("startListening");
+    method(_javaPart, JSpeechToTextParams::fromCpp(params));
+  }
+  void JHybridRecognizerSpec::stopListening() {
+    static const auto method = javaClassStatic()->getMethod<void()>("stopListening");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::nitrospeech

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

@@ -0,0 +1,77 @@
+///
+/// HybridRecognizerSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridRecognizerSpec.hpp"
+
+
+
+
+namespace margelo::nitro::nitrospeech {
+
+  using namespace facebook;
+
+  class JHybridRecognizerSpec: public jni::HybridClass<JHybridRecognizerSpec, JHybridObject>,
+                               public virtual HybridRecognizerSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrospeech/HybridRecognizerSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridRecognizerSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridRecognizerSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridRecognizerSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridRecognizerSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::optional<std::function<void()>> getOnReadyForSpeech() override;
+    void setOnReadyForSpeech(const std::optional<std::function<void()>>& onReadyForSpeech) override;
+    std::optional<std::function<void()>> getOnRecordingStopped() override;
+    void setOnRecordingStopped(const std::optional<std::function<void()>>& onRecordingStopped) override;
+    std::optional<std::function<void(const std::vector<std::string>& /* resultBatches */)>> getOnResult() override;
+    void setOnResult(const std::optional<std::function<void(const std::vector<std::string>& /* resultBatches */)>>& onResult) override;
+    std::optional<std::function<void(double /* timeLeftMs */)>> getOnAutoFinishProgress() override;
+    void setOnAutoFinishProgress(const std::optional<std::function<void(double /* timeLeftMs */)>>& onAutoFinishProgress) override;
+    std::optional<std::function<void(const std::string& /* message */)>> getOnError() override;
+    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;
+
+  public:
+    // Methods
+    void startListening(const SpeechToTextParams& params) override;
+    void stopListening() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridRecognizerSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::nitrospeech