@onekeyfe/react-native-image 3.0.98

package/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/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/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

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

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

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

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

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

@@ -0,0 +1,61 @@
+///
+/// JOneKeyImageLoadingStrategy.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 "OneKeyImageLoadingStrategy.hpp"
+
+namespace margelo::nitro::onekeyimage {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "OneKeyImageLoadingStrategy" and the Kotlin enum "OneKeyImageLoadingStrategy".
+   */
+  struct JOneKeyImageLoadingStrategy final: public jni::JavaClass<JOneKeyImageLoadingStrategy> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/OneKeyImageLoadingStrategy;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum OneKeyImageLoadingStrategy.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    OneKeyImageLoadingStrategy toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<OneKeyImageLoadingStrategy>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JOneKeyImageLoadingStrategy> fromCpp(OneKeyImageLoadingStrategy value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case OneKeyImageLoadingStrategy::STATIC:
+          static const auto fieldSTATIC = clazz->getStaticField<JOneKeyImageLoadingStrategy>("STATIC");
+          return clazz->getStaticFieldValue(fieldSTATIC);
+        case OneKeyImageLoadingStrategy::SKELETON:
+          static const auto fieldSKELETON = clazz->getStaticField<JOneKeyImageLoadingStrategy>("SKELETON");
+          return clazz->getStaticFieldValue(fieldSKELETON);
+        case OneKeyImageLoadingStrategy::NONE:
+          static const auto fieldNONE = clazz->getStaticField<JOneKeyImageLoadingStrategy>("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