react-native-nitro-player 0.0.1 → 0.3.0-alpha.10

package/lib/hooks/usePlaylist.d.ts

@@ -0,0 +1,48 @@
+import type { Playlist, TrackItem } from '../types/PlayerQueue';
+export interface UsePlaylistResult {
+    /** The currently loaded playlist */
+    currentPlaylist: Playlist | null;
+    /** ID of the currently loaded playlist */
+    currentPlaylistId: string | null;
+    /** All available playlists */
+    allPlaylists: Playlist[];
+    /** All tracks from all playlists (flattened) */
+    allTracks: TrackItem[];
+    /** Whether the playlists are currently loading */
+    isLoading: boolean;
+    /** Manually refresh playlist data */
+    refreshPlaylists: () => void;
+}
+/**
+ * Hook to manage playlist state
+ *
+ * Provides current playlist, all playlists, and all tracks across playlists.
+ * Automatically refreshes when:
+ * - Component mounts
+ * - Track changes (to update currentPlaylistId)
+ * - Playlists are modified via PlayerQueue methods
+ *
+ * Call `refreshPlaylists()` after creating/deleting playlists to update the state.
+ *
+ * @returns Object containing playlist state and refresh function
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { currentPlaylist, allTracks, refreshPlaylists } = usePlaylist();
+ *
+ *   const handleCreatePlaylist = () => {
+ *     PlayerQueue.createPlaylist('New Playlist');
+ *     refreshPlaylists(); // Refresh to see the new playlist
+ *   };
+ *
+ *   return (
+ *     <View>
+ *       <Text>{currentPlaylist?.name}</Text>
+ *       <Text>Total tracks: {allTracks.length}</Text>
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+export declare function usePlaylist(): UsePlaylistResult;

package/lib/hooks/usePlaylist.js

@@ -0,0 +1,136 @@
+import { useEffect, useState, useRef, useCallback } from 'react';
+import { PlayerQueue } from '../index';
+import { callbackManager } from './callbackManager';
+/**
+ * Hook to manage playlist state
+ *
+ * Provides current playlist, all playlists, and all tracks across playlists.
+ * Automatically refreshes when:
+ * - Component mounts
+ * - Track changes (to update currentPlaylistId)
+ * - Playlists are modified via PlayerQueue methods
+ *
+ * Call `refreshPlaylists()` after creating/deleting playlists to update the state.
+ *
+ * @returns Object containing playlist state and refresh function
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { currentPlaylist, allTracks, refreshPlaylists } = usePlaylist();
+ *
+ *   const handleCreatePlaylist = () => {
+ *     PlayerQueue.createPlaylist('New Playlist');
+ *     refreshPlaylists(); // Refresh to see the new playlist
+ *   };
+ *
+ *   return (
+ *     <View>
+ *       <Text>{currentPlaylist?.name}</Text>
+ *       <Text>Total tracks: {allTracks.length}</Text>
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+export function usePlaylist() {
+    const [currentPlaylist, setCurrentPlaylist] = useState(null);
+    const [currentPlaylistId, setCurrentPlaylistId] = useState(null);
+    const [allPlaylists, setAllPlaylists] = useState([]);
+    const [allTracks, setAllTracks] = useState([]);
+    const [isLoading, setIsLoading] = useState(true);
+    const isMounted = useRef(true);
+    const hasSubscribed = useRef(false);
+    const refreshPlaylists = useCallback(() => {
+        if (!isMounted.current)
+            return;
+        try {
+            // Get current playlist ID
+            const playlistId = PlayerQueue.getCurrentPlaylistId();
+            if (!isMounted.current)
+                return;
+            setCurrentPlaylistId(playlistId);
+            // Get current playlist details
+            if (playlistId) {
+                const playlist = PlayerQueue.getPlaylist(playlistId);
+                if (isMounted.current) {
+                    setCurrentPlaylist(playlist);
+                }
+            }
+            else {
+                if (isMounted.current) {
+                    setCurrentPlaylist(null);
+                }
+            }
+            // Get all playlists
+            const playlists = PlayerQueue.getAllPlaylists();
+            if (!isMounted.current)
+                return;
+            setAllPlaylists(playlists);
+            // Get all tracks from all playlists (deduplicated by id)
+            const trackMap = new Map();
+            playlists.forEach((playlist) => {
+                playlist.tracks.forEach((track) => {
+                    if (!trackMap.has(track.id)) {
+                        trackMap.set(track.id, track);
+                    }
+                });
+            });
+            if (isMounted.current) {
+                setAllTracks(Array.from(trackMap.values()));
+                setIsLoading(false);
+            }
+        }
+        catch (error) {
+            console.error('[usePlaylist] Error refreshing playlists:', error);
+            if (isMounted.current) {
+                setIsLoading(false);
+            }
+        }
+    }, []);
+    // Initialize and setup mounted ref
+    useEffect(() => {
+        isMounted.current = true;
+        // Initial load
+        refreshPlaylists();
+        return () => {
+            isMounted.current = false;
+        };
+    }, [refreshPlaylists]);
+    // Subscribe to native playlist changes (only once)
+    useEffect(() => {
+        if (hasSubscribed.current)
+            return;
+        hasSubscribed.current = true;
+        try {
+            PlayerQueue.onPlaylistsChanged(() => {
+                if (isMounted.current) {
+                    refreshPlaylists();
+                }
+            });
+        }
+        catch (error) {
+            console.error('[usePlaylist] Error setting up playlist listener:', error);
+        }
+    }, [refreshPlaylists]);
+    // Also refresh when track changes (as it might indicate playlist loaded)
+    useEffect(() => {
+        const unsubscribe = callbackManager.subscribeToTrackChange(() => {
+            // Refresh to update currentPlaylistId when track changes
+            if (isMounted.current) {
+                refreshPlaylists();
+            }
+        });
+        return () => {
+            unsubscribe();
+        };
+    }, [refreshPlaylists]);
+    return {
+        currentPlaylist,
+        currentPlaylistId,
+        allPlaylists,
+        allTracks,
+        isLoading,
+        refreshPlaylists,
+    };
+}

package/lib/index.d.ts

@@ -11,4 +11,5 @@ export * from './hooks';
 export * from './types/PlayerQueue';
 export * from './types/AndroidAutoMediaLibrary';
 export type { TAudioDevice } from './specs/AudioDevices.nitro';
+export type { RepeatMode } from './specs/TrackPlayer.nitro';
 export { AndroidAutoMediaLibraryHelper } from './utils/androidAutoMediaLibrary';

package/lib/specs/TrackPlayer.nitro.d.ts

@@ -18,6 +18,7 @@ export interface PlayerQueue extends HybridObject<{
     onPlaylistsChanged(callback: (playlists: Playlist[], operation?: QueueOperation) => void): void;
     onPlaylistChanged(callback: (playlistId: string, playlist: Playlist, operation?: QueueOperation) => void): void;
 }
+export type RepeatMode = 'off' | 'Playlist' | 'track';
 export interface TrackPlayer extends HybridObject<{
     android: 'kotlin';
     ios: 'swift';
@@ -28,7 +29,11 @@ export interface TrackPlayer extends HybridObject<{
     skipToNext(): void;
     skipToPrevious(): void;
     seek(position: number): void;
+    addToUpNext(trackId: string): void;
+    playNext(trackId: string): void;
+    getActualQueue(): TrackItem[];
     getState(): PlayerState;
+    setRepeatMode(mode: RepeatMode): boolean;
     configure(config: PlayerConfig): void;
     onChangeTrack(callback: (track: TrackItem, reason?: Reason) => void): void;
     onPlaybackStateChange(callback: (state: TrackPlayerState, reason?: Reason) => void): void;
@@ -36,4 +41,5 @@ export interface TrackPlayer extends HybridObject<{
     onPlaybackProgressChange(callback: (position: number, totalDuration: number, isManuallySeeked?: boolean) => void): void;
     onAndroidAutoConnectionChange(callback: (connected: boolean) => void): void;
     isAndroidAutoConnected(): boolean;
+    setVolume(volume: number): boolean;
 }

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

@@ -7,30 +7,35 @@
 
 #include "JHybridTrackPlayerSpec.hpp"
 
-// Forward declaration of `PlayerState` to properly resolve imports.
-namespace margelo::nitro::nitroplayer { struct PlayerState; }
 // Forward declaration of `TrackItem` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct TrackItem; }
+// Forward declaration of `PlayerState` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct PlayerState; }
 // Forward declaration of `TrackPlayerState` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class TrackPlayerState; }
+// Forward declaration of `RepeatMode` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class RepeatMode; }
 // Forward declaration of `PlayerConfig` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct PlayerConfig; }
 // Forward declaration of `Reason` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class Reason; }
 
-#include "PlayerState.hpp"
-#include "JPlayerState.hpp"
-#include <NitroModules/Null.hpp>
 #include "TrackItem.hpp"
-#include <variant>
-#include <optional>
-#include "JVariant_NullType_TrackItem.hpp"
-#include <NitroModules/JNull.hpp>
+#include <vector>
 #include "JTrackItem.hpp"
 #include <string>
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include <optional>
 #include "JVariant_NullType_String.hpp"
+#include <NitroModules/JNull.hpp>
+#include "PlayerState.hpp"
+#include "JPlayerState.hpp"
+#include "JVariant_NullType_TrackItem.hpp"
 #include "TrackPlayerState.hpp"
 #include "JTrackPlayerState.hpp"
+#include "RepeatMode.hpp"
+#include "JRepeatMode.hpp"
 #include "PlayerConfig.hpp"
 #include "JPlayerConfig.hpp"
 #include "Reason.hpp"
@@ -99,11 +104,38 @@ namespace margelo::nitro::nitroplayer {
     static const auto method = javaClassStatic()->getMethod<void(double /* position */)>("seek");
     method(_javaPart, position);
   }
