react-native-nitro-fetch 0.1.6 → 0.2.0

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

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

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

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

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

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

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

@@ -0,0 +1,85 @@
+///
+/// JFunc_void_std__optional_UrlResponseInfo__RequestException.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "UrlResponseInfo.hpp"
+#include <optional>
+#include "RequestException.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JUrlResponseInfo.hpp"
+#include <string>
+#include <unordered_map>
+#include "HttpHeader.hpp"
+#include <vector>
+#include "JHttpHeader.hpp"
+#include "JRequestException.hpp"
+
+namespace margelo::nitro::nitrofetch {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(info: UrlResponseInfo?, error: RequestException) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__optional_UrlResponseInfo__RequestException: public jni::JavaClass<JFunc_void_std__optional_UrlResponseInfo__RequestException> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrofetch/Func_void_std__optional_UrlResponseInfo__RequestException;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__optional_UrlResponseInfo__RequestException` instance holds through JNI.
+     */
+    void invoke(const std::optional<UrlResponseInfo>& info, const RequestException& error) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JUrlResponseInfo> /* info */, jni::alias_ref<JRequestException> /* error */)>("invoke");
+      method(self(), info.has_value() ? JUrlResponseInfo::fromCpp(info.value()) : nullptr, JRequestException::fromCpp(error));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__optional_UrlResponseInfo__RequestException that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__optional_UrlResponseInfo__RequestException_cxx final: public jni::HybridClass<JFunc_void_std__optional_UrlResponseInfo__RequestException_cxx, JFunc_void_std__optional_UrlResponseInfo__RequestException> {
+  public:
+    static jni::local_ref<JFunc_void_std__optional_UrlResponseInfo__RequestException::javaobject> fromCpp(const std::function<void(const std::optional<UrlResponseInfo>& /* info */, const RequestException& /* error */)>& func) {
+      return JFunc_void_std__optional_UrlResponseInfo__RequestException_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__optional_UrlResponseInfo__RequestException_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JUrlResponseInfo> info, jni::alias_ref<JRequestException> error) {
+      _func(info != nullptr ? std::make_optional(info->toCpp()) : std::nullopt, error->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::optional<UrlResponseInfo>& /* info */, const RequestException& /* error */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrofetch/Func_void_std__optional_UrlResponseInfo__RequestException_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__optional_UrlResponseInfo__RequestException_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__optional_UrlResponseInfo__RequestException_cxx(const std::function<void(const std::optional<UrlResponseInfo>& /* info */, const RequestException& /* error */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::optional<UrlResponseInfo>& /* info */, const RequestException& /* error */)> _func;
+  };
+
+} // namespace margelo::nitro::nitrofetch

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

@@ -0,0 +1,61 @@
+///
+/// JHttpHeader.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "HttpHeader.hpp"
+
+#include <string>
+
+namespace margelo::nitro::nitrofetch {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "HttpHeader" and the the Kotlin data class "HttpHeader".
+   */
+  struct JHttpHeader final: public jni::JavaClass<JHttpHeader> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrofetch/HttpHeader;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct HttpHeader by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    HttpHeader toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldKey = clazz->getField<jni::JString>("key");
+      jni::local_ref<jni::JString> key = this->getFieldValue(fieldKey);
+      static const auto fieldValue = clazz->getField<jni::JString>("value");
+      jni::local_ref<jni::JString> value = this->getFieldValue(fieldValue);
+      return HttpHeader(
+        key->toStdString(),
+        value->toStdString()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JHttpHeader::javaobject> fromCpp(const HttpHeader& value) {
+      using JSignature = JHttpHeader(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.key),
+        jni::make_jstring(value.value)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrofetch

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

@@ -2,7 +2,7 @@
 /// JHybridNativeStorageSpec.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #include "JHybridNativeStorageSpec.hpp"
@@ -13,24 +13,31 @@
 
 namespace margelo::nitro::nitrofetch {
 
-  jni::local_ref<JHybridNativeStorageSpec::jhybriddata> JHybridNativeStorageSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
-    return makeCxxInstance(jThis);
+  std::shared_ptr<JHybridNativeStorageSpec> JHybridNativeStorageSpec::JavaPart::getJHybridNativeStorageSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridNativeStorageSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridNativeStorageSpec!");
+    }
+    return castHybridObject;
   }
 
-  void JHybridNativeStorageSpec::registerNatives() {
-    registerHybrid({
-      makeNativeMethod("initHybrid", JHybridNativeStorageSpec::initHybrid),
-    });
+  jni::local_ref<JHybridNativeStorageSpec::CxxPart::jhybriddata> JHybridNativeStorageSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
   }
 
-  size_t JHybridNativeStorageSpec::getExternalMemorySize() noexcept {
-    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
-    return method(_javaPart);
+  std::shared_ptr<JHybridObject> JHybridNativeStorageSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridNativeStorageSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridNativeStorageSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridNativeStorageSpec>(castJavaPart);
   }
 
-  void JHybridNativeStorageSpec::dispose() noexcept {
-    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
-    method(_javaPart);
+  void JHybridNativeStorageSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridNativeStorageSpec::CxxPart::initHybrid),
+    });
   }
 
   // Properties
@@ -38,16 +45,16 @@ namespace margelo::nitro::nitrofetch {
 
   // Methods
   std::string JHybridNativeStorageSpec::getString(const std::string& key) {
-    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>(jni::alias_ref<jni::JString> /* key */)>("getString");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>(jni::alias_ref<jni::JString> /* key */)>("getString");
     auto __result = method(_javaPart, jni::make_jstring(key));
     return __result->toStdString();
   }
   void JHybridNativeStorageSpec::setString(const std::string& key, const std::string& value) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* key */, jni::alias_ref<jni::JString> /* value */)>("setString");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* key */, jni::alias_ref<jni::JString> /* value */)>("setString");
     method(_javaPart, jni::make_jstring(key), jni::make_jstring(value));
   }
   void JHybridNativeStorageSpec::removeString(const std::string& key) {
-    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* key */)>("removeString");
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* key */)>("removeString");
     method(_javaPart, jni::make_jstring(key));
   }
 

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

@@ -2,7 +2,7 @@
 /// HybridNativeStorageSpec.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2025 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #pragma once
@@ -18,32 +18,33 @@ namespace margelo::nitro::nitrofetch {
 
   using namespace facebook;
 
-  class JHybridNativeStorageSpec: public jni::HybridClass<JHybridNativeStorageSpec, JHybridObject>,
-                                  public virtual HybridNativeStorageSpec {
+  class JHybridNativeStorageSpec: public virtual HybridNativeStorageSpec, public virtual JHybridObject {
   public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrofetch/HybridNativeStorageSpec;";
-    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
-    static void registerNatives();
-
-  protected:
-    // C++ constructor (called from Java via `initHybrid()`)
-    explicit JHybridNativeStorageSpec(jni::alias_ref<jhybridobject> jThis) :
-      HybridObject(HybridNativeStorageSpec::TAG),
-      HybridBase(jThis),
-      _javaPart(jni::make_global(jThis)) {}
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrofetch/HybridNativeStorageSpec;";
+      std::shared_ptr<JHybridNativeStorageSpec> getJHybridNativeStorageSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrofetch/HybridNativeStorageSpec$CxxPart;";
+      static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+      static void registerNatives();
+      using HybridBase::HybridBase;
+    protected:
+      std::shared_ptr<JHybridObject> createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) override;
+    };
 
   public:
+    explicit JHybridNativeStorageSpec(const jni::local_ref<JHybridNativeStorageSpec::JavaPart>& javaPart):
+      HybridObject(HybridNativeStorageSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
     ~JHybridNativeStorageSpec() 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;
-
-  public:
-    inline const jni::global_ref<JHybridNativeStorageSpec::javaobject>& getJavaPart() const noexcept {
+    inline const jni::global_ref<JHybridNativeStorageSpec::JavaPart>& getJavaPart() const noexcept {
       return _javaPart;
     }
 
@@ -58,9 +59,7 @@ namespace margelo::nitro::nitrofetch {
     void removeString(const std::string& key) override;
 
   private:
-    friend HybridBase;
-    using HybridBase::HybridBase;
-    jni::global_ref<JHybridNativeStorageSpec::javaobject> _javaPart;
+    jni::global_ref<JHybridNativeStorageSpec::JavaPart> _javaPart;
   };
 
 } // namespace margelo::nitro::nitrofetch

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

@@ -0,0 +1,57 @@
+///
+/// JHybridNitroCronetSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridNitroCronetSpec.hpp"
+
+// Forward declaration of `HybridUrlRequestBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::nitrofetch { class HybridUrlRequestBuilderSpec; }
+
+#include <memory>
+#include "HybridUrlRequestBuilderSpec.hpp"
+#include "JHybridUrlRequestBuilderSpec.hpp"
+#include <string>
+
+namespace margelo::nitro::nitrofetch {
+
+  std::shared_ptr<JHybridNitroCronetSpec> JHybridNitroCronetSpec::JavaPart::getJHybridNitroCronetSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridNitroCronetSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridNitroCronetSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridNitroCronetSpec::CxxPart::jhybriddata> JHybridNitroCronetSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridNitroCronetSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridNitroCronetSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridNitroCronetSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridNitroCronetSpec>(castJavaPart);
+  }
+
+  void JHybridNitroCronetSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridNitroCronetSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::shared_ptr<HybridUrlRequestBuilderSpec> JHybridNitroCronetSpec::newUrlRequestBuilder(const std::string& url) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JHybridUrlRequestBuilderSpec::JavaPart>(jni::alias_ref<jni::JString> /* url */)>("newUrlRequestBuilder");
+    auto __result = method(_javaPart, jni::make_jstring(url));
+    return __result->getJHybridUrlRequestBuilderSpec();
+  }
+
+} // namespace margelo::nitro::nitrofetch

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

@@ -0,0 +1,63 @@
+///
+/// HybridNitroCronetSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridNitroCronetSpec.hpp"
+
+
+
+
+namespace margelo::nitro::nitrofetch {
+
+  using namespace facebook;
+
+  class JHybridNitroCronetSpec: public virtual HybridNitroCronetSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrofetch/HybridNitroCronetSpec;";
+      std::shared_ptr<JHybridNitroCronetSpec> getJHybridNitroCronetSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/nitrofetch/HybridNitroCronetSpec$CxxPart;";
+      static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+      static void registerNatives();
+      using HybridBase::HybridBase;
+    protected:
+      std::shared_ptr<JHybridObject> createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) override;
+    };
+
+  public:
+    explicit JHybridNitroCronetSpec(const jni::local_ref<JHybridNitroCronetSpec::JavaPart>& javaPart):
+      HybridObject(HybridNitroCronetSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridNitroCronetSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridNitroCronetSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::shared_ptr<HybridUrlRequestBuilderSpec> newUrlRequestBuilder(const std::string& url) override;
+
+  private:
+    jni::global_ref<JHybridNitroCronetSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::nitrofetch