react-native-nitro-net 0.1.5

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

@@ -0,0 +1,127 @@
+///
+/// JHybridNetSocketDriverSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JHybridNetSocketDriverSpec.hpp"
+
+
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <functional>
+#include "JFunc_void_double_std__shared_ptr_ArrayBuffer_.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+#include <string>
+
+namespace margelo::nitro::net {
+
+  jni::local_ref<JHybridNetSocketDriverSpec::jhybriddata> JHybridNetSocketDriverSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridNetSocketDriverSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridNetSocketDriverSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridNetSocketDriverSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridNetSocketDriverSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridNetSocketDriverSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  double JHybridNetSocketDriverSpec::getId() {
+    static const auto method = javaClassStatic()->getMethod<double()>("getId");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  std::function<void(double /* event */, const std::shared_ptr<ArrayBuffer>& /* data */)> JHybridNetSocketDriverSpec::getOnEvent() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JFunc_void_double_std__shared_ptr_ArrayBuffer_::javaobject>()>("getOnEvent_cxx");
+    auto __result = method(_javaPart);
+    return [&]() -> std::function<void(double /* event */, const std::shared_ptr<ArrayBuffer>& /* data */)> {
+      if (__result->isInstanceOf(JFunc_void_double_std__shared_ptr_ArrayBuffer__cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_double_std__shared_ptr_ArrayBuffer__cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_double_std__shared_ptr_ArrayBuffer_, void(double, std::shared_ptr<ArrayBuffer>)>(std::move(__resultRef));
+      }
+    }();
+  }
+  void JHybridNetSocketDriverSpec::setOnEvent(const std::function<void(double /* event */, const std::shared_ptr<ArrayBuffer>& /* data */)>& onEvent) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_double_std__shared_ptr_ArrayBuffer_::javaobject> /* onEvent */)>("setOnEvent_cxx");
+    method(_javaPart, JFunc_void_double_std__shared_ptr_ArrayBuffer__cxx::fromCpp(onEvent));
+  }
+
+  // Methods
+  void JHybridNetSocketDriverSpec::connect(const std::string& host, double port) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* host */, double /* port */)>("connect");
+    method(_javaPart, jni::make_jstring(host), port);
+  }
+  void JHybridNetSocketDriverSpec::connectUnix(const std::string& path) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* path */)>("connectUnix");
+    method(_javaPart, jni::make_jstring(path));
+  }
+  void JHybridNetSocketDriverSpec::write(const std::shared_ptr<ArrayBuffer>& data) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JArrayBuffer::javaobject> /* data */)>("write");
+    method(_javaPart, JArrayBuffer::wrap(data));
+  }
+  void JHybridNetSocketDriverSpec::pause() {
+    static const auto method = javaClassStatic()->getMethod<void()>("pause");
+    method(_javaPart);
+  }
+  void JHybridNetSocketDriverSpec::resume() {
+    static const auto method = javaClassStatic()->getMethod<void()>("resume");
+    method(_javaPart);
+  }
+  void JHybridNetSocketDriverSpec::shutdown() {
+    static const auto method = javaClassStatic()->getMethod<void()>("shutdown");
+    method(_javaPart);
+  }
+  void JHybridNetSocketDriverSpec::setTimeout(double timeout) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* timeout */)>("setTimeout");
+    method(_javaPart, timeout);
+  }
+  void JHybridNetSocketDriverSpec::destroy() {
+    static const auto method = javaClassStatic()->getMethod<void()>("destroy");
+    method(_javaPart);
+  }
+  void JHybridNetSocketDriverSpec::resetAndDestroy() {
+    static const auto method = javaClassStatic()->getMethod<void()>("resetAndDestroy");
+    method(_javaPart);
+  }
+  void JHybridNetSocketDriverSpec::setNoDelay(bool enable) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* enable */)>("setNoDelay");
+    method(_javaPart, enable);
+  }
+  void JHybridNetSocketDriverSpec::setKeepAlive(bool enable, double delay) {
+    static const auto method = javaClassStatic()->getMethod<void(jboolean /* enable */, double /* delay */)>("setKeepAlive");
+    method(_javaPart, enable, delay);
+  }
+  std::string JHybridNetSocketDriverSpec::getLocalAddress() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getLocalAddress");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+  std::string JHybridNetSocketDriverSpec::getRemoteAddress() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getRemoteAddress");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+
+} // namespace margelo::nitro::net

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

