react-native-queue-player 1.0.0

package/nitrogen/generated/shared/c++/HybridCastManagerSpec.cpp

@@ -0,0 +1,42 @@
+///
+/// HybridCastManagerSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridCastManagerSpec.hpp"
+
+namespace margelo::nitro::queueplayer {
+
+  void HybridCastManagerSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("getSupportedProtocols", &HybridCastManagerSpec::getSupportedProtocols);
+      prototype.registerHybridMethod("configure", &HybridCastManagerSpec::configure);
+      prototype.registerHybridMethod("startDiscovery", &HybridCastManagerSpec::startDiscovery);
+      prototype.registerHybridMethod("stopDiscovery", &HybridCastManagerSpec::stopDiscovery);
+      prototype.registerHybridMethod("isDiscovering", &HybridCastManagerSpec::isDiscovering);
+      prototype.registerHybridMethod("getReceivers", &HybridCastManagerSpec::getReceivers);
+      prototype.registerHybridMethod("getCurrentRoute", &HybridCastManagerSpec::getCurrentRoute);
+      prototype.registerHybridMethod("connect", &HybridCastManagerSpec::connect);
+      prototype.registerHybridMethod("disconnect", &HybridCastManagerSpec::disconnect);
+      prototype.registerHybridMethod("showSystemPicker", &HybridCastManagerSpec::showSystemPicker);
+      prototype.registerHybridMethod("getRouteVolume", &HybridCastManagerSpec::getRouteVolume);
+      prototype.registerHybridMethod("setRouteVolume", &HybridCastManagerSpec::setRouteVolume);
+      prototype.registerHybridMethod("submitPairingPin", &HybridCastManagerSpec::submitPairingPin);
+      prototype.registerHybridMethod("getLocalNetworkPermissionState", &HybridCastManagerSpec::getLocalNetworkPermissionState);
+      prototype.registerHybridMethod("requestLocalNetworkPermission", &HybridCastManagerSpec::requestLocalNetworkPermission);
+      prototype.registerHybridMethod("onRouteChange", &HybridCastManagerSpec::onRouteChange);
+      prototype.registerHybridMethod("onReceiversChange", &HybridCastManagerSpec::onReceiversChange);
+      prototype.registerHybridMethod("onDiscoveryStateChange", &HybridCastManagerSpec::onDiscoveryStateChange);
+      prototype.registerHybridMethod("onSessionDied", &HybridCastManagerSpec::onSessionDied);
+      prototype.registerHybridMethod("onLocalNetworkPermissionChange", &HybridCastManagerSpec::onLocalNetworkPermissionChange);
+      prototype.registerHybridMethod("getCurrentAudioRoute", &HybridCastManagerSpec::getCurrentAudioRoute);
+      prototype.registerHybridMethod("onAudioRouteChange", &HybridCastManagerSpec::onAudioRouteChange);
+    });
+  }
+
+} // namespace margelo::nitro::queueplayer

package/nitrogen/generated/shared/c++/HybridCastManagerSpec.hpp

@@ -0,0 +1,115 @@
+///
+/// HybridCastManagerSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `CastProtocol` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class CastProtocol; }
+// Forward declaration of `CastConfigureOptions` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct CastConfigureOptions; }
+// Forward declaration of `CastReceiver` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct CastReceiver; }
+// Forward declaration of `CastRoute` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct CastRoute; }
+// Forward declaration of `CastConnectOptions` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct CastConnectOptions; }
+// Forward declaration of `CastLocalNetworkPermission` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class CastLocalNetworkPermission; }
+// Forward declaration of `CastDiscoveryState` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct CastDiscoveryState; }
+// Forward declaration of `CastSessionDiedEvent` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct CastSessionDiedEvent; }
+// Forward declaration of `CastLocalNetworkPermissionEvent` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct CastLocalNetworkPermissionEvent; }
+// Forward declaration of `AudioRoute` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct AudioRoute; }
+
+#include "CastProtocol.hpp"
+#include <vector>
+#include <NitroModules/Promise.hpp>
+#include "CastConfigureOptions.hpp"
+#include "CastReceiver.hpp"
+#include "CastRoute.hpp"
+#include <string>
+#include "CastConnectOptions.hpp"
+#include "CastLocalNetworkPermission.hpp"
+#include <functional>
+#include "CastDiscoveryState.hpp"
+#include "CastSessionDiedEvent.hpp"
+#include "CastLocalNetworkPermissionEvent.hpp"
+#include "AudioRoute.hpp"
+
+namespace margelo::nitro::queueplayer {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `CastManager`
+   * Inherit this class to create instances of `HybridCastManagerSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCastManager: public HybridCastManagerSpec {
+   * public:
+   *   HybridCastManager(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCastManagerSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCastManagerSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCastManagerSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::vector<CastProtocol> getSupportedProtocols() = 0;
+      virtual std::shared_ptr<Promise<void>> configure(const CastConfigureOptions& config) = 0;
+      virtual std::shared_ptr<Promise<void>> startDiscovery() = 0;
+      virtual std::shared_ptr<Promise<void>> stopDiscovery() = 0;
+      virtual bool isDiscovering() = 0;
+      virtual std::vector<CastReceiver> getReceivers() = 0;
+      virtual CastRoute getCurrentRoute() = 0;
+      virtual std::shared_ptr<Promise<void>> connect(const std::string& receiverId, const CastConnectOptions& options) = 0;
+      virtual std::shared_ptr<Promise<void>> disconnect() = 0;
+      virtual std::shared_ptr<Promise<void>> showSystemPicker() = 0;
+      virtual double getRouteVolume() = 0;
+      virtual std::shared_ptr<Promise<void>> setRouteVolume(double value) = 0;
+      virtual std::shared_ptr<Promise<void>> submitPairingPin(const std::string& pin) = 0;
+      virtual CastLocalNetworkPermission getLocalNetworkPermissionState() = 0;
+      virtual std::shared_ptr<Promise<CastLocalNetworkPermission>> requestLocalNetworkPermission() = 0;
+      virtual std::function<void()> onRouteChange(const std::function<void(const CastRoute& /* route */)>& callback) = 0;
+      virtual std::function<void()> onReceiversChange(const std::function<void(const std::vector<CastReceiver>& /* receivers */)>& callback) = 0;
+      virtual std::function<void()> onDiscoveryStateChange(const std::function<void(const CastDiscoveryState& /* state */)>& callback) = 0;
+      virtual std::function<void()> onSessionDied(const std::function<void(const CastSessionDiedEvent& /* event */)>& callback) = 0;
+      virtual std::function<void()> onLocalNetworkPermissionChange(const std::function<void(const CastLocalNetworkPermissionEvent& /* event */)>& callback) = 0;
+      virtual AudioRoute getCurrentAudioRoute() = 0;
+      virtual std::function<void()> onAudioRouteChange(const std::function<void(const AudioRoute& /* route */)>& callback) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "CastManager";
+  };
+
+} // namespace margelo::nitro::queueplayer

package/nitrogen/generated/shared/c++/HybridEqualizerSpec.cpp

@@ -0,0 +1,32 @@
+///
+/// HybridEqualizerSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridEqualizerSpec.hpp"
+
+namespace margelo::nitro::queueplayer {
+
+  void HybridEqualizerSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("setEnabled", &HybridEqualizerSpec::setEnabled);
+      prototype.registerHybridMethod("isEnabled", &HybridEqualizerSpec::isEnabled);
+      prototype.registerHybridMethod("getBands", &HybridEqualizerSpec::getBands);
+      prototype.registerHybridMethod("setBandGain", &HybridEqualizerSpec::setBandGain);
+      prototype.registerHybridMethod("setAllBandGains", &HybridEqualizerSpec::setAllBandGains);
+      prototype.registerHybridMethod("applyPreset", &HybridEqualizerSpec::applyPreset);
+      prototype.registerHybridMethod("getPresets", &HybridEqualizerSpec::getPresets);
+      prototype.registerHybridMethod("saveCustomPreset", &HybridEqualizerSpec::saveCustomPreset);
+      prototype.registerHybridMethod("deleteCustomPreset", &HybridEqualizerSpec::deleteCustomPreset);
+      prototype.registerHybridMethod("reset", &HybridEqualizerSpec::reset);
+      prototype.registerHybridMethod("onBandChange", &HybridEqualizerSpec::onBandChange);
+      prototype.registerHybridMethod("onEnabledChange", &HybridEqualizerSpec::onEnabledChange);
+    });
+  }
+
+} // namespace margelo::nitro::queueplayer

package/nitrogen/generated/shared/c++/HybridEqualizerSpec.hpp

@@ -0,0 +1,81 @@
+///
+/// HybridEqualizerSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `EqualizerBand` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct EqualizerBand; }
+// Forward declaration of `EqualizerPreset` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct EqualizerPreset; }
+
+#include <NitroModules/Promise.hpp>
+#include "EqualizerBand.hpp"
+#include <vector>
+#include <string>
+#include "EqualizerPreset.hpp"
+#include <functional>
+
+namespace margelo::nitro::queueplayer {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Equalizer`
+   * Inherit this class to create instances of `HybridEqualizerSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridEqualizer: public HybridEqualizerSpec {
+   * public:
+   *   HybridEqualizer(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridEqualizerSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridEqualizerSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridEqualizerSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<void>> setEnabled(bool enabled) = 0;
+      virtual bool isEnabled() = 0;
+      virtual std::vector<EqualizerBand> getBands() = 0;
+      virtual std::shared_ptr<Promise<void>> setBandGain(double index, double gainDb) = 0;
+      virtual std::shared_ptr<Promise<void>> setAllBandGains(const std::vector<double>& gains) = 0;
+      virtual std::shared_ptr<Promise<void>> applyPreset(const std::string& name) = 0;
+      virtual std::vector<EqualizerPreset> getPresets() = 0;
+      virtual std::shared_ptr<Promise<void>> saveCustomPreset(const std::string& name) = 0;
+      virtual std::shared_ptr<Promise<void>> deleteCustomPreset(const std::string& name) = 0;
+      virtual std::shared_ptr<Promise<void>> reset() = 0;
+      virtual std::function<void()> onBandChange(const std::function<void(const std::vector<EqualizerBand>& /* bands */)>& callback) = 0;
+      virtual std::function<void()> onEnabledChange(const std::function<void(bool /* enabled */)>& callback) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Equalizer";
+  };
+
+} // namespace margelo::nitro::queueplayer

package/nitrogen/generated/shared/c++/HybridTrackPlayerSpec.cpp

@@ -0,0 +1,88 @@
+///
+/// HybridTrackPlayerSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridTrackPlayerSpec.hpp"
+
+namespace margelo::nitro::queueplayer {
+
+  void HybridTrackPlayerSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("configure", &HybridTrackPlayerSpec::configure);
+      prototype.registerHybridMethod("destroy", &HybridTrackPlayerSpec::destroy);
+      prototype.registerHybridMethod("setQueue", &HybridTrackPlayerSpec::setQueue);
+      prototype.registerHybridMethod("addToQueue", &HybridTrackPlayerSpec::addToQueue);
+      prototype.registerHybridMethod("removeFromQueue", &HybridTrackPlayerSpec::removeFromQueue);
+      prototype.registerHybridMethod("moveInQueue", &HybridTrackPlayerSpec::moveInQueue);
+      prototype.registerHybridMethod("getQueue", &HybridTrackPlayerSpec::getQueue);
+      prototype.registerHybridMethod("clearQueue", &HybridTrackPlayerSpec::clearQueue);
+      prototype.registerHybridMethod("play", &HybridTrackPlayerSpec::play);
+      prototype.registerHybridMethod("pause", &HybridTrackPlayerSpec::pause);
+      prototype.registerHybridMethod("stop", &HybridTrackPlayerSpec::stop);
+      prototype.registerHybridMethod("retry", &HybridTrackPlayerSpec::retry);
+      prototype.registerHybridMethod("seekTo", &HybridTrackPlayerSpec::seekTo);
+      prototype.registerHybridMethod("skipToIndex", &HybridTrackPlayerSpec::skipToIndex);
+      prototype.registerHybridMethod("skipToNext", &HybridTrackPlayerSpec::skipToNext);
+      prototype.registerHybridMethod("skipToPrevious", &HybridTrackPlayerSpec::skipToPrevious);
+      prototype.registerHybridMethod("setPlaybackMode", &HybridTrackPlayerSpec::setPlaybackMode);
+      prototype.registerHybridMethod("getPlaybackMode", &HybridTrackPlayerSpec::getPlaybackMode);
+      prototype.registerHybridMethod("setPlaybackSpeed", &HybridTrackPlayerSpec::setPlaybackSpeed);
+      prototype.registerHybridMethod("setPitchCorrectionMode", &HybridTrackPlayerSpec::setPitchCorrectionMode);
+      prototype.registerHybridMethod("setVolume", &HybridTrackPlayerSpec::setVolume);
+      prototype.registerHybridMethod("setRepeatMode", &HybridTrackPlayerSpec::setRepeatMode);
+      prototype.registerHybridMethod("setRemoteControls", &HybridTrackPlayerSpec::setRemoteControls);
+      prototype.registerHybridMethod("setSleepTimer", &HybridTrackPlayerSpec::setSleepTimer);
+      prototype.registerHybridMethod("setSleepTimerToTrackEnd", &HybridTrackPlayerSpec::setSleepTimerToTrackEnd);
+      prototype.registerHybridMethod("clearSleepTimer", &HybridTrackPlayerSpec::clearSleepTimer);
+      prototype.registerHybridMethod("shuffleQueue", &HybridTrackPlayerSpec::shuffleQueue);
+      prototype.registerHybridMethod("getState", &HybridTrackPlayerSpec::getState);
+      prototype.registerHybridMethod("getCurrentTrackIndex", &HybridTrackPlayerSpec::getCurrentTrackIndex);
+      prototype.registerHybridMethod("getCurrentTrackSource", &HybridTrackPlayerSpec::getCurrentTrackSource);
+      prototype.registerHybridMethod("getPlaybackSpeed", &HybridTrackPlayerSpec::getPlaybackSpeed);
+      prototype.registerHybridMethod("getPitchCorrectionMode", &HybridTrackPlayerSpec::getPitchCorrectionMode);
+      prototype.registerHybridMethod("getVolume", &HybridTrackPlayerSpec::getVolume);
+      prototype.registerHybridMethod("getRemoteControls", &HybridTrackPlayerSpec::getRemoteControls);
+      prototype.registerHybridMethod("getBufferState", &HybridTrackPlayerSpec::getBufferState);
+      prototype.registerHybridMethod("getIsSeekable", &HybridTrackPlayerSpec::getIsSeekable);
+      prototype.registerHybridMethod("isFullyBuffered", &HybridTrackPlayerSpec::isFullyBuffered);
+      prototype.registerHybridMethod("getCanSkipNext", &HybridTrackPlayerSpec::getCanSkipNext);
+      prototype.registerHybridMethod("getCanSkipPrevious", &HybridTrackPlayerSpec::getCanSkipPrevious);
+      prototype.registerHybridMethod("getSkipCapability", &HybridTrackPlayerSpec::getSkipCapability);
+      prototype.registerHybridMethod("getSleepTimer", &HybridTrackPlayerSpec::getSleepTimer);
+      prototype.registerHybridMethod("onStateChange", &HybridTrackPlayerSpec::onStateChange);
+      prototype.registerHybridMethod("onTrackChange", &HybridTrackPlayerSpec::onTrackChange);
+      prototype.registerHybridMethod("onProgress", &HybridTrackPlayerSpec::onProgress);
+      prototype.registerHybridMethod("onPlaybackMilestone", &HybridTrackPlayerSpec::onPlaybackMilestone);
+      prototype.registerHybridMethod("onError", &HybridTrackPlayerSpec::onError);
+      prototype.registerHybridMethod("onQueueEnd", &HybridTrackPlayerSpec::onQueueEnd);
+      prototype.registerHybridMethod("onSkipCapabilityChange", &HybridTrackPlayerSpec::onSkipCapabilityChange);
+      prototype.registerHybridMethod("onSleepTimerChange", &HybridTrackPlayerSpec::onSleepTimerChange);
+      prototype.registerHybridMethod("onBufferStateChange", &HybridTrackPlayerSpec::onBufferStateChange);
+      prototype.registerHybridMethod("onFullyBufferedChange", &HybridTrackPlayerSpec::onFullyBufferedChange);
+      prototype.registerHybridMethod("setBrowseSnapshot", &HybridTrackPlayerSpec::setBrowseSnapshot);
+      prototype.registerHybridMethod("onBrowseRequest", &HybridTrackPlayerSpec::onBrowseRequest);
+      prototype.registerHybridMethod("onSearchRequest", &HybridTrackPlayerSpec::onSearchRequest);
+      prototype.registerHybridMethod("onPlayFromSearchRequest", &HybridTrackPlayerSpec::onPlayFromSearchRequest);
+      prototype.registerHybridMethod("onPlayFromIdRequest", &HybridTrackPlayerSpec::onPlayFromIdRequest);
+      prototype.registerHybridMethod("donateVoiceVocabulary", &HybridTrackPlayerSpec::donateVoiceVocabulary);
+      prototype.registerHybridMethod("onCarConnect", &HybridTrackPlayerSpec::onCarConnect);
+      prototype.registerHybridMethod("onCarDisconnect", &HybridTrackPlayerSpec::onCarDisconnect);
+      prototype.registerHybridMethod("onServiceReady", &HybridTrackPlayerSpec::onServiceReady);
+      prototype.registerHybridMethod("setLookaheadCache", &HybridTrackPlayerSpec::setLookaheadCache);
+      prototype.registerHybridMethod("getLookaheadCacheStatus", &HybridTrackPlayerSpec::getLookaheadCacheStatus);
+      prototype.registerHybridMethod("clearLookaheadCache", &HybridTrackPlayerSpec::clearLookaheadCache);
+      prototype.registerHybridMethod("onCacheStatusChange", &HybridTrackPlayerSpec::onCacheStatusChange);
+      prototype.registerHybridMethod("setReplayGainMode", &HybridTrackPlayerSpec::setReplayGainMode);
+      prototype.registerHybridMethod("getReplayGainMode", &HybridTrackPlayerSpec::getReplayGainMode);
+      prototype.registerHybridMethod("getNowPlayingFormat", &HybridTrackPlayerSpec::getNowPlayingFormat);
+      prototype.registerHybridMethod("onNowPlayingFormatChange", &HybridTrackPlayerSpec::onNowPlayingFormatChange);
+    });
+  }
+
+} // namespace margelo::nitro::queueplayer

package/nitrogen/generated/shared/c++/HybridTrackPlayerSpec.hpp

@@ -0,0 +1,209 @@
+///
+/// HybridTrackPlayerSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `PlayerConfig` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct PlayerConfig; }
+// 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 `PitchCorrectionMode` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class PitchCorrectionMode; }
+// Forward declaration of `RepeatMode` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class RepeatMode; }
+// Forward declaration of `RemoteControlOptions` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct RemoteControlOptions; }
+// 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 `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 `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 `BrowseSnapshot` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct BrowseSnapshot; }
+// 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 `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; }
+// 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; }
+
+#include <NitroModules/Promise.hpp>
+#include "PlayerConfig.hpp"
+#include "TrackItem.hpp"
+#include <vector>
+#include <optional>
+#include "PlaybackMode.hpp"
+#include "PitchCorrectionMode.hpp"
+#include "RepeatMode.hpp"
+#include "RemoteControlOptions.hpp"
+#include "ShuffleResult.hpp"
+#include "PlayerState.hpp"
+#include "TrackSource.hpp"
+#include "BufferState.hpp"
+#include "SkipCapability.hpp"
+#include "SleepTimerState.hpp"
+#include <functional>
+#include "StateChangeReason.hpp"
+#include "TrackChangeReason.hpp"
+#include "PlayerProgress.hpp"
+#include "PlaybackError.hpp"
+#include "BrowseSnapshot.hpp"
+#include "BrowseItem.hpp"
+#include <string>
+#include "MediaSearchRequest.hpp"
+#include "VoiceVocabulary.hpp"
+#include "ServiceReadyReason.hpp"
+#include "LookaheadCacheConfig.hpp"
+#include "CacheStatus.hpp"
+#include "ReplayGainMode.hpp"
+#include <NitroModules/Null.hpp>
+#include "NowPlayingFormat.hpp"
+#include <variant>
+
+namespace margelo::nitro::queueplayer {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `TrackPlayer`
+   * Inherit this class to create instances of `HybridTrackPlayerSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridTrackPlayer: public HybridTrackPlayerSpec {
+   * public:
+   *   HybridTrackPlayer(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridTrackPlayerSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridTrackPlayerSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridTrackPlayerSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<void>> configure(const PlayerConfig& config) = 0;
+      virtual std::shared_ptr<Promise<void>> destroy() = 0;
+      virtual std::shared_ptr<Promise<void>> setQueue(const std::vector<TrackItem>& tracks, std::optional<double> startAtIndex) = 0;
+      virtual std::shared_ptr<Promise<void>> addToQueue(const std::vector<TrackItem>& tracks, std::optional<double> insertBefore) = 0;
+      virtual std::shared_ptr<Promise<void>> removeFromQueue(const std::vector<double>& indices) = 0;
+      virtual std::shared_ptr<Promise<void>> moveInQueue(double fromIndex, double toIndex) = 0;
+      virtual std::vector<TrackItem> getQueue() = 0;
+      virtual std::shared_ptr<Promise<void>> clearQueue() = 0;
+      virtual std::shared_ptr<Promise<void>> play() = 0;
+      virtual std::shared_ptr<Promise<void>> pause() = 0;
+      virtual std::shared_ptr<Promise<void>> stop() = 0;
+      virtual std::shared_ptr<Promise<void>> retry() = 0;
+      virtual std::shared_ptr<Promise<void>> seekTo(double position) = 0;
+      virtual std::shared_ptr<Promise<void>> skipToIndex(double index) = 0;
+      virtual std::shared_ptr<Promise<void>> skipToNext() = 0;
+      virtual std::shared_ptr<Promise<void>> skipToPrevious() = 0;
+      virtual std::shared_ptr<Promise<void>> setPlaybackMode(const PlaybackMode& mode) = 0;
+      virtual PlaybackMode getPlaybackMode() = 0;
+      virtual std::shared_ptr<Promise<void>> setPlaybackSpeed(double rate) = 0;
+      virtual std::shared_ptr<Promise<void>> setPitchCorrectionMode(PitchCorrectionMode mode) = 0;
+      virtual std::shared_ptr<Promise<void>> setVolume(double volume) = 0;
+      virtual std::shared_ptr<Promise<void>> setRepeatMode(RepeatMode mode) = 0;
+      virtual std::shared_ptr<Promise<void>> setRemoteControls(const RemoteControlOptions& options) = 0;
+      virtual std::shared_ptr<Promise<void>> setSleepTimer(double seconds) = 0;
+      virtual std::shared_ptr<Promise<void>> setSleepTimerToTrackEnd() = 0;
+      virtual std::shared_ptr<Promise<void>> clearSleepTimer() = 0;
+      virtual std::shared_ptr<Promise<ShuffleResult>> shuffleQueue() = 0;
+      virtual PlayerState getState() = 0;
+      virtual double getCurrentTrackIndex() = 0;
+      virtual std::optional<TrackSource> getCurrentTrackSource() = 0;
+      virtual double getPlaybackSpeed() = 0;
+      virtual PitchCorrectionMode getPitchCorrectionMode() = 0;
+      virtual double getVolume() = 0;
+      virtual RemoteControlOptions getRemoteControls() = 0;
+      virtual BufferState getBufferState() = 0;
+      virtual bool getIsSeekable() = 0;
+      virtual bool isFullyBuffered() = 0;
+      virtual bool getCanSkipNext() = 0;
+      virtual bool getCanSkipPrevious() = 0;
+      virtual SkipCapability getSkipCapability() = 0;
+      virtual SleepTimerState getSleepTimer() = 0;
+      virtual std::function<void()> onStateChange(const std::function<void(PlayerState /* state */, StateChangeReason /* reason */)>& callback) = 0;
+      virtual std::function<void()> onTrackChange(const std::function<void(const std::optional<TrackItem>& /* track */, double /* index */, TrackChangeReason /* reason */, std::optional<double> /* transitionGapMs */)>& callback) = 0;
+      virtual std::function<void()> onProgress(const std::function<void(const PlayerProgress& /* progress */)>& callback) = 0;
+      virtual std::function<void()> onPlaybackMilestone(const std::function<void(double /* milestone */, double /* trackIndex */)>& callback) = 0;
+      virtual std::function<void()> onError(const std::function<void(const PlaybackError& /* error */)>& callback) = 0;
+      virtual std::function<void()> onQueueEnd(const std::function<void()>& callback) = 0;
+      virtual std::function<void()> onSkipCapabilityChange(const std::function<void(const SkipCapability& /* capability */)>& callback) = 0;
+      virtual std::function<void()> onSleepTimerChange(const std::function<void(const SleepTimerState& /* state */)>& callback) = 0;
+      virtual std::function<void()> onBufferStateChange(const std::function<void(BufferState /* state */)>& callback) = 0;
+      virtual std::function<void()> onFullyBufferedChange(const std::function<void(bool /* fullyBuffered */)>& callback) = 0;
+      virtual void setBrowseSnapshot(const BrowseSnapshot& snapshot) = 0;
+      virtual std::function<void()> onBrowseRequest(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<BrowseItem>>>>>(const std::string& /* parentId */)>& callback) = 0;
+      virtual std::function<void()> onSearchRequest(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<BrowseItem>>>>>(const std::string& /* query */)>& callback) = 0;
+      virtual std::function<void()> onPlayFromSearchRequest(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>(const MediaSearchRequest& /* request */)>& callback) = 0;
+      virtual std::function<void()> onPlayFromIdRequest(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>(const std::string& /* mediaId */)>& callback) = 0;
+      virtual void donateVoiceVocabulary(const VoiceVocabulary& vocabulary) = 0;
+      virtual std::function<void()> onCarConnect(const std::function<void()>& callback) = 0;
+      virtual std::function<void()> onCarDisconnect(const std::function<void()>& callback) = 0;
+      virtual std::function<void()> onServiceReady(const std::function<void(ServiceReadyReason /* reason */)>& callback) = 0;
+      virtual std::shared_ptr<Promise<void>> setLookaheadCache(const LookaheadCacheConfig& config) = 0;
+      virtual CacheStatus getLookaheadCacheStatus() = 0;
+      virtual std::shared_ptr<Promise<void>> clearLookaheadCache() = 0;
+      virtual std::function<void()> onCacheStatusChange(const std::function<void(const CacheStatus& /* status */)>& callback) = 0;
+      virtual std::shared_ptr<Promise<void>> setReplayGainMode(ReplayGainMode mode) = 0;
+      virtual ReplayGainMode getReplayGainMode() = 0;
+      virtual std::variant<nitro::NullType, NowPlayingFormat> getNowPlayingFormat() = 0;
+      virtual std::function<void()> onNowPlayingFormatChange(const std::function<void(const std::optional<std::variant<nitro::NullType, NowPlayingFormat>>& /* format */)>& callback) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "TrackPlayer";
+  };
+
+} // namespace margelo::nitro::queueplayer

package/nitrogen/generated/shared/c++/HybridVisualizerSpec.cpp

@@ -0,0 +1,22 @@
+///
+/// HybridVisualizerSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridVisualizerSpec.hpp"
+
+namespace margelo::nitro::queueplayer {
+
+  void HybridVisualizerSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("subscribe", &HybridVisualizerSpec::subscribe);
+      prototype.registerHybridMethod("getSubscriberCount", &HybridVisualizerSpec::getSubscriberCount);
+    });
+  }
+
+} // namespace margelo::nitro::queueplayer