@onekeyfe/react-native-image 3.0.98

package/lib/nitrogen/generated/android/c++/JHybridOneKeyImageCacheSpec.cpp

@@ -0,0 +1,130 @@
+///
+/// JHybridOneKeyImageCacheSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridOneKeyImageCacheSpec.hpp"
+
+// Forward declaration of `OneKeyImagePreloadSource` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { struct OneKeyImagePreloadSource; }
+// Forward declaration of `OneKeyImageCachePolicy` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { enum class OneKeyImageCachePolicy; }
+
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include <NitroModules/JUnit.hpp>
+#include "OneKeyImagePreloadSource.hpp"
+#include <vector>
+#include "JOneKeyImagePreloadSource.hpp"
+#include <string>
+#include <optional>
+#include "OneKeyImageCachePolicy.hpp"
+#include "JOneKeyImageCachePolicy.hpp"
+
+namespace margelo::nitro::onekeyimage {
+
+  std::shared_ptr<JHybridOneKeyImageCacheSpec> JHybridOneKeyImageCacheSpec::JavaPart::getJHybridOneKeyImageCacheSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridOneKeyImageCacheSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridOneKeyImageCacheSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridOneKeyImageCacheSpec::CxxPart::jhybriddata> JHybridOneKeyImageCacheSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridOneKeyImageCacheSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridOneKeyImageCacheSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridOneKeyImageCacheSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridOneKeyImageCacheSpec>(castJavaPart);
+  }
+
+  void JHybridOneKeyImageCacheSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridOneKeyImageCacheSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::shared_ptr<Promise<bool>> JHybridOneKeyImageCacheSpec::preload(const std::vector<OneKeyImagePreloadSource>& sources) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JArrayClass<JOneKeyImagePreloadSource>> /* sources */)>("preload");
+    auto __result = method(_javaPart, [&](auto&& __input) {
+      size_t __size = __input.size();
+      jni::local_ref<jni::JArrayClass<JOneKeyImagePreloadSource>> __array = jni::JArrayClass<JOneKeyImagePreloadSource>::newArray(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        const auto& __element = __input[__i];
+        auto __elementJni = JOneKeyImagePreloadSource::fromCpp(__element);
+        __array->setElement(__i, *__elementJni);
+      }
+      return __array;
+    }(sources));
+    return [&]() {
+      auto __promise = Promise<bool>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JBoolean>(__boxedResult);
+        __promise->resolve(static_cast<bool>(__result->value()));
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridOneKeyImageCacheSpec::clearMemory() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("clearMemory");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridOneKeyImageCacheSpec::clearDisk() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("clearDisk");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridOneKeyImageCacheSpec::clearAll() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("clearAll");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+
+} // namespace margelo::nitro::onekeyimage

package/lib/nitrogen/generated/android/c++/JHybridOneKeyImageCacheSpec.hpp