@@ -0,0 +1,79 @@
+///
+/// HybridNetSocketDriverSpec.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 "HybridNetSocketDriverSpec.hpp"
+
+
+
+
+namespace margelo::nitro::net {
+
+  using namespace facebook;
+
+  class JHybridNetSocketDriverSpec: public jni::HybridClass<JHybridNetSocketDriverSpec, JHybridObject>,
+                                    public virtual HybridNetSocketDriverSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/net/HybridNetSocketDriverSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridNetSocketDriverSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridNetSocketDriverSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridNetSocketDriverSpec() 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<JHybridNetSocketDriverSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    double getId() override;
+    std::function<void(double /* event */, const std::shared_ptr<ArrayBuffer>& /* data */)> getOnEvent() override;
+    void setOnEvent(const std::function<void(double /* event */, const std::shared_ptr<ArrayBuffer>& /* data */)>& onEvent) override;
+
+  public:
+    // Methods
+    void connect(const std::string& host, double port) override;
+    void connectUnix(const std::string& path) override;
+    void write(const std::shared_ptr<ArrayBuffer>& data) override;
+    void pause() override;
+    void resume() override;
+    void shutdown() override;
+    void setTimeout(double timeout) override;
+    void destroy() override;
+    void resetAndDestroy() override;
+    void setNoDelay(bool enable) override;
+    void setKeepAlive(bool enable, double delay) override;
+    std::string getLocalAddress() override;
+    std::string getRemoteAddress() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridNetSocketDriverSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::net

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

@@ -0,0 +1,57 @@
+///
+/// JNetConfig.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 "NetConfig.hpp"
+
+#include <optional>
+
+namespace margelo::nitro::net {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "NetConfig" and the the Kotlin data class "NetConfig".
+   */
+  struct JNetConfig final: public jni::JavaClass<JNetConfig> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/net/NetConfig;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct NetConfig by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    NetConfig toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldWorkerThreads = clazz->getField<jni::JDouble>("workerThreads");
+      jni::local_ref<jni::JDouble> workerThreads = this->getFieldValue(fieldWorkerThreads);
+      return NetConfig(
+        workerThreads != nullptr ? std::make_optional(workerThreads->value()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JNetConfig::javaobject> fromCpp(const NetConfig& value) {
+      using JSignature = JNetConfig(jni::alias_ref<jni::JDouble>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.workerThreads.has_value() ? jni::JDouble::valueOf(value.workerThreads.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::net

package/nitrogen/generated/android/kotlin/com/margelo/nitro/net/Func_void_double_std__shared_ptr_ArrayBuffer_.kt

@@ -0,0 +1,80 @@
+///
+/// Func_void_double_std__shared_ptr_ArrayBuffer_.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.net
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+import com.margelo.nitro.core.ArrayBuffer
+
+/**
+ * Represents the JavaScript callback `(event: number, data: array-buffer) => void`.
+ * This can be either implemented in C++ (in which case it might be a callback coming from JS),
+ * or in Kotlin/Java (in which case it is a native callback).
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType")
+fun interface Func_void_double_std__shared_ptr_ArrayBuffer_: (Double, ArrayBuffer) -> Unit {
+  /**
+   * Call the given JS callback.
+   * @throws Throwable if the JS function itself throws an error, or if the JS function/runtime has already been deleted.
+   */
+  @DoNotStrip
+  @Keep
+  override fun invoke(event: Double, data: ArrayBuffer): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(event: number, data: array-buffer) => void`.
+ * This is implemented in C++, via a `std::function<...>`.
+ * The callback might be coming from JS.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "FunctionName",
+  "ConvertSecondaryConstructorToPrimary", "ClassName", "LocalVariableName",
+)
+class Func_void_double_std__shared_ptr_ArrayBuffer__cxx: Func_void_double_std__shared_ptr_ArrayBuffer_ {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(event: Double, data: ArrayBuffer): Unit
+    = invoke_cxx(event,data)
+
+  @FastNative
+  private external fun invoke_cxx(event: Double, data: ArrayBuffer): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(event: number, data: array-buffer) => void`.
+ * This is implemented in Java/Kotlin, via a `(Double, ArrayBuffer) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_double_std__shared_ptr_ArrayBuffer__java(private val function: (Double, ArrayBuffer) -> Unit): Func_void_double_std__shared_ptr_ArrayBuffer_ {
+  @DoNotStrip
+  @Keep
+  override fun invoke(event: Double, data: ArrayBuffer): Unit {
+    return this.function(event, data)
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/net/HybridNetDriverSpec.kt

@@ -0,0 +1,65 @@
+///
+/// HybridNetDriverSpec.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.net
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.HybridObject
+
+/**
+ * A Kotlin class representing the NetDriver HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of NetDriver.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class HybridNetDriverSpec: HybridObject() {
+  @DoNotStrip
+  private var mHybridData: HybridData = initHybrid()
+
+  init {
+    super.updateNative(mHybridData)
+  }
+
+  override fun updateNative(hybridData: HybridData) {
+    mHybridData = hybridData
+    super.updateNative(hybridData)
+  }
+
+  // Default implementation of `HybridObject.toString()`
+  override fun toString(): String {
+    return "[HybridObject NetDriver]"
+  }
+
+  // Properties
+  
+
+  // Methods
+  @DoNotStrip
+  @Keep
+  abstract fun createSocket(id: String?): HybridNetSocketDriverSpec
+  
+  @DoNotStrip
+  @Keep
+  abstract fun createServer(): HybridNetServerDriverSpec
+  
+  @DoNotStrip
+  @Keep
+  abstract fun initWithConfig(config: NetConfig): Unit
+
+  private external fun initHybrid(): HybridData
+
+  companion object {
+    protected const val TAG = "HybridNetDriverSpec"
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/net/HybridNetServerDriverSpec.kt

@@ -0,0 +1,92 @@
+///
+/// HybridNetServerDriverSpec.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.net
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.ArrayBuffer
+import com.margelo.nitro.core.HybridObject
+
+/**
+ * A Kotlin class representing the NetServerDriver HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of NetServerDriver.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class HybridNetServerDriverSpec: HybridObject() {
+  @DoNotStrip
+  private var mHybridData: HybridData = initHybrid()
+
+  init {
+    super.updateNative(mHybridData)
+  }
+
+  override fun updateNative(hybridData: HybridData) {
+    mHybridData = hybridData
+    super.updateNative(hybridData)
+  }
+
+  // Default implementation of `HybridObject.toString()`
+  override fun toString(): String {
+    return "[HybridObject NetServerDriver]"
+  }
+
+  // Properties
+  abstract var onEvent: (event: Double, data: ArrayBuffer) -> Unit
+  
+  private var onEvent_cxx: Func_void_double_std__shared_ptr_ArrayBuffer_
+    @Keep
+    @DoNotStrip
+    get() {
+      return Func_void_double_std__shared_ptr_ArrayBuffer__java(onEvent)
+    }
+    @Keep
+    @DoNotStrip
+    set(value) {
+      onEvent = value
+    }
+  
+  @get:DoNotStrip
+  @get:Keep
+  @set:DoNotStrip
+  @set:Keep
+  abstract var maxConnections: Double
+
+  // Methods
+  @DoNotStrip
+  @Keep
+  abstract fun listen(port: Double, backlog: Double?, ipv6Only: Boolean?, reusePort: Boolean?): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun listenUnix(path: String, backlog: Double?): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun listenHandle(fd: Double, backlog: Double?): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getLocalAddress(): String
+  
+  @DoNotStrip
+  @Keep
+  abstract fun close(): Unit
+
+  private external fun initHybrid(): HybridData
+
+  companion object {
+    protected const val TAG = "HybridNetServerDriverSpec"
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/net/HybridNetSocketDriverSpec.kt

@@ -0,0 +1,122 @@
+///
+/// HybridNetSocketDriverSpec.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.net
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.ArrayBuffer
+import com.margelo.nitro.core.HybridObject
+
+/**
+ * A Kotlin class representing the NetSocketDriver HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of NetSocketDriver.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class HybridNetSocketDriverSpec: HybridObject() {
+  @DoNotStrip
+  private var mHybridData: HybridData = initHybrid()
+
+  init {
+    super.updateNative(mHybridData)
+  }
+
+  override fun updateNative(hybridData: HybridData) {
+    mHybridData = hybridData
+    super.updateNative(hybridData)
+  }
+
+  // Default implementation of `HybridObject.toString()`
+  override fun toString(): String {
+    return "[HybridObject NetSocketDriver]"
+  }
+
+  // Properties
+  @get:DoNotStrip
+  @get:Keep
+  abstract val id: Double
+  
+  abstract var onEvent: (event: Double, data: ArrayBuffer) -> Unit
+  
+  private var onEvent_cxx: Func_void_double_std__shared_ptr_ArrayBuffer_
+    @Keep
+    @DoNotStrip
+    get() {
+      return Func_void_double_std__shared_ptr_ArrayBuffer__java(onEvent)
+    }
+    @Keep
+    @DoNotStrip
+    set(value) {
+      onEvent = value
+    }
+
+  // Methods
+  @DoNotStrip
+  @Keep
+  abstract fun connect(host: String, port: Double): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun connectUnix(path: String): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun write(data: ArrayBuffer): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun pause(): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun resume(): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun shutdown(): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setTimeout(timeout: Double): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun destroy(): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun resetAndDestroy(): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setNoDelay(enable: Boolean): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setKeepAlive(enable: Boolean, delay: Double): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getLocalAddress(): String
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getRemoteAddress(): String
+
+  private external fun initHybrid(): HybridData
+
+  companion object {
+    protected const val TAG = "HybridNetSocketDriverSpec"
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/net/NetConfig.kt

@@ -0,0 +1,38 @@
+///
+/// NetConfig.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.net
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+
+/**
+ * Represents the JavaScript object/struct "NetConfig".
+ */
+@DoNotStrip
+@Keep
+data class NetConfig(
+  @DoNotStrip
+  @Keep
+  val workerThreads: Double?
+) {
+  /* primary constructor */
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(workerThreads: Double?): NetConfig {
+      return NetConfig(workerThreads)
+    }
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/net/RustCNetOnLoad.kt

@@ -0,0 +1,35 @@
+///
+/// RustCNetOnLoad.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.net
+
+import android.util.Log
+
+internal class RustCNetOnLoad {
+  companion object {
+    private const val TAG = "RustCNetOnLoad"
+    private var didLoad = false
+    /**
+     * Initializes the native part of "RustCNet".
+     * This method is idempotent and can be called more than once.
+     */
+    @JvmStatic
+    fun initializeNative() {
+      if (didLoad) return
+      try {
+        Log.i(TAG, "Loading RustCNet C++ library...")
+        System.loadLibrary("RustCNet")
+        Log.i(TAG, "Successfully loaded RustCNet C++ library!")
+        didLoad = true
+      } catch (e: Error) {
+        Log.e(TAG, "Failed to load RustCNet C++ library! Is it properly installed and linked? " +
+                    "Is the name correct? (see `CMakeLists.txt`, at `add_library(...)`)", e)
+        throw e
+      }
+    }
+  }
+}