@5stones/react-native-audio-browser 0.1.0

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

@@ -0,0 +1,250 @@
+///
+/// HybridAudioBrowserSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridAudioBrowserSpec.hpp"
+
+
+
+
+namespace margelo::nitro::audiobrowser {
+
+  using namespace facebook;
+
+  class JHybridAudioBrowserSpec: public jni::HybridClass<JHybridAudioBrowserSpec, JHybridObject>,
+                                 public virtual HybridAudioBrowserSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/HybridAudioBrowserSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridAudioBrowserSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridAudioBrowserSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridAudioBrowserSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridAudioBrowserSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    std::optional<std::string> getPath() override;
+    void setPath(const std::optional<std::string>& path) override;
+    std::optional<std::vector<Track>> getTabs() override;
+    void setTabs(const std::optional<std::vector<Track>>& tabs) override;
+    std::function<void(const std::string& /* path */)> getOnPathChanged() override;
+    void setOnPathChanged(const std::function<void(const std::string& /* path */)>& onPathChanged) override;
+    std::function<void(const std::optional<ResolvedTrack>& /* content */)> getOnContentChanged() override;
+    void setOnContentChanged(const std::function<void(const std::optional<ResolvedTrack>& /* content */)>& onContentChanged) override;
+    std::function<void(const std::vector<Track>& /* tabs */)> getOnTabsChanged() override;
+    void setOnTabsChanged(const std::function<void(const std::vector<Track>& /* tabs */)>& onTabsChanged) override;
+    std::function<void(const NavigationErrorEvent& /* data */)> getOnNavigationError() override;
+    void setOnNavigationError(const std::function<void(const NavigationErrorEvent& /* data */)>& onNavigationError) override;
+    std::function<void(const std::optional<FormattedNavigationError>& /* formattedError */)> getOnFormattedNavigationError() override;
+    void setOnFormattedNavigationError(const std::function<void(const std::optional<FormattedNavigationError>& /* formattedError */)>& onFormattedNavigationError) override;
+    NativeBrowserConfiguration getConfiguration() override;
+    void setConfiguration(const NativeBrowserConfiguration& configuration) 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;
+    void setOnTrackMetadata(const std::function<void(const TrackMetadata& /* metadata */)>& onTrackMetadata) override;
+    std::function<void(const TimedMetadata& /* metadata */)> getOnTimedMetadata() override;
+    void setOnTimedMetadata(const std::function<void(const TimedMetadata& /* metadata */)>& onTimedMetadata) override;
+    std::function<void(const PlaybackActiveTrackChangedEvent& /* data */)> getOnPlaybackActiveTrackChanged() override;
+    void setOnPlaybackActiveTrackChanged(const std::function<void(const PlaybackActiveTrackChangedEvent& /* data */)>& onPlaybackActiveTrackChanged) override;
+    std::function<void(const PlaybackErrorEvent& /* data */)> getOnPlaybackError() override;
+    void setOnPlaybackError(const std::function<void(const PlaybackErrorEvent& /* data */)>& onPlaybackError) override;
+    std::function<void(const PlaybackPlayWhenReadyChangedEvent& /* data */)> getOnPlaybackPlayWhenReadyChanged() override;
+    void setOnPlaybackPlayWhenReadyChanged(const std::function<void(const PlaybackPlayWhenReadyChangedEvent& /* data */)>& onPlaybackPlayWhenReadyChanged) override;
+    std::function<void(const PlayingState& /* data */)> getOnPlaybackPlayingState() override;
+    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(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;
+    void setOnPlaybackQueueChanged(const std::function<void(const std::vector<Track>& /* queue */)>& onPlaybackQueueChanged) override;
+    std::function<void(const RepeatModeChangedEvent& /* data */)> getOnPlaybackRepeatModeChanged() override;
+    void setOnPlaybackRepeatModeChanged(const std::function<void(const RepeatModeChangedEvent& /* data */)>& onPlaybackRepeatModeChanged) override;
+    std::function<void(bool /* enabled */)> getOnPlaybackShuffleModeChanged() override;
+    void setOnPlaybackShuffleModeChanged(const std::function<void(bool /* enabled */)>& onPlaybackShuffleModeChanged) override;
+    std::function<void(const std::optional<std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>>& /* data */)> getOnSleepTimerChanged() override;
+    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;
+    void setOnRemotePause(const std::function<void()>& onRemotePause) override;
+    std::function<void()> getOnRemotePlay() override;
+    void setOnRemotePlay(const std::function<void()>& onRemotePlay) override;
+    std::function<void(const RemotePlayIdEvent& /* event */)> getOnRemotePlayId() override;
+    void setOnRemotePlayId(const std::function<void(const RemotePlayIdEvent& /* event */)>& onRemotePlayId) override;
+    std::function<void(const RemotePlaySearchEvent& /* event */)> getOnRemotePlaySearch() override;
+    void setOnRemotePlaySearch(const std::function<void(const RemotePlaySearchEvent& /* event */)>& onRemotePlaySearch) override;
+    std::function<void()> getOnRemotePrevious() override;
+    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;
+    void setOnRemoteStop(const std::function<void()>& onRemoteStop) override;
+    std::function<void(const Options& /* event */)> getOnOptionsChanged() override;
+    void setOnOptionsChanged(const std::function<void(const Options& /* event */)>& onOptionsChanged) override;
+    std::function<void(const FavoriteChangedEvent& /* event */)> getOnFavoriteChanged() override;
+    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;
+    void setHandleRemotePause(const std::optional<std::function<void()>>& handleRemotePause) override;
+    std::optional<std::function<void()>> getHandleRemotePlay() override;
+    void setHandleRemotePlay(const std::optional<std::function<void()>>& handleRemotePlay) override;
+    std::optional<std::function<void(const RemotePlayIdEvent& /* event */)>> getHandleRemotePlayId() override;
+    void setHandleRemotePlayId(const std::optional<std::function<void(const RemotePlayIdEvent& /* event */)>>& handleRemotePlayId) override;
+    std::optional<std::function<void(const RemotePlaySearchEvent& /* event */)>> getHandleRemotePlaySearch() override;
+    void setHandleRemotePlaySearch(const std::optional<std::function<void(const RemotePlaySearchEvent& /* event */)>>& handleRemotePlaySearch) override;
+    std::optional<std::function<void()>> getHandleRemotePrevious() override;
+    void setHandleRemotePrevious(const std::optional<std::function<void()>>& handleRemotePrevious) override;
+    std::optional<std::function<void(const RemoteSeekEvent& /* event */)>> getHandleRemoteSeek() override;
+    void setHandleRemoteSeek(const std::optional<std::function<void(const RemoteSeekEvent& /* event */)>>& handleRemoteSeek) override;
+    std::optional<std::function<void()>> getHandleRemoteSkip() override;
+    void setHandleRemoteSkip(const std::optional<std::function<void()>>& handleRemoteSkip) override;
+    std::optional<std::function<void()>> getHandleRemoteStop() override;
+    void setHandleRemoteStop(const std::optional<std::function<void()>>& handleRemoteStop) override;
+    std::function<void(bool /* online */)> getOnOnlineChanged() override;
+    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 EqualizerSettings& /* settings */)> getOnEqualizerChanged() override;
+    void setOnEqualizerChanged(const std::function<void(const EqualizerSettings& /* settings */)>& onEqualizerChanged) override;
+    std::function<void(const BatteryWarningPendingChangedEvent& /* event */)> getOnBatteryWarningPendingChanged() override;
+    void setOnBatteryWarningPendingChanged(const std::function<void(const BatteryWarningPendingChangedEvent& /* event */)>& onBatteryWarningPendingChanged) override;
+    std::function<void(const BatteryOptimizationStatusChangedEvent& /* event */)> getOnBatteryOptimizationStatusChanged() override;
+    void setOnBatteryOptimizationStatusChanged(const std::function<void(const BatteryOptimizationStatusChangedEvent& /* event */)>& onBatteryOptimizationStatusChanged) override;
+
+  public:
+    // Methods
+    void navigatePath(const std::string& path) override;
+    void navigateTrack(const Track& track) override;
+    std::shared_ptr<Promise<std::vector<Track>>> onSearch(const std::string& query) override;
+    std::optional<ResolvedTrack> getContent() override;
+    std::optional<NavigationError> getNavigationError() override;
+    std::optional<FormattedNavigationError> getFormattedNavigationError() override;
+    void notifyContentChanged(const std::string& path) override;
+    void setFavorites(const std::vector<std::string>& favorites) override;
+    std::shared_ptr<Promise<void>> setupPlayer(const PartialSetupPlayerOptions& options) override;
+    void updateOptions(const NativeUpdateOptions& options) override;
+    UpdateOptions getOptions() override;
+    void load(const Track& track) override;
+    void reset() override;
+    void play() override;
+    void pause() override;
+    void togglePlayback() override;
+    void stop() override;
+    void setPlayWhenReady(bool playWhenReady) override;
+    bool getPlayWhenReady() override;
+    void seekTo(double position) override;
+    void seekBy(double offset) override;
+    void setVolume(double level) override;
+    double getVolume() override;
+    void setRate(double rate) override;
+    double getRate() override;
+    Progress getProgress() override;
+    Playback getPlayback() override;
+    PlayingState getPlayingState() override;
+    RepeatMode getRepeatMode() override;
+    void setRepeatMode(RepeatMode mode) override;
+    bool getShuffleEnabled() override;
+    void setShuffleEnabled(bool enabled) override;
+    std::optional<PlaybackError> getPlaybackError() override;
+    void retry() override;
+    std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack> getSleepTimer() override;
+    void setSleepTimer(double seconds) override;
+    void setSleepTimerToEndOfTrack() override;
+    bool clearSleepTimer() override;
+    void add(const std::vector<Track>& tracks, std::optional<double> insertBeforeIndex) override;
+    void move(double fromIndex, double toIndex) override;
+    void remove(const std::vector<double>& indexes) override;
+    void removeUpcomingTracks() override;
+    void skip(double index, std::optional<double> initialPosition) override;
+    void skipToNext(std::optional<double> initialPosition) override;
+    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;
+    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;
+    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<EqualizerSettings> getEqualizerSettings() override;
+    void setEqualizerEnabled(bool enabled) override;
+    void setEqualizerPreset(const std::string& preset) override;
+    void setEqualizerLevels(const std::vector<double>& levels) override;
+    bool getBatteryWarningPending() override;
+    BatteryOptimizationStatus getBatteryOptimizationStatus() override;
+    void dismissBatteryWarning() override;
+    void openBatterySettings() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridAudioBrowserSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::audiobrowser

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

@@ -0,0 +1,71 @@
+///
+/// JIOSCategory.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "IOSCategory.hpp"
+
+namespace margelo::nitro::audiobrowser {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "IOSCategory" and the the Kotlin enum "IOSCategory".
+   */
+  struct JIOSCategory final: public jni::JavaClass<JIOSCategory> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/IOSCategory;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum IOSCategory.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    IOSCategory toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<IOSCategory>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JIOSCategory> fromCpp(IOSCategory value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldPLAYBACK = clazz->getStaticField<JIOSCategory>("PLAYBACK");
+      static const auto fieldPLAYANDRECORD = clazz->getStaticField<JIOSCategory>("PLAYANDRECORD");
+      static const auto fieldMULTIROUTE = clazz->getStaticField<JIOSCategory>("MULTIROUTE");
+      static const auto fieldAMBIENT = clazz->getStaticField<JIOSCategory>("AMBIENT");
+      static const auto fieldSOLOAMBIENT = clazz->getStaticField<JIOSCategory>("SOLOAMBIENT");
+      static const auto fieldRECORD = clazz->getStaticField<JIOSCategory>("RECORD");
+      
+      switch (value) {
+        case IOSCategory::PLAYBACK:
+          return clazz->getStaticFieldValue(fieldPLAYBACK);
+        case IOSCategory::PLAYANDRECORD:
+          return clazz->getStaticFieldValue(fieldPLAYANDRECORD);
+        case IOSCategory::MULTIROUTE:
+          return clazz->getStaticFieldValue(fieldMULTIROUTE);
+        case IOSCategory::AMBIENT:
+          return clazz->getStaticFieldValue(fieldAMBIENT);
+        case IOSCategory::SOLOAMBIENT:
+          return clazz->getStaticFieldValue(fieldSOLOAMBIENT);
+        case IOSCategory::RECORD:
+          return clazz->getStaticFieldValue(fieldRECORD);
+        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++/JIOSCategoryMode.hpp

@@ -0,0 +1,80 @@
+///
+/// JIOSCategoryMode.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "IOSCategoryMode.hpp"
+
+namespace margelo::nitro::audiobrowser {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "IOSCategoryMode" and the the Kotlin enum "IOSCategoryMode".
+   */
+  struct JIOSCategoryMode final: public jni::JavaClass<JIOSCategoryMode> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/IOSCategoryMode;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum IOSCategoryMode.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    IOSCategoryMode toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<IOSCategoryMode>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JIOSCategoryMode> fromCpp(IOSCategoryMode value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldDEFAULT = clazz->getStaticField<JIOSCategoryMode>("DEFAULT");
+      static const auto fieldGAMECHAT = clazz->getStaticField<JIOSCategoryMode>("GAMECHAT");
+      static const auto fieldMEASUREMENT = clazz->getStaticField<JIOSCategoryMode>("MEASUREMENT");
+      static const auto fieldMOVIEPLAYBACK = clazz->getStaticField<JIOSCategoryMode>("MOVIEPLAYBACK");
+      static const auto fieldSPOKENAUDIO = clazz->getStaticField<JIOSCategoryMode>("SPOKENAUDIO");
+      static const auto fieldVIDEOCHAT = clazz->getStaticField<JIOSCategoryMode>("VIDEOCHAT");
+      static const auto fieldVIDEORECORDING = clazz->getStaticField<JIOSCategoryMode>("VIDEORECORDING");
+      static const auto fieldVOICECHAT = clazz->getStaticField<JIOSCategoryMode>("VOICECHAT");
+      static const auto fieldVOICEPROMPT = clazz->getStaticField<JIOSCategoryMode>("VOICEPROMPT");
+      
+      switch (value) {
+        case IOSCategoryMode::DEFAULT:
+          return clazz->getStaticFieldValue(fieldDEFAULT);
+        case IOSCategoryMode::GAMECHAT:
+          return clazz->getStaticFieldValue(fieldGAMECHAT);
+        case IOSCategoryMode::MEASUREMENT:
+          return clazz->getStaticFieldValue(fieldMEASUREMENT);
+        case IOSCategoryMode::MOVIEPLAYBACK:
+          return clazz->getStaticFieldValue(fieldMOVIEPLAYBACK);
+        case IOSCategoryMode::SPOKENAUDIO:
+          return clazz->getStaticFieldValue(fieldSPOKENAUDIO);
+        case IOSCategoryMode::VIDEOCHAT:
+          return clazz->getStaticFieldValue(fieldVIDEOCHAT);
+        case IOSCategoryMode::VIDEORECORDING:
+          return clazz->getStaticFieldValue(fieldVIDEORECORDING);
+        case IOSCategoryMode::VOICECHAT:
+          return clazz->getStaticFieldValue(fieldVOICECHAT);
+        case IOSCategoryMode::VOICEPROMPT:
+          return clazz->getStaticFieldValue(fieldVOICEPROMPT);
+        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++/JIOSCategoryOptions.hpp

@@ -0,0 +1,74 @@
+///
+/// JIOSCategoryOptions.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "IOSCategoryOptions.hpp"
+
+namespace margelo::nitro::audiobrowser {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "IOSCategoryOptions" and the the Kotlin enum "IOSCategoryOptions".
+   */
+  struct JIOSCategoryOptions final: public jni::JavaClass<JIOSCategoryOptions> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/IOSCategoryOptions;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum IOSCategoryOptions.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    IOSCategoryOptions toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<IOSCategoryOptions>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JIOSCategoryOptions> fromCpp(IOSCategoryOptions value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldMIXWITHOTHERS = clazz->getStaticField<JIOSCategoryOptions>("MIXWITHOTHERS");
+      static const auto fieldDUCKOTHERS = clazz->getStaticField<JIOSCategoryOptions>("DUCKOTHERS");
+      static const auto fieldINTERRUPTSPOKENAUDIOANDMIXWITHOTHERS = clazz->getStaticField<JIOSCategoryOptions>("INTERRUPTSPOKENAUDIOANDMIXWITHOTHERS");
+      static const auto fieldALLOWBLUETOOTH = clazz->getStaticField<JIOSCategoryOptions>("ALLOWBLUETOOTH");
+      static const auto fieldALLOWBLUETOOTHA2DP = clazz->getStaticField<JIOSCategoryOptions>("ALLOWBLUETOOTHA2DP");
+      static const auto fieldALLOWAIRPLAY = clazz->getStaticField<JIOSCategoryOptions>("ALLOWAIRPLAY");
+      static const auto fieldDEFAULTTOSPEAKER = clazz->getStaticField<JIOSCategoryOptions>("DEFAULTTOSPEAKER");
+      
+      switch (value) {
+        case IOSCategoryOptions::MIXWITHOTHERS:
+          return clazz->getStaticFieldValue(fieldMIXWITHOTHERS);
+        case IOSCategoryOptions::DUCKOTHERS:
+          return clazz->getStaticFieldValue(fieldDUCKOTHERS);
+        case IOSCategoryOptions::INTERRUPTSPOKENAUDIOANDMIXWITHOTHERS:
+          return clazz->getStaticFieldValue(fieldINTERRUPTSPOKENAUDIOANDMIXWITHOTHERS);
+        case IOSCategoryOptions::ALLOWBLUETOOTH:
+          return clazz->getStaticFieldValue(fieldALLOWBLUETOOTH);
+        case IOSCategoryOptions::ALLOWBLUETOOTHA2DP:
+          return clazz->getStaticFieldValue(fieldALLOWBLUETOOTHA2DP);
+        case IOSCategoryOptions::ALLOWAIRPLAY:
+          return clazz->getStaticFieldValue(fieldALLOWAIRPLAY);
+        case IOSCategoryOptions::DEFAULTTOSPEAKER:
+          return clazz->getStaticFieldValue(fieldDEFAULTTOSPEAKER);
+        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++/JIOSCategoryPolicy.hpp

@@ -0,0 +1,62 @@
+///
+/// JIOSCategoryPolicy.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "IOSCategoryPolicy.hpp"
+
+namespace margelo::nitro::audiobrowser {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "IOSCategoryPolicy" and the the Kotlin enum "IOSCategoryPolicy".
+   */
+  struct JIOSCategoryPolicy final: public jni::JavaClass<JIOSCategoryPolicy> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/IOSCategoryPolicy;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum IOSCategoryPolicy.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    IOSCategoryPolicy toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<IOSCategoryPolicy>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JIOSCategoryPolicy> fromCpp(IOSCategoryPolicy value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldDEFAULT = clazz->getStaticField<JIOSCategoryPolicy>("DEFAULT");
+      static const auto fieldLONGFORMAUDIO = clazz->getStaticField<JIOSCategoryPolicy>("LONGFORMAUDIO");
+      static const auto fieldLONGFORMVIDEO = clazz->getStaticField<JIOSCategoryPolicy>("LONGFORMVIDEO");
+      
+      switch (value) {
+        case IOSCategoryPolicy::DEFAULT:
+          return clazz->getStaticFieldValue(fieldDEFAULT);
+        case IOSCategoryPolicy::LONGFORMAUDIO:
+          return clazz->getStaticFieldValue(fieldLONGFORMAUDIO);
+        case IOSCategoryPolicy::LONGFORMVIDEO:
+          return clazz->getStaticFieldValue(fieldLONGFORMVIDEO);
+        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++/JImageContext.hpp

@@ -0,0 +1,61 @@
+///
+/// JImageContext.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "ImageContext.hpp"
+
+#include <optional>
+
+namespace margelo::nitro::audiobrowser {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "ImageContext" and the the Kotlin data class "ImageContext".
+   */
+  struct JImageContext final: public jni::JavaClass<JImageContext> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/ImageContext;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct ImageContext by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    ImageContext toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldWidth = clazz->getField<jni::JDouble>("width");
+      jni::local_ref<jni::JDouble> width = this->getFieldValue(fieldWidth);
+      static const auto fieldHeight = clazz->getField<jni::JDouble>("height");
+      jni::local_ref<jni::JDouble> height = this->getFieldValue(fieldHeight);
+      return ImageContext(
+        width != nullptr ? std::make_optional(width->value()) : std::nullopt,
+        height != nullptr ? std::make_optional(height->value()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JImageContext::javaobject> fromCpp(const ImageContext& value) {
+      using JSignature = JImageContext(jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.width.has_value() ? jni::JDouble::valueOf(value.width.value()) : nullptr,
+        value.height.has_value() ? jni::JDouble::valueOf(value.height.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::audiobrowser