react-native-nitro-player 0.3.0-alpha.9 → 0.4.1-alpha.0

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

@@ -0,0 +1,111 @@
+///
+/// JDownloadedPlaylist.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 "DownloadedPlaylist.hpp"
+
+#include "DownloadedTrack.hpp"
+#include "JDownloadedTrack.hpp"
+#include "JPlaylist.hpp"
+#include "JStorageLocation.hpp"
+#include "JTrackItem.hpp"
+#include "JVariant_NullType_String.hpp"
+#include "Playlist.hpp"
+#include "StorageLocation.hpp"
+#include "TrackItem.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.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 "DownloadedPlaylist" and the the Kotlin data class "DownloadedPlaylist".
+   */
+  struct JDownloadedPlaylist final: public jni::JavaClass<JDownloadedPlaylist> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/DownloadedPlaylist;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct DownloadedPlaylist by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    DownloadedPlaylist toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldPlaylistId = clazz->getField<jni::JString>("playlistId");
+      jni::local_ref<jni::JString> playlistId = this->getFieldValue(fieldPlaylistId);
+      static const auto fieldOriginalPlaylist = clazz->getField<JPlaylist>("originalPlaylist");
+      jni::local_ref<JPlaylist> originalPlaylist = this->getFieldValue(fieldOriginalPlaylist);
+      static const auto fieldDownloadedTracks = clazz->getField<jni::JArrayClass<JDownloadedTrack>>("downloadedTracks");
+      jni::local_ref<jni::JArrayClass<JDownloadedTrack>> downloadedTracks = this->getFieldValue(fieldDownloadedTracks);
+      static const auto fieldTotalSize = clazz->getField<double>("totalSize");
+      double totalSize = this->getFieldValue(fieldTotalSize);
+      static const auto fieldDownloadedAt = clazz->getField<double>("downloadedAt");
+      double downloadedAt = this->getFieldValue(fieldDownloadedAt);
+      static const auto fieldIsComplete = clazz->getField<jboolean>("isComplete");
+      jboolean isComplete = this->getFieldValue(fieldIsComplete);
+      return DownloadedPlaylist(
+        playlistId->toStdString(),
+        originalPlaylist->toCpp(),
+        [&]() {
+          size_t __size = downloadedTracks->size();
+          std::vector<DownloadedTrack> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = downloadedTracks->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }(),
+        totalSize,
+        downloadedAt,
+        static_cast<bool>(isComplete)
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JDownloadedPlaylist::javaobject> fromCpp(const DownloadedPlaylist& value) {
+      using JSignature = JDownloadedPlaylist(jni::alias_ref<jni::JString>, jni::alias_ref<JPlaylist>, jni::alias_ref<jni::JArrayClass<JDownloadedTrack>>, double, double, jboolean);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.playlistId),
+        JPlaylist::fromCpp(value.originalPlaylist),
+        [&]() {
+          size_t __size = value.downloadedTracks.size();
+          jni::local_ref<jni::JArrayClass<JDownloadedTrack>> __array = jni::JArrayClass<JDownloadedTrack>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.downloadedTracks[__i];
+            auto __elementJni = JDownloadedTrack::fromCpp(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }(),
+        value.totalSize,
+        value.downloadedAt,
+        value.isComplete
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitroplayer

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

@@ -0,0 +1,92 @@
+///
+/// JDownloadedTrack.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 "DownloadedTrack.hpp"
+
+#include "JStorageLocation.hpp"
+#include "JTrackItem.hpp"
+#include "JVariant_NullType_String.hpp"
+#include "StorageLocation.hpp"
+#include "TrackItem.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
+#include <NitroModules/JNull.hpp>
+#include <NitroModules/Null.hpp>
+#include <optional>
+#include <string>
+#include <variant>
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "DownloadedTrack" and the the Kotlin data class "DownloadedTrack".
+   */
+  struct JDownloadedTrack final: public jni::JavaClass<JDownloadedTrack> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/DownloadedTrack;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct DownloadedTrack by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    DownloadedTrack toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldTrackId = clazz->getField<jni::JString>("trackId");
+      jni::local_ref<jni::JString> trackId = this->getFieldValue(fieldTrackId);
+      static const auto fieldOriginalTrack = clazz->getField<JTrackItem>("originalTrack");
+      jni::local_ref<JTrackItem> originalTrack = this->getFieldValue(fieldOriginalTrack);
+      static const auto fieldLocalPath = clazz->getField<jni::JString>("localPath");
+      jni::local_ref<jni::JString> localPath = this->getFieldValue(fieldLocalPath);
+      static const auto fieldLocalArtworkPath = clazz->getField<JVariant_NullType_String>("localArtworkPath");
+      jni::local_ref<JVariant_NullType_String> localArtworkPath = this->getFieldValue(fieldLocalArtworkPath);
+      static const auto fieldDownloadedAt = clazz->getField<double>("downloadedAt");
+      double downloadedAt = this->getFieldValue(fieldDownloadedAt);
+      static const auto fieldFileSize = clazz->getField<double>("fileSize");
+      double fileSize = this->getFieldValue(fieldFileSize);
+      static const auto fieldStorageLocation = clazz->getField<JStorageLocation>("storageLocation");
+      jni::local_ref<JStorageLocation> storageLocation = this->getFieldValue(fieldStorageLocation);
+      return DownloadedTrack(
+        trackId->toStdString(),
+        originalTrack->toCpp(),
+        localPath->toStdString(),
+        localArtworkPath != nullptr ? std::make_optional(localArtworkPath->toCpp()) : std::nullopt,
+        downloadedAt,
+        fileSize,
+        storageLocation->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<JDownloadedTrack::javaobject> fromCpp(const DownloadedTrack& value) {
+      using JSignature = JDownloadedTrack(jni::alias_ref<jni::JString>, jni::alias_ref<JTrackItem>, jni::alias_ref<jni::JString>, jni::alias_ref<JVariant_NullType_String>, double, double, jni::alias_ref<JStorageLocation>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        jni::make_jstring(value.trackId),
+        JTrackItem::fromCpp(value.originalTrack),
+        jni::make_jstring(value.localPath),
+        value.localArtworkPath.has_value() ? JVariant_NullType_String::fromCpp(value.localArtworkPath.value()) : nullptr,
+        value.downloadedAt,
+        value.fileSize,
+        JStorageLocation::fromCpp(value.storageLocation)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitroplayer

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 {