react-native-queue-player 1.0.0

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

@@ -0,0 +1,130 @@
+///
+/// HybridTrackPlayerSpec.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 "HybridTrackPlayerSpec.hpp"
+
+
+
+
+namespace margelo::nitro::queueplayer {
+
+  using namespace facebook;
+
+  class JHybridTrackPlayerSpec: public virtual HybridTrackPlayerSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/queueplayer/HybridTrackPlayerSpec;";
+      std::shared_ptr<JHybridTrackPlayerSpec> getJHybridTrackPlayerSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/queueplayer/HybridTrackPlayerSpec$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 JHybridTrackPlayerSpec(const jni::local_ref<JHybridTrackPlayerSpec::JavaPart>& javaPart):
+      HybridObject(HybridTrackPlayerSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridTrackPlayerSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridTrackPlayerSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::shared_ptr<Promise<void>> configure(const PlayerConfig& config) override;
+    std::shared_ptr<Promise<void>> destroy() override;
+    std::shared_ptr<Promise<void>> setQueue(const std::vector<TrackItem>& tracks, std::optional<double> startAtIndex) override;
+    std::shared_ptr<Promise<void>> addToQueue(const std::vector<TrackItem>& tracks, std::optional<double> insertBefore) override;
+    std::shared_ptr<Promise<void>> removeFromQueue(const std::vector<double>& indices) override;
+    std::shared_ptr<Promise<void>> moveInQueue(double fromIndex, double toIndex) override;
+    std::vector<TrackItem> getQueue() override;
+    std::shared_ptr<Promise<void>> clearQueue() override;
+    std::shared_ptr<Promise<void>> play() override;
+    std::shared_ptr<Promise<void>> pause() override;
+    std::shared_ptr<Promise<void>> stop() override;
+    std::shared_ptr<Promise<void>> retry() override;
+    std::shared_ptr<Promise<void>> seekTo(double position) override;
+    std::shared_ptr<Promise<void>> skipToIndex(double index) override;
+    std::shared_ptr<Promise<void>> skipToNext() override;
+    std::shared_ptr<Promise<void>> skipToPrevious() override;
+    std::shared_ptr<Promise<void>> setPlaybackMode(const PlaybackMode& mode) override;
+    PlaybackMode getPlaybackMode() override;
+    std::shared_ptr<Promise<void>> setPlaybackSpeed(double rate) override;
+    std::shared_ptr<Promise<void>> setPitchCorrectionMode(PitchCorrectionMode mode) override;
+    std::shared_ptr<Promise<void>> setVolume(double volume) override;
+    std::shared_ptr<Promise<void>> setRepeatMode(RepeatMode mode) override;
+    std::shared_ptr<Promise<void>> setRemoteControls(const RemoteControlOptions& options) override;
+    std::shared_ptr<Promise<void>> setSleepTimer(double seconds) override;
+    std::shared_ptr<Promise<void>> setSleepTimerToTrackEnd() override;
+    std::shared_ptr<Promise<void>> clearSleepTimer() override;
+    std::shared_ptr<Promise<ShuffleResult>> shuffleQueue() override;
+    PlayerState getState() override;
+    double getCurrentTrackIndex() override;
+    std::optional<TrackSource> getCurrentTrackSource() override;
+    double getPlaybackSpeed() override;
+    PitchCorrectionMode getPitchCorrectionMode() override;
+    double getVolume() override;
+    RemoteControlOptions getRemoteControls() override;
+    BufferState getBufferState() override;
+    bool getIsSeekable() override;
+    bool isFullyBuffered() override;
+    bool getCanSkipNext() override;
+    bool getCanSkipPrevious() override;
+    SkipCapability getSkipCapability() override;
+    SleepTimerState getSleepTimer() override;
+    std::function<void()> onStateChange(const std::function<void(PlayerState /* state */, StateChangeReason /* reason */)>& callback) override;
+    std::function<void()> onTrackChange(const std::function<void(const std::optional<TrackItem>& /* track */, double /* index */, TrackChangeReason /* reason */, std::optional<double> /* transitionGapMs */)>& callback) override;
+    std::function<void()> onProgress(const std::function<void(const PlayerProgress& /* progress */)>& callback) override;
+    std::function<void()> onPlaybackMilestone(const std::function<void(double /* milestone */, double /* trackIndex */)>& callback) override;
+    std::function<void()> onError(const std::function<void(const PlaybackError& /* error */)>& callback) override;
+    std::function<void()> onQueueEnd(const std::function<void()>& callback) override;
+    std::function<void()> onSkipCapabilityChange(const std::function<void(const SkipCapability& /* capability */)>& callback) override;
+    std::function<void()> onSleepTimerChange(const std::function<void(const SleepTimerState& /* state */)>& callback) override;
+    std::function<void()> onBufferStateChange(const std::function<void(BufferState /* state */)>& callback) override;
+    std::function<void()> onFullyBufferedChange(const std::function<void(bool /* fullyBuffered */)>& callback) override;
+    void setBrowseSnapshot(const BrowseSnapshot& snapshot) override;
+    std::function<void()> onBrowseRequest(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<BrowseItem>>>>>(const std::string& /* parentId */)>& callback) override;
+    std::function<void()> onSearchRequest(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<BrowseItem>>>>>(const std::string& /* query */)>& callback) override;
+    std::function<void()> onPlayFromSearchRequest(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>(const MediaSearchRequest& /* request */)>& callback) override;
+    std::function<void()> onPlayFromIdRequest(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>(const std::string& /* mediaId */)>& callback) override;
+    void donateVoiceVocabulary(const VoiceVocabulary& vocabulary) override;
+    std::function<void()> onCarConnect(const std::function<void()>& callback) override;
+    std::function<void()> onCarDisconnect(const std::function<void()>& callback) override;
+    std::function<void()> onServiceReady(const std::function<void(ServiceReadyReason /* reason */)>& callback) override;
+    std::shared_ptr<Promise<void>> setLookaheadCache(const LookaheadCacheConfig& config) override;
+    CacheStatus getLookaheadCacheStatus() override;
+    std::shared_ptr<Promise<void>> clearLookaheadCache() override;
+    std::function<void()> onCacheStatusChange(const std::function<void(const CacheStatus& /* status */)>& callback) override;
+    std::shared_ptr<Promise<void>> setReplayGainMode(ReplayGainMode mode) override;
+    ReplayGainMode getReplayGainMode() override;
+    std::variant<nitro::NullType, NowPlayingFormat> getNowPlayingFormat() override;
+    std::function<void()> onNowPlayingFormatChange(const std::function<void(const std::optional<std::variant<nitro::NullType, NowPlayingFormat>>& /* format */)>& callback) override;
+
+  private:
+    jni::global_ref<JHybridTrackPlayerSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::queueplayer

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

@@ -0,0 +1,84 @@
+///
+/// JHybridVisualizerSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridVisualizerSpec.hpp"
+
+// Forward declaration of `VisualizerConfig` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct VisualizerConfig; }
+// Forward declaration of `VisualizerFrame` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct VisualizerFrame; }
+// Forward declaration of `VisualizerErrorReason` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class VisualizerErrorReason; }
+
+#include <functional>
+#include "JFunc_void.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "VisualizerConfig.hpp"
+#include "JVisualizerConfig.hpp"
+#include <optional>
+#include "VisualizerFrame.hpp"
+#include "JFunc_void_VisualizerFrame.hpp"
+#include "JVisualizerFrame.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+#include "VisualizerErrorReason.hpp"
+#include "JFunc_void_VisualizerErrorReason.hpp"
+#include "JVisualizerErrorReason.hpp"
+
+namespace margelo::nitro::queueplayer {
+
+  std::shared_ptr<JHybridVisualizerSpec> JHybridVisualizerSpec::JavaPart::getJHybridVisualizerSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridVisualizerSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridVisualizerSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridVisualizerSpec::CxxPart::jhybriddata> JHybridVisualizerSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridVisualizerSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridVisualizerSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridVisualizerSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridVisualizerSpec>(castJavaPart);
+  }
+
+  void JHybridVisualizerSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridVisualizerSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::function<void()> JHybridVisualizerSpec::subscribe(const VisualizerConfig& config, const std::function<void(const VisualizerFrame& /* frame */)>& onFrame, const std::function<void(VisualizerErrorReason /* reason */)>& onError) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JVisualizerConfig> /* config */, jni::alias_ref<JFunc_void_VisualizerFrame::javaobject> /* onFrame */, jni::alias_ref<JFunc_void_VisualizerErrorReason::javaobject> /* onError */)>("subscribe_cxx");
+    auto __result = method(_javaPart, JVisualizerConfig::fromCpp(config), JFunc_void_VisualizerFrame_cxx::fromCpp(onFrame), JFunc_void_VisualizerErrorReason_cxx::fromCpp(onError));
+    return [&]() -> 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));
+      }
+    }();
+  }
+  double JHybridVisualizerSpec::getSubscriberCount() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getSubscriberCount");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+
+} // namespace margelo::nitro::queueplayer

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

@@ -0,0 +1,64 @@
+///
+/// HybridVisualizerSpec.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 "HybridVisualizerSpec.hpp"
+
+
+
+
+namespace margelo::nitro::queueplayer {
+
+  using namespace facebook;
+
+  class JHybridVisualizerSpec: public virtual HybridVisualizerSpec, public virtual JHybridObject {
+  public:
+    struct JavaPart: public jni::JavaClass<JavaPart, JHybridObject::JavaPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/queueplayer/HybridVisualizerSpec;";
+      std::shared_ptr<JHybridVisualizerSpec> getJHybridVisualizerSpec();
+    };
+    struct CxxPart: public jni::HybridClass<CxxPart, JHybridObject::CxxPart> {
+      static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/queueplayer/HybridVisualizerSpec$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 JHybridVisualizerSpec(const jni::local_ref<JHybridVisualizerSpec::JavaPart>& javaPart):
+      HybridObject(HybridVisualizerSpec::TAG),
+      JHybridObject(javaPart),
+      _javaPart(jni::make_global(javaPart)) {}
+    ~JHybridVisualizerSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    inline const jni::global_ref<JHybridVisualizerSpec::JavaPart>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::function<void()> subscribe(const VisualizerConfig& config, const std::function<void(const VisualizerFrame& /* frame */)>& onFrame, const std::function<void(VisualizerErrorReason /* reason */)>& onError) override;
+    double getSubscriberCount() override;
+
+  private:
+    jni::global_ref<JHybridVisualizerSpec::JavaPart> _javaPart;
+  };
+
+} // namespace margelo::nitro::queueplayer

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

@@ -0,0 +1,61 @@
+///
+/// JLookaheadCacheConfig.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 "LookaheadCacheConfig.hpp"
+
+
+
+namespace margelo::nitro::queueplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "LookaheadCacheConfig" and the Kotlin data class "LookaheadCacheConfig".
+   */
+  struct JLookaheadCacheConfig final: public jni::JavaClass<JLookaheadCacheConfig> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/queueplayer/LookaheadCacheConfig;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct LookaheadCacheConfig by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    LookaheadCacheConfig toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldEnabled = clazz->getField<jboolean>("enabled");
+      jboolean enabled = this->getFieldValue(fieldEnabled);
+      static const auto fieldLookaheadCount = clazz->getField<double>("lookaheadCount");
+      double lookaheadCount = this->getFieldValue(fieldLookaheadCount);
+      return LookaheadCacheConfig(
+        static_cast<bool>(enabled),
+        lookaheadCount
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JLookaheadCacheConfig::javaobject> fromCpp(const LookaheadCacheConfig& value) {
+      using JSignature = JLookaheadCacheConfig(jboolean, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.enabled,
+        value.lookaheadCount
+      );
+    }
+  };
+
+} // namespace margelo::nitro::queueplayer

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

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

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

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

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

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

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

@@ -0,0 +1,61 @@
+///
+/// JMediaSearchReleaseDateRange.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 "MediaSearchReleaseDateRange.hpp"
+
+#include <optional>
+
+namespace margelo::nitro::queueplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "MediaSearchReleaseDateRange" and the Kotlin data class "MediaSearchReleaseDateRange".
+   */
+  struct JMediaSearchReleaseDateRange final: public jni::JavaClass<JMediaSearchReleaseDateRange> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/queueplayer/MediaSearchReleaseDateRange;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct MediaSearchReleaseDateRange by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    MediaSearchReleaseDateRange toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldStartYear = clazz->getField<jni::JDouble>("startYear");
+      jni::local_ref<jni::JDouble> startYear = this->getFieldValue(fieldStartYear);
+      static const auto fieldEndYear = clazz->getField<jni::JDouble>("endYear");
+      jni::local_ref<jni::JDouble> endYear = this->getFieldValue(fieldEndYear);
+      return MediaSearchReleaseDateRange(
+        startYear != nullptr ? std::make_optional(startYear->value()) : std::nullopt,
+        endYear != nullptr ? std::make_optional(endYear->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<JMediaSearchReleaseDateRange::javaobject> fromCpp(const MediaSearchReleaseDateRange& value) {
+      using JSignature = JMediaSearchReleaseDateRange(jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.startYear.has_value() ? jni::JDouble::valueOf(value.startYear.value()) : nullptr,
+        value.endYear.has_value() ? jni::JDouble::valueOf(value.endYear.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::queueplayer

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

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