react-native-queue-player 1.0.7 → 1.0.8

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

@@ -0,0 +1,101 @@
+///
+/// JFunc_void_std__vector_TrackItem__double_QueueChangeReason.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 <functional>
+
+#include "TrackItem.hpp"
+#include <vector>
+#include "QueueChangeReason.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JTrackItem.hpp"
+#include <string>
+#include <optional>
+#include <unordered_map>
+#include "JQueueChangeReason.hpp"
+
+namespace margelo::nitro::queueplayer {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(queue: Array<TrackItem>, currentIndex: Double, reason: QueueChangeReason) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__vector_TrackItem__double_QueueChangeReason: public jni::JavaClass<JFunc_void_std__vector_TrackItem__double_QueueChangeReason> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/queueplayer/Func_void_std__vector_TrackItem__double_QueueChangeReason;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__vector_TrackItem__double_QueueChangeReason` instance holds through JNI.
+     */
+    void invoke(const std::vector<TrackItem>& queue, double currentIndex, QueueChangeReason reason) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JTrackItem>> /* queue */, double /* currentIndex */, jni::alias_ref<JQueueChangeReason> /* reason */)>("invoke");
+      method(self(), [&](auto&& __input) {
+        size_t __size = __input.size();
+        jni::local_ref<jni::JArrayClass<JTrackItem>> __array = jni::JArrayClass<JTrackItem>::newArray(__size);
+        for (size_t __i = 0; __i < __size; __i++) {
+          const auto& __element = __input[__i];
+          auto __elementJni = JTrackItem::fromCpp(__element);
+          __array->setElement(__i, *__elementJni);
+        }
+        return __array;
+      }(queue), currentIndex, JQueueChangeReason::fromCpp(reason));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__vector_TrackItem__double_QueueChangeReason that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__vector_TrackItem__double_QueueChangeReason_cxx final: public jni::HybridClass<JFunc_void_std__vector_TrackItem__double_QueueChangeReason_cxx, JFunc_void_std__vector_TrackItem__double_QueueChangeReason> {
+  public:
+    static jni::local_ref<JFunc_void_std__vector_TrackItem__double_QueueChangeReason::javaobject> fromCpp(const std::function<void(const std::vector<TrackItem>& /* queue */, double /* currentIndex */, QueueChangeReason /* reason */)>& func) {
+      return JFunc_void_std__vector_TrackItem__double_QueueChangeReason_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__vector_TrackItem__double_QueueChangeReason_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JArrayClass<JTrackItem>> queue, double currentIndex, jni::alias_ref<JQueueChangeReason> reason) {
+      _func([&](auto&& __input) {
+        size_t __size = __input->size();
+        std::vector<TrackItem> __vector;
+        __vector.reserve(__size);
+        for (size_t __i = 0; __i < __size; __i++) {
+          auto __element = __input->getElement(__i);
+          __vector.push_back(__element->toCpp());
+        }
+        return __vector;
+      }(queue), currentIndex, reason->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::vector<TrackItem>& /* queue */, double /* currentIndex */, QueueChangeReason /* reason */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/queueplayer/Func_void_std__vector_TrackItem__double_QueueChangeReason_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__vector_TrackItem__double_QueueChangeReason_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__vector_TrackItem__double_QueueChangeReason_cxx(const std::function<void(const std::vector<TrackItem>& /* queue */, double /* currentIndex */, QueueChangeReason /* reason */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::vector<TrackItem>& /* queue */, double /* currentIndex */, QueueChangeReason /* reason */)> _func;
+  };
+
+} // namespace margelo::nitro::queueplayer

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

@@ -59,6 +59,8 @@ namespace margelo::nitro::queueplayer { enum class RepeatMode; }
 namespace margelo::nitro::queueplayer { enum class StateChangeReason; }
 // Forward declaration of `TrackChangeReason` to properly resolve imports.
 namespace margelo::nitro::queueplayer { enum class TrackChangeReason; }
+// Forward declaration of `QueueChangeReason` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class QueueChangeReason; }
 // Forward declaration of `PlayerProgress` to properly resolve imports.
 namespace margelo::nitro::queueplayer { struct PlayerProgress; }
 // Forward declaration of `PlaybackError` to properly resolve imports.
@@ -164,6 +166,9 @@ namespace margelo::nitro::queueplayer { struct LookaheadCacheConfig; }
 #include "TrackChangeReason.hpp"
 #include "JFunc_void_std__optional_TrackItem__double_TrackChangeReason_std__optional_double_.hpp"
 #include "JTrackChangeReason.hpp"
+#include "QueueChangeReason.hpp"
+#include "JFunc_void_std__vector_TrackItem__double_QueueChangeReason.hpp"
+#include "JQueueChangeReason.hpp"
 #include "PlayerProgress.hpp"
 #include "JFunc_void_PlayerProgress.hpp"
 #include "JPlayerProgress.hpp"
@@ -759,6 +764,19 @@ namespace margelo::nitro::queueplayer {
       }
     }();
   }
+  std::function<void()> JHybridTrackPlayerSpec::onQueueChange(const std::function<void(const std::vector<TrackItem>& /* queue */, double /* currentIndex */, QueueChangeReason /* reason */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void_std__vector_TrackItem__double_QueueChangeReason::javaobject> /* callback */)>("onQueueChange_cxx");
+    auto __result = method(_javaPart, JFunc_void_std__vector_TrackItem__double_QueueChangeReason_cxx::fromCpp(callback));
+    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));
+      }
+    }();
+  }
   std::function<void()> JHybridTrackPlayerSpec::onProgress(const std::function<void(const PlayerProgress& /* progress */)>& callback) {
     static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void_PlayerProgress::javaobject> /* callback */)>("onProgress_cxx");
     auto __result = method(_javaPart, JFunc_void_PlayerProgress_cxx::fromCpp(callback));

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

@@ -97,6 +97,7 @@ namespace margelo::nitro::queueplayer {
     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()> onQueueChange(const std::function<void(const std::vector<TrackItem>& /* queue */, double /* currentIndex */, QueueChangeReason /* reason */)>& 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;

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

@@ -0,0 +1,70 @@
+///
+/// JQueueChangeReason.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 "QueueChangeReason.hpp"
+
+namespace margelo::nitro::queueplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "QueueChangeReason" and the Kotlin enum "QueueChangeReason".
+   */
+  struct JQueueChangeReason final: public jni::JavaClass<JQueueChangeReason> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/queueplayer/QueueChangeReason;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum QueueChangeReason.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    QueueChangeReason toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<QueueChangeReason>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JQueueChangeReason> fromCpp(QueueChangeReason value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case QueueChangeReason::SET_QUEUE:
+          static const auto fieldSET_QUEUE = clazz->getStaticField<JQueueChangeReason>("SET_QUEUE");
+          return clazz->getStaticFieldValue(fieldSET_QUEUE);
+        case QueueChangeReason::ADD:
+          static const auto fieldADD = clazz->getStaticField<JQueueChangeReason>("ADD");
+          return clazz->getStaticFieldValue(fieldADD);
+        case QueueChangeReason::REMOVE:
+          static const auto fieldREMOVE = clazz->getStaticField<JQueueChangeReason>("REMOVE");
+          return clazz->getStaticFieldValue(fieldREMOVE);
+        case QueueChangeReason::MOVE:
+          static const auto fieldMOVE = clazz->getStaticField<JQueueChangeReason>("MOVE");
+          return clazz->getStaticFieldValue(fieldMOVE);
+        case QueueChangeReason::CLEAR:
+          static const auto fieldCLEAR = clazz->getStaticField<JQueueChangeReason>("CLEAR");
+          return clazz->getStaticFieldValue(fieldCLEAR);
+        case QueueChangeReason::SHUFFLE:
+          static const auto fieldSHUFFLE = clazz->getStaticField<JQueueChangeReason>("SHUFFLE");
+          return clazz->getStaticFieldValue(fieldSHUFFLE);
+        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/kotlin/com/margelo/nitro/queueplayer/Func_void_std__vector_TrackItem__double_QueueChangeReason.kt

@@ -0,0 +1,80 @@
+///
+/// Func_void_std__vector_TrackItem__double_QueueChangeReason.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.queueplayer
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import dalvik.annotation.optimization.FastNative
+
+
+/**
+ * Represents the JavaScript callback `(queue: array, currentIndex: number, reason: enum) => 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_std__vector_TrackItem__double_QueueChangeReason: (Array<TrackItem>, Double, QueueChangeReason) -> 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(queue: Array<TrackItem>, currentIndex: Double, reason: QueueChangeReason): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(queue: array, currentIndex: number, reason: enum) => 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_std__vector_TrackItem__double_QueueChangeReason_cxx: Func_void_std__vector_TrackItem__double_QueueChangeReason {
+  @DoNotStrip
+  @Keep
+  private val mHybridData: HybridData
+
+  @DoNotStrip
+  @Keep
+  private constructor(hybridData: HybridData) {
+    mHybridData = hybridData
+  }
+
+  @DoNotStrip
+  @Keep
+  override fun invoke(queue: Array<TrackItem>, currentIndex: Double, reason: QueueChangeReason): Unit
+    = invoke_cxx(queue,currentIndex,reason)
+
+  @FastNative
+  private external fun invoke_cxx(queue: Array<TrackItem>, currentIndex: Double, reason: QueueChangeReason): Unit
+}
+
+/**
+ * Represents the JavaScript callback `(queue: array, currentIndex: number, reason: enum) => void`.
+ * This is implemented in Java/Kotlin, via a `(Array<TrackItem>, Double, QueueChangeReason) -> Unit`.
+ * The callback is always coming from native.
+ */
+@DoNotStrip
+@Keep
+@Suppress("ClassName", "RedundantUnitReturnType", "unused")
+class Func_void_std__vector_TrackItem__double_QueueChangeReason_java(private val function: (Array<TrackItem>, Double, QueueChangeReason) -> Unit): Func_void_std__vector_TrackItem__double_QueueChangeReason {
+  @DoNotStrip
+  @Keep
+  override fun invoke(queue: Array<TrackItem>, currentIndex: Double, reason: QueueChangeReason): Unit {
+    return this.function(queue, currentIndex, reason)
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/queueplayer/HybridTrackPlayerSpec.kt

@@ -212,6 +212,15 @@ abstract class HybridTrackPlayerSpec: HybridObject() {
     return Func_void_java(__result)
   }
   
+  abstract fun onQueueChange(callback: (queue: Array<TrackItem>, currentIndex: Double, reason: QueueChangeReason) -> Unit): () -> Unit
+  
+  @DoNotStrip
+  @Keep
+  private fun onQueueChange_cxx(callback: Func_void_std__vector_TrackItem__double_QueueChangeReason): Func_void {
+    val __result = onQueueChange(callback)
+    return Func_void_java(__result)
+  }
+  
   abstract fun onProgress(callback: (progress: PlayerProgress) -> Unit): () -> Unit
   
   @DoNotStrip

package/nitrogen/generated/android/kotlin/com/margelo/nitro/queueplayer/QueueChangeReason.kt

@@ -0,0 +1,27 @@
+///
+/// QueueChangeReason.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.queueplayer
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "QueueChangeReason".
+ */
+@DoNotStrip
+@Keep
+enum class QueueChangeReason(@DoNotStrip @Keep val value: Int) {
+  SET_QUEUE(0),
+  ADD(1),
+  REMOVE(2),
+  MOVE(3),
+  CLEAR(4),
+  SHUFFLE(5);
+
+  companion object
+}

package/nitrogen/generated/android/queueplayerOnLoad.cpp

@@ -29,6 +29,7 @@
 #include "JHybridTrackPlayerSpec.hpp"
 #include "JFunc_void_PlayerState_StateChangeReason.hpp"
 #include "JFunc_void_std__optional_TrackItem__double_TrackChangeReason_std__optional_double_.hpp"
+#include "JFunc_void_std__vector_TrackItem__double_QueueChangeReason.hpp"
 #include "JFunc_void_PlayerProgress.hpp"
 #include "JFunc_void_double_double.hpp"
 #include "JFunc_void_PlaybackError.hpp"
@@ -106,6 +107,7 @@ void registerAllNatives() {
   margelo::nitro::queueplayer::JHybridTrackPlayerSpec::CxxPart::registerNatives();
   margelo::nitro::queueplayer::JFunc_void_PlayerState_StateChangeReason_cxx::registerNatives();
   margelo::nitro::queueplayer::JFunc_void_std__optional_TrackItem__double_TrackChangeReason_std__optional_double__cxx::registerNatives();
+  margelo::nitro::queueplayer::JFunc_void_std__vector_TrackItem__double_QueueChangeReason_cxx::registerNatives();
   margelo::nitro::queueplayer::JFunc_void_PlayerProgress_cxx::registerNatives();
   margelo::nitro::queueplayer::JFunc_void_double_double_cxx::registerNatives();
   margelo::nitro::queueplayer::JFunc_void_PlaybackError_cxx::registerNatives();

package/nitrogen/generated/ios/QueuePlayer-Swift-Cxx-Bridge.cpp

@@ -161,6 +161,14 @@ namespace margelo::nitro::queueplayer::bridge::swift {
     };
   }
   
+  // pragma MARK: std::function<void(const std::vector<TrackItem>& /* queue */, double /* currentIndex */, QueueChangeReason /* reason */)>
+  Func_void_std__vector_TrackItem__double_QueueChangeReason create_Func_void_std__vector_TrackItem__double_QueueChangeReason(void* NON_NULL swiftClosureWrapper) noexcept {
+    auto swiftClosure = QueuePlayer::Func_void_std__vector_TrackItem__double_QueueChangeReason::fromUnsafe(swiftClosureWrapper);
+    return [swiftClosure = std::move(swiftClosure)](const std::vector<TrackItem>& queue, double currentIndex, QueueChangeReason reason) mutable -> void {
+      swiftClosure.call(queue, currentIndex, static_cast<int>(reason));
+    };
+  }
+  
   // pragma MARK: std::function<void(const PlayerProgress& /* progress */)>
   Func_void_PlayerProgress create_Func_void_PlayerProgress(void* NON_NULL swiftClosureWrapper) noexcept {
     auto swiftClosure = QueuePlayer::Func_void_PlayerProgress::fromUnsafe(swiftClosureWrapper);

package/nitrogen/generated/ios/QueuePlayer-Swift-Cxx-Bridge.hpp

@@ -98,6 +98,8 @@ namespace margelo::nitro::queueplayer { struct PlaybackMode; }
 namespace margelo::nitro::queueplayer { struct PlayerProgress; }
 // Forward declaration of `PlayerState` to properly resolve imports.
 namespace margelo::nitro::queueplayer { enum class PlayerState; }
+// Forward declaration of `QueueChangeReason` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class QueueChangeReason; }
 // Forward declaration of `RemoteControlOptions` to properly resolve imports.
 namespace margelo::nitro::queueplayer { struct RemoteControlOptions; }
 // Forward declaration of `ReplayGainMode` to properly resolve imports.
@@ -180,6 +182,7 @@ namespace QueuePlayer { class HybridVisualizerSpec_cxx; }
 #include "PlaybackMode.hpp"
 #include "PlayerProgress.hpp"
 #include "PlayerState.hpp"
+#include "QueueChangeReason.hpp"
 #include "RemoteControlOptions.hpp"
 #include "ReplayGainMode.hpp"
 #include "SectionIcon.hpp"
@@ -916,6 +919,28 @@ namespace margelo::nitro::queueplayer::bridge::swift {
     return Func_void_std__optional_TrackItem__double_TrackChangeReason_std__optional_double__Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::function<void(const std::vector<TrackItem>& /* queue */, double /* currentIndex */, QueueChangeReason /* reason */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<TrackItem>&, double, QueueChangeReason)>`.
+   */
+  using Func_void_std__vector_TrackItem__double_QueueChangeReason = std::function<void(const std::vector<TrackItem>& /* queue */, double /* currentIndex */, QueueChangeReason /* reason */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<TrackItem>& / * queue * /, double / * currentIndex * /, QueueChangeReason / * reason * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_TrackItem__double_QueueChangeReason_Wrapper final {
+  public:
+    explicit Func_void_std__vector_TrackItem__double_QueueChangeReason_Wrapper(std::function<void(const std::vector<TrackItem>& /* queue */, double /* currentIndex */, QueueChangeReason /* reason */)>&& func): _function(std::make_unique<std::function<void(const std::vector<TrackItem>& /* queue */, double /* currentIndex */, QueueChangeReason /* reason */)>>(std::move(func))) {}
+    inline void call(std::vector<TrackItem> queue, double currentIndex, int reason) const noexcept {
+      _function->operator()(queue, currentIndex, static_cast<QueueChangeReason>(reason));
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::vector<TrackItem>& /* queue */, double /* currentIndex */, QueueChangeReason /* reason */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_TrackItem__double_QueueChangeReason create_Func_void_std__vector_TrackItem__double_QueueChangeReason(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_TrackItem__double_QueueChangeReason_Wrapper wrap_Func_void_std__vector_TrackItem__double_QueueChangeReason(Func_void_std__vector_TrackItem__double_QueueChangeReason value) noexcept {
+    return Func_void_std__vector_TrackItem__double_QueueChangeReason_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::function<void(const PlayerProgress& /* progress */)>
   /**
    * Specialized version of `std::function<void(const PlayerProgress&)>`.

package/nitrogen/generated/ios/QueuePlayer-Swift-Cxx-Umbrella.hpp

@@ -108,6 +108,8 @@ namespace margelo::nitro::queueplayer { struct PlayerConfig; }
 namespace margelo::nitro::queueplayer { struct PlayerProgress; }
 // Forward declaration of `PlayerState` to properly resolve imports.
 namespace margelo::nitro::queueplayer { enum class PlayerState; }
+// Forward declaration of `QueueChangeReason` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class QueueChangeReason; }
 // Forward declaration of `RemoteControlOptions` to properly resolve imports.
 namespace margelo::nitro::queueplayer { struct RemoteControlOptions; }
 // Forward declaration of `RemoteSkipMode` to properly resolve imports.
@@ -194,6 +196,7 @@ namespace margelo::nitro::queueplayer { struct VoiceVocabulary; }
 #include "PlayerConfig.hpp"
 #include "PlayerProgress.hpp"
 #include "PlayerState.hpp"
+#include "QueueChangeReason.hpp"
 #include "RemoteControlOptions.hpp"
 #include "RemoteSkipMode.hpp"
 #include "RepeatMode.hpp"

package/nitrogen/generated/ios/c++/HybridTrackPlayerSpecSwift.hpp

@@ -50,6 +50,8 @@ namespace margelo::nitro::queueplayer { struct SleepTimerState; }
 namespace margelo::nitro::queueplayer { enum class StateChangeReason; }
 // Forward declaration of `TrackChangeReason` to properly resolve imports.
 namespace margelo::nitro::queueplayer { enum class TrackChangeReason; }
+// Forward declaration of `QueueChangeReason` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class QueueChangeReason; }
 // Forward declaration of `PlayerProgress` to properly resolve imports.
 namespace margelo::nitro::queueplayer { struct PlayerProgress; }
 // Forward declaration of `PlaybackError` to properly resolve imports.
@@ -124,6 +126,7 @@ namespace margelo::nitro::queueplayer { struct NowPlayingFormatAndroidExtras; }
 #include <functional>
 #include "StateChangeReason.hpp"
 #include "TrackChangeReason.hpp"
+#include "QueueChangeReason.hpp"
 #include "PlayerProgress.hpp"
 #include "PlaybackError.hpp"
 #include "PlaybackErrorCode.hpp"
@@ -545,6 +548,14 @@ namespace margelo::nitro::queueplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::function<void()> onQueueChange(const std::function<void(const std::vector<TrackItem>& /* queue */, double /* currentIndex */, QueueChangeReason /* reason */)>& callback) override {
+      auto __result = _swiftPart.onQueueChange(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline std::function<void()> onProgress(const std::function<void(const PlayerProgress& /* progress */)>& callback) override {
       auto __result = _swiftPart.onProgress(callback);
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/swift/Func_void_std__vector_TrackItem__double_QueueChangeReason.swift

@@ -0,0 +1,46 @@
+///
+/// Func_void_std__vector_TrackItem__double_QueueChangeReason.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ queue: [TrackItem], _ currentIndex: Double, _ reason: QueueChangeReason) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_std__vector_TrackItem__double_QueueChangeReason {
+  public typealias bridge = margelo.nitro.queueplayer.bridge.swift
+
+  private let closure: (_ queue: [TrackItem], _ currentIndex: Double, _ reason: QueueChangeReason) -> Void
+
+  public init(_ closure: @escaping (_ queue: [TrackItem], _ currentIndex: Double, _ reason: QueueChangeReason) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(queue: bridge.std__vector_TrackItem_, currentIndex: Double, reason: Int32) -> Void {
+    self.closure(queue.map({ __item in __item }), currentIndex, margelo.nitro.queueplayer.QueueChangeReason(rawValue: reason)!)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_std__vector_TrackItem__double_QueueChangeReason`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__vector_TrackItem__double_QueueChangeReason>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__vector_TrackItem__double_QueueChangeReason {
+    return Unmanaged<Func_void_std__vector_TrackItem__double_QueueChangeReason>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/HybridTrackPlayerSpec.swift

@@ -56,6 +56,7 @@ public protocol HybridTrackPlayerSpec_protocol: HybridObject {
   func getSleepTimer() throws -> SleepTimerState
   func onStateChange(callback: @escaping (_ state: PlayerState, _ reason: StateChangeReason) -> Void) throws -> () -> Void
   func onTrackChange(callback: @escaping (_ track: TrackItem?, _ index: Double, _ reason: TrackChangeReason, _ transitionGapMs: Double?) -> Void) throws -> () -> Void
+  func onQueueChange(callback: @escaping (_ queue: [TrackItem], _ currentIndex: Double, _ reason: QueueChangeReason) -> Void) throws -> () -> Void
   func onProgress(callback: @escaping (_ progress: PlayerProgress) -> Void) throws -> () -> Void
   func onPlaybackMilestone(callback: @escaping (_ milestone: Double, _ trackIndex: Double) -> Void) throws -> () -> Void
   func onError(callback: @escaping (_ error: PlaybackError) -> Void) throws -> () -> Void

package/nitrogen/generated/ios/swift/HybridTrackPlayerSpec_cxx.swift

@@ -869,6 +869,32 @@ open class HybridTrackPlayerSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func onQueueChange(callback: bridge.Func_void_std__vector_TrackItem__double_QueueChangeReason) -> bridge.Result_std__function_void____ {
+    do {
+      let __result = try self.__implementation.onQueueChange(callback: { () -> ([TrackItem], Double, QueueChangeReason) -> Void in
+        let __wrappedFunction = bridge.wrap_Func_void_std__vector_TrackItem__double_QueueChangeReason(callback)
+        return { (__queue: [TrackItem], __currentIndex: Double, __reason: QueueChangeReason) -> Void in
+          __wrappedFunction.call({ () -> bridge.std__vector_TrackItem_ in
+            var __vector = bridge.create_std__vector_TrackItem_(__queue.count)
+            for __item in __queue {
+              __vector.push_back(__item)
+            }
+            return __vector
+          }(), __currentIndex, __reason.rawValue)
+        }
+      }())
+      let __resultCpp = { () -> bridge.Func_void in
+        let __closureWrapper = Func_void(__result)
+        return bridge.create_Func_void(__closureWrapper.toUnsafe())
+      }()
+      return bridge.create_Result_std__function_void____(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__function_void____(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func onProgress(callback: bridge.Func_void_PlayerProgress) -> bridge.Result_std__function_void____ {
     do {

package/nitrogen/generated/ios/swift/QueueChangeReason.swift

@@ -0,0 +1,56 @@
+///
+/// QueueChangeReason.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `QueueChangeReason`, backed by a C++ enum.
+ */
+public typealias QueueChangeReason = margelo.nitro.queueplayer.QueueChangeReason
+
+public extension QueueChangeReason {
+  /**
+   * Get a QueueChangeReason for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "set-queue":
+        self = .setQueue
+      case "add":
+        self = .add
+      case "remove":
+        self = .remove
+      case "move":
+        self = .move
+      case "clear":
+        self = .clear
+      case "shuffle":
+        self = .shuffle
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this QueueChangeReason represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .setQueue:
+        return "set-queue"
+      case .add:
+        return "add"
+      case .remove:
+        return "remove"
+      case .move:
+        return "move"
+      case .clear:
+        return "clear"
+      case .shuffle:
+        return "shuffle"
+    }
+  }
+}

package/nitrogen/generated/shared/c++/HybridTrackPlayerSpec.cpp

@@ -57,6 +57,7 @@ namespace margelo::nitro::queueplayer {
       prototype.registerHybridMethod("getSleepTimer", &HybridTrackPlayerSpec::getSleepTimer);
       prototype.registerHybridMethod("onStateChange", &HybridTrackPlayerSpec::onStateChange);
       prototype.registerHybridMethod("onTrackChange", &HybridTrackPlayerSpec::onTrackChange);
+      prototype.registerHybridMethod("onQueueChange", &HybridTrackPlayerSpec::onQueueChange);
       prototype.registerHybridMethod("onProgress", &HybridTrackPlayerSpec::onProgress);
       prototype.registerHybridMethod("onPlaybackMilestone", &HybridTrackPlayerSpec::onPlaybackMilestone);
       prototype.registerHybridMethod("onError", &HybridTrackPlayerSpec::onError);