react-native-audio-browser 0.1.1 → 0.2.0-next.1

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

@@ -66,6 +66,12 @@ namespace margelo::nitro::audiobrowser {
     void setOnFormattedNavigationError(const std::function<void(const std::optional<FormattedNavigationError>& /* formattedError */)>& onFormattedNavigationError) override;
     NativeBrowserConfiguration getConfiguration() override;
     void setConfiguration(const NativeBrowserConfiguration& configuration) override;
+    std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<GateDecision>>>>(const NativeGateRequest& /* request */)> getResolveGate() override;
+    void setResolveGate(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<GateDecision>>>>(const NativeGateRequest& /* request */)>& resolveGate) override;
+    std::function<void(const GateEvent& /* event */)> getOnGate() override;
+    void setOnGate(const std::function<void(const GateEvent& /* event */)>& onGate) override;
+    std::function<void(bool /* connected */)> getOnCarConnectedChanged() override;
+    void setOnCarConnectedChanged(const std::function<void(bool /* connected */)>& onCarConnectedChanged) override;
     std::function<void(const std::vector<ChapterMetadata>& /* chapters */)> getOnChapterMetadata() override;
     void setOnChapterMetadata(const std::function<void(const std::vector<ChapterMetadata>& /* chapters */)>& onChapterMetadata) override;
     std::function<void(const TrackMetadata& /* metadata */)> getOnTrackMetadata() override;
@@ -82,6 +88,8 @@ namespace margelo::nitro::audiobrowser {
     void setOnPlaybackPlayingState(const std::function<void(const PlayingState& /* data */)>& onPlaybackPlayingState) override;
     std::function<void(const PlaybackProgressUpdatedEvent& /* data */)> getOnPlaybackProgressUpdated() override;
     void setOnPlaybackProgressUpdated(const std::function<void(const PlaybackProgressUpdatedEvent& /* data */)>& onPlaybackProgressUpdated) override;
+    std::function<void()> getOnPlaybackInterval() override;
+    void setOnPlaybackInterval(const std::function<void()>& onPlaybackInterval) override;
     std::function<void(const PlaybackQueueEndedEvent& /* data */)> getOnPlaybackQueueEnded() override;
     void setOnPlaybackQueueEnded(const std::function<void(const PlaybackQueueEndedEvent& /* data */)>& onPlaybackQueueEnded) override;
     std::function<void(const std::vector<Track>& /* queue */)> getOnPlaybackQueueChanged() override;
@@ -94,16 +102,10 @@ namespace margelo::nitro::audiobrowser {
     void setOnSleepTimerChanged(const std::function<void(const std::optional<std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>>& /* data */)>& onSleepTimerChanged) override;
     std::function<void(const Playback& /* data */)> getOnPlaybackChanged() override;
     void setOnPlaybackChanged(const std::function<void(const Playback& /* data */)>& onPlaybackChanged) override;
-    std::function<void()> getOnRemoteBookmark() override;
-    void setOnRemoteBookmark(const std::function<void()>& onRemoteBookmark) override;
-    std::function<void()> getOnRemoteDislike() override;
-    void setOnRemoteDislike(const std::function<void()>& onRemoteDislike) override;
     std::function<void(const RemoteJumpBackwardEvent& /* event */)> getOnRemoteJumpBackward() override;
     void setOnRemoteJumpBackward(const std::function<void(const RemoteJumpBackwardEvent& /* event */)>& onRemoteJumpBackward) override;
     std::function<void(const RemoteJumpForwardEvent& /* event */)> getOnRemoteJumpForward() override;
     void setOnRemoteJumpForward(const std::function<void(const RemoteJumpForwardEvent& /* event */)>& onRemoteJumpForward) override;
-    std::function<void()> getOnRemoteLike() override;
-    void setOnRemoteLike(const std::function<void()>& onRemoteLike) override;
     std::function<void()> getOnRemoteNext() override;
     void setOnRemoteNext(const std::function<void()>& onRemoteNext) override;
     std::function<void()> getOnRemotePause() override;
@@ -118,8 +120,6 @@ namespace margelo::nitro::audiobrowser {
     void setOnRemotePrevious(const std::function<void()>& onRemotePrevious) override;
     std::function<void(const RemoteSeekEvent& /* event */)> getOnRemoteSeek() override;
     void setOnRemoteSeek(const std::function<void(const RemoteSeekEvent& /* event */)>& onRemoteSeek) override;
-    std::function<void(const RemoteSetRatingEvent& /* event */)> getOnRemoteSetRating() override;
-    void setOnRemoteSetRating(const std::function<void(const RemoteSetRatingEvent& /* event */)>& onRemoteSetRating) override;
     std::function<void(const RemoteSkipEvent& /* event */)> getOnRemoteSkip() override;
     void setOnRemoteSkip(const std::function<void(const RemoteSkipEvent& /* event */)>& onRemoteSkip) override;
     std::function<void()> getOnRemoteStop() override;
@@ -130,16 +130,10 @@ namespace margelo::nitro::audiobrowser {
     void setOnFavoriteChanged(const std::function<void(const FavoriteChangedEvent& /* event */)>& onFavoriteChanged) override;
     std::function<void(const NowPlayingMetadata& /* metadata */)> getOnNowPlayingChanged() override;
     void setOnNowPlayingChanged(const std::function<void(const NowPlayingMetadata& /* metadata */)>& onNowPlayingChanged) override;
-    std::optional<std::function<void()>> getHandleRemoteBookmark() override;
-    void setHandleRemoteBookmark(const std::optional<std::function<void()>>& handleRemoteBookmark) override;
-    std::optional<std::function<void()>> getHandleRemoteDislike() override;
-    void setHandleRemoteDislike(const std::optional<std::function<void()>>& handleRemoteDislike) override;
     std::optional<std::function<void(const RemoteJumpBackwardEvent& /* event */)>> getHandleRemoteJumpBackward() override;
     void setHandleRemoteJumpBackward(const std::optional<std::function<void(const RemoteJumpBackwardEvent& /* event */)>>& handleRemoteJumpBackward) override;
     std::optional<std::function<void(const RemoteJumpForwardEvent& /* event */)>> getHandleRemoteJumpForward() override;
     void setHandleRemoteJumpForward(const std::optional<std::function<void(const RemoteJumpForwardEvent& /* event */)>>& handleRemoteJumpForward) override;
-    std::optional<std::function<void()>> getHandleRemoteLike() override;
-    void setHandleRemoteLike(const std::optional<std::function<void()>>& handleRemoteLike) override;
     std::optional<std::function<void()>> getHandleRemoteNext() override;
     void setHandleRemoteNext(const std::optional<std::function<void()>>& handleRemoteNext) override;
     std::optional<std::function<void()>> getHandleRemotePause() override;
@@ -162,8 +156,8 @@ namespace margelo::nitro::audiobrowser {
     void setOnOnlineChanged(const std::function<void(bool /* online */)>& onOnlineChanged) override;
     std::function<void(double /* volume */)> getOnSystemVolumeChanged() override;
     void setOnSystemVolumeChanged(const std::function<void(double /* volume */)>& onSystemVolumeChanged) override;
-    std::function<void(const IosOutput& /* output */)> getOnIosOutputChanged() override;
-    void setOnIosOutputChanged(const std::function<void(const IosOutput& /* output */)>& onIosOutputChanged) override;
+    std::function<void(const Output& /* output */)> getOnOutputChanged() override;
+    void setOnOutputChanged(const std::function<void(const Output& /* output */)>& onOutputChanged) override;
     std::function<void(const EqualizerSettings& /* settings */)> getOnEqualizerChanged() override;
     void setOnEqualizerChanged(const std::function<void(const EqualizerSettings& /* settings */)>& onEqualizerChanged) override;
     std::function<void(const BatteryWarningPendingChangedEvent& /* event */)> getOnBatteryWarningPendingChanged() override;
@@ -180,10 +174,14 @@ namespace margelo::nitro::audiobrowser {
     std::optional<NavigationError> getNavigationError() override;
     std::optional<FormattedNavigationError> getFormattedNavigationError() override;
     void notifyContentChanged(const std::string& path) override;
+    void invalidateAllContent() override;
     void setFavorites(const std::vector<std::string>& favorites) override;
-    std::shared_ptr<Promise<void>> setupPlayer(const PartialSetupPlayerOptions& options) override;
+    void setGate(const std::optional<Gate>& gate, bool hasResolver) override;
+    void clearGate() override;
+    bool isCarConnected() override;
+    std::shared_ptr<Promise<void>> setupPlayer(const NativeSetupPlayerOptions& options) override;
     void updateOptions(const NativeUpdateOptions& options) override;
-    UpdateOptions getOptions() override;
+    Options getOptions() override;
     void load(const Track& track) override;
     void reset() override;
     void play() override;
@@ -194,11 +192,13 @@ namespace margelo::nitro::audiobrowser {
     bool getPlayWhenReady() override;
     void seekTo(double position) override;
     void seekBy(double offset) override;
+    void seekToLiveEdge() override;
     void setVolume(double level) override;
     double getVolume() override;
     void setRate(double rate) override;
     double getRate() override;
     Progress getProgress() override;
+    void setPlaybackIntervalEnabled(bool enabled) override;
     Playback getPlayback() override;
     PlayingState getPlayingState() override;
     RepeatMode getRepeatMode() override;
@@ -208,7 +208,7 @@ namespace margelo::nitro::audiobrowser {
     std::optional<PlaybackError> getPlaybackError() override;
     void retry() override;
     std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack> getSleepTimer() override;
-    void setSleepTimer(double seconds) override;
+    void setSleepTimer(double seconds, std::optional<double> fadeDuration) override;
     void setSleepTimerToEndOfTrack() override;
     bool clearSleepTimer() override;
     void add(const std::vector<Track>& tracks, std::optional<double> insertBeforeIndex) override;
@@ -220,18 +220,21 @@ namespace margelo::nitro::audiobrowser {
     void skipToPrevious(std::optional<double> initialPosition) override;
     void setActiveTrackFavorited(bool favorited) override;
     void toggleActiveTrackFavorited() override;
-    void setQueue(const std::vector<Track>& tracks, std::optional<double> startIndex, std::optional<double> startPositionMs) override;
+    void setQueue(const std::vector<Track>& tracks, std::optional<double> startIndex, std::optional<double> startPosition) override;
     std::vector<Track> getQueue() override;
     std::optional<Track> getTrack(double index) override;
     std::optional<double> getActiveTrackIndex() override;
     std::optional<Track> getActiveTrack() override;
     void updateNowPlaying(const std::optional<NowPlayingUpdate>& update) override;
+    void flashNowPlaying(const NowPlayingUpdate& update, double durationMs) override;
+    void clearNowPlayingFlash() override;
     std::optional<NowPlayingMetadata> getNowPlaying() override;
     bool getOnline() override;
     double getSystemVolume() override;
     void setSystemVolume(double volume) override;
-    std::optional<IosOutput> getIosOutput() override;
-    void openIosOutputPicker() override;
+    std::optional<Output> getOutput() override;
+    void openOutputPicker() override;
+    bool supportsOutputSwitcher() override;
     std::optional<EqualizerSettings> getEqualizerSettings() override;
     void setEqualizerEnabled(bool enabled) override;
     void setEqualizerPreset(const std::string& preset) override;

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

@@ -0,0 +1,95 @@
+///
+/// JIOSOptions.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "IOSOptions.hpp"
+
+#include "CarPlayNowPlayingButton.hpp"
+#include "JCarPlayNowPlayingButton.hpp"
+#include <vector>
+
+namespace margelo::nitro::audiobrowser {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "IOSOptions" and the the Kotlin data class "IOSOptions".
+   */
+  struct JIOSOptions final: public jni::JavaClass<JIOSOptions> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/IOSOptions;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct IOSOptions by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    IOSOptions toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldPlaybackRates = clazz->getField<jni::JArrayDouble>("playbackRates");
+      jni::local_ref<jni::JArrayDouble> playbackRates = this->getFieldValue(fieldPlaybackRates);
+      static const auto fieldCarPlayUpNextButton = clazz->getField<jboolean>("carPlayUpNextButton");
+      jboolean carPlayUpNextButton = this->getFieldValue(fieldCarPlayUpNextButton);
+      static const auto fieldCarPlayNowPlayingButtons = clazz->getField<jni::JArrayClass<JCarPlayNowPlayingButton>>("carPlayNowPlayingButtons");
+      jni::local_ref<jni::JArrayClass<JCarPlayNowPlayingButton>> carPlayNowPlayingButtons = this->getFieldValue(fieldCarPlayNowPlayingButtons);
+      return IOSOptions(
+        [&]() {
+          size_t __size = playbackRates->size();
+          std::vector<double> __vector(__size);
+          playbackRates->getRegion(0, __size, __vector.data());
+          return __vector;
+        }(),
+        static_cast<bool>(carPlayUpNextButton),
+        [&]() {
+          size_t __size = carPlayNowPlayingButtons->size();
+          std::vector<CarPlayNowPlayingButton> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = carPlayNowPlayingButtons->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JIOSOptions::javaobject> fromCpp(const IOSOptions& value) {
+      using JSignature = JIOSOptions(jni::alias_ref<jni::JArrayDouble>, jboolean, jni::alias_ref<jni::JArrayClass<JCarPlayNowPlayingButton>>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        [&]() {
+          size_t __size = value.playbackRates.size();
+          jni::local_ref<jni::JArrayDouble> __array = jni::JArrayDouble::newArray(__size);
+          __array->setRegion(0, __size, value.playbackRates.data());
+          return __array;
+        }(),
+        value.carPlayUpNextButton,
+        [&]() {
+          size_t __size = value.carPlayNowPlayingButtons.size();
+          jni::local_ref<jni::JArrayClass<JCarPlayNowPlayingButton>> __array = jni::JArrayClass<JCarPlayNowPlayingButton>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.carPlayNowPlayingButtons[__i];
+            auto __elementJni = JCarPlayNowPlayingButton::fromCpp(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }()
+      );
+    }
+  };
+
+} // namespace margelo::nitro::audiobrowser

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

@@ -14,6 +14,8 @@
 #include "ImageSource.hpp"
 #include "JHttpMethod.hpp"
 #include "JImageSource.hpp"
+#include "JTrackRequest.hpp"
+#include "TrackRequest.hpp"
 #include <optional>
 #include <string>
 #include <unordered_map>
@@ -37,19 +39,40 @@ namespace margelo::nitro::audiobrowser {
     [[nodiscard]]
     ImageRowItem toCpp() const {
       static const auto clazz = javaClassStatic();
+      static const auto fieldId = clazz->getField<jni::JString>("id");
+      jni::local_ref<jni::JString> id = this->getFieldValue(fieldId);
       static const auto fieldUrl = clazz->getField<jni::JString>("url");
       jni::local_ref<jni::JString> url = this->getFieldValue(fieldUrl);
+      static const auto fieldSrc = clazz->getField<jni::JString>("src");
+      jni::local_ref<jni::JString> src = this->getFieldValue(fieldSrc);
       static const auto fieldArtwork = clazz->getField<jni::JString>("artwork");
       jni::local_ref<jni::JString> artwork = this->getFieldValue(fieldArtwork);
       static const auto fieldArtworkSource = clazz->getField<JImageSource>("artworkSource");
       jni::local_ref<JImageSource> artworkSource = this->getFieldValue(fieldArtworkSource);
       static const auto fieldTitle = clazz->getField<jni::JString>("title");
       jni::local_ref<jni::JString> title = this->getFieldValue(fieldTitle);
+      static const auto fieldArtist = clazz->getField<jni::JString>("artist");
+      jni::local_ref<jni::JString> artist = this->getFieldValue(fieldArtist);
+      static const auto fieldAlbum = clazz->getField<jni::JString>("album");
+      jni::local_ref<jni::JString> album = this->getFieldValue(fieldAlbum);
+      static const auto fieldAlbumUrl = clazz->getField<jni::JString>("albumUrl");
+      jni::local_ref<jni::JString> albumUrl = this->getFieldValue(fieldAlbumUrl);
+      static const auto fieldLive = clazz->getField<jni::JBoolean>("live");
+      jni::local_ref<jni::JBoolean> live = this->getFieldValue(fieldLive);
+      static const auto fieldRequest = clazz->getField<JTrackRequest>("request");
+      jni::local_ref<JTrackRequest> request = this->getFieldValue(fieldRequest);
       return ImageRowItem(
+        id != nullptr ? std::make_optional(id->toStdString()) : std::nullopt,
         url != nullptr ? std::make_optional(url->toStdString()) : std::nullopt,
+        src != nullptr ? std::make_optional(src->toStdString()) : std::nullopt,
         artwork != nullptr ? std::make_optional(artwork->toStdString()) : std::nullopt,
         artworkSource != nullptr ? std::make_optional(artworkSource->toCpp()) : std::nullopt,
-        title->toStdString()
+        title->toStdString(),
+        artist != nullptr ? std::make_optional(artist->toStdString()) : std::nullopt,
+        album != nullptr ? std::make_optional(album->toStdString()) : std::nullopt,
+        albumUrl != nullptr ? std::make_optional(albumUrl->toStdString()) : std::nullopt,
+        live != nullptr ? std::make_optional(static_cast<bool>(live->value())) : std::nullopt,
+        request != nullptr ? std::make_optional(request->toCpp()) : std::nullopt
       );
     }
 
@@ -59,15 +82,22 @@ namespace margelo::nitro::audiobrowser {
      */
     [[maybe_unused]]
     static jni::local_ref<JImageRowItem::javaobject> fromCpp(const ImageRowItem& value) {
-      using JSignature = JImageRowItem(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<JImageSource>, jni::alias_ref<jni::JString>);
+      using JSignature = JImageRowItem(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<JImageSource>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<JTrackRequest>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
         clazz,
+        value.id.has_value() ? jni::make_jstring(value.id.value()) : nullptr,
         value.url.has_value() ? jni::make_jstring(value.url.value()) : nullptr,
+        value.src.has_value() ? jni::make_jstring(value.src.value()) : nullptr,
         value.artwork.has_value() ? jni::make_jstring(value.artwork.value()) : nullptr,
         value.artworkSource.has_value() ? JImageSource::fromCpp(value.artworkSource.value()) : nullptr,
-        jni::make_jstring(value.title)
+        jni::make_jstring(value.title),
+        value.artist.has_value() ? jni::make_jstring(value.artist.value()) : nullptr,
+        value.album.has_value() ? jni::make_jstring(value.album.value()) : nullptr,
+        value.albumUrl.has_value() ? jni::make_jstring(value.albumUrl.value()) : nullptr,
+        value.live.has_value() ? jni::JBoolean::valueOf(value.live.value()) : nullptr,
+        value.request.has_value() ? JTrackRequest::fromCpp(value.request.value()) : nullptr
       );
     }
   };

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

@@ -0,0 +1,58 @@
+///
+/// JMediaReference.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "MediaReference.hpp"
+
+namespace margelo::nitro::audiobrowser {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "MediaReference" and the the Kotlin enum "MediaReference".
+   */
+  struct JMediaReference final: public jni::JavaClass<JMediaReference> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/MediaReference;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum MediaReference.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    MediaReference toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<MediaReference>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JMediaReference> fromCpp(MediaReference value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case MediaReference::MY:
+          static const auto fieldMY = clazz->getStaticField<JMediaReference>("MY");
+          return clazz->getStaticFieldValue(fieldMY);
+        case MediaReference::UNKNOWN:
+          static const auto fieldUNKNOWN = clazz->getStaticField<JMediaReference>("UNKNOWN");
+          return clazz->getStaticFieldValue(fieldUNKNOWN);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::audiobrowser

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

@@ -10,9 +10,13 @@
 #include <fbjni/fbjni.h>
 #include "MediaRequestConfig.hpp"
 
+#include "ArtworkVariants.hpp"
 #include "HttpMethod.hpp"
 #include "ImageRowItem.hpp"
 #include "ImageSource.hpp"
+#include "JArtworkVariants.hpp"
+#include "JFunc_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string__.hpp"
+#include "JFunc_std__shared_ptr_Promise_RequestConfig___Track.hpp"
 #include "JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____RequestConfig_std__optional_std__unordered_map_std__string__std__string__.hpp"
 #include "JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____Track.hpp"
 #include "JHttpMethod.hpp"
@@ -20,9 +24,12 @@
 #include "JImageSource.hpp"
 #include "JRequestConfig.hpp"
 #include "JTrack.hpp"
+#include "JTrackRequest.hpp"
 #include "JTrackStyle.hpp"
+#include "JVariant_String_ArtworkVariants.hpp"
 #include "RequestConfig.hpp"
 #include "Track.hpp"
+#include "TrackRequest.hpp"
 #include "TrackStyle.hpp"
 #include <NitroModules/JNICallable.hpp>
 #include <NitroModules/JPromise.hpp>
@@ -31,6 +38,7 @@
 #include <optional>
 #include <string>
 #include <unordered_map>
+#include <variant>
 #include <vector>
 
 namespace margelo::nitro::audiobrowser {
@@ -54,8 +62,12 @@ namespace margelo::nitro::audiobrowser {
       static const auto clazz = javaClassStatic();
       static const auto fieldResolve = clazz->getField<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____Track::javaobject>("resolve");
       jni::local_ref<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____Track::javaobject> resolve = this->getFieldValue(fieldResolve);
+      static const auto fieldResolveSync = clazz->getField<JFunc_std__shared_ptr_Promise_RequestConfig___Track::javaobject>("resolveSync");
+      jni::local_ref<JFunc_std__shared_ptr_Promise_RequestConfig___Track::javaobject> resolveSync = this->getFieldValue(fieldResolveSync);
       static const auto fieldTransform = clazz->getField<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____RequestConfig_std__optional_std__unordered_map_std__string__std__string__::javaobject>("transform");
       jni::local_ref<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____RequestConfig_std__optional_std__unordered_map_std__string__std__string__::javaobject> transform = this->getFieldValue(fieldTransform);
+      static const auto fieldTransformSync = clazz->getField<JFunc_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string__::javaobject>("transformSync");
+      jni::local_ref<JFunc_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string__::javaobject> transformSync = this->getFieldValue(fieldTransformSync);
       static const auto fieldMethod = clazz->getField<JHttpMethod>("method");
       jni::local_ref<JHttpMethod> method = this->getFieldValue(fieldMethod);
       static const auto fieldPath = clazz->getField<jni::JString>("path");
@@ -82,6 +94,15 @@ namespace margelo::nitro::audiobrowser {
             return JNICallable<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____Track, std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(Track)>(std::move(resolveRef));
           }
         }()) : std::nullopt,
+        resolveSync != nullptr ? std::make_optional([&]() -> std::function<std::shared_ptr<Promise<RequestConfig>>(const Track& /* track */)> {
+          if (resolveSync->isInstanceOf(JFunc_std__shared_ptr_Promise_RequestConfig___Track_cxx::javaClassStatic())) [[likely]] {
+            auto downcast = jni::static_ref_cast<JFunc_std__shared_ptr_Promise_RequestConfig___Track_cxx::javaobject>(resolveSync);
+            return downcast->cthis()->getFunction();
+          } else {
+            auto resolveSyncRef = jni::make_global(resolveSync);
+            return JNICallable<JFunc_std__shared_ptr_Promise_RequestConfig___Track, std::shared_ptr<Promise<RequestConfig>>(Track)>(std::move(resolveSyncRef));
+          }
+        }()) : std::nullopt,
         transform != nullptr ? std::make_optional([&]() -> std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)> {
           if (transform->isInstanceOf(JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____RequestConfig_std__optional_std__unordered_map_std__string__std__string___cxx::javaClassStatic())) [[likely]] {
             auto downcast = jni::static_ref_cast<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____RequestConfig_std__optional_std__unordered_map_std__string__std__string___cxx::javaobject>(transform);
@@ -91,6 +112,15 @@ namespace margelo::nitro::audiobrowser {
             return JNICallable<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____RequestConfig_std__optional_std__unordered_map_std__string__std__string__, std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(RequestConfig, std::optional<std::unordered_map<std::string, std::string>>)>(std::move(transformRef));
           }
         }()) : std::nullopt,
+        transformSync != nullptr ? std::make_optional([&]() -> std::function<std::shared_ptr<Promise<RequestConfig>>(const RequestConfig& /* request */, const std::optional<std::unordered_map<std::string, std::string>>& /* routeParams */)> {
+          if (transformSync->isInstanceOf(JFunc_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string___cxx::javaClassStatic())) [[likely]] {
+            auto downcast = jni::static_ref_cast<JFunc_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string___cxx::javaobject>(transformSync);
+            return downcast->cthis()->getFunction();
+          } else {
+            auto transformSyncRef = jni::make_global(transformSync);
+            return JNICallable<JFunc_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string__, std::shared_ptr<Promise<RequestConfig>>(RequestConfig, std::optional<std::unordered_map<std::string, std::string>>)>(std::move(transformSyncRef));
+          }
+        }()) : std::nullopt,
         method != nullptr ? std::make_optional(method->toCpp()) : std::nullopt,
         path != nullptr ? std::make_optional(path->toStdString()) : std::nullopt,
         baseUrl != nullptr ? std::make_optional(baseUrl->toStdString()) : std::nullopt,
@@ -122,13 +152,15 @@ namespace margelo::nitro::audiobrowser {
      */
     [[maybe_unused]]
     static jni::local_ref<JMediaRequestConfig::javaobject> fromCpp(const MediaRequestConfig& value) {
-      using JSignature = JMediaRequestConfig(jni::alias_ref<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____Track::javaobject>, jni::alias_ref<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____RequestConfig_std__optional_std__unordered_map_std__string__std__string__::javaobject>, jni::alias_ref<JHttpMethod>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JMap<jni::JString, jni::JString>>, jni::alias_ref<jni::JMap<jni::JString, jni::JString>>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>);
+      using JSignature = JMediaRequestConfig(jni::alias_ref<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____Track::javaobject>, jni::alias_ref<JFunc_std__shared_ptr_Promise_RequestConfig___Track::javaobject>, jni::alias_ref<JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____RequestConfig_std__optional_std__unordered_map_std__string__std__string__::javaobject>, jni::alias_ref<JFunc_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string__::javaobject>, jni::alias_ref<JHttpMethod>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JMap<jni::JString, jni::JString>>, jni::alias_ref<jni::JMap<jni::JString, jni::JString>>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
         clazz,
         value.resolve.has_value() ? JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____Track_cxx::fromCpp(value.resolve.value()) : nullptr,
+        value.resolveSync.has_value() ? JFunc_std__shared_ptr_Promise_RequestConfig___Track_cxx::fromCpp(value.resolveSync.value()) : nullptr,
         value.transform.has_value() ? JFunc_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____RequestConfig_std__optional_std__unordered_map_std__string__std__string___cxx::fromCpp(value.transform.value()) : nullptr,
+        value.transformSync.has_value() ? JFunc_std__shared_ptr_Promise_RequestConfig___RequestConfig_std__optional_std__unordered_map_std__string__std__string___cxx::fromCpp(value.transformSync.value()) : nullptr,
         value.method.has_value() ? JHttpMethod::fromCpp(value.method.value()) : nullptr,
         value.path.has_value() ? jni::make_jstring(value.path.value()) : nullptr,
         value.baseUrl.has_value() ? jni::make_jstring(value.baseUrl.value()) : nullptr,

package/nitrogen/generated/android/c++/{JPartialAndroidSetupPlayerOptions.hpp → JNativeAndroidSetupOptions.hpp}

@@ -1,5 +1,5 @@
 ///
-/// JPartialAndroidSetupPlayerOptions.hpp
+/// JNativeAndroidSetupOptions.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © Marc Rousavy @ Margelo
@@ -8,7 +8,7 @@
 #pragma once
 
 #include <fbjni/fbjni.h>
-#include "PartialAndroidSetupPlayerOptions.hpp"
+#include "NativeAndroidSetupOptions.hpp"
 
 #include "AndroidAudioContentType.hpp"
 #include "AndroidAudioOffloadSettings.hpp"
@@ -28,19 +28,19 @@ namespace margelo::nitro::audiobrowser {
   using namespace facebook;
 
   /**
-   * The C++ JNI bridge between the C++ struct "PartialAndroidSetupPlayerOptions" and the the Kotlin data class "PartialAndroidSetupPlayerOptions".
+   * The C++ JNI bridge between the C++ struct "NativeAndroidSetupOptions" and the the Kotlin data class "NativeAndroidSetupOptions".
    */
-  struct JPartialAndroidSetupPlayerOptions final: public jni::JavaClass<JPartialAndroidSetupPlayerOptions> {
+  struct JNativeAndroidSetupOptions final: public jni::JavaClass<JNativeAndroidSetupOptions> {
   public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/PartialAndroidSetupPlayerOptions;";
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/NativeAndroidSetupOptions;";
 
   public:
     /**
-     * Convert this Java/Kotlin-based struct to the C++ struct PartialAndroidSetupPlayerOptions by copying all values to C++.
+     * Convert this Java/Kotlin-based struct to the C++ struct NativeAndroidSetupOptions by copying all values to C++.
      */
     [[maybe_unused]]
     [[nodiscard]]
-    PartialAndroidSetupPlayerOptions toCpp() const {
+    NativeAndroidSetupOptions toCpp() const {
       static const auto clazz = javaClassStatic();
       static const auto fieldMinBuffer = clazz->getField<jni::JDouble>("minBuffer");
       jni::local_ref<jni::JDouble> minBuffer = this->getFieldValue(fieldMinBuffer);
@@ -62,7 +62,7 @@ namespace margelo::nitro::audiobrowser {
       jni::local_ref<jni::JBoolean> handleAudioBecomingNoisy = this->getFieldValue(fieldHandleAudioBecomingNoisy);
       static const auto fieldWakeMode = clazz->getField<JAndroidPlayerWakeMode>("wakeMode");
       jni::local_ref<JAndroidPlayerWakeMode> wakeMode = this->getFieldValue(fieldWakeMode);
-      return PartialAndroidSetupPlayerOptions(
+      return NativeAndroidSetupOptions(
         minBuffer != nullptr ? std::make_optional(minBuffer->value()) : std::nullopt,
         audioOffload != nullptr ? std::make_optional(audioOffload->toCpp()) : std::nullopt,
         maxBuffer != nullptr ? std::make_optional(maxBuffer->value()) : std::nullopt,
@@ -81,8 +81,8 @@ namespace margelo::nitro::audiobrowser {
      * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
      */
     [[maybe_unused]]
-    static jni::local_ref<JPartialAndroidSetupPlayerOptions::javaobject> fromCpp(const PartialAndroidSetupPlayerOptions& value) {
-      using JSignature = JPartialAndroidSetupPlayerOptions(jni::alias_ref<jni::JDouble>, jni::alias_ref<JVariant_Boolean_AndroidAudioOffloadSettings>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<JVariant_NullType_Double>, jni::alias_ref<jni::JDouble>, jni::alias_ref<JAndroidAudioContentType>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<JAndroidPlayerWakeMode>);
+    static jni::local_ref<JNativeAndroidSetupOptions::javaobject> fromCpp(const NativeAndroidSetupOptions& value) {
+      using JSignature = JNativeAndroidSetupOptions(jni::alias_ref<jni::JDouble>, jni::alias_ref<JVariant_Boolean_AndroidAudioOffloadSettings>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>, jni::alias_ref<JVariant_NullType_Double>, jni::alias_ref<jni::JDouble>, jni::alias_ref<JAndroidAudioContentType>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<JAndroidPlayerWakeMode>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(