+  void JHybridTrackPlayerSpec::addToUpNext(const std::string& trackId) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* trackId */)>("addToUpNext");
+    method(_javaPart, jni::make_jstring(trackId));
+  }
+  void JHybridTrackPlayerSpec::playNext(const std::string& trackId) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* trackId */)>("playNext");
+    method(_javaPart, jni::make_jstring(trackId));
+  }
+  std::vector<TrackItem> JHybridTrackPlayerSpec::getActualQueue() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JTrackItem>>()>("getActualQueue");
+    auto __result = method(_javaPart);
+    return [&]() {
+      size_t __size = __result->size();
+      std::vector<TrackItem> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __result->getElement(__i);
+        __vector.push_back(__element->toCpp());
+      }
+      return __vector;
+    }();
+  }
   PlayerState JHybridTrackPlayerSpec::getState() {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPlayerState>()>("getState");
     auto __result = method(_javaPart);
     return __result->toCpp();
   }
+  bool JHybridTrackPlayerSpec::setRepeatMode(RepeatMode mode) {
+    static const auto method = javaClassStatic()->getMethod<jboolean(jni::alias_ref<JRepeatMode> /* mode */)>("setRepeatMode");
+    auto __result = method(_javaPart, JRepeatMode::fromCpp(mode));
+    return static_cast<bool>(__result);
+  }
   void JHybridTrackPlayerSpec::configure(const PlayerConfig& config) {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JPlayerConfig> /* config */)>("configure");
     method(_javaPart, JPlayerConfig::fromCpp(config));
