@onekeyfe/react-native-image 3.0.98

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

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

@@ -0,0 +1,88 @@
+///
+/// JOneKeyImagePreloadSource.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 "OneKeyImagePreloadSource.hpp"
+
+#include "JOneKeyImageCachePolicy.hpp"
+#include "OneKeyImageCachePolicy.hpp"
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::onekeyimage {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "OneKeyImagePreloadSource" and the Kotlin data class "OneKeyImagePreloadSource".
+   */
+  struct JOneKeyImagePreloadSource final: public jni::JavaClass<JOneKeyImagePreloadSource> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/OneKeyImagePreloadSource;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct OneKeyImagePreloadSource by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    OneKeyImagePreloadSource toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldUri = clazz->getField<jni::JString>("uri");
+      jni::local_ref<jni::JString> uri = this->getFieldValue(fieldUri);
+      static const auto fieldHeadersJson = clazz->getField<jni::JString>("headersJson");
+      jni::local_ref<jni::JString> headersJson = this->getFieldValue(fieldHeadersJson);
+      static const auto fieldCachePolicy = clazz->getField<JOneKeyImageCachePolicy>("cachePolicy");
+      jni::local_ref<JOneKeyImageCachePolicy> cachePolicy = this->getFieldValue(fieldCachePolicy);
+      static const auto fieldResizeWidth = clazz->getField<jni::JDouble>("resizeWidth");
+      jni::local_ref<jni::JDouble> resizeWidth = this->getFieldValue(fieldResizeWidth);
+      static const auto fieldResizeHeight = clazz->getField<jni::JDouble>("resizeHeight");
+      jni::local_ref<jni::JDouble> resizeHeight = this->getFieldValue(fieldResizeHeight);
+      static const auto fieldPixelRatio = clazz->getField<jni::JDouble>("pixelRatio");
+      jni::local_ref<jni::JDouble> pixelRatio = this->getFieldValue(fieldPixelRatio);
+      static const auto fieldOverscan = clazz->getField<jni::JDouble>("overscan");
+      jni::local_ref<jni::JDouble> overscan = this->getFieldValue(fieldOverscan);
+      static const auto fieldOptimizeTos = clazz->getField<jni::JBoolean>("optimizeTos");
+      jni::local_ref<jni::JBoolean> optimizeTos = this->getFieldValue(fieldOptimizeTos);
+      return OneKeyImagePreloadSource(
+        uri->toStdString(),
+        headersJson != nullptr ? std::make_optional(headersJson->toStdString()) : std::nullopt,
+        cachePolicy != nullptr ? std::make_optional(cachePolicy->toCpp()) : std::nullopt,
+        resizeWidth != nullptr ? std::make_optional(resizeWidth->value()) : std::nullopt,
+        resizeHeight != nullptr ? std::make_optional(resizeHeight->value()) : std::nullopt,
+        pixelRatio != nullptr ? std::make_optional(pixelRatio->value()) : std::nullopt,
+        overscan != nullptr ? std::make_optional(overscan->value()) : std::nullopt,
+        optimizeTos != nullptr ? std::make_optional(static_cast<bool>(optimizeTos->value())) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JOneKeyImagePreloadSource::javaobject> fromCpp(const OneKeyImagePreloadSource& value) {
+      using JSignature = JOneKeyImagePreloadSource(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<JOneKeyImageCachePolicy>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JBoolean>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.uri),
+        value.headersJson.has_value() ? jni::make_jstring(value.headersJson.value()) : nullptr,
+        value.cachePolicy.has_value() ? JOneKeyImageCachePolicy::fromCpp(value.cachePolicy.value()) : nullptr,
+        value.resizeWidth.has_value() ? jni::JDouble::valueOf(value.resizeWidth.value()) : nullptr,
+        value.resizeHeight.has_value() ? jni::JDouble::valueOf(value.resizeHeight.value()) : nullptr,
+        value.pixelRatio.has_value() ? jni::JDouble::valueOf(value.pixelRatio.value()) : nullptr,
+        value.overscan.has_value() ? jni::JDouble::valueOf(value.overscan.value()) : nullptr,
+        value.optimizeTos.has_value() ? jni::JBoolean::valueOf(value.optimizeTos.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::onekeyimage

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

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

package/lib/nitrogen/generated/android/c++/views/JHybridOneKeyImageStateUpdater.cpp

@@ -0,0 +1,144 @@
+///
+/// JHybridOneKeyImageStateUpdater.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridOneKeyImageStateUpdater.hpp"
+#include "views/HybridOneKeyImageComponent.hpp"
+#include <NitroModules/NitroDefines.hpp>
+#include <react/fabric/StateWrapperImpl.h>
+
+namespace margelo::nitro::onekeyimage::views {
+
+using namespace facebook;
+using ConcreteStateData = react::ConcreteState<HybridOneKeyImageState>;
+
+std::shared_ptr<const HybridOneKeyImageProps> JHybridOneKeyImageStateUpdater::getPropsFromStateWrapper(
+    jni::alias_ref<JStateWrapper::javaobject> stateWrapper) {
+  if (stateWrapper.get() == nullptr) {
+    return nullptr;
+  }
+  // Get concrete StateWrapperImpl from passed StateWrapper interface object
+  jobject rawStateWrapper = stateWrapper.get();
+  if (!stateWrapper->isInstanceOf(react::StateWrapperImpl::javaClassStatic())) [[unlikely]] {
+    throw std::runtime_error("StateWrapper is not a StateWrapperImpl");
+  }
+  auto stateWrapperImpl = jni::alias_ref<react::StateWrapperImpl::javaobject>{
+    static_cast<react::StateWrapperImpl::javaobject>(rawStateWrapper)
+  };
+  std::shared_ptr<const react::State> state = stateWrapperImpl->cthis()->getState();
+  if (state == nullptr) {
+    return nullptr;
+  }
+  auto concreteState = std::static_pointer_cast<const ConcreteStateData>(state);
+  const HybridOneKeyImageState& data = concreteState->getData();
+  const std::shared_ptr<const HybridOneKeyImageProps>& props = data.getProps();
+  if (props == nullptr) [[unlikely]] {
+    throw std::runtime_error("HybridOneKeyImageState's data doesn't contain any props!");
+  }
+  return props;
+}
+
+void JHybridOneKeyImageStateUpdater::updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                                           jni::alias_ref<JHybridOneKeyImageSpec::JavaPart> javaView,
+                                           jni::alias_ref<JStateWrapper::javaobject> newState,
+                                           jni::alias_ref<JStateWrapper::javaobject> oldState) {
+  std::shared_ptr<JHybridOneKeyImageSpec> hybridView = javaView->getJHybridOneKeyImageSpec();
+  std::shared_ptr<const HybridOneKeyImageProps> newProps = getPropsFromStateWrapper(newState);
+  std::shared_ptr<const HybridOneKeyImageProps> oldProps = getPropsFromStateWrapper(oldState);
+  if (newProps == nullptr) [[unlikely]] {
+    throw std::runtime_error("Current StateWrapper doesn't contain any props!");
+  }
+
+  // Update only props that differ from the previous State snapshot.
+  if (oldProps == nullptr
+        ? newProps->sourceUri.isProvided()
+        : !newProps->sourceUri.hasSameValue(oldProps->sourceUri)) {
+    hybridView->setSourceUri(newProps->sourceUri.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->sourceHeadersJson.isProvided()
+        : !newProps->sourceHeadersJson.hasSameValue(oldProps->sourceHeadersJson)) {
+    hybridView->setSourceHeadersJson(newProps->sourceHeadersJson.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->variant.isProvided()
+        : !newProps->variant.hasSameValue(oldProps->variant)) {
+    hybridView->setVariant(newProps->variant.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->contentFit.isProvided()
+        : !newProps->contentFit.hasSameValue(oldProps->contentFit)) {
+    hybridView->setContentFit(newProps->contentFit.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->cachePolicy.isProvided()
+        : !newProps->cachePolicy.hasSameValue(oldProps->cachePolicy)) {
+    hybridView->setCachePolicy(newProps->cachePolicy.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->autoplay.isProvided()
+        : !newProps->autoplay.hasSameValue(oldProps->autoplay)) {
+    hybridView->setAutoplay(newProps->autoplay.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->recyclingKey.isProvided()
+        : !newProps->recyclingKey.hasSameValue(oldProps->recyclingKey)) {
+    hybridView->setRecyclingKey(newProps->recyclingKey.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->optimizeTos.isProvided()
+        : !newProps->optimizeTos.hasSameValue(oldProps->optimizeTos)) {
+    hybridView->setOptimizeTos(newProps->optimizeTos.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->overscan.isProvided()
+        : !newProps->overscan.hasSameValue(oldProps->overscan)) {
+    hybridView->setOverscan(newProps->overscan.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->loadingStrategy.isProvided()
+        : !newProps->loadingStrategy.hasSameValue(oldProps->loadingStrategy)) {
+    hybridView->setLoadingStrategy(newProps->loadingStrategy.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->onLoadStart.isProvided()
+        : !newProps->onLoadStart.hasSameValue(oldProps->onLoadStart)) {
+    hybridView->setOnLoadStart(newProps->onLoadStart.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->onLoad.isProvided()
+        : !newProps->onLoad.hasSameValue(oldProps->onLoad)) {
+    hybridView->setOnLoad(newProps->onLoad.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->onDisplay.isProvided()
+        : !newProps->onDisplay.hasSameValue(oldProps->onDisplay)) {
+    hybridView->setOnDisplay(newProps->onDisplay.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->onError.isProvided()
+        : !newProps->onError.hasSameValue(oldProps->onError)) {
+    hybridView->setOnError(newProps->onError.get());
+  }
+  if (oldProps == nullptr
+        ? newProps->onLoadEnd.isProvided()
+        : !newProps->onLoadEnd.hasSameValue(oldProps->onLoadEnd)) {
+    hybridView->setOnLoadEnd(newProps->onLoadEnd.get());
+  }
+
+  // Update hybridRef if it changed
+  if (oldProps == nullptr
+        ? newProps->hybridRef.isProvided()
+        : !newProps->hybridRef.hasSameValue(oldProps->hybridRef)) {
+    // hybridRef changed - call it with new this
+    const auto& maybeFunc = newProps->hybridRef.get();
+    if (maybeFunc.has_value()) {
+      maybeFunc.value()(hybridView);
+    }
+  }
+}
+
+} // namespace margelo::nitro::onekeyimage::views

package/lib/nitrogen/generated/android/c++/views/JHybridOneKeyImageStateUpdater.hpp

@@ -0,0 +1,54 @@
+///
+/// JHybridOneKeyImageStateUpdater.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#ifndef RN_SERIALIZABLE_STATE
+#error onekeyimage was compiled without the 'RN_SERIALIZABLE_STATE' flag. This flag is required for Nitro Views - set it in your CMakeLists!
+#endif
+
+#include <fbjni/fbjni.h>
+#include <react/fabric/CoreComponentsRegistry.h>
+#include <react/fabric/StateWrapperImpl.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+#include <NitroModules/NitroDefines.hpp>
+#include <NitroModules/JStateWrapper.hpp>
+#include "JHybridOneKeyImageSpec.hpp"
+#include "views/HybridOneKeyImageComponent.hpp"
+
+namespace margelo::nitro::onekeyimage::views {
+
+using namespace facebook;
+
+class JHybridOneKeyImageStateUpdater final: public jni::JavaClass<JHybridOneKeyImageStateUpdater> {
+public:
+  static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/onekeyimage/views/HybridOneKeyImageStateUpdater;";
+
+public:
+  static void updateViewProps(jni::alias_ref<jni::JClass> /* class */,
+                              jni::alias_ref<JHybridOneKeyImageSpec::JavaPart> view,
+                              jni::alias_ref<JStateWrapper::javaobject> newState,
+                              jni::alias_ref<JStateWrapper::javaobject> oldState);
+
+private:
+  static std::shared_ptr<const HybridOneKeyImageProps> getPropsFromStateWrapper(
+      jni::alias_ref<JStateWrapper::javaobject> stateWrapper);
+
+public:
+  static void registerNatives() {
+    // Register JNI calls
+    javaClassStatic()->registerNatives({
+      makeNativeMethod("updateViewProps", JHybridOneKeyImageStateUpdater::updateViewProps),
+    });
+    // Register React Native view component descriptor
+    auto provider = react::concreteComponentDescriptorProvider<HybridOneKeyImageComponentDescriptor>();
+    auto providerRegistry = react::CoreComponentsRegistry::sharedProviderRegistry();
+    providerRegistry->add(provider);
+  }
+};
+
+} // namespace margelo::nitro::onekeyimage::views

package/lib/nitrogen/generated/android/kotlin/com/margelo/nitro/onekeyimage/Func_void.kt

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