@pigeonmal/react-native-video 7.0.0-beta.2

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

@@ -0,0 +1,59 @@
+///
+/// JSurfaceType.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "SurfaceType.hpp"
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "SurfaceType" and the the Kotlin enum "SurfaceType".
+   */
+  struct JSurfaceType final: public jni::JavaClass<JSurfaceType> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/SurfaceType;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum SurfaceType.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    SurfaceType toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<SurfaceType>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JSurfaceType> fromCpp(SurfaceType value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldSURFACE = clazz->getStaticField<JSurfaceType>("SURFACE");
+      static const auto fieldTEXTURE = clazz->getStaticField<JSurfaceType>("TEXTURE");
+      
+      switch (value) {
+        case SurfaceType::SURFACE:
+          return clazz->getStaticFieldValue(fieldSURFACE);
+        case SurfaceType::TEXTURE:
+          return clazz->getStaticFieldValue(fieldTEXTURE);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::video

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

@@ -0,0 +1,78 @@
+///
+/// JTimedMetadata.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "TimedMetadata.hpp"
+
+#include "JTimedMetadataObject.hpp"
+#include "TimedMetadataObject.hpp"
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "TimedMetadata" and the the Kotlin data class "TimedMetadata".
+   */
+  struct JTimedMetadata final: public jni::JavaClass<JTimedMetadata> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/TimedMetadata;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct TimedMetadata by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    TimedMetadata toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldMetadata = clazz->getField<jni::JArrayClass<JTimedMetadataObject>>("metadata");
+      jni::local_ref<jni::JArrayClass<JTimedMetadataObject>> metadata = this->getFieldValue(fieldMetadata);
+      return TimedMetadata(
+        [&]() {
+          size_t __size = metadata->size();
+          std::vector<TimedMetadataObject> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = metadata->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JTimedMetadata::javaobject> fromCpp(const TimedMetadata& value) {
+      using JSignature = JTimedMetadata(jni::alias_ref<jni::JArrayClass<JTimedMetadataObject>>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        [&]() {
+          size_t __size = value.metadata.size();
+          jni::local_ref<jni::JArrayClass<JTimedMetadataObject>> __array = jni::JArrayClass<JTimedMetadataObject>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.metadata[__i];
+            auto __elementJni = JTimedMetadataObject::fromCpp(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }()
+      );
+    }
+  };
+
+} // namespace margelo::nitro::video

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

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

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

@@ -0,0 +1,62 @@
+///
+/// JTrackType.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "TrackType.hpp"
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "TrackType" and the the Kotlin enum "TrackType".
+   */
+  struct JTrackType final: public jni::JavaClass<JTrackType> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/TrackType;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum TrackType.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    TrackType toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<TrackType>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JTrackType> fromCpp(TrackType value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldAUDIO = clazz->getStaticField<JTrackType>("AUDIO");
+      static const auto fieldVIDEO = clazz->getStaticField<JTrackType>("VIDEO");
+      static const auto fieldTEXT = clazz->getStaticField<JTrackType>("TEXT");
+      
+      switch (value) {
+        case TrackType::AUDIO:
+          return clazz->getStaticFieldValue(fieldAUDIO);
+        case TrackType::VIDEO:
+          return clazz->getStaticFieldValue(fieldVIDEO);
+        case TrackType::TEXT:
+          return clazz->getStaticFieldValue(fieldTEXT);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::video

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

@@ -0,0 +1,26 @@
+///
+/// JVariant_NullType_HybridVideoPlayerSourceSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JVariant_NullType_HybridVideoPlayerSourceSpec.hpp"
+
+namespace margelo::nitro::video {
+  /**
+   * Converts JVariant_NullType_HybridVideoPlayerSourceSpec to std::variant<nitro::NullType, std::shared_ptr<HybridVideoPlayerSourceSpec>>
+   */
+  std::variant<nitro::NullType, std::shared_ptr<HybridVideoPlayerSourceSpec>> JVariant_NullType_HybridVideoPlayerSourceSpec::toCpp() const {
+    if (isInstanceOf(JVariant_NullType_HybridVideoPlayerSourceSpec_impl::First::javaClassStatic())) {
+      // It's a `nitro::NullType`
+      auto jniValue = static_cast<const JVariant_NullType_HybridVideoPlayerSourceSpec_impl::First*>(this)->getValue();
+      return nitro::null;
+    } else if (isInstanceOf(JVariant_NullType_HybridVideoPlayerSourceSpec_impl::Second::javaClassStatic())) {
+      // It's a `std::shared_ptr<HybridVideoPlayerSourceSpec>`
+      auto jniValue = static_cast<const JVariant_NullType_HybridVideoPlayerSourceSpec_impl::Second*>(this)->getValue();
+      return jniValue->cthis()->shared_cast<JHybridVideoPlayerSourceSpec>();
+    }
+    throw std::invalid_argument("Variant is unknown Kotlin instance!");
+  }
+} // namespace margelo::nitro::video

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

@@ -0,0 +1,72 @@
+///
+/// JVariant_NullType_HybridVideoPlayerSourceSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <variant>
+
+#include <NitroModules/Null.hpp>
+#include <memory>
+#include "HybridVideoPlayerSourceSpec.hpp"
+#include <variant>
+#include <NitroModules/JNull.hpp>
+#include "JHybridVideoPlayerSourceSpec.hpp"
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_HybridVideoPlayerSourceSpec".
+   */
+  class JVariant_NullType_HybridVideoPlayerSourceSpec: public jni::JavaClass<JVariant_NullType_HybridVideoPlayerSourceSpec> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Variant_NullType_HybridVideoPlayerSourceSpec;";
+
+    static jni::local_ref<JVariant_NullType_HybridVideoPlayerSourceSpec> create_0(jni::alias_ref<JNull> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_HybridVideoPlayerSourceSpec(jni::alias_ref<JNull>)>("create");
+      return method(javaClassStatic(), value);
+    }
+    static jni::local_ref<JVariant_NullType_HybridVideoPlayerSourceSpec> create_1(jni::alias_ref<JHybridVideoPlayerSourceSpec::javaobject> value) {
+      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_HybridVideoPlayerSourceSpec(jni::alias_ref<JHybridVideoPlayerSourceSpec::javaobject>)>("create");
+      return method(javaClassStatic(), value);
+    }
+
+    static jni::local_ref<JVariant_NullType_HybridVideoPlayerSourceSpec> fromCpp(const std::variant<nitro::NullType, std::shared_ptr<HybridVideoPlayerSourceSpec>>& variant) {
+      switch (variant.index()) {
+        case 0: return create_0(JNull::null());
+        case 1: return create_1(std::dynamic_pointer_cast<JHybridVideoPlayerSourceSpec>(std::get<1>(variant))->getJavaPart());
+        default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
+      }
+    }
+
+    [[nodiscard]] std::variant<nitro::NullType, std::shared_ptr<HybridVideoPlayerSourceSpec>> toCpp() const;
+  };
+
+  namespace JVariant_NullType_HybridVideoPlayerSourceSpec_impl {
+    class First: public jni::JavaClass<First, JVariant_NullType_HybridVideoPlayerSourceSpec> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Variant_NullType_HybridVideoPlayerSourceSpec$First;";
+    
+      [[nodiscard]] jni::local_ref<JNull> getValue() const {
+        static const auto field = javaClassStatic()->getField<JNull>("value");
+        return getFieldValue(field);
+      }
+    };
+    
+    class Second: public jni::JavaClass<Second, JVariant_NullType_HybridVideoPlayerSourceSpec> {
+    public:
+      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/Variant_NullType_HybridVideoPlayerSourceSpec$Second;";
+    
+      [[nodiscard]] jni::local_ref<JHybridVideoPlayerSourceSpec::javaobject> getValue() const {
+        static const auto field = javaClassStatic()->getField<JHybridVideoPlayerSourceSpec::javaobject>("value");
+        return getFieldValue(field);
+      }
+    };
+  } // namespace JVariant_NullType_HybridVideoPlayerSourceSpec_impl
+} // namespace margelo::nitro::video

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

@@ -0,0 +1,86 @@
+///
+/// JVideoInformation.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "VideoInformation.hpp"
+
+#include "JVideoOrientation.hpp"
+#include "VideoOrientation.hpp"
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "VideoInformation" and the the Kotlin data class "VideoInformation".
+   */
+  struct JVideoInformation final: public jni::JavaClass<JVideoInformation> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/VideoInformation;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct VideoInformation by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    VideoInformation toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldBitrate = clazz->getField<double>("bitrate");
+      double bitrate = this->getFieldValue(fieldBitrate);
+      static const auto fieldWidth = clazz->getField<double>("width");
+      double width = this->getFieldValue(fieldWidth);
+      static const auto fieldHeight = clazz->getField<double>("height");
+      double height = this->getFieldValue(fieldHeight);
+      static const auto fieldDuration = clazz->getField<int64_t>("duration");
+      int64_t duration = this->getFieldValue(fieldDuration);
+      static const auto fieldFileSize = clazz->getField<int64_t>("fileSize");
+      int64_t fileSize = this->getFieldValue(fieldFileSize);
+      static const auto fieldIsHDR = clazz->getField<jboolean>("isHDR");
+      jboolean isHDR = this->getFieldValue(fieldIsHDR);
+      static const auto fieldIsLive = clazz->getField<jboolean>("isLive");
+      jboolean isLive = this->getFieldValue(fieldIsLive);
+      static const auto fieldOrientation = clazz->getField<JVideoOrientation>("orientation");
+      jni::local_ref<JVideoOrientation> orientation = this->getFieldValue(fieldOrientation);
+      return VideoInformation(
+        bitrate,
+        width,
+        height,
+        duration,
+        fileSize,
+        static_cast<bool>(isHDR),
+        static_cast<bool>(isLive),
+        orientation->toCpp()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JVideoInformation::javaobject> fromCpp(const VideoInformation& value) {
+      using JSignature = JVideoInformation(double, double, double, int64_t, int64_t, jboolean, jboolean, jni::alias_ref<JVideoOrientation>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.bitrate,
+        value.width,
+        value.height,
+        value.duration,
+        value.fileSize,
+        value.isHDR,
+        value.isLive,
+        JVideoOrientation::fromCpp(value.orientation)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::video

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

@@ -0,0 +1,74 @@
+///
+/// JVideoOrientation.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "VideoOrientation.hpp"
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "VideoOrientation" and the the Kotlin enum "VideoOrientation".
+   */
+  struct JVideoOrientation final: public jni::JavaClass<JVideoOrientation> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/VideoOrientation;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum VideoOrientation.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    VideoOrientation toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<VideoOrientation>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JVideoOrientation> fromCpp(VideoOrientation value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldPORTRAIT = clazz->getStaticField<JVideoOrientation>("PORTRAIT");
+      static const auto fieldLANDSCAPE = clazz->getStaticField<JVideoOrientation>("LANDSCAPE");
+      static const auto fieldPORTRAIT_UPSIDE_DOWN = clazz->getStaticField<JVideoOrientation>("PORTRAIT_UPSIDE_DOWN");
+      static const auto fieldLANDSCAPE_LEFT = clazz->getStaticField<JVideoOrientation>("LANDSCAPE_LEFT");
+      static const auto fieldLANDSCAPE_RIGHT = clazz->getStaticField<JVideoOrientation>("LANDSCAPE_RIGHT");
+      static const auto fieldSQUARE = clazz->getStaticField<JVideoOrientation>("SQUARE");
+      static const auto fieldUNKNOWN = clazz->getStaticField<JVideoOrientation>("UNKNOWN");
+      
+      switch (value) {
+        case VideoOrientation::PORTRAIT:
+          return clazz->getStaticFieldValue(fieldPORTRAIT);
+        case VideoOrientation::LANDSCAPE:
+          return clazz->getStaticFieldValue(fieldLANDSCAPE);
+        case VideoOrientation::PORTRAIT_UPSIDE_DOWN:
+          return clazz->getStaticFieldValue(fieldPORTRAIT_UPSIDE_DOWN);
+        case VideoOrientation::LANDSCAPE_LEFT:
+          return clazz->getStaticFieldValue(fieldLANDSCAPE_LEFT);
+        case VideoOrientation::LANDSCAPE_RIGHT:
+          return clazz->getStaticFieldValue(fieldLANDSCAPE_RIGHT);
+        case VideoOrientation::SQUARE:
+          return clazz->getStaticFieldValue(fieldSQUARE);
+        case VideoOrientation::UNKNOWN:
+          return clazz->getStaticFieldValue(fieldUNKNOWN);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::video

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

@@ -0,0 +1,65 @@
+///
+/// JVideoPlayerStatus.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "VideoPlayerStatus.hpp"
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "VideoPlayerStatus" and the the Kotlin enum "VideoPlayerStatus".
+   */
+  struct JVideoPlayerStatus final: public jni::JavaClass<JVideoPlayerStatus> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/VideoPlayerStatus;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum VideoPlayerStatus.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    VideoPlayerStatus toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<VideoPlayerStatus>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JVideoPlayerStatus> fromCpp(VideoPlayerStatus value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldIDLE = clazz->getStaticField<JVideoPlayerStatus>("IDLE");
+      static const auto fieldLOADING = clazz->getStaticField<JVideoPlayerStatus>("LOADING");
+      static const auto fieldREADYTOPLAY = clazz->getStaticField<JVideoPlayerStatus>("READYTOPLAY");
+      static const auto fieldERROR = clazz->getStaticField<JVideoPlayerStatus>("ERROR");
+      
+      switch (value) {
+        case VideoPlayerStatus::IDLE:
+          return clazz->getStaticFieldValue(fieldIDLE);
+        case VideoPlayerStatus::LOADING:
+          return clazz->getStaticFieldValue(fieldLOADING);
+        case VideoPlayerStatus::READYTOPLAY:
+          return clazz->getStaticFieldValue(fieldREADYTOPLAY);
+        case VideoPlayerStatus::ERROR:
+          return clazz->getStaticFieldValue(fieldERROR);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::video

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

@@ -0,0 +1,78 @@
+///
+/// JVideoPlayerTrack.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "VideoPlayerTrack.hpp"
+
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::video {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "VideoPlayerTrack" and the the Kotlin data class "VideoPlayerTrack".
+   */
+  struct JVideoPlayerTrack final: public jni::JavaClass<JVideoPlayerTrack> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/video/VideoPlayerTrack;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct VideoPlayerTrack by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    VideoPlayerTrack toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldWidth = clazz->getField<double>("width");
+      double width = this->getFieldValue(fieldWidth);
+      static const auto fieldHeight = clazz->getField<double>("height");
+      double height = this->getFieldValue(fieldHeight);
+      static const auto fieldId = clazz->getField<jni::JString>("id");
+      jni::local_ref<jni::JString> id = this->getFieldValue(fieldId);
+      static const auto fieldLabel = clazz->getField<jni::JString>("label");
+      jni::local_ref<jni::JString> label = this->getFieldValue(fieldLabel);
+      static const auto fieldLanguage = clazz->getField<jni::JString>("language");
+      jni::local_ref<jni::JString> language = this->getFieldValue(fieldLanguage);
+      static const auto fieldSelected = clazz->getField<jboolean>("selected");
+      jboolean selected = this->getFieldValue(fieldSelected);
+      return VideoPlayerTrack(
+        width,
+        height,
+        id->toStdString(),
+        label->toStdString(),
+        language != nullptr ? std::make_optional(language->toStdString()) : std::nullopt,
+        static_cast<bool>(selected)
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JVideoPlayerTrack::javaobject> fromCpp(const VideoPlayerTrack& value) {
+      using JSignature = JVideoPlayerTrack(double, double, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jboolean);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.width,
+        value.height,
+        jni::make_jstring(value.id),
+        jni::make_jstring(value.label),
+        value.language.has_value() ? jni::make_jstring(value.language.value()) : nullptr,
+        value.selected
+      );
+    }
+  };
+
+} // namespace margelo::nitro::video