@@ -133,5 +165,10 @@ namespace margelo::nitro::nitroplayer {
     auto __result = method(_javaPart);
     return static_cast<bool>(__result);
   }
+  bool JHybridTrackPlayerSpec::setVolume(double volume) {
+    static const auto method = javaClassStatic()->getMethod<jboolean(double /* volume */)>("setVolume");
+    auto __result = method(_javaPart, volume);
+    return static_cast<bool>(__result);
+  }
 
 } // namespace margelo::nitro::nitroplayer

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

@@ -60,7 +60,11 @@ namespace margelo::nitro::nitroplayer {
     void skipToNext() override;
     void skipToPrevious() override;
     void seek(double position) override;
+    void addToUpNext(const std::string& trackId) override;
+    void playNext(const std::string& trackId) override;
+    std::vector<TrackItem> getActualQueue() override;
     PlayerState getState() override;
+    bool setRepeatMode(RepeatMode mode) override;
     void configure(const PlayerConfig& config) override;
     void onChangeTrack(const std::function<void(const TrackItem& /* track */, std::optional<Reason> /* reason */)>& callback) override;
     void onPlaybackStateChange(const std::function<void(TrackPlayerState /* state */, std::optional<Reason> /* reason */)>& callback) override;
@@ -68,6 +72,7 @@ namespace margelo::nitro::nitroplayer {
     void onPlaybackProgressChange(const std::function<void(double /* position */, double /* totalDuration */, std::optional<bool> /* isManuallySeeked */)>& callback) override;
     void onAndroidAutoConnectionChange(const std::function<void(bool /* connected */)>& callback) override;
     bool isAndroidAutoConnected() override;
+    bool setVolume(double volume) override;
 
   private:
     friend HybridBase;

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

@@ -0,0 +1,62 @@
+///
+/// JRepeatMode.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 "RepeatMode.hpp"
+
+namespace margelo::nitro::nitroplayer {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "RepeatMode" and the the Kotlin enum "RepeatMode".
+   */
+  struct JRepeatMode final: public jni::JavaClass<JRepeatMode> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitroplayer/RepeatMode;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum RepeatMode.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RepeatMode toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<RepeatMode>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JRepeatMode> fromCpp(RepeatMode value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOFF = clazz->getStaticField<JRepeatMode>("OFF");
+      static const auto fieldPLAYLIST = clazz->getStaticField<JRepeatMode>("PLAYLIST");
+      static const auto fieldTRACK = clazz->getStaticField<JRepeatMode>("TRACK");
+      
+      switch (value) {
+        case RepeatMode::OFF:
+          return clazz->getStaticFieldValue(fieldOFF);
+        case RepeatMode::PLAYLIST:
+          return clazz->getStaticFieldValue(fieldPLAYLIST);
+        case RepeatMode::TRACK:
+          return clazz->getStaticFieldValue(fieldTRACK);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::nitroplayer

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroplayer/HybridTrackPlayerSpec.kt

@@ -69,10 +69,26 @@ abstract class HybridTrackPlayerSpec: HybridObject() {
   @Keep
   abstract fun seek(position: Double): Unit
   
+  @DoNotStrip
+  @Keep
+  abstract fun addToUpNext(trackId: String): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun playNext(trackId: String): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getActualQueue(): Array<TrackItem>
+  
   @DoNotStrip
   @Keep
   abstract fun getState(): PlayerState
   
+  @DoNotStrip
+  @Keep
+  abstract fun setRepeatMode(mode: RepeatMode): Boolean
+  
   @DoNotStrip
   @Keep
   abstract fun configure(config: PlayerConfig): Unit
@@ -125,6 +141,10 @@ abstract class HybridTrackPlayerSpec: HybridObject() {
   @DoNotStrip
   @Keep
   abstract fun isAndroidAutoConnected(): Boolean
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setVolume(volume: Double): Boolean
 
   private external fun initHybrid(): HybridData
 

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroplayer/RepeatMode.kt

@@ -0,0 +1,22 @@
+///
+/// RepeatMode.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nitroplayer
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+
+/**
+ * Represents the JavaScript enum/union "RepeatMode".
+ */
+@DoNotStrip
+@Keep
+enum class RepeatMode(@DoNotStrip @Keep val value: Int) {
+  OFF(0),
+  PLAYLIST(1),
+  TRACK(2);
+}

package/nitrogen/generated/ios/NitroPlayer-Swift-Cxx-Bridge.hpp

@@ -510,6 +510,15 @@ namespace margelo::nitro::nitroplayer::bridge::swift {
   using std__weak_ptr_HybridTrackPlayerSpec_ = std::weak_ptr<HybridTrackPlayerSpec>;
   inline std__weak_ptr_HybridTrackPlayerSpec_ weakify_std__shared_ptr_HybridTrackPlayerSpec_(const std::shared_ptr<HybridTrackPlayerSpec>& strong) noexcept { return strong; }
   
+  // pragma MARK: Result<std::vector<TrackItem>>
+  using Result_std__vector_TrackItem__ = Result<std::vector<TrackItem>>;
+  inline Result_std__vector_TrackItem__ create_Result_std__vector_TrackItem__(const std::vector<TrackItem>& value) noexcept {
+    return Result<std::vector<TrackItem>>::withValue(value);
+  }
+  inline Result_std__vector_TrackItem__ create_Result_std__vector_TrackItem__(const std::exception_ptr& error) noexcept {
+    return Result<std::vector<TrackItem>>::withError(error);
+  }
+  
   // pragma MARK: Result<PlayerState>
   using Result_PlayerState_ = Result<PlayerState>;
   inline Result_PlayerState_ create_Result_PlayerState_(const PlayerState& value) noexcept {

package/nitrogen/generated/ios/NitroPlayer-Swift-Cxx-Umbrella.hpp

@@ -24,6 +24,8 @@ namespace margelo::nitro::nitroplayer { struct Playlist; }
 namespace margelo::nitro::nitroplayer { enum class QueueOperation; }
 // Forward declaration of `Reason` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class Reason; }
+// Forward declaration of `RepeatMode` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class RepeatMode; }
 // Forward declaration of `TrackItem` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct TrackItem; }
 // Forward declaration of `TrackPlayerState` to properly resolve imports.
@@ -38,6 +40,7 @@ namespace margelo::nitro::nitroplayer { enum class TrackPlayerState; }
 #include "Playlist.hpp"
 #include "QueueOperation.hpp"
 #include "Reason.hpp"
+#include "RepeatMode.hpp"
 #include "TrackItem.hpp"
 #include "TrackPlayerState.hpp"
 #include <NitroModules/Null.hpp>

package/nitrogen/generated/ios/c++/HybridTrackPlayerSpecSwift.hpp

@@ -12,12 +12,14 @@
 // Forward declaration of `HybridTrackPlayerSpec_cxx` to properly resolve imports.
 namespace NitroPlayer { class HybridTrackPlayerSpec_cxx; }
 
-// Forward declaration of `PlayerState` to properly resolve imports.
-namespace margelo::nitro::nitroplayer { struct PlayerState; }
 // Forward declaration of `TrackItem` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct TrackItem; }
+// Forward declaration of `PlayerState` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct PlayerState; }
 // Forward declaration of `TrackPlayerState` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class TrackPlayerState; }
+// Forward declaration of `RepeatMode` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class RepeatMode; }
 // Forward declaration of `PlayerConfig` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct PlayerConfig; }
 // Forward declaration of `Reason` to properly resolve imports.
@@ -25,11 +27,13 @@ namespace margelo::nitro::nitroplayer { enum class Reason; }
 
 #include <string>
 #include <optional>
-#include "PlayerState.hpp"
-#include <NitroModules/Null.hpp>
 #include "TrackItem.hpp"
+#include <vector>
+#include <NitroModules/Null.hpp>
 #include <variant>
+#include "PlayerState.hpp"
 #include "TrackPlayerState.hpp"
+#include "RepeatMode.hpp"
 #include "PlayerConfig.hpp"
 #include "Reason.hpp"
 #include <functional>
@@ -114,6 +118,26 @@ namespace margelo::nitro::nitroplayer {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void addToUpNext(const std::string& trackId) override {
+      auto __result = _swiftPart.addToUpNext(trackId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void playNext(const std::string& trackId) override {
+      auto __result = _swiftPart.playNext(trackId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::vector<TrackItem> getActualQueue() override {
+      auto __result = _swiftPart.getActualQueue();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline PlayerState getState() override {
       auto __result = _swiftPart.getState();
       if (__result.hasError()) [[unlikely]] {
@@ -122,6 +146,14 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline bool setRepeatMode(RepeatMode mode) override {
+      auto __result = _swiftPart.setRepeatMode(static_cast<int>(mode));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline void configure(const PlayerConfig& config) override {
       auto __result = _swiftPart.configure(std::forward<decltype(config)>(config));
       if (__result.hasError()) [[unlikely]] {
@@ -166,6 +198,14 @@ namespace margelo::nitro::nitroplayer {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline bool setVolume(double volume) override {
+      auto __result = _swiftPart.setVolume(std::forward<decltype(volume)>(volume));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
     NitroPlayer::HybridTrackPlayerSpec_cxx _swiftPart;

package/nitrogen/generated/ios/swift/HybridTrackPlayerSpec.swift

@@ -20,7 +20,11 @@ public protocol HybridTrackPlayerSpec_protocol: HybridObject {
   func skipToNext() throws -> Void
   func skipToPrevious() throws -> Void
   func seek(position: Double) throws -> Void
+  func addToUpNext(trackId: String) throws -> Void
+  func playNext(trackId: String) throws -> Void
+  func getActualQueue() throws -> [TrackItem]
   func getState() throws -> PlayerState
+  func setRepeatMode(mode: RepeatMode) throws -> Bool
   func configure(config: PlayerConfig) throws -> Void
   func onChangeTrack(callback: @escaping (_ track: TrackItem, _ reason: Reason?) -> Void) throws -> Void
   func onPlaybackStateChange(callback: @escaping (_ state: TrackPlayerState, _ reason: Reason?) -> Void) throws -> Void
@@ -28,6 +32,7 @@ public protocol HybridTrackPlayerSpec_protocol: HybridObject {
   func onPlaybackProgressChange(callback: @escaping (_ position: Double, _ totalDuration: Double, _ isManuallySeeked: Bool?) -> Void) throws -> Void
   func onAndroidAutoConnectionChange(callback: @escaping (_ connected: Bool) -> Void) throws -> Void
   func isAndroidAutoConnected() throws -> Bool
+  func setVolume(volume: Double) throws -> Bool
 }
 
 public extension HybridTrackPlayerSpec_protocol {