react-native-nitro-dgram 0.1.4

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

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

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 © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <string>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+
+namespace margelo::nitro::udp {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(error: 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/udp/Func_void_std__string;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__string` instance holds through JNI.
+     */
+    void invoke(const std::string& error) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* error */)>("invoke");
+      method(self(), jni::make_jstring(error));
+    }
+  };
+
+  /**
+   * 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& /* error */)>& 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> error) {
+      _func(error->toStdString());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::string& /* error */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/udp/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& /* error */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::string& /* error */)> _func;
+  };
+
+} // namespace margelo::nitro::udp

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

@@ -0,0 +1,57 @@
+///
+/// JHybridUdpDriverSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JHybridUdpDriverSpec.hpp"
+
+// Forward declaration of `HybridUdpSocketDriverSpec` to properly resolve imports.
+namespace margelo::nitro::udp { class HybridUdpSocketDriverSpec; }
+
+#include <memory>
+#include "HybridUdpSocketDriverSpec.hpp"
+#include "JHybridUdpSocketDriverSpec.hpp"
+#include <string>
+#include <optional>
+
+namespace margelo::nitro::udp {
+
+  jni::local_ref<JHybridUdpDriverSpec::jhybriddata> JHybridUdpDriverSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridUdpDriverSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridUdpDriverSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridUdpDriverSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridUdpDriverSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridUdpDriverSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::shared_ptr<HybridUdpSocketDriverSpec> JHybridUdpDriverSpec::createSocket(const std::optional<std::string>& id) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JHybridUdpSocketDriverSpec::javaobject>(jni::alias_ref<jni::JString> /* id */)>("createSocket");
+    auto __result = method(_javaPart, id.has_value() ? jni::make_jstring(id.value()) : nullptr);
+    return __result->cthis()->shared_cast<JHybridUdpSocketDriverSpec>();
+  }
+
+} // namespace margelo::nitro::udp

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

@@ -0,0 +1,65 @@
+///
+/// HybridUdpDriverSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridUdpDriverSpec.hpp"
+
+
+
+
+namespace margelo::nitro::udp {
+
+  using namespace facebook;
+
+  class JHybridUdpDriverSpec: public jni::HybridClass<JHybridUdpDriverSpec, JHybridObject>,
+                              public virtual HybridUdpDriverSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/udp/HybridUdpDriverSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridUdpDriverSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridUdpDriverSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridUdpDriverSpec() 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<JHybridUdpDriverSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::shared_ptr<HybridUdpSocketDriverSpec> createSocket(const std::optional<std::string>& id) override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridUdpDriverSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::udp

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

@@ -0,0 +1,261 @@
+///
+/// JHybridUdpSocketDriverSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JHybridUdpSocketDriverSpec.hpp"
+
+
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <string>
+#include <functional>
+#include "JFunc_void_std__shared_ptr_ArrayBuffer__std__string_double.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+#include "JFunc_void.hpp"
+#include "JFunc_void_std__string.hpp"
+#include <vector>
+#include <optional>
+
+namespace margelo::nitro::udp {
+
+  jni::local_ref<JHybridUdpSocketDriverSpec::jhybriddata> JHybridUdpSocketDriverSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridUdpSocketDriverSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridUdpSocketDriverSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridUdpSocketDriverSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridUdpSocketDriverSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridUdpSocketDriverSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  double JHybridUdpSocketDriverSpec::getId() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getId");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  std::function<void(const std::shared_ptr<ArrayBuffer>& /* data */, const std::string& /* address */, double /* port */)> JHybridUdpSocketDriverSpec::getOnMessage() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_std__shared_ptr_ArrayBuffer__std__string_double::javaobject>()>("getOnMessage_cxx");
+    auto __result = method(_javaPart);
+    return [&]() -> std::function<void(const std::shared_ptr<ArrayBuffer>& /* data */, const std::string& /* address */, double /* port */)> {
+      if (__result->isInstanceOf(JFunc_void_std__shared_ptr_ArrayBuffer__std__string_double_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_std__shared_ptr_ArrayBuffer__std__string_double_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_std__shared_ptr_ArrayBuffer__std__string_double, void(std::shared_ptr<ArrayBuffer>, std::string, double)>(std::move(__resultRef));
+      }
+    }();
+  }
+  void JHybridUdpSocketDriverSpec::setOnMessage(const std::function<void(const std::shared_ptr<ArrayBuffer>& /* data */, const std::string& /* address */, double /* port */)>& onMessage) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__shared_ptr_ArrayBuffer__std__string_double::javaobject> /* onMessage */)>("setOnMessage_cxx");
+    method(_javaPart, JFunc_void_std__shared_ptr_ArrayBuffer__std__string_double_cxx::fromCpp(onMessage));
+  }
+  std::function<void()> JHybridUdpSocketDriverSpec::getOnConnect() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>()>("getOnConnect_cxx");
+    auto __result = method(_javaPart);
+    return [&]() -> 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));
+      }
+    }();
+  }
+  void JHybridUdpSocketDriverSpec::setOnConnect(const std::function<void()>& onConnect) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* onConnect */)>("setOnConnect_cxx");
+    method(_javaPart, JFunc_void_cxx::fromCpp(onConnect));
+  }
+  std::function<void(const std::string& /* error */)> JHybridUdpSocketDriverSpec::getOnError() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_std__string::javaobject>()>("getOnError_cxx");
+    auto __result = method(_javaPart);
+    return [&]() -> std::function<void(const std::string& /* error */)> {
+      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));
+      }
+    }();
+  }
+  void JHybridUdpSocketDriverSpec::setOnError(const std::function<void(const std::string& /* error */)>& onError) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__string::javaobject> /* onError */)>("setOnError_cxx");
+    method(_javaPart, JFunc_void_std__string_cxx::fromCpp(onError));
+  }
+  std::function<void()> JHybridUdpSocketDriverSpec::getOnClose() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>()>("getOnClose_cxx");
+    auto __result = method(_javaPart);
+    return [&]() -> 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));
+      }
+    }();
+  }
+  void JHybridUdpSocketDriverSpec::setOnClose(const std::function<void()>& onClose) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* onClose */)>("setOnClose_cxx");
+    method(_javaPart, JFunc_void_cxx::fromCpp(onClose));
+  }
+
+  // Methods
+  double JHybridUdpSocketDriverSpec::bind(double port, const std::string& address, bool ipv6Only) {
+    static const auto method = javaClassStatic()->getMethod<double(double /* port */, jni::alias_ref<jni::JString> /* address */, jboolean /* ipv6Only */)>("bind");
+    auto __result = method(_javaPart, port, jni::make_jstring(address), ipv6Only);
+    return __result;
+  }
+  double JHybridUdpSocketDriverSpec::connect(double port, const std::string& address) {
+    static const auto method = javaClassStatic()->getMethod<double(double /* port */, jni::alias_ref<jni::JString> /* address */)>("connect");
+    auto __result = method(_javaPart, port, jni::make_jstring(address));
+    return __result;
+  }
+  double JHybridUdpSocketDriverSpec::disconnect() {
+    static const auto method = javaClassStatic()->getMethod<double()>("disconnect");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  double JHybridUdpSocketDriverSpec::send(const std::shared_ptr<ArrayBuffer>& data, double port, const std::string& address) {
+    static const auto method = javaClassStatic()->getMethod<double(jni::alias_ref<JArrayBuffer::javaobject> /* data */, double /* port */, jni::alias_ref<jni::JString> /* address */)>("send");
+    auto __result = method(_javaPart, JArrayBuffer::wrap(data), port, jni::make_jstring(address));
+    return __result;
+  }
+  double JHybridUdpSocketDriverSpec::sendMultiple(const std::vector<std::shared_ptr<ArrayBuffer>>& data, double port, const std::string& address) {
+    static const auto method = javaClassStatic()->getMethod<double(jni::alias_ref<jni::JArrayClass<JArrayBuffer::javaobject>> /* data */, double /* port */, jni::alias_ref<jni::JString> /* address */)>("sendMultiple");
+    auto __result = method(_javaPart, [&]() {
+      size_t __size = data.size();
+      jni::local_ref<jni::JArrayClass<JArrayBuffer::javaobject>> __array = jni::JArrayClass<JArrayBuffer::javaobject>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = data[__i];
+        auto __elementJni = JArrayBuffer::wrap(__element);
+        __array->setElement(__i, __elementJni.get());
+      }
+      return __array;
+    }(), port, jni::make_jstring(address));
+    return __result;
+  }
+  void JHybridUdpSocketDriverSpec::close() {
+    static const auto method = javaClassStatic()->getMethod<void()>("close");
+    method(_javaPart);
+  }
+  double JHybridUdpSocketDriverSpec::setBroadcast(bool flag) {
+    static const auto method = javaClassStatic()->getMethod<double(jboolean /* flag */)>("setBroadcast");
+    auto __result = method(_javaPart, flag);
+    return __result;
+  }
+  double JHybridUdpSocketDriverSpec::setTTL(double ttl) {
+    static const auto method = javaClassStatic()->getMethod<double(double /* ttl */)>("setTTL");
+    auto __result = method(_javaPart, ttl);
+    return __result;
+  }
+  double JHybridUdpSocketDriverSpec::setMulticastTTL(double ttl) {
+    static const auto method = javaClassStatic()->getMethod<double(double /* ttl */)>("setMulticastTTL");
+    auto __result = method(_javaPart, ttl);
+    return __result;
+  }
+  double JHybridUdpSocketDriverSpec::setMulticastLoopback(bool flag) {
+    static const auto method = javaClassStatic()->getMethod<double(jboolean /* flag */)>("setMulticastLoopback");
+    auto __result = method(_javaPart, flag);
+    return __result;
+  }
+  double JHybridUdpSocketDriverSpec::setMulticastInterface(const std::string& interfaceAddress) {
+    static const auto method = javaClassStatic()->getMethod<double(jni::alias_ref<jni::JString> /* interfaceAddress */)>("setMulticastInterface");
+    auto __result = method(_javaPart, jni::make_jstring(interfaceAddress));
+    return __result;
+  }
+  double JHybridUdpSocketDriverSpec::addMembership(const std::string& multicastAddress, const std::optional<std::string>& interfaceAddress) {
+    static const auto method = javaClassStatic()->getMethod<double(jni::alias_ref<jni::JString> /* multicastAddress */, jni::alias_ref<jni::JString> /* interfaceAddress */)>("addMembership");
+    auto __result = method(_javaPart, jni::make_jstring(multicastAddress), interfaceAddress.has_value() ? jni::make_jstring(interfaceAddress.value()) : nullptr);
+    return __result;
+  }
+  double JHybridUdpSocketDriverSpec::dropMembership(const std::string& multicastAddress, const std::optional<std::string>& interfaceAddress) {
+    static const auto method = javaClassStatic()->getMethod<double(jni::alias_ref<jni::JString> /* multicastAddress */, jni::alias_ref<jni::JString> /* interfaceAddress */)>("dropMembership");
+    auto __result = method(_javaPart, jni::make_jstring(multicastAddress), interfaceAddress.has_value() ? jni::make_jstring(interfaceAddress.value()) : nullptr);
+    return __result;
+  }
+  double JHybridUdpSocketDriverSpec::addSourceSpecificMembership(const std::string& sourceAddress, const std::string& groupAddress, const std::optional<std::string>& interfaceAddress) {
+    static const auto method = javaClassStatic()->getMethod<double(jni::alias_ref<jni::JString> /* sourceAddress */, jni::alias_ref<jni::JString> /* groupAddress */, jni::alias_ref<jni::JString> /* interfaceAddress */)>("addSourceSpecificMembership");
+    auto __result = method(_javaPart, jni::make_jstring(sourceAddress), jni::make_jstring(groupAddress), interfaceAddress.has_value() ? jni::make_jstring(interfaceAddress.value()) : nullptr);
+    return __result;
+  }
+  double JHybridUdpSocketDriverSpec::dropSourceSpecificMembership(const std::string& sourceAddress, const std::string& groupAddress, const std::optional<std::string>& interfaceAddress) {
+    static const auto method = javaClassStatic()->getMethod<double(jni::alias_ref<jni::JString> /* sourceAddress */, jni::alias_ref<jni::JString> /* groupAddress */, jni::alias_ref<jni::JString> /* interfaceAddress */)>("dropSourceSpecificMembership");
+    auto __result = method(_javaPart, jni::make_jstring(sourceAddress), jni::make_jstring(groupAddress), interfaceAddress.has_value() ? jni::make_jstring(interfaceAddress.value()) : nullptr);
+    return __result;
+  }
+  std::string JHybridUdpSocketDriverSpec::getLocalAddress() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getLocalAddress");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  double JHybridUdpSocketDriverSpec::getLocalPort() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getLocalPort");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  std::string JHybridUdpSocketDriverSpec::getRemoteAddress() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getRemoteAddress");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  double JHybridUdpSocketDriverSpec::getRemotePort() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getRemotePort");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  double JHybridUdpSocketDriverSpec::getRecvBufferSize() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getRecvBufferSize");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  double JHybridUdpSocketDriverSpec::setRecvBufferSize(double size) {
+    static const auto method = javaClassStatic()->getMethod<double(double /* size */)>("setRecvBufferSize");
+    auto __result = method(_javaPart, size);
+    return __result;
+  }
+  double JHybridUdpSocketDriverSpec::getSendBufferSize() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getSendBufferSize");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  double JHybridUdpSocketDriverSpec::setSendBufferSize(double size) {
+    static const auto method = javaClassStatic()->getMethod<double(double /* size */)>("setSendBufferSize");
+    auto __result = method(_javaPart, size);
+    return __result;
+  }
+  double JHybridUdpSocketDriverSpec::getSendQueueCount() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getSendQueueCount");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  double JHybridUdpSocketDriverSpec::getSendQueueSize() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getSendQueueSize");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+
+} // namespace margelo::nitro::udp

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

@@ -0,0 +1,97 @@
+///
+/// HybridUdpSocketDriverSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridUdpSocketDriverSpec.hpp"
+
+
+
+
+namespace margelo::nitro::udp {
+
+  using namespace facebook;
+
+  class JHybridUdpSocketDriverSpec: public jni::HybridClass<JHybridUdpSocketDriverSpec, JHybridObject>,
+                                    public virtual HybridUdpSocketDriverSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/udp/HybridUdpSocketDriverSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridUdpSocketDriverSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridUdpSocketDriverSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridUdpSocketDriverSpec() 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<JHybridUdpSocketDriverSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    double getId() override;
+    std::function<void(const std::shared_ptr<ArrayBuffer>& /* data */, const std::string& /* address */, double /* port */)> getOnMessage() override;
+    void setOnMessage(const std::function<void(const std::shared_ptr<ArrayBuffer>& /* data */, const std::string& /* address */, double /* port */)>& onMessage) override;
+    std::function<void()> getOnConnect() override;
+    void setOnConnect(const std::function<void()>& onConnect) override;
+    std::function<void(const std::string& /* error */)> getOnError() override;
+    void setOnError(const std::function<void(const std::string& /* error */)>& onError) override;
+    std::function<void()> getOnClose() override;
+    void setOnClose(const std::function<void()>& onClose) override;
+
+  public:
+    // Methods
+    double bind(double port, const std::string& address, bool ipv6Only) override;
+    double connect(double port, const std::string& address) override;
+    double disconnect() override;
+    double send(const std::shared_ptr<ArrayBuffer>& data, double port, const std::string& address) override;
+    double sendMultiple(const std::vector<std::shared_ptr<ArrayBuffer>>& data, double port, const std::string& address) override;
+    void close() override;
+    double setBroadcast(bool flag) override;
+    double setTTL(double ttl) override;
+    double setMulticastTTL(double ttl) override;
+    double setMulticastLoopback(bool flag) override;
+    double setMulticastInterface(const std::string& interfaceAddress) override;
+    double addMembership(const std::string& multicastAddress, const std::optional<std::string>& interfaceAddress) override;
+    double dropMembership(const std::string& multicastAddress, const std::optional<std::string>& interfaceAddress) override;
+    double addSourceSpecificMembership(const std::string& sourceAddress, const std::string& groupAddress, const std::optional<std::string>& interfaceAddress) override;
+    double dropSourceSpecificMembership(const std::string& sourceAddress, const std::string& groupAddress, const std::optional<std::string>& interfaceAddress) override;
+    std::string getLocalAddress() override;
+    double getLocalPort() override;
+    std::string getRemoteAddress() override;
+    double getRemotePort() override;
+    double getRecvBufferSize() override;
+    double setRecvBufferSize(double size) override;
+    double getSendBufferSize() override;
+    double setSendBufferSize(double size) override;
+    double getSendQueueCount() override;
+    double getSendQueueSize() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridUdpSocketDriverSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::udp