@@ -0,0 +1,66 @@
+///
+/// HybridOneKeyImageCacheSpec.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 "HybridOneKeyImageCacheSpec.hpp"
+
+
+
+
+namespace margelo::nitro::onekeyimage {
+
+  using namespace facebook;
+
+  class JHybridOneKeyImageCacheSpec: public virtual HybridOneKeyImageCacheSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/HybridOneKeyImageCacheSpec;";
+      std::shared_ptr<JHybridOneKeyImageCacheSpec> getJHybridOneKeyImageCacheSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/HybridOneKeyImageCacheSpec$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 JHybridOneKeyImageCacheSpec(const jni::local_ref<JHybridOneKeyImageCacheSpec::JavaPart>& javaPart):
+      HybridObject(HybridOneKeyImageCacheSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridOneKeyImageCacheSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridOneKeyImageCacheSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::shared_ptr<Promise<bool>> preload(const std::vector<OneKeyImagePreloadSource>& sources) override;
+    std::shared_ptr<Promise<void>> clearMemory() override;
+    std::shared_ptr<Promise<void>> clearDisk() override;
+    std::shared_ptr<Promise<void>> clearAll() override;
+
+  private:
+    jni::global_ref<JHybridOneKeyImageCacheSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::onekeyimage

package/lib/nitrogen/generated/android/c++/JHybridOneKeyImageSpec.cpp

@@ -0,0 +1,255 @@
+///
+/// JHybridOneKeyImageSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridOneKeyImageSpec.hpp"
+
+// Forward declaration of `OneKeyImageVariant` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { enum class OneKeyImageVariant; }
+// Forward declaration of `OneKeyImageContentFit` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { enum class OneKeyImageContentFit; }
+// Forward declaration of `OneKeyImageCachePolicy` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { enum class OneKeyImageCachePolicy; }
+// Forward declaration of `OneKeyImageLoadingStrategy` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { enum class OneKeyImageLoadingStrategy; }
+// Forward declaration of `OneKeyImageCacheType` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { enum class OneKeyImageCacheType; }
+
+#include <string>
+#include <optional>
+#include "OneKeyImageVariant.hpp"
+#include "JOneKeyImageVariant.hpp"
+#include "OneKeyImageContentFit.hpp"
+#include "JOneKeyImageContentFit.hpp"
+#include "OneKeyImageCachePolicy.hpp"
+#include "JOneKeyImageCachePolicy.hpp"
+#include "OneKeyImageLoadingStrategy.hpp"
+#include "JOneKeyImageLoadingStrategy.hpp"
+#include <functional>
+#include "JFunc_void.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "OneKeyImageCacheType.hpp"
+#include "JFunc_void_double_double_OneKeyImageCacheType.hpp"
+#include "JOneKeyImageCacheType.hpp"
+#include "JFunc_void_std__string.hpp"
+
+namespace margelo::nitro::onekeyimage {
+
+  std::shared_ptr<JHybridOneKeyImageSpec> JHybridOneKeyImageSpec::JavaPart::getJHybridOneKeyImageSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridOneKeyImageSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridOneKeyImageSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridOneKeyImageSpec::CxxPart::jhybriddata> JHybridOneKeyImageSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridOneKeyImageSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridOneKeyImageSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridOneKeyImageSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridOneKeyImageSpec>(castJavaPart);
+  }
+
+  void JHybridOneKeyImageSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridOneKeyImageSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  std::optional<std::string> JHybridOneKeyImageSpec::getSourceUri() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getSourceUri");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridOneKeyImageSpec::setSourceUri(const std::optional<std::string>& sourceUri) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* sourceUri */)>("setSourceUri");
+    method(_javaPart, sourceUri.has_value() ? jni::make_jstring(sourceUri.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridOneKeyImageSpec::getSourceHeadersJson() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getSourceHeadersJson");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridOneKeyImageSpec::setSourceHeadersJson(const std::optional<std::string>& sourceHeadersJson) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* sourceHeadersJson */)>("setSourceHeadersJson");
+    method(_javaPart, sourceHeadersJson.has_value() ? jni::make_jstring(sourceHeadersJson.value()) : nullptr);
+  }
+  std::optional<OneKeyImageVariant> JHybridOneKeyImageSpec::getVariant() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JOneKeyImageVariant>()>("getVariant");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  void JHybridOneKeyImageSpec::setVariant(std::optional<OneKeyImageVariant> variant) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JOneKeyImageVariant> /* variant */)>("setVariant");
+    method(_javaPart, variant.has_value() ? JOneKeyImageVariant::fromCpp(variant.value()) : nullptr);
+  }
+  std::optional<OneKeyImageContentFit> JHybridOneKeyImageSpec::getContentFit() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JOneKeyImageContentFit>()>("getContentFit");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  void JHybridOneKeyImageSpec::setContentFit(std::optional<OneKeyImageContentFit> contentFit) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JOneKeyImageContentFit> /* contentFit */)>("setContentFit");
+    method(_javaPart, contentFit.has_value() ? JOneKeyImageContentFit::fromCpp(contentFit.value()) : nullptr);
+  }
+  std::optional<OneKeyImageCachePolicy> JHybridOneKeyImageSpec::getCachePolicy() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JOneKeyImageCachePolicy>()>("getCachePolicy");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  void JHybridOneKeyImageSpec::setCachePolicy(std::optional<OneKeyImageCachePolicy> cachePolicy) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JOneKeyImageCachePolicy> /* cachePolicy */)>("setCachePolicy");
+    method(_javaPart, cachePolicy.has_value() ? JOneKeyImageCachePolicy::fromCpp(cachePolicy.value()) : nullptr);
+  }
+  std::optional<bool> JHybridOneKeyImageSpec::getAutoplay() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getAutoplay");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridOneKeyImageSpec::setAutoplay(std::optional<bool> autoplay) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* autoplay */)>("setAutoplay");
+    method(_javaPart, autoplay.has_value() ? jni::JBoolean::valueOf(autoplay.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridOneKeyImageSpec::getRecyclingKey() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getRecyclingKey");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  void JHybridOneKeyImageSpec::setRecyclingKey(const std::optional<std::string>& recyclingKey) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* recyclingKey */)>("setRecyclingKey");
+    method(_javaPart, recyclingKey.has_value() ? jni::make_jstring(recyclingKey.value()) : nullptr);
+  }
+  std::optional<bool> JHybridOneKeyImageSpec::getOptimizeTos() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JBoolean>()>("getOptimizeTos");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(static_cast<bool>(__result->value())) : std::nullopt;
+  }
+  void JHybridOneKeyImageSpec::setOptimizeTos(std::optional<bool> optimizeTos) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JBoolean> /* optimizeTos */)>("setOptimizeTos");
+    method(_javaPart, optimizeTos.has_value() ? jni::JBoolean::valueOf(optimizeTos.value()) : nullptr);
+  }
+  std::optional<double> JHybridOneKeyImageSpec::getOverscan() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JDouble>()>("getOverscan");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->value()) : std::nullopt;
+  }
+  void JHybridOneKeyImageSpec::setOverscan(std::optional<double> overscan) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JDouble> /* overscan */)>("setOverscan");
+    method(_javaPart, overscan.has_value() ? jni::JDouble::valueOf(overscan.value()) : nullptr);
+  }
+  std::optional<OneKeyImageLoadingStrategy> JHybridOneKeyImageSpec::getLoadingStrategy() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JOneKeyImageLoadingStrategy>()>("getLoadingStrategy");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  void JHybridOneKeyImageSpec::setLoadingStrategy(std::optional<OneKeyImageLoadingStrategy> loadingStrategy) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JOneKeyImageLoadingStrategy> /* loadingStrategy */)>("setLoadingStrategy");
+    method(_javaPart, loadingStrategy.has_value() ? JOneKeyImageLoadingStrategy::fromCpp(loadingStrategy.value()) : nullptr);
+  }
+  std::optional<std::function<void()>> JHybridOneKeyImageSpec::getOnLoadStart() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>()>("getOnLoadStart_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 JHybridOneKeyImageSpec::setOnLoadStart(const std::optional<std::function<void()>>& onLoadStart) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* onLoadStart */)>("setOnLoadStart_cxx");
+    method(_javaPart, onLoadStart.has_value() ? JFunc_void_cxx::fromCpp(onLoadStart.value()) : nullptr);
+  }
+  std::optional<std::function<void(double /* width */, double /* height */, OneKeyImageCacheType /* cacheType */)>> JHybridOneKeyImageSpec::getOnLoad() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void_double_double_OneKeyImageCacheType::javaobject>()>("getOnLoad_cxx");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional([&]() -> std::function<void(double /* width */, double /* height */, OneKeyImageCacheType /* cacheType */)> {
+      if (__result->isInstanceOf(JFunc_void_double_double_OneKeyImageCacheType_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_double_double_OneKeyImageCacheType_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void_double_double_OneKeyImageCacheType, void(double, double, OneKeyImageCacheType)>(std::move(__resultRef));
+      }
+    }()) : std::nullopt;
+  }
+  void JHybridOneKeyImageSpec::setOnLoad(const std::optional<std::function<void(double /* width */, double /* height */, OneKeyImageCacheType /* cacheType */)>>& onLoad) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_double_double_OneKeyImageCacheType::javaobject> /* onLoad */)>("setOnLoad_cxx");
+    method(_javaPart, onLoad.has_value() ? JFunc_void_double_double_OneKeyImageCacheType_cxx::fromCpp(onLoad.value()) : nullptr);
+  }
+  std::optional<std::function<void()>> JHybridOneKeyImageSpec::getOnDisplay() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>()>("getOnDisplay_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 JHybridOneKeyImageSpec::setOnDisplay(const std::optional<std::function<void()>>& onDisplay) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* onDisplay */)>("setOnDisplay_cxx");
+    method(_javaPart, onDisplay.has_value() ? JFunc_void_cxx::fromCpp(onDisplay.value()) : nullptr);
+  }
+  std::optional<std::function<void(const std::string& /* message */)>> JHybridOneKeyImageSpec::getOnError() {
+    static const auto method = _javaPart->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 JHybridOneKeyImageSpec::setOnError(const std::optional<std::function<void(const std::string& /* message */)>>& onError) {
+    static const auto method = _javaPart->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()>> JHybridOneKeyImageSpec::getOnLoadEnd() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>()>("getOnLoadEnd_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 JHybridOneKeyImageSpec::setOnLoadEnd(const std::optional<std::function<void()>>& onLoadEnd) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* onLoadEnd */)>("setOnLoadEnd_cxx");
+    method(_javaPart, onLoadEnd.has_value() ? JFunc_void_cxx::fromCpp(onLoadEnd.value()) : nullptr);
+  }
+
+  // Methods
+  void JHybridOneKeyImageSpec::reload() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("reload");
+    method(_javaPart);
+  }
+  void JHybridOneKeyImageSpec::cancel() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("cancel");
+    method(_javaPart);
+  }
+
+} // namespace margelo::nitro::onekeyimage

package/lib/nitrogen/generated/android/c++/JHybridOneKeyImageSpec.hpp

@@ -0,0 +1,93 @@
+///
+/// HybridOneKeyImageSpec.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 "HybridOneKeyImageSpec.hpp"
+
+
+
+
+namespace margelo::nitro::onekeyimage {
+
+  using namespace facebook;
+
+  class JHybridOneKeyImageSpec: public virtual HybridOneKeyImageSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/HybridOneKeyImageSpec;";
+      std::shared_ptr<JHybridOneKeyImageSpec> getJHybridOneKeyImageSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/HybridOneKeyImageSpec$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 JHybridOneKeyImageSpec(const jni::local_ref<JHybridOneKeyImageSpec::JavaPart>& javaPart):
+      HybridObject(HybridOneKeyImageSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridOneKeyImageSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridOneKeyImageSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::optional<std::string> getSourceUri() override;
+    void setSourceUri(const std::optional<std::string>& sourceUri) override;
+    std::optional<std::string> getSourceHeadersJson() override;
+    void setSourceHeadersJson(const std::optional<std::string>& sourceHeadersJson) override;
+    std::optional<OneKeyImageVariant> getVariant() override;
+    void setVariant(std::optional<OneKeyImageVariant> variant) override;
+    std::optional<OneKeyImageContentFit> getContentFit() override;
+    void setContentFit(std::optional<OneKeyImageContentFit> contentFit) override;
+    std::optional<OneKeyImageCachePolicy> getCachePolicy() override;
+    void setCachePolicy(std::optional<OneKeyImageCachePolicy> cachePolicy) override;
+    std::optional<bool> getAutoplay() override;
+    void setAutoplay(std::optional<bool> autoplay) override;
+    std::optional<std::string> getRecyclingKey() override;
+    void setRecyclingKey(const std::optional<std::string>& recyclingKey) override;
+    std::optional<bool> getOptimizeTos() override;
+    void setOptimizeTos(std::optional<bool> optimizeTos) override;
+    std::optional<double> getOverscan() override;
+    void setOverscan(std::optional<double> overscan) override;
+    std::optional<OneKeyImageLoadingStrategy> getLoadingStrategy() override;
+    void setLoadingStrategy(std::optional<OneKeyImageLoadingStrategy> loadingStrategy) override;
+    std::optional<std::function<void()>> getOnLoadStart() override;
+    void setOnLoadStart(const std::optional<std::function<void()>>& onLoadStart) override;
+    std::optional<std::function<void(double /* width */, double /* height */, OneKeyImageCacheType /* cacheType */)>> getOnLoad() override;
+    void setOnLoad(const std::optional<std::function<void(double /* width */, double /* height */, OneKeyImageCacheType /* cacheType */)>>& onLoad) override;
+    std::optional<std::function<void()>> getOnDisplay() override;
+    void setOnDisplay(const std::optional<std::function<void()>>& onDisplay) 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()>> getOnLoadEnd() override;
+    void setOnLoadEnd(const std::optional<std::function<void()>>& onLoadEnd) override;
+
+  public:
+    // Methods
+    void reload() override;
+    void cancel() override;
+
+  private:
+    jni::global_ref<JHybridOneKeyImageSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::onekeyimage

package/lib/nitrogen/generated/android/c++/JOneKeyImageCachePolicy.hpp

@@ -0,0 +1,64 @@
+///
+/// JOneKeyImageCachePolicy.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 "OneKeyImageCachePolicy.hpp"
+
+namespace margelo::nitro::onekeyimage {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "OneKeyImageCachePolicy" and the Kotlin enum "OneKeyImageCachePolicy".
+   */
+  struct JOneKeyImageCachePolicy final: public jni::JavaClass<JOneKeyImageCachePolicy> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/OneKeyImageCachePolicy;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum OneKeyImageCachePolicy.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    OneKeyImageCachePolicy toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<OneKeyImageCachePolicy>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JOneKeyImageCachePolicy> fromCpp(OneKeyImageCachePolicy value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case OneKeyImageCachePolicy::MEMORY_DISK:
+          static const auto fieldMEMORY_DISK = clazz->getStaticField<JOneKeyImageCachePolicy>("MEMORY_DISK");
+          return clazz->getStaticFieldValue(fieldMEMORY_DISK);
+        case OneKeyImageCachePolicy::MEMORY:
+          static const auto fieldMEMORY = clazz->getStaticField<JOneKeyImageCachePolicy>("MEMORY");
+          return clazz->getStaticFieldValue(fieldMEMORY);
+        case OneKeyImageCachePolicy::DISK:
+          static const auto fieldDISK = clazz->getStaticField<JOneKeyImageCachePolicy>("DISK");
+          return clazz->getStaticFieldValue(fieldDISK);
+        case OneKeyImageCachePolicy::NONE:
+          static const auto fieldNONE = clazz->getStaticField<JOneKeyImageCachePolicy>("NONE");
+          return clazz->getStaticFieldValue(fieldNONE);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::onekeyimage