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

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

@@ -0,0 +1,69 @@
+///
+/// JEqualizerBand.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 "EqualizerBand.hpp"
+
+#include <string>
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "EqualizerBand" and the the Kotlin data class "EqualizerBand".
+   */
+  struct JEqualizerBand final: public jni::JavaClass<JEqualizerBand> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/EqualizerBand;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct EqualizerBand by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    EqualizerBand toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldIndex = clazz->getField<double>("index");
+      double index = this->getFieldValue(fieldIndex);
+      static const auto fieldCenterFrequency = clazz->getField<double>("centerFrequency");
+      double centerFrequency = this->getFieldValue(fieldCenterFrequency);
+      static const auto fieldGainDb = clazz->getField<double>("gainDb");
+      double gainDb = this->getFieldValue(fieldGainDb);
+      static const auto fieldFrequencyLabel = clazz->getField<jni::JString>("frequencyLabel");
+      jni::local_ref<jni::JString> frequencyLabel = this->getFieldValue(fieldFrequencyLabel);
+      return EqualizerBand(
+        index,
+        centerFrequency,
+        gainDb,
+        frequencyLabel->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<JEqualizerBand::javaobject> fromCpp(const EqualizerBand& value) {
+      using JSignature = JEqualizerBand(double, double, double, jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.index,
+        value.centerFrequency,
+        value.gainDb,
+        jni::make_jstring(value.frequencyLabel)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,78 @@
+///
+/// JEqualizerPreset.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 "EqualizerPreset.hpp"
+
+#include "JPresetType.hpp"
+#include "PresetType.hpp"
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "EqualizerPreset" and the the Kotlin data class "EqualizerPreset".
+   */
+  struct JEqualizerPreset final: public jni::JavaClass<JEqualizerPreset> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/EqualizerPreset;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct EqualizerPreset by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    EqualizerPreset toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldName = clazz->getField<jni::JString>("name");
+      jni::local_ref<jni::JString> name = this->getFieldValue(fieldName);
+      static const auto fieldGains = clazz->getField<jni::JArrayDouble>("gains");
+      jni::local_ref<jni::JArrayDouble> gains = this->getFieldValue(fieldGains);
+      static const auto fieldType = clazz->getField<JPresetType>("type");
+      jni::local_ref<JPresetType> type = this->getFieldValue(fieldType);
+      return EqualizerPreset(
+        name->toStdString(),
+        [&]() {
+          size_t __size = gains->size();
+          std::vector<double> __vector(__size);
+          gains->getRegion(0, __size, __vector.data());
+          return __vector;
+        }(),
+        type->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<JEqualizerPreset::javaobject> fromCpp(const EqualizerPreset& value) {
+      using JSignature = JEqualizerPreset(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JArrayDouble>, jni::alias_ref<JPresetType>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.name),
+        [&]() {
+          size_t __size = value.gains.size();
+          jni::local_ref<jni::JArrayDouble> __array = jni::JArrayDouble::newArray(__size);
+          __array->setRegion(0, __size, value.gains.data());
+          return __array;
+        }(),
+        JPresetType::fromCpp(value.type)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,91 @@
+///
+/// JEqualizerState.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 "EqualizerState.hpp"
+
+#include "EqualizerBand.hpp"
+#include "JEqualizerBand.hpp"
+#include "JVariant_NullType_String.hpp"
+#include <NitroModules/JNull.hpp>
+#include <NitroModules/Null.hpp>
+#include <optional>
+#include <string>
+#include <variant>
+#include <vector>
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "EqualizerState" and the the Kotlin data class "EqualizerState".
+   */
+  struct JEqualizerState final: public jni::JavaClass<JEqualizerState> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/EqualizerState;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct EqualizerState by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    EqualizerState toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldEnabled = clazz->getField<jboolean>("enabled");
+      jboolean enabled = this->getFieldValue(fieldEnabled);
+      static const auto fieldBands = clazz->getField<jni::JArrayClass<JEqualizerBand>>("bands");
+      jni::local_ref<jni::JArrayClass<JEqualizerBand>> bands = this->getFieldValue(fieldBands);
+      static const auto fieldCurrentPreset = clazz->getField<JVariant_NullType_String>("currentPreset");
+      jni::local_ref<JVariant_NullType_String> currentPreset = this->getFieldValue(fieldCurrentPreset);
+      return EqualizerState(
+        static_cast<bool>(enabled),
+        [&]() {
+          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;
+        }(),
+        currentPreset != nullptr ? std::make_optional(currentPreset->toCpp()) : 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<JEqualizerState::javaobject> fromCpp(const EqualizerState& value) {
+      using JSignature = JEqualizerState(jboolean, jni::alias_ref<jni::JArrayClass<JEqualizerBand>>, jni::alias_ref<JVariant_NullType_String>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.enabled,
+        [&]() {
+          size_t __size = value.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 = value.bands[__i];
+            auto __elementJni = JEqualizerBand::fromCpp(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }(),
+        value.currentPreset.has_value() ? JVariant_NullType_String::fromCpp(value.currentPreset.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitroplayer

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