react-native-nitro-player 0.3.0-alpha.8 → 0.4.0

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

@@ -0,0 +1,80 @@
+///
+/// JFunc_void_DownloadProgress.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "DownloadProgress.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JDownloadProgress.hpp"
+#include <string>
+#include "DownloadState.hpp"
+#include "JDownloadState.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(progress: DownloadProgress) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_DownloadProgress: public jni::JavaClass<JFunc_void_DownloadProgress> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_DownloadProgress;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_DownloadProgress` instance holds through JNI.
+     */
+    void invoke(const DownloadProgress& progress) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JDownloadProgress> /* progress */)>("invoke");
+      method(self(), JDownloadProgress::fromCpp(progress));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_DownloadProgress that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_DownloadProgress_cxx final: public jni::HybridClass<JFunc_void_DownloadProgress_cxx, JFunc_void_DownloadProgress> {
+  public:
+    static jni::local_ref<JFunc_void_DownloadProgress::javaobject> fromCpp(const std::function<void(const DownloadProgress& /* progress */)>& func) {
+      return JFunc_void_DownloadProgress_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_DownloadProgress_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JDownloadProgress> progress) {
+      _func(progress->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const DownloadProgress& /* progress */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_DownloadProgress_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_DownloadProgress_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_DownloadProgress_cxx(const std::function<void(const DownloadProgress& /* progress */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const DownloadProgress& /* progress */)> _func;
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,89 @@
+///
+/// JFunc_void_DownloadedTrack.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "DownloadedTrack.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JDownloadedTrack.hpp"
+#include <string>
+#include "TrackItem.hpp"
+#include "JTrackItem.hpp"
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include <optional>
+#include "JVariant_NullType_String.hpp"
+#include <NitroModules/JNull.hpp>
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
+#include "StorageLocation.hpp"
+#include "JStorageLocation.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(downloadedTrack: DownloadedTrack) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_DownloadedTrack: public jni::JavaClass<JFunc_void_DownloadedTrack> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_DownloadedTrack;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_DownloadedTrack` instance holds through JNI.
+     */
+    void invoke(const DownloadedTrack& downloadedTrack) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JDownloadedTrack> /* downloadedTrack */)>("invoke");
+      method(self(), JDownloadedTrack::fromCpp(downloadedTrack));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_DownloadedTrack that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_DownloadedTrack_cxx final: public jni::HybridClass<JFunc_void_DownloadedTrack_cxx, JFunc_void_DownloadedTrack> {
+  public:
+    static jni::local_ref<JFunc_void_DownloadedTrack::javaobject> fromCpp(const std::function<void(const DownloadedTrack& /* downloadedTrack */)>& func) {
+      return JFunc_void_DownloadedTrack_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_DownloadedTrack_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JDownloadedTrack> downloadedTrack) {
+      _func(downloadedTrack->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const DownloadedTrack& /* downloadedTrack */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_DownloadedTrack_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_DownloadedTrack_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_DownloadedTrack_cxx(const std::function<void(const DownloadedTrack& /* downloadedTrack */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const DownloadedTrack& /* downloadedTrack */)> _func;
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -21,6 +21,8 @@
 #include <variant>
 #include "JVariant_NullType_String.hpp"
 #include <NitroModules/JNull.hpp>
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
 #include "JReason.hpp"
 
 namespace margelo::nitro::nitroplayer {

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

@@ -0,0 +1,81 @@
+///
+/// JFunc_void_std__optional_std__variant_nitro__NullType__std__string__.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <NitroModules/Null.hpp>
+#include <string>
+#include <variant>
+#include <optional>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JVariant_NullType_String.hpp"
+#include <NitroModules/JNull.hpp>
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(presetName: Variant_NullType_String?) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__optional_std__variant_nitro__NullType__std__string__: public jni::JavaClass<JFunc_void_std__optional_std__variant_nitro__NullType__std__string__> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_std__optional_std__variant_nitro__NullType__std__string__;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__optional_std__variant_nitro__NullType__std__string__` instance holds through JNI.
+     */
+    void invoke(const std::optional<std::variant<nitro::NullType, std::string>>& presetName) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JVariant_NullType_String> /* presetName */)>("invoke");
+      method(self(), presetName.has_value() ? JVariant_NullType_String::fromCpp(presetName.value()) : nullptr);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__optional_std__variant_nitro__NullType__std__string__ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__optional_std__variant_nitro__NullType__std__string___cxx final: public jni::HybridClass<JFunc_void_std__optional_std__variant_nitro__NullType__std__string___cxx, JFunc_void_std__optional_std__variant_nitro__NullType__std__string__> {
+  public:
+    static jni::local_ref<JFunc_void_std__optional_std__variant_nitro__NullType__std__string__::javaobject> fromCpp(const std::function<void(const std::optional<std::variant<nitro::NullType, std::string>>& /* presetName */)>& func) {
+      return JFunc_void_std__optional_std__variant_nitro__NullType__std__string___cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__optional_std__variant_nitro__NullType__std__string___cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JVariant_NullType_String> presetName) {
+      _func(presetName != nullptr ? std::make_optional(presetName->toCpp()) : std::nullopt);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::optional<std::variant<nitro::NullType, std::string>>& /* presetName */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_std__optional_std__variant_nitro__NullType__std__string___cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__optional_std__variant_nitro__NullType__std__string___cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__optional_std__variant_nitro__NullType__std__string___cxx(const std::function<void(const std::optional<std::variant<nitro::NullType, std::string>>& /* presetName */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::optional<std::variant<nitro::NullType, std::string>>& /* presetName */)> _func;
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -24,6 +24,8 @@
 #include "TrackItem.hpp"
 #include <vector>
 #include "JTrackItem.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
 #include "JQueueOperation.hpp"
 
 namespace margelo::nitro::nitroplayer {

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

@@ -0,0 +1,83 @@
+///
+/// JFunc_void_std__string_std__string_DownloadState_std__optional_DownloadError_.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include <string>
+#include "DownloadState.hpp"
+#include "DownloadError.hpp"
+#include <optional>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JDownloadState.hpp"
+#include "JDownloadError.hpp"
+#include "DownloadErrorReason.hpp"
+#include "JDownloadErrorReason.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(downloadId: String, trackId: String, state: DownloadState, error: DownloadError?) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__string_std__string_DownloadState_std__optional_DownloadError_: public jni::JavaClass<JFunc_void_std__string_std__string_DownloadState_std__optional_DownloadError_> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_std__string_std__string_DownloadState_std__optional_DownloadError_;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__string_std__string_DownloadState_std__optional_DownloadError_` instance holds through JNI.
+     */
+    void invoke(const std::string& downloadId, const std::string& trackId, DownloadState state, const std::optional<DownloadError>& error) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* downloadId */, jni::alias_ref<jni::JString> /* trackId */, jni::alias_ref<JDownloadState> /* state */, jni::alias_ref<JDownloadError> /* error */)>("invoke");
+      method(self(), jni::make_jstring(downloadId), jni::make_jstring(trackId), JDownloadState::fromCpp(state), error.has_value() ? JDownloadError::fromCpp(error.value()) : nullptr);
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__string_std__string_DownloadState_std__optional_DownloadError_ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__string_std__string_DownloadState_std__optional_DownloadError__cxx final: public jni::HybridClass<JFunc_void_std__string_std__string_DownloadState_std__optional_DownloadError__cxx, JFunc_void_std__string_std__string_DownloadState_std__optional_DownloadError_> {
+  public:
+    static jni::local_ref<JFunc_void_std__string_std__string_DownloadState_std__optional_DownloadError_::javaobject> fromCpp(const std::function<void(const std::string& /* downloadId */, const std::string& /* trackId */, DownloadState /* state */, const std::optional<DownloadError>& /* error */)>& func) {
+      return JFunc_void_std__string_std__string_DownloadState_std__optional_DownloadError__cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__string_std__string_DownloadState_std__optional_DownloadError__cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JString> downloadId, jni::alias_ref<jni::JString> trackId, jni::alias_ref<JDownloadState> state, jni::alias_ref<JDownloadError> error) {
+      _func(downloadId->toStdString(), trackId->toStdString(), state->toCpp(), error != nullptr ? std::make_optional(error->toCpp()) : std::nullopt);
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::string& /* downloadId */, const std::string& /* trackId */, DownloadState /* state */, const std::optional<DownloadError>& /* error */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_std__string_std__string_DownloadState_std__optional_DownloadError__cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__string_std__string_DownloadState_std__optional_DownloadError__cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__string_std__string_DownloadState_std__optional_DownloadError__cxx(const std::function<void(const std::string& /* downloadId */, const std::string& /* trackId */, DownloadState /* state */, const std::optional<DownloadError>& /* error */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::string& /* downloadId */, const std::string& /* trackId */, DownloadState /* state */, const std::optional<DownloadError>& /* error */)> _func;
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,97 @@
+///
+/// JFunc_void_std__vector_EqualizerBand_.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "EqualizerBand.hpp"
+#include <vector>
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JEqualizerBand.hpp"
+#include <string>
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(bands: Array<EqualizerBand>) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_std__vector_EqualizerBand_: public jni::JavaClass<JFunc_void_std__vector_EqualizerBand_> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_std__vector_EqualizerBand_;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_std__vector_EqualizerBand_` instance holds through JNI.
+     */
+    void invoke(const std::vector<EqualizerBand>& bands) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JEqualizerBand>> /* bands */)>("invoke");
+      method(self(), [&]() {
+        size_t __size = bands.size();
+        jni::local_ref<jni::JArrayClass<JEqualizerBand>> __array = jni::JArrayClass<JEqualizerBand>::newArray(__size);
+        for (size_t __i = 0; __i < __size; __i++) {
+          const auto& __element = bands[__i];
+          auto __elementJni = JEqualizerBand::fromCpp(__element);
+          __array->setElement(__i, *__elementJni);
+        }
+        return __array;
+      }());
+    }
+  };
+
+  /**
+   * An implementation of Func_void_std__vector_EqualizerBand_ that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_std__vector_EqualizerBand__cxx final: public jni::HybridClass<JFunc_void_std__vector_EqualizerBand__cxx, JFunc_void_std__vector_EqualizerBand_> {
+  public:
+    static jni::local_ref<JFunc_void_std__vector_EqualizerBand_::javaobject> fromCpp(const std::function<void(const std::vector<EqualizerBand>& /* bands */)>& func) {
+      return JFunc_void_std__vector_EqualizerBand__cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_std__vector_EqualizerBand__cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<jni::JArrayClass<JEqualizerBand>> bands) {
+      _func([&]() {
+              size_t __size = bands->size();
+              std::vector<EqualizerBand> __vector;
+              __vector.reserve(__size);
+              for (size_t __i = 0; __i < __size; __i++) {
+                auto __element = bands->getElement(__i);
+                __vector.push_back(__element->toCpp());
+              }
+              return __vector;
+            }());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const std::vector<EqualizerBand>& /* bands */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/Func_void_std__vector_EqualizerBand__cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_std__vector_EqualizerBand__cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_std__vector_EqualizerBand__cxx(const std::function<void(const std::vector<EqualizerBand>& /* bands */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const std::vector<EqualizerBand>& /* bands */)> _func;
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -24,6 +24,8 @@
 #include <NitroModules/JNull.hpp>
 #include "TrackItem.hpp"
 #include "JTrackItem.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
 #include "JQueueOperation.hpp"
 
 namespace margelo::nitro::nitroplayer {

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

@@ -0,0 +1,61 @@
+///
+/// JGainRange.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "GainRange.hpp"
+
+
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "GainRange" and the the Kotlin data class "GainRange".
+   */
+  struct JGainRange final: public jni::JavaClass<JGainRange> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/GainRange;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct GainRange by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    GainRange toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldMin = clazz->getField<double>("min");
+      double min = this->getFieldValue(fieldMin);
+      static const auto fieldMax = clazz->getField<double>("max");
+      double max = this->getFieldValue(fieldMax);
+      return GainRange(
+        min,
+        max
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JGainRange::javaobject> fromCpp(const GainRange& value) {
+      using JSignature = JGainRange(double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.min,
+        value.max
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitroplayer