///
/// JHybridPlaybackEngineSpec.cpp
/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
/// https://github.com/mrousavy/nitro
/// Copyright © Marc Rousavy @ Margelo
///

#include "JHybridPlaybackEngineSpec.hpp"

// Forward declaration of `PlaybackState` to properly resolve imports.
namespace margelo::nitro::aviation { enum class PlaybackState; }
// Forward declaration of `MediaPosition` to properly resolve imports.
namespace margelo::nitro::aviation { struct MediaPosition; }
// Forward declaration of `HybridMediaItemSpec` to properly resolve imports.
namespace margelo::nitro::aviation { class HybridMediaItemSpec; }
// Forward declaration of `ItemSource` to properly resolve imports.
namespace margelo::nitro::aviation { enum class ItemSource; }
// Forward declaration of `SubtitleTrack` to properly resolve imports.
namespace margelo::nitro::aviation { struct SubtitleTrack; }
// Forward declaration of `AudioTrack` to properly resolve imports.
namespace margelo::nitro::aviation { struct AudioTrack; }
// Forward declaration of `RepeatMode` to properly resolve imports.
namespace margelo::nitro::aviation { enum class RepeatMode; }
// Forward declaration of `RemoteCommand` to properly resolve imports.
namespace margelo::nitro::aviation { enum class RemoteCommand; }
// Forward declaration of `NowPlayingInfo` to properly resolve imports.
namespace margelo::nitro::aviation { struct NowPlayingInfo; }
// Forward declaration of `HybridAudioSessionSpec` to properly resolve imports.
namespace margelo::nitro::aviation { class HybridAudioSessionSpec; }
// Forward declaration of `RemoteCommandEvent` to properly resolve imports.
namespace margelo::nitro::aviation { struct RemoteCommandEvent; }
// Forward declaration of `PlaybackMetricEvent` to properly resolve imports.
namespace margelo::nitro::aviation { struct PlaybackMetricEvent; }
// Forward declaration of `PlaybackMetricType` to properly resolve imports.
namespace margelo::nitro::aviation { enum class PlaybackMetricType; }
// Forward declaration of `TtffSource` to properly resolve imports.
namespace margelo::nitro::aviation { enum class TtffSource; }
// Forward declaration of `AvailableTracks` to properly resolve imports.
namespace margelo::nitro::aviation { struct AvailableTracks; }
// Forward declaration of `DomainEvent` to properly resolve imports.
namespace margelo::nitro::aviation { struct DomainEvent; }
// Forward declaration of `DomainEventType` to properly resolve imports.
namespace margelo::nitro::aviation { enum class DomainEventType; }
// Forward declaration of `AviationInterruptionMode` to properly resolve imports.
namespace margelo::nitro::aviation { enum class AviationInterruptionMode; }
// Forward declaration of `BecomingNoisyBehavior` to properly resolve imports.
namespace margelo::nitro::aviation { enum class BecomingNoisyBehavior; }
// Forward declaration of `VideoTrackSelection` to properly resolve imports.
namespace margelo::nitro::aviation { struct VideoTrackSelection; }
// Forward declaration of `VideoTrackSelectionType` to properly resolve imports.
namespace margelo::nitro::aviation { enum class VideoTrackSelectionType; }
// Forward declaration of `SubtitleTrackSelection` to properly resolve imports.
namespace margelo::nitro::aviation { struct SubtitleTrackSelection; }
// Forward declaration of `SubtitleTrackSelectionType` to properly resolve imports.
namespace margelo::nitro::aviation { enum class SubtitleTrackSelectionType; }
// Forward declaration of `AudioTrackSelection` to properly resolve imports.
namespace margelo::nitro::aviation { struct AudioTrackSelection; }
// Forward declaration of `AudioTrackSelectionType` to properly resolve imports.
namespace margelo::nitro::aviation { enum class AudioTrackSelectionType; }
// Forward declaration of `PreloadConfig` to properly resolve imports.
namespace margelo::nitro::aviation { struct PreloadConfig; }
// Forward declaration of `BufferConfig` to properly resolve imports.
namespace margelo::nitro::aviation { struct BufferConfig; }

#include <string>
#include "PlaybackState.hpp"
#include "JPlaybackState.hpp"
#include "MediaPosition.hpp"
#include "JMediaPosition.hpp"
#include <memory>
#include "HybridMediaItemSpec.hpp"
#include <optional>
#include "JHybridMediaItemSpec.hpp"
#include "ItemSource.hpp"
#include "JItemSource.hpp"
#include "SubtitleTrack.hpp"
#include <vector>
#include "JSubtitleTrack.hpp"
#include "AudioTrack.hpp"
#include "JAudioTrack.hpp"
#include "RepeatMode.hpp"
#include "JRepeatMode.hpp"
#include <NitroModules/Promise.hpp>
#include <NitroModules/JPromise.hpp>
#include <NitroModules/JUnit.hpp>
#include "RemoteCommand.hpp"
#include "JRemoteCommand.hpp"
#include "NowPlayingInfo.hpp"
#include "JNowPlayingInfo.hpp"
#include "HybridAudioSessionSpec.hpp"
#include "JHybridAudioSessionSpec.hpp"
#include <functional>
#include "JFunc_void_PlaybackState.hpp"
#include <NitroModules/JNICallable.hpp>
#include "JFunc_void_MediaPosition.hpp"
#include "JFunc_void_std__optional_std__shared_ptr_HybridMediaItemSpec___ItemSource.hpp"
#include "RemoteCommandEvent.hpp"
#include "JFunc_void_RemoteCommandEvent.hpp"
#include "JRemoteCommandEvent.hpp"
#include "JFunc_void_std__string_std__string.hpp"
#include "JFunc_void.hpp"
#include "PlaybackMetricEvent.hpp"
#include "JFunc_void_PlaybackMetricEvent.hpp"
#include "JPlaybackMetricEvent.hpp"
#include "PlaybackMetricType.hpp"
#include "JPlaybackMetricType.hpp"
#include "TtffSource.hpp"
#include "JTtffSource.hpp"
#include "AvailableTracks.hpp"
#include "JFunc_void_AvailableTracks.hpp"
#include "JAvailableTracks.hpp"
#include "DomainEvent.hpp"
#include "JFunc_void_DomainEvent.hpp"
#include "JDomainEvent.hpp"
#include "DomainEventType.hpp"
#include "JDomainEventType.hpp"
#include "AviationInterruptionMode.hpp"
#include "JAviationInterruptionMode.hpp"
#include "BecomingNoisyBehavior.hpp"
#include "JBecomingNoisyBehavior.hpp"
#include "VideoTrackSelection.hpp"
#include "JVideoTrackSelection.hpp"
#include "VideoTrackSelectionType.hpp"
#include "JVideoTrackSelectionType.hpp"
#include "SubtitleTrackSelection.hpp"
#include "JSubtitleTrackSelection.hpp"
#include "SubtitleTrackSelectionType.hpp"
#include "JSubtitleTrackSelectionType.hpp"
#include "AudioTrackSelection.hpp"
#include "JAudioTrackSelection.hpp"
#include "AudioTrackSelectionType.hpp"
#include "JAudioTrackSelectionType.hpp"
#include "PreloadConfig.hpp"
#include "JPreloadConfig.hpp"
#include "BufferConfig.hpp"
#include "JBufferConfig.hpp"

namespace margelo::nitro::aviation {

  jni::local_ref<JHybridPlaybackEngineSpec::jhybriddata> JHybridPlaybackEngineSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
    return makeCxxInstance(jThis);
  }

  void JHybridPlaybackEngineSpec::registerNatives() {
    registerHybrid({
      makeNativeMethod("initHybrid", JHybridPlaybackEngineSpec::initHybrid),
    });
  }

  size_t JHybridPlaybackEngineSpec::getExternalMemorySize() noexcept {
    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
    return method(_javaPart);
  }

  bool JHybridPlaybackEngineSpec::equals(const std::shared_ptr<HybridObject>& other) {
    if (auto otherCast = std::dynamic_pointer_cast<JHybridPlaybackEngineSpec>(other)) {
      return _javaPart == otherCast->_javaPart;
    }
    return false;
  }

  void JHybridPlaybackEngineSpec::dispose() noexcept {
    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
    method(_javaPart);
  }

  std::string JHybridPlaybackEngineSpec::toString() {
    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
    auto javaString = method(_javaPart);
    return javaString->toStdString();
  }

  // Properties
  std::string JHybridPlaybackEngineSpec::getEngineId() {
    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getEngineId");
    auto __result = method(_javaPart);
    return __result->toStdString();
  }
  PlaybackState JHybridPlaybackEngineSpec::getState() {
    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPlaybackState>()>("getState");
    auto __result = method(_javaPart);
    return __result->toCpp();
  }
  MediaPosition JHybridPlaybackEngineSpec::getMediaPosition() {
    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JMediaPosition>()>("getMediaPosition");
    auto __result = method(_javaPart);
    return __result->toCpp();
  }
  std::optional<std::shared_ptr<HybridMediaItemSpec>> JHybridPlaybackEngineSpec::getCurrentItem() {
    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JHybridMediaItemSpec::javaobject>()>("getCurrentItem");
    auto __result = method(_javaPart);
    return __result != nullptr ? std::make_optional(__result->cthis()->shared_cast<JHybridMediaItemSpec>()) : std::nullopt;
  }
  ItemSource JHybridPlaybackEngineSpec::getCurrentItemSource() {
    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JItemSource>()>("getCurrentItemSource");
    auto __result = method(_javaPart);
    return __result->toCpp();
  }
  bool JHybridPlaybackEngineSpec::getIsLive() {
    static const auto method = javaClassStatic()->getMethod<jboolean()>("isLive");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }
  bool JHybridPlaybackEngineSpec::getIsPlaying() {
    static const auto method = javaClassStatic()->getMethod<jboolean()>("isPlaying");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }
  bool JHybridPlaybackEngineSpec::getIsPaused() {
    static const auto method = javaClassStatic()->getMethod<jboolean()>("isPaused");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }
  bool JHybridPlaybackEngineSpec::getIsLoaded() {
    static const auto method = javaClassStatic()->getMethod<jboolean()>("isLoaded");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }
  std::vector<SubtitleTrack> JHybridPlaybackEngineSpec::getAvailableSubtitleTracks() {
    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JSubtitleTrack>>()>("getAvailableSubtitleTracks");
    auto __result = method(_javaPart);
    return [&]() {
      size_t __size = __result->size();
      std::vector<SubtitleTrack> __vector;
      __vector.reserve(__size);
      for (size_t __i = 0; __i < __size; __i++) {
        auto __element = __result->getElement(__i);
        __vector.push_back(__element->toCpp());
      }
      return __vector;
    }();
  }
  std::vector<AudioTrack> JHybridPlaybackEngineSpec::getAvailableAudioTracks() {
    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JAudioTrack>>()>("getAvailableAudioTracks");
    auto __result = method(_javaPart);
    return [&]() {
      size_t __size = __result->size();
      std::vector<AudioTrack> __vector;
      __vector.reserve(__size);
      for (size_t __i = 0; __i < __size; __i++) {
        auto __element = __result->getElement(__i);
        __vector.push_back(__element->toCpp());
      }
      return __vector;
    }();
  }
  double JHybridPlaybackEngineSpec::getVolume() {
    static const auto method = javaClassStatic()->getMethod<double()>("getVolume");
    auto __result = method(_javaPart);
    return __result;
  }
  void JHybridPlaybackEngineSpec::setVolume(double volume) {
    static const auto method = javaClassStatic()->getMethod<void(double /* volume */)>("setVolume");
    method(_javaPart, volume);
  }
  double JHybridPlaybackEngineSpec::getRate() {
    static const auto method = javaClassStatic()->getMethod<double()>("getRate");
    auto __result = method(_javaPart);
    return __result;
  }
  void JHybridPlaybackEngineSpec::setRate(double rate) {
    static const auto method = javaClassStatic()->getMethod<void(double /* rate */)>("setRate");
    method(_javaPart, rate);
  }
  bool JHybridPlaybackEngineSpec::getMuted() {
    static const auto method = javaClassStatic()->getMethod<jboolean()>("getMuted");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }
  void JHybridPlaybackEngineSpec::setMuted(bool muted) {
    static const auto method = javaClassStatic()->getMethod<void(jboolean /* muted */)>("setMuted");
    method(_javaPart, muted);
  }
  bool JHybridPlaybackEngineSpec::getLoop() {
    static const auto method = javaClassStatic()->getMethod<jboolean()>("getLoop");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }
  void JHybridPlaybackEngineSpec::setLoop(bool loop) {
    static const auto method = javaClassStatic()->getMethod<void(jboolean /* loop */)>("setLoop");
    method(_javaPart, loop);
  }
  std::vector<std::shared_ptr<HybridMediaItemSpec>> JHybridPlaybackEngineSpec::getQueueItems() {
    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JHybridMediaItemSpec::javaobject>>()>("getQueueItems");
    auto __result = method(_javaPart);
    return [&]() {
      size_t __size = __result->size();
      std::vector<std::shared_ptr<HybridMediaItemSpec>> __vector;
      __vector.reserve(__size);
      for (size_t __i = 0; __i < __size; __i++) {
        auto __element = __result->getElement(__i);
        __vector.push_back(__element->cthis()->shared_cast<JHybridMediaItemSpec>());
      }
      return __vector;
    }();
  }
  double JHybridPlaybackEngineSpec::getQueueIndex() {
    static const auto method = javaClassStatic()->getMethod<double()>("getQueueIndex");
    auto __result = method(_javaPart);
    return __result;
  }
  double JHybridPlaybackEngineSpec::getQueueCount() {
    static const auto method = javaClassStatic()->getMethod<double()>("getQueueCount");
    auto __result = method(_javaPart);
    return __result;
  }
  RepeatMode JHybridPlaybackEngineSpec::getRepeatMode() {
    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JRepeatMode>()>("getRepeatMode");
    auto __result = method(_javaPart);
    return __result->toCpp();
  }
  void JHybridPlaybackEngineSpec::setRepeatMode(RepeatMode repeatMode) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRepeatMode> /* repeatMode */)>("setRepeatMode");
    method(_javaPart, JRepeatMode::fromCpp(repeatMode));
  }
  bool JHybridPlaybackEngineSpec::getShuffleEnabled() {
    static const auto method = javaClassStatic()->getMethod<jboolean()>("getShuffleEnabled");
    auto __result = method(_javaPart);
    return static_cast<bool>(__result);
  }
  void JHybridPlaybackEngineSpec::setShuffleEnabled(bool shuffleEnabled) {
    static const auto method = javaClassStatic()->getMethod<void(jboolean /* shuffleEnabled */)>("setShuffleEnabled");
    method(_javaPart, shuffleEnabled);
  }

  // Methods
  std::shared_ptr<Promise<void>> JHybridPlaybackEngineSpec::load(const std::shared_ptr<HybridMediaItemSpec>& item) {
    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JHybridMediaItemSpec::javaobject> /* item */)>("load");
    auto __result = method(_javaPart, std::dynamic_pointer_cast<JHybridMediaItemSpec>(item)->getJavaPart());
    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>> JHybridPlaybackEngineSpec::loadAndPlay(const std::shared_ptr<HybridMediaItemSpec>& item) {
    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JHybridMediaItemSpec::javaobject> /* item */)>("loadAndPlay");
    auto __result = method(_javaPart, std::dynamic_pointer_cast<JHybridMediaItemSpec>(item)->getJavaPart());
    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>> JHybridPlaybackEngineSpec::play() {
    static const auto method = 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>> JHybridPlaybackEngineSpec::pause() {
    static const auto method = 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>> JHybridPlaybackEngineSpec::stop() {
    static const auto method = 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>> JHybridPlaybackEngineSpec::seekTo(double positionMs) {
    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(double /* positionMs */)>("seekTo");
    auto __result = method(_javaPart, positionMs);
    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;
    }();
  }
  void JHybridPlaybackEngineSpec::release() {
    static const auto method = javaClassStatic()->getMethod<void()>("release");
    method(_javaPart);
  }
  void JHybridPlaybackEngineSpec::activateDefaultDecoder() {
    static const auto method = javaClassStatic()->getMethod<void()>("activateDefaultDecoder");
    method(_javaPart);
  }
  void JHybridPlaybackEngineSpec::setQueue(const std::vector<std::shared_ptr<HybridMediaItemSpec>>& items) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JHybridMediaItemSpec::javaobject>> /* items */)>("setQueue");
    method(_javaPart, [&]() {
      size_t __size = items.size();
      jni::local_ref<jni::JArrayClass<JHybridMediaItemSpec::javaobject>> __array = jni::JArrayClass<JHybridMediaItemSpec::javaobject>::newArray(__size);
      for (size_t __i = 0; __i < __size; __i++) {
        const auto& __element = items[__i];
        auto __elementJni = std::dynamic_pointer_cast<JHybridMediaItemSpec>(__element)->getJavaPart();
        __array->setElement(__i, __elementJni.get());
      }
      return __array;
    }());
  }
  void JHybridPlaybackEngineSpec::addToQueue(const std::shared_ptr<HybridMediaItemSpec>& item) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JHybridMediaItemSpec::javaobject> /* item */)>("addToQueue");
    method(_javaPart, std::dynamic_pointer_cast<JHybridMediaItemSpec>(item)->getJavaPart());
  }
  void JHybridPlaybackEngineSpec::insertInQueue(const std::shared_ptr<HybridMediaItemSpec>& item, double afterIndex) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JHybridMediaItemSpec::javaobject> /* item */, double /* afterIndex */)>("insertInQueue");
    method(_javaPart, std::dynamic_pointer_cast<JHybridMediaItemSpec>(item)->getJavaPart(), afterIndex);
  }
  void JHybridPlaybackEngineSpec::removeFromQueue(double index) {
    static const auto method = javaClassStatic()->getMethod<void(double /* index */)>("removeFromQueue");
    method(_javaPart, index);
  }
  void JHybridPlaybackEngineSpec::moveInQueue(double fromIndex, double toIndex) {
    static const auto method = javaClassStatic()->getMethod<void(double /* fromIndex */, double /* toIndex */)>("moveInQueue");
    method(_javaPart, fromIndex, toIndex);
  }
  void JHybridPlaybackEngineSpec::clearQueue() {
    static const auto method = javaClassStatic()->getMethod<void()>("clearQueue");
    method(_javaPart);
  }
  std::shared_ptr<Promise<void>> JHybridPlaybackEngineSpec::skipToNext() {
    static const auto method = 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>> JHybridPlaybackEngineSpec::skipToPrevious() {
    static const auto method = 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>> JHybridPlaybackEngineSpec::skipToIndex(double index, bool autoPlay) {
    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(double /* index */, jboolean /* autoPlay */)>("skipToIndex");
    auto __result = method(_javaPart, index, autoPlay);
    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;
    }();
  }
  void JHybridPlaybackEngineSpec::setEnabledCommands(const std::vector<RemoteCommand>& commands) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JRemoteCommand>> /* commands */)>("setEnabledCommands");
    method(_javaPart, [&]() {
      size_t __size = commands.size();
      jni::local_ref<jni::JArrayClass<JRemoteCommand>> __array = jni::JArrayClass<JRemoteCommand>::newArray(__size);
      for (size_t __i = 0; __i < __size; __i++) {
        const auto& __element = commands[__i];
        auto __elementJni = JRemoteCommand::fromCpp(__element);
        __array->setElement(__i, *__elementJni);
      }
      return __array;
    }());
  }
  void JHybridPlaybackEngineSpec::setCompactCommands(const std::vector<RemoteCommand>& commands) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JRemoteCommand>> /* commands */)>("setCompactCommands");
    method(_javaPart, [&]() {
      size_t __size = commands.size();
      jni::local_ref<jni::JArrayClass<JRemoteCommand>> __array = jni::JArrayClass<JRemoteCommand>::newArray(__size);
      for (size_t __i = 0; __i < __size; __i++) {
        const auto& __element = commands[__i];
        auto __elementJni = JRemoteCommand::fromCpp(__element);
        __array->setElement(__i, *__elementJni);
      }
      return __array;
    }());
  }
  void JHybridPlaybackEngineSpec::setSkipIntervalMs(double intervalMs) {
    static const auto method = javaClassStatic()->getMethod<void(double /* intervalMs */)>("setSkipIntervalMs");
    method(_javaPart, intervalMs);
  }
  void JHybridPlaybackEngineSpec::updateNowPlaying(const NowPlayingInfo& info) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JNowPlayingInfo> /* info */)>("updateNowPlaying");
    method(_javaPart, JNowPlayingInfo::fromCpp(info));
  }
  void JHybridPlaybackEngineSpec::overrideRemoteCommand(RemoteCommand command) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRemoteCommand> /* command */)>("overrideRemoteCommand");
    method(_javaPart, JRemoteCommand::fromCpp(command));
  }
  void JHybridPlaybackEngineSpec::clearRemoteCommandOverride(RemoteCommand command) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRemoteCommand> /* command */)>("clearRemoteCommandOverride");
    method(_javaPart, JRemoteCommand::fromCpp(command));
  }
  void JHybridPlaybackEngineSpec::setAudioSession(const std::shared_ptr<HybridAudioSessionSpec>& session) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JHybridAudioSessionSpec::javaobject> /* session */)>("setAudioSession");
    method(_javaPart, std::dynamic_pointer_cast<JHybridAudioSessionSpec>(session)->getJavaPart());
  }
  void JHybridPlaybackEngineSpec::clearCallbacks() {
    static const auto method = javaClassStatic()->getMethod<void()>("clearCallbacks");
    method(_javaPart);
  }
  void JHybridPlaybackEngineSpec::onStateChange(const std::function<void(PlaybackState /* state */)>& callback) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_PlaybackState::javaobject> /* callback */)>("onStateChange_cxx");
    method(_javaPart, JFunc_void_PlaybackState_cxx::fromCpp(callback));
  }
  void JHybridPlaybackEngineSpec::onMediaPositionChange(const std::function<void(const MediaPosition& /* position */)>& callback) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_MediaPosition::javaobject> /* callback */)>("onMediaPositionChange_cxx");
    method(_javaPart, JFunc_void_MediaPosition_cxx::fromCpp(callback));
  }
  void JHybridPlaybackEngineSpec::onCurrentItemChange(const std::function<void(const std::optional<std::shared_ptr<HybridMediaItemSpec>>& /* item */, ItemSource /* source */)>& callback) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__optional_std__shared_ptr_HybridMediaItemSpec___ItemSource::javaobject> /* callback */)>("onCurrentItemChange_cxx");
    method(_javaPart, JFunc_void_std__optional_std__shared_ptr_HybridMediaItemSpec___ItemSource_cxx::fromCpp(callback));
  }
  void JHybridPlaybackEngineSpec::onRemoteCommand(const std::function<void(const RemoteCommandEvent& /* event */)>& callback) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_RemoteCommandEvent::javaobject> /* callback */)>("onRemoteCommand_cxx");
    method(_javaPart, JFunc_void_RemoteCommandEvent_cxx::fromCpp(callback));
  }
  void JHybridPlaybackEngineSpec::onError(const std::function<void(const std::string& /* message */, const std::string& /* code */)>& callback) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_std__string_std__string::javaobject> /* callback */)>("onError_cxx");
    method(_javaPart, JFunc_void_std__string_std__string_cxx::fromCpp(callback));
  }
  void JHybridPlaybackEngineSpec::onPlaybackEnded(const std::function<void()>& callback) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* callback */)>("onPlaybackEnded_cxx");
    method(_javaPart, JFunc_void_cxx::fromCpp(callback));
  }
  void JHybridPlaybackEngineSpec::onQueueEnd(const std::function<void()>& callback) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* callback */)>("onQueueEnd_cxx");
    method(_javaPart, JFunc_void_cxx::fromCpp(callback));
  }
  void JHybridPlaybackEngineSpec::onQueueChange(const std::function<void()>& callback) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void::javaobject> /* callback */)>("onQueueChange_cxx");
    method(_javaPart, JFunc_void_cxx::fromCpp(callback));
  }
  void JHybridPlaybackEngineSpec::onPlaybackMetric(const std::function<void(const PlaybackMetricEvent& /* event */)>& callback) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_PlaybackMetricEvent::javaobject> /* callback */)>("onPlaybackMetric_cxx");
    method(_javaPart, JFunc_void_PlaybackMetricEvent_cxx::fromCpp(callback));
  }
  void JHybridPlaybackEngineSpec::onTracksAvailable(const std::function<void(const AvailableTracks& /* tracks */)>& callback) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_AvailableTracks::javaobject> /* callback */)>("onTracksAvailable_cxx");
    method(_javaPart, JFunc_void_AvailableTracks_cxx::fromCpp(callback));
  }
  void JHybridPlaybackEngineSpec::onDomainEvent(const std::function<void(const DomainEvent& /* event */)>& callback) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JFunc_void_DomainEvent::javaobject> /* callback */)>("onDomainEvent_cxx");
    method(_javaPart, JFunc_void_DomainEvent_cxx::fromCpp(callback));
  }
  void JHybridPlaybackEngineSpec::setInterruptionMode(AviationInterruptionMode mode) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JAviationInterruptionMode> /* mode */)>("setInterruptionMode");
    method(_javaPart, JAviationInterruptionMode::fromCpp(mode));
  }
  void JHybridPlaybackEngineSpec::setBecomingNoisyBehavior(BecomingNoisyBehavior behavior) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JBecomingNoisyBehavior> /* behavior */)>("setBecomingNoisyBehavior");
    method(_javaPart, JBecomingNoisyBehavior::fromCpp(behavior));
  }
  void JHybridPlaybackEngineSpec::selectVideoTrack(const VideoTrackSelection& selection) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JVideoTrackSelection> /* selection */)>("selectVideoTrack");
    method(_javaPart, JVideoTrackSelection::fromCpp(selection));
  }
  void JHybridPlaybackEngineSpec::selectSubtitleTrack(const SubtitleTrackSelection& selection) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JSubtitleTrackSelection> /* selection */)>("selectSubtitleTrack");
    method(_javaPart, JSubtitleTrackSelection::fromCpp(selection));
  }
  void JHybridPlaybackEngineSpec::selectAudioTrack(const AudioTrackSelection& selection) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JAudioTrackSelection> /* selection */)>("selectAudioTrack");
    method(_javaPart, JAudioTrackSelection::fromCpp(selection));
  }
  std::shared_ptr<Promise<void>> JHybridPlaybackEngineSpec::clearCache() {
    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("clearCache");
    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;
    }();
  }
  double JHybridPlaybackEngineSpec::getCacheSize() {
    static const auto method = javaClassStatic()->getMethod<double()>("getCacheSize");
    auto __result = method(_javaPart);
    return __result;
  }
  bool JHybridPlaybackEngineSpec::isCached(const std::string& uri) {
    static const auto method = javaClassStatic()->getMethod<jboolean(jni::alias_ref<jni::JString> /* uri */)>("isCached");
    auto __result = method(_javaPart, jni::make_jstring(uri));
    return static_cast<bool>(__result);
  }
  void JHybridPlaybackEngineSpec::setCacheEnabled(bool enabled) {
    static const auto method = javaClassStatic()->getMethod<void(jboolean /* enabled */)>("setCacheEnabled");
    method(_javaPart, enabled);
  }
  void JHybridPlaybackEngineSpec::preload(const std::vector<std::shared_ptr<HybridMediaItemSpec>>& items) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JArrayClass<JHybridMediaItemSpec::javaobject>> /* items */)>("preload");
    method(_javaPart, [&]() {
      size_t __size = items.size();
      jni::local_ref<jni::JArrayClass<JHybridMediaItemSpec::javaobject>> __array = jni::JArrayClass<JHybridMediaItemSpec::javaobject>::newArray(__size);
      for (size_t __i = 0; __i < __size; __i++) {
        const auto& __element = items[__i];
        auto __elementJni = std::dynamic_pointer_cast<JHybridMediaItemSpec>(__element)->getJavaPart();
        __array->setElement(__i, __elementJni.get());
      }
      return __array;
    }());
  }
  void JHybridPlaybackEngineSpec::setPreloadConfig(const PreloadConfig& config) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JPreloadConfig> /* config */)>("setPreloadConfig");
    method(_javaPart, JPreloadConfig::fromCpp(config));
  }
  void JHybridPlaybackEngineSpec::setBufferConfig(const BufferConfig& config) {
    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JBufferConfig> /* config */)>("setBufferConfig");
    method(_javaPart, JBufferConfig::fromCpp(config));
  }
  void JHybridPlaybackEngineSpec::setCacheMaxSize(double sizeBytes) {
    static const auto method = javaClassStatic()->getMethod<void(double /* sizeBytes */)>("setCacheMaxSize");
    method(_javaPart, sizeBytes);
  }
  void JHybridPlaybackEngineSpec::setPreloadEnabled(bool enabled) {
    static const auto method = javaClassStatic()->getMethod<void(jboolean /* enabled */)>("setPreloadEnabled");
    method(_javaPart, enabled);
  }

} // namespace margelo::nitro::aviation