react-native-queue-player 1.0.0

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

@@ -0,0 +1,1052 @@
+///
+/// JHybridTrackPlayerSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "JHybridTrackPlayerSpec.hpp"
+
+// Forward declaration of `TrackItem` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct TrackItem; }
+// Forward declaration of `PlaybackMode` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct PlaybackMode; }
+// Forward declaration of `PlaybackModeKind` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class PlaybackModeKind; }
+// Forward declaration of `ShuffleResult` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct ShuffleResult; }
+// Forward declaration of `PlayerState` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class PlayerState; }
+// Forward declaration of `TrackSource` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class TrackSource; }
+// Forward declaration of `PitchCorrectionMode` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class PitchCorrectionMode; }
+// Forward declaration of `RemoteControlOptions` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct RemoteControlOptions; }
+// Forward declaration of `RemoteSkipMode` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class RemoteSkipMode; }
+// Forward declaration of `BufferState` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class BufferState; }
+// Forward declaration of `SkipCapability` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct SkipCapability; }
+// Forward declaration of `SleepTimerState` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct SleepTimerState; }
+// Forward declaration of `CacheStatus` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct CacheStatus; }
+// Forward declaration of `ReplayGainMode` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class ReplayGainMode; }
+// Forward declaration of `NowPlayingFormat` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct NowPlayingFormat; }
+// Forward declaration of `AudioCodec` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class AudioCodec; }
+// Forward declaration of `AudioContainer` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class AudioContainer; }
+// Forward declaration of `NowPlayingFormatIosExtras` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct NowPlayingFormatIosExtras; }
+// Forward declaration of `NowPlayingFormatAndroidExtras` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct NowPlayingFormatAndroidExtras; }
+// Forward declaration of `PlayerConfig` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct PlayerConfig; }
+// Forward declaration of `AudioContentType` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class AudioContentType; }
+// Forward declaration of `AudioCategoryOptions` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct AudioCategoryOptions; }
+// Forward declaration of `EvictionPolicy` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class EvictionPolicy; }
+// Forward declaration of `RepeatMode` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class RepeatMode; }
+// Forward declaration of `StateChangeReason` to properly resolve imports.
+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 `PlayerProgress` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct PlayerProgress; }
+// Forward declaration of `PlaybackError` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct PlaybackError; }
+// Forward declaration of `PlaybackErrorCode` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class PlaybackErrorCode; }
+// Forward declaration of `BrowseSnapshot` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct BrowseSnapshot; }
+// Forward declaration of `BrowseSection` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct BrowseSection; }
+// Forward declaration of `SectionIcon` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class SectionIcon; }
+// Forward declaration of `BrowseItem` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct BrowseItem; }
+// Forward declaration of `MediaSearchRequest` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct MediaSearchRequest; }
+// Forward declaration of `MediaSearchType` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class MediaSearchType; }
+// Forward declaration of `MediaSearchOrigin` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class MediaSearchOrigin; }
+// Forward declaration of `MediaSearchReference` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class MediaSearchReference; }
+// Forward declaration of `MediaSearchRepeatMode` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class MediaSearchRepeatMode; }
+// Forward declaration of `MediaSearchReleaseDateRange` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct MediaSearchReleaseDateRange; }
+// Forward declaration of `MediaSearchQueueLocation` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class MediaSearchQueueLocation; }
+// Forward declaration of `VoiceVocabulary` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct VoiceVocabulary; }
+// Forward declaration of `ServiceReadyReason` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class ServiceReadyReason; }
+// Forward declaration of `LookaheadCacheConfig` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct LookaheadCacheConfig; }
+
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include <NitroModules/JUnit.hpp>
+#include "TrackItem.hpp"
+#include <vector>
+#include "JTrackItem.hpp"
+#include <string>
+#include <optional>
+#include <unordered_map>
+#include "PlaybackMode.hpp"
+#include "JPlaybackMode.hpp"
+#include "PlaybackModeKind.hpp"
+#include "JPlaybackModeKind.hpp"
+#include "ShuffleResult.hpp"
+#include "JShuffleResult.hpp"
+#include "PlayerState.hpp"
+#include "JPlayerState.hpp"
+#include "TrackSource.hpp"
+#include "JTrackSource.hpp"
+#include "PitchCorrectionMode.hpp"
+#include "JPitchCorrectionMode.hpp"
+#include "RemoteControlOptions.hpp"
+#include "JRemoteControlOptions.hpp"
+#include "RemoteSkipMode.hpp"
+#include "JRemoteSkipMode.hpp"
+#include "BufferState.hpp"
+#include "JBufferState.hpp"
+#include "SkipCapability.hpp"
+#include "JSkipCapability.hpp"
+#include "SleepTimerState.hpp"
+#include "JSleepTimerState.hpp"
+#include <functional>
+#include "JFunc_void.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "CacheStatus.hpp"
+#include "JCacheStatus.hpp"
+#include "ReplayGainMode.hpp"
+#include "JReplayGainMode.hpp"
+#include <NitroModules/Null.hpp>
+#include "NowPlayingFormat.hpp"
+#include <variant>
+#include "JVariant_NullType_NowPlayingFormat.hpp"
+#include <NitroModules/JNull.hpp>
+#include "JNowPlayingFormat.hpp"
+#include "AudioCodec.hpp"
+#include "JAudioCodec.hpp"
+#include "AudioContainer.hpp"
+#include "JAudioContainer.hpp"
+#include "JVariant_NullType_String.hpp"
+#include "JVariant_NullType_Double.hpp"
+#include "NowPlayingFormatIosExtras.hpp"
+#include "JNowPlayingFormatIosExtras.hpp"
+#include "NowPlayingFormatAndroidExtras.hpp"
+#include "JNowPlayingFormatAndroidExtras.hpp"
+#include "PlayerConfig.hpp"
+#include "JPlayerConfig.hpp"
+#include "AudioContentType.hpp"
+#include "JAudioContentType.hpp"
+#include "AudioCategoryOptions.hpp"
+#include "JAudioCategoryOptions.hpp"
+#include "EvictionPolicy.hpp"
+#include "JEvictionPolicy.hpp"
+#include "RepeatMode.hpp"
+#include "JRepeatMode.hpp"
+#include "StateChangeReason.hpp"
+#include "JFunc_void_PlayerState_StateChangeReason.hpp"
+#include "JStateChangeReason.hpp"
+#include "TrackChangeReason.hpp"
+#include "JFunc_void_std__optional_TrackItem__double_TrackChangeReason_std__optional_double_.hpp"
+#include "JTrackChangeReason.hpp"
+#include "PlayerProgress.hpp"
+#include "JFunc_void_PlayerProgress.hpp"
+#include "JPlayerProgress.hpp"
+#include "JFunc_void_double_double.hpp"
+#include "PlaybackError.hpp"
+#include "JFunc_void_PlaybackError.hpp"
+#include "JPlaybackError.hpp"
+#include "PlaybackErrorCode.hpp"
+#include "JPlaybackErrorCode.hpp"
+#include "JFunc_void_SkipCapability.hpp"
+#include "JFunc_void_SleepTimerState.hpp"
+#include "JFunc_void_BufferState.hpp"
+#include "JFunc_void_bool.hpp"
+#include "BrowseSnapshot.hpp"
+#include "JBrowseSnapshot.hpp"
+#include "BrowseSection.hpp"
+#include "JBrowseSection.hpp"
+#include "SectionIcon.hpp"
+#include "JSectionIcon.hpp"
+#include "BrowseItem.hpp"
+#include "JBrowseItem.hpp"
+#include "JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_BrowseItem______std__string.hpp"
+#include "MediaSearchRequest.hpp"
+#include "JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______MediaSearchRequest.hpp"
+#include "JMediaSearchRequest.hpp"
+#include "MediaSearchType.hpp"
+#include "JMediaSearchType.hpp"
+#include "MediaSearchOrigin.hpp"
+#include "JMediaSearchOrigin.hpp"
+#include "MediaSearchReference.hpp"
+#include "JMediaSearchReference.hpp"
+#include "MediaSearchRepeatMode.hpp"
+#include "JMediaSearchRepeatMode.hpp"
+#include "MediaSearchReleaseDateRange.hpp"
+#include "JMediaSearchReleaseDateRange.hpp"
+#include "MediaSearchQueueLocation.hpp"
+#include "JMediaSearchQueueLocation.hpp"
+#include "JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______std__string.hpp"
+#include "VoiceVocabulary.hpp"
+#include "JVoiceVocabulary.hpp"
+#include "ServiceReadyReason.hpp"
+#include "JFunc_void_ServiceReadyReason.hpp"
+#include "JServiceReadyReason.hpp"
+#include "LookaheadCacheConfig.hpp"
+#include "JLookaheadCacheConfig.hpp"
+#include "JFunc_void_CacheStatus.hpp"
+#include "JFunc_void_std__optional_std__variant_nitro__NullType__NowPlayingFormat__.hpp"
+
+namespace margelo::nitro::queueplayer {
+
+  std::shared_ptr<JHybridTrackPlayerSpec> JHybridTrackPlayerSpec::JavaPart::getJHybridTrackPlayerSpec() {
+    auto hybridObject = JHybridObject::JavaPart::getJHybridObject();
+    auto castHybridObject = std::dynamic_pointer_cast<JHybridTrackPlayerSpec>(hybridObject);
+    if (castHybridObject == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to downcast JHybridObject to JHybridTrackPlayerSpec!");
+    }
+    return castHybridObject;
+  }
+
+  jni::local_ref<JHybridTrackPlayerSpec::CxxPart::jhybriddata> JHybridTrackPlayerSpec::CxxPart::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  std::shared_ptr<JHybridObject> JHybridTrackPlayerSpec::CxxPart::createHybridObject(const jni::local_ref<JHybridObject::JavaPart>& javaPart) {
+    auto castJavaPart = jni::dynamic_ref_cast<JHybridTrackPlayerSpec::JavaPart>(javaPart);
+    if (castJavaPart == nullptr) [[unlikely]] {
+      throw std::runtime_error("Failed to cast JHybridObject::JavaPart to JHybridTrackPlayerSpec::JavaPart!");
+    }
+    return std::make_shared<JHybridTrackPlayerSpec>(castJavaPart);
+  }
+
+  void JHybridTrackPlayerSpec::CxxPart::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridTrackPlayerSpec::CxxPart::initHybrid),
+    });
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::configure(const PlayerConfig& config) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JPlayerConfig> /* config */)>("configure");
+    auto __result = method(_javaPart, JPlayerConfig::fromCpp(config));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::destroy() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("destroy");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::setQueue(const std::vector<TrackItem>& tracks, std::optional<double> startAtIndex) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JArrayClass<JTrackItem>> /* tracks */, jni::alias_ref<jni::JDouble> /* startAtIndex */)>("setQueue");
+    auto __result = method(_javaPart, [&](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;
+    }(tracks), startAtIndex.has_value() ? jni::JDouble::valueOf(startAtIndex.value()) : nullptr);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::addToQueue(const std::vector<TrackItem>& tracks, std::optional<double> insertBefore) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JArrayClass<JTrackItem>> /* tracks */, jni::alias_ref<jni::JDouble> /* insertBefore */)>("addToQueue");
+    auto __result = method(_javaPart, [&](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;
+    }(tracks), insertBefore.has_value() ? jni::JDouble::valueOf(insertBefore.value()) : nullptr);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::removeFromQueue(const std::vector<double>& indices) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JArrayDouble> /* indices */)>("removeFromQueue");
+    auto __result = method(_javaPart, [&]() {
+      size_t __size = indices.size();
+      jni::local_ref<jni::JArrayDouble> __array = jni::JArrayDouble::newArray(__size);
+      __array->setRegion(0, __size, indices.data());
+      return __array;
+    }());
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::moveInQueue(double fromIndex, double toIndex) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(double /* fromIndex */, double /* toIndex */)>("moveInQueue");
+    auto __result = method(_javaPart, fromIndex, toIndex);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::vector<TrackItem> JHybridTrackPlayerSpec::getQueue() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JTrackItem>>()>("getQueue");
+    auto __result = method(_javaPart);
+    return [&](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;
+    }(__result);
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::clearQueue() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("clearQueue");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::play() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("play");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::pause() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("pause");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::stop() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("stop");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::retry() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("retry");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::seekTo(double position) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(double /* position */)>("seekTo");
+    auto __result = method(_javaPart, position);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::skipToIndex(double index) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(double /* index */)>("skipToIndex");
+    auto __result = method(_javaPart, index);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::skipToNext() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("skipToNext");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::skipToPrevious() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("skipToPrevious");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::setPlaybackMode(const PlaybackMode& mode) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JPlaybackMode> /* mode */)>("setPlaybackMode");
+    auto __result = method(_javaPart, JPlaybackMode::fromCpp(mode));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  PlaybackMode JHybridTrackPlayerSpec::getPlaybackMode() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPlaybackMode>()>("getPlaybackMode");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::setPlaybackSpeed(double rate) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(double /* rate */)>("setPlaybackSpeed");
+    auto __result = method(_javaPart, rate);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::setPitchCorrectionMode(PitchCorrectionMode mode) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JPitchCorrectionMode> /* mode */)>("setPitchCorrectionMode");
+    auto __result = method(_javaPart, JPitchCorrectionMode::fromCpp(mode));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::setVolume(double volume) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(double /* volume */)>("setVolume");
+    auto __result = method(_javaPart, volume);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::setRepeatMode(RepeatMode mode) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JRepeatMode> /* mode */)>("setRepeatMode");
+    auto __result = method(_javaPart, JRepeatMode::fromCpp(mode));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::setRemoteControls(const RemoteControlOptions& options) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JRemoteControlOptions> /* options */)>("setRemoteControls");
+    auto __result = method(_javaPart, JRemoteControlOptions::fromCpp(options));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::setSleepTimer(double seconds) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(double /* seconds */)>("setSleepTimer");
+    auto __result = method(_javaPart, seconds);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::setSleepTimerToTrackEnd() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("setSleepTimerToTrackEnd");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::clearSleepTimer() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("clearSleepTimer");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<ShuffleResult>> JHybridTrackPlayerSpec::shuffleQueue() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("shuffleQueue");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<ShuffleResult>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JShuffleResult>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  PlayerState JHybridTrackPlayerSpec::getState() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPlayerState>()>("getState");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  double JHybridTrackPlayerSpec::getCurrentTrackIndex() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getCurrentTrackIndex");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  std::optional<TrackSource> JHybridTrackPlayerSpec::getCurrentTrackSource() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JTrackSource>()>("getCurrentTrackSource");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toCpp()) : std::nullopt;
+  }
+  double JHybridTrackPlayerSpec::getPlaybackSpeed() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getPlaybackSpeed");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  PitchCorrectionMode JHybridTrackPlayerSpec::getPitchCorrectionMode() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPitchCorrectionMode>()>("getPitchCorrectionMode");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  double JHybridTrackPlayerSpec::getVolume() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<double()>("getVolume");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  RemoteControlOptions JHybridTrackPlayerSpec::getRemoteControls() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JRemoteControlOptions>()>("getRemoteControls");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  BufferState JHybridTrackPlayerSpec::getBufferState() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JBufferState>()>("getBufferState");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  bool JHybridTrackPlayerSpec::getIsSeekable() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getIsSeekable");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  bool JHybridTrackPlayerSpec::isFullyBuffered() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("isFullyBuffered");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  bool JHybridTrackPlayerSpec::getCanSkipNext() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getCanSkipNext");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  bool JHybridTrackPlayerSpec::getCanSkipPrevious() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jboolean()>("getCanSkipPrevious");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  SkipCapability JHybridTrackPlayerSpec::getSkipCapability() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JSkipCapability>()>("getSkipCapability");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  SleepTimerState JHybridTrackPlayerSpec::getSleepTimer() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JSleepTimerState>()>("getSleepTimer");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  std::function<void()> JHybridTrackPlayerSpec::onStateChange(const std::function<void(PlayerState /* state */, StateChangeReason /* reason */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void_PlayerState_StateChangeReason::javaobject> /* callback */)>("onStateChange_cxx");
+    auto __result = method(_javaPart, JFunc_void_PlayerState_StateChangeReason_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::onTrackChange(const std::function<void(const std::optional<TrackItem>& /* track */, double /* index */, TrackChangeReason /* reason */, std::optional<double> /* transitionGapMs */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void_std__optional_TrackItem__double_TrackChangeReason_std__optional_double_::javaobject> /* callback */)>("onTrackChange_cxx");
+    auto __result = method(_javaPart, JFunc_void_std__optional_TrackItem__double_TrackChangeReason_std__optional_double__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));
+    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::onPlaybackMilestone(const std::function<void(double /* milestone */, double /* trackIndex */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void_double_double::javaobject> /* callback */)>("onPlaybackMilestone_cxx");
+    auto __result = method(_javaPart, JFunc_void_double_double_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::onError(const std::function<void(const PlaybackError& /* error */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void_PlaybackError::javaobject> /* callback */)>("onError_cxx");
+    auto __result = method(_javaPart, JFunc_void_PlaybackError_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::onQueueEnd(const std::function<void()>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void::javaobject> /* callback */)>("onQueueEnd_cxx");
+    auto __result = method(_javaPart, JFunc_void_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::onSkipCapabilityChange(const std::function<void(const SkipCapability& /* capability */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void_SkipCapability::javaobject> /* callback */)>("onSkipCapabilityChange_cxx");
+    auto __result = method(_javaPart, JFunc_void_SkipCapability_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::onSleepTimerChange(const std::function<void(const SleepTimerState& /* state */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void_SleepTimerState::javaobject> /* callback */)>("onSleepTimerChange_cxx");
+    auto __result = method(_javaPart, JFunc_void_SleepTimerState_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::onBufferStateChange(const std::function<void(BufferState /* state */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void_BufferState::javaobject> /* callback */)>("onBufferStateChange_cxx");
+    auto __result = method(_javaPart, JFunc_void_BufferState_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::onFullyBufferedChange(const std::function<void(bool /* fullyBuffered */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void_bool::javaobject> /* callback */)>("onFullyBufferedChange_cxx");
+    auto __result = method(_javaPart, JFunc_void_bool_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));
+      }
+    }();
+  }
+  void JHybridTrackPlayerSpec::setBrowseSnapshot(const BrowseSnapshot& snapshot) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JBrowseSnapshot> /* snapshot */)>("setBrowseSnapshot");
+    method(_javaPart, JBrowseSnapshot::fromCpp(snapshot));
+  }
+  std::function<void()> JHybridTrackPlayerSpec::onBrowseRequest(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<BrowseItem>>>>>(const std::string& /* parentId */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_BrowseItem______std__string::javaobject> /* callback */)>("onBrowseRequest_cxx");
+    auto __result = method(_javaPart, JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_BrowseItem______std__string_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::onSearchRequest(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<BrowseItem>>>>>(const std::string& /* query */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_BrowseItem______std__string::javaobject> /* callback */)>("onSearchRequest_cxx");
+    auto __result = method(_javaPart, JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_BrowseItem______std__string_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::onPlayFromSearchRequest(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>(const MediaSearchRequest& /* request */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______MediaSearchRequest::javaobject> /* callback */)>("onPlayFromSearchRequest_cxx");
+    auto __result = method(_javaPart, JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______MediaSearchRequest_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::onPlayFromIdRequest(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>(const std::string& /* mediaId */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______std__string::javaobject> /* callback */)>("onPlayFromIdRequest_cxx");
+    auto __result = method(_javaPart, JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______std__string_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));
+      }
+    }();
+  }
+  void JHybridTrackPlayerSpec::donateVoiceVocabulary(const VoiceVocabulary& vocabulary) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JVoiceVocabulary> /* vocabulary */)>("donateVoiceVocabulary");
+    method(_javaPart, JVoiceVocabulary::fromCpp(vocabulary));
+  }
+  std::function<void()> JHybridTrackPlayerSpec::onCarConnect(const std::function<void()>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void::javaobject> /* callback */)>("onCarConnect_cxx");
+    auto __result = method(_javaPart, JFunc_void_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::onCarDisconnect(const std::function<void()>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void::javaobject> /* callback */)>("onCarDisconnect_cxx");
+    auto __result = method(_javaPart, JFunc_void_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::onServiceReady(const std::function<void(ServiceReadyReason /* reason */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void_ServiceReadyReason::javaobject> /* callback */)>("onServiceReady_cxx");
+    auto __result = method(_javaPart, JFunc_void_ServiceReadyReason_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::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::setLookaheadCache(const LookaheadCacheConfig& config) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JLookaheadCacheConfig> /* config */)>("setLookaheadCache");
+    auto __result = method(_javaPart, JLookaheadCacheConfig::fromCpp(config));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  CacheStatus JHybridTrackPlayerSpec::getLookaheadCacheStatus() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JCacheStatus>()>("getLookaheadCacheStatus");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  std::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::clearLookaheadCache() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("clearLookaheadCache");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::function<void()> JHybridTrackPlayerSpec::onCacheStatusChange(const std::function<void(const CacheStatus& /* status */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void_CacheStatus::javaobject> /* callback */)>("onCacheStatusChange_cxx");
+    auto __result = method(_javaPart, JFunc_void_CacheStatus_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::shared_ptr<Promise<void>> JHybridTrackPlayerSpec::setReplayGainMode(ReplayGainMode mode) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JReplayGainMode> /* mode */)>("setReplayGainMode");
+    auto __result = method(_javaPart, JReplayGainMode::fromCpp(mode));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  ReplayGainMode JHybridTrackPlayerSpec::getReplayGainMode() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JReplayGainMode>()>("getReplayGainMode");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  std::variant<nitro::NullType, NowPlayingFormat> JHybridTrackPlayerSpec::getNowPlayingFormat() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JVariant_NullType_NowPlayingFormat>()>("getNowPlayingFormat");
+    auto __result = method(_javaPart);
+    return __result->toCpp();
+  }
+  std::function<void()> JHybridTrackPlayerSpec::onNowPlayingFormatChange(const std::function<void(const std::optional<std::variant<nitro::NullType, NowPlayingFormat>>& /* format */)>& callback) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void_std__optional_std__variant_nitro__NullType__NowPlayingFormat__::javaobject> /* callback */)>("onNowPlayingFormatChange_cxx");
+    auto __result = method(_javaPart, JFunc_void_std__optional_std__variant_nitro__NullType__NowPlayingFormat___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));
+      }
+    }();
+  }
+
+} // namespace margelo::nitro::queueplayer