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

package/android/src/main/java/com/margelo/nitro/nitroplayer/core/TrackPlayerCore.kt

@@ -4,6 +4,8 @@ package com.margelo.nitro.nitroplayer.core
 
 import android.content.Context
 import android.net.Uri
+import androidx.media3.common.AudioAttributes
+import androidx.media3.common.C
 import androidx.media3.common.MediaItem
 import androidx.media3.common.MediaMetadata
 import androidx.media3.common.Player
@@ -13,6 +15,7 @@ import com.margelo.nitro.core.NullType
 import com.margelo.nitro.nitroplayer.NitroPlayerPackage
 import com.margelo.nitro.nitroplayer.PlayerState
 import com.margelo.nitro.nitroplayer.Reason
+import com.margelo.nitro.nitroplayer.RepeatMode
 import com.margelo.nitro.nitroplayer.TrackItem
 import com.margelo.nitro.nitroplayer.TrackPlayerState
 import com.margelo.nitro.nitroplayer.Variant_NullType_String
@@ -40,6 +43,7 @@ class TrackPlayerCore private constructor(
     private var isAndroidAutoConnected: Boolean = false
     private var androidAutoConnectionDetector: AndroidAutoConnectionDetector? = null
     var onAndroidAutoConnectionChange: ((Boolean) -> Unit)? = null
+    private var previousMediaItem: MediaItem? = null
     private val progressUpdateRunnable =
         object : Runnable {
             override fun run() {
@@ -58,6 +62,19 @@ class TrackPlayerCore private constructor(
     var onSeek: ((Double, Double) -> Unit)? = null
     var onPlaybackProgressChange: ((Double, Double, Boolean?) -> Unit)? = null
 
+    // Temporary tracks for addToUpNext and playNext
+    private var playNextStack: MutableList<TrackItem> = mutableListOf() // LIFO - last added plays first
+    private var upNextQueue: MutableList<TrackItem> = mutableListOf() // FIFO - first added plays first
+    private var currentTemporaryType: TemporaryType = TemporaryType.NONE
+    private var currentTracks: List<TrackItem> = emptyList()
+
+    // Enum to track what type of track is currently playing
+    private enum class TemporaryType {
+        NONE, // Playing from original playlist
+        PLAY_NEXT, // Currently in playNextStack
+        UP_NEXT, // Currently in upNextQueue
+    }
+
     companion object {
         @Volatile
         @Suppress("ktlint:standard:property-naming")
@@ -71,25 +88,43 @@ class TrackPlayerCore private constructor(
 
     init {
         handler.post {
-            // Configure LoadControl for gapless playback
-            // This enables pre-buffering of the next track for seamless transitions
+            // ============================================================
+            // GAPLESS PLAYBACK CONFIGURATION
+            // ============================================================
+            // Configure LoadControl for maximum gapless playback
+            // Large buffers ensure next track is fully ready before current ends
             val loadControl =
                 DefaultLoadControl
                     .Builder()
                     .setBufferDurationsMs(
-                        DefaultLoadControl.DEFAULT_MIN_BUFFER_MS, // Minimum buffer: 1.5s
-                        DefaultLoadControl.DEFAULT_MAX_BUFFER_MS, // Maximum buffer: 5s
-                        DefaultLoadControl.DEFAULT_BUFFER_FOR_PLAYBACK_MS, // Buffer for playback: 2.5s
-                        DefaultLoadControl.DEFAULT_BUFFER_FOR_PLAYBACK_AFTER_REBUFFER_MS, // Buffer after rebuffer: 5s
-                    ).setBackBuffer(DefaultLoadControl.DEFAULT_BACK_BUFFER_DURATION_MS, true) // Keep back buffer for seamless transitions
+                        30_000, // MIN_BUFFER_MS: 30 seconds minimum buffer
+                        120_000, // MAX_BUFFER_MS: 2 minutes maximum buffer (enables preloading next tracks)
+                        2_500, // BUFFER_FOR_PLAYBACK_MS: 2.5s before playback starts
+                        5_000, // BUFFER_FOR_PLAYBACK_AFTER_REBUFFER_MS: 5s after rebuffer
+                    ).setBackBuffer(30_000, true) // Keep 30s back buffer for seamless seek-back
+                    .setTargetBufferBytes(C.LENGTH_UNSET) // No size limit - prioritize time
                     .setPrioritizeTimeOverSizeThresholds(true) // Prioritize time-based buffering
                     .build()
 
+            // Configure audio attributes for optimal music playback
+            // This enables gapless audio processing in the audio pipeline
+            val audioAttributes =
+                AudioAttributes
+                    .Builder()
+                    .setUsage(C.USAGE_MEDIA)
+                    .setContentType(C.AUDIO_CONTENT_TYPE_MUSIC)
+                    .build()
+
             player =
                 ExoPlayer
                     .Builder(context)
                     .setLoadControl(loadControl)
+                    .setAudioAttributes(audioAttributes, true) // handleAudioFocus = true for gapless
+                    .setHandleAudioBecomingNoisy(true) // Pause when headphones disconnected
+                    .setPauseAtEndOfMediaItems(false) // Don't pause between items - key for gapless!
                     .build()
+
+            println("🎵 TrackPlayerCore: Gapless playback configured - 120s buffer, audio focus handling enabled")
             mediaSessionManager =
                 MediaSessionManager(context, player, playlistManager).apply {
                     setTrackPlayerCore(this@TrackPlayerCore)
@@ -122,6 +157,60 @@ class TrackPlayerCore private constructor(
                         mediaItem: MediaItem?,
                         reason: Int,
                     ) {
+                        println("\n🔄 onMediaItemTransition called")
+                        println(
+                            "   reason: ${when (reason) {
+                                Player.MEDIA_ITEM_TRANSITION_REASON_AUTO -> "AUTO (track ended)"
+                                Player.MEDIA_ITEM_TRANSITION_REASON_SEEK -> "SEEK"
+                                Player.MEDIA_ITEM_TRANSITION_REASON_PLAYLIST_CHANGED -> "PLAYLIST_CHANGED"
+                                Player.MEDIA_ITEM_TRANSITION_REASON_REPEAT -> "REPEAT"
+                                else -> "UNKNOWN($reason)"
+                            }}",
+                        )
+                        println("   previousMediaItem: ${previousMediaItem?.mediaId}")
+                        println("   new mediaItem: ${mediaItem?.mediaId}")
+                        println("   playNextStack: ${playNextStack.map { it.id }}")
+                        println("   upNextQueue: ${upNextQueue.map { it.id }}")
+
+                        // Remove finished track from temporary lists
+                        // Handle AUTO (natural end) and SEEK (skip next) transitions
+                        if ((
+                                reason == Player.MEDIA_ITEM_TRANSITION_REASON_AUTO ||
+                                    reason == Player.MEDIA_ITEM_TRANSITION_REASON_SEEK
+                            ) &&
+                            previousMediaItem != null
+                        ) {
+                            previousMediaItem?.mediaId?.let { mediaId ->
+                                val trackId = extractTrackId(mediaId)
+                                println("🏁 Track finished/skipped, checking for removal: $trackId")
+
+                                // Find and remove from playNext stack (like iOS does)
+                                val playNextIndex = playNextStack.indexOfFirst { it.id == trackId }
+                                if (playNextIndex >= 0) {
+                                    val track = playNextStack.removeAt(playNextIndex)
+                                    println("   ✅ Removed from playNext stack: ${track.title}")
+                                } else {
+                                    // Find and remove from upNext queue
+                                    val upNextIndex = upNextQueue.indexOfFirst { it.id == trackId }
+                                    if (upNextIndex >= 0) {
+                                        val track = upNextQueue.removeAt(upNextIndex)
+                                        println("   ✅ Removed from upNext queue: ${track.title}")
+                                    } else {
+                                        println("   ℹ️  Was an original playlist track")
+                                    }
+                                }
+                            }
+                        } else {
+                            println("   ⏭️  Skipping removal (reason=$reason, prev=${previousMediaItem != null})")
+                        }
+
+                        // Store current item as previous for next transition
+                        previousMediaItem = mediaItem
+
+                        // Update temporary type for current track
+                        currentTemporaryType = determineCurrentTemporaryType()
+                        println("   Updated currentTemporaryType: $currentTemporaryType")
+
                         // Handle playlist switching if needed
                         mediaItem?.mediaId?.let { mediaId ->
                             if (mediaId.contains(':')) {
@@ -141,7 +230,8 @@ class TrackPlayerCore private constructor(
                             }
                         }
 
-                        val track = findTrack(mediaItem)
+                        // Use getCurrentTrack() which handles temporary tracks properly
+                        val track = getCurrentTrack()
                         if (track != null) {
                             val r =
                                 when (reason) {
@@ -209,6 +299,12 @@ class TrackPlayerCore private constructor(
      */
     fun loadPlaylist(playlistId: String) {
         handler.post {
+            // Clear temporary tracks when loading new playlist
+            playNextStack.clear()
+            upNextQueue.clear()
+            currentTemporaryType = TemporaryType.NONE
+            println("   🧹 Cleared temporary tracks")
+
             val playlist = playlistManager.getPlaylist(playlistId)
             if (playlist != null) {
                 currentPlaylistId = playlistId
@@ -295,6 +391,9 @@ class TrackPlayerCore private constructor(
     }
 
     private fun updatePlayerQueue(tracks: List<TrackItem>) {
+        // Store the original tracks
+        currentTracks = tracks
+
         // Create MediaItems with playlist info in mediaId for Android Auto
         val mediaItems =
             tracks.mapIndexed { index, track ->
@@ -365,6 +464,12 @@ class TrackPlayerCore private constructor(
         println("🎵 TrackPlayerCore: playSong() called - songId: $songId, fromPlaylist: $fromPlaylist")
 
         handler.post {
+            // Clear temporary tracks when directly playing a song
+            playNextStack.clear()
+            upNextQueue.clear()
+            currentTemporaryType = TemporaryType.NONE
+            println("   🧹 Cleared temporary tracks")
+
             var targetPlaylistId: String? = null
             var songIndex: Int = -1
 
@@ -463,8 +568,15 @@ class TrackPlayerCore private constructor(
 
     fun skipToPrevious() {
         handler.post {
-            if (player.hasPreviousMediaItem()) {
+            // If playing temporary track, just seek to beginning (temps not navigable backwards)
+            if (currentTemporaryType != TemporaryType.NONE) {
+                println("🔄 TrackPlayerCore: Playing temporary track - seeking to beginning")
+                player.seekTo(0)
+            } else if (player.hasPreviousMediaItem()) {
                 player.seekToPreviousMediaItem()
+            } else {
+                // Already at first track, seek to beginning
+                player.seekTo(0)
             }
         }
     }
@@ -476,6 +588,21 @@ class TrackPlayerCore private constructor(
         }
     }
 
+    fun setRepeatMode(mode: RepeatMode): Boolean {
+        println("🔁 TrackPlayerCore: setRepeatMode called with mode: $mode")
+        handler.post {
+            val exoRepeatMode =
+                when (mode) {
+                    RepeatMode.OFF -> Player.REPEAT_MODE_OFF
+                    RepeatMode.TRACK -> Player.REPEAT_MODE_ONE
+                    RepeatMode.PLAYLIST -> Player.REPEAT_MODE_ALL
+                }
+            player.repeatMode = exoRepeatMode
+            println("🔁 TrackPlayerCore: ExoPlayer repeat mode set to: $exoRepeatMode")
+        }
+        return true
+    }
+
     fun getState(): PlayerState {
         // Check if we're already on the main thread
         if (android.os.Looper.myLooper() == handler.looper) {
@@ -506,13 +633,8 @@ class TrackPlayerCore private constructor(
 
     private fun getStateInternal(): PlayerState =
         if (::player.isInitialized) {
-            val currentMediaItem = player.currentMediaItem
-            val track =
-                if (currentMediaItem != null) {
-                    findTrack(currentMediaItem)
-                } else {
-                    null
-                }
+            // Use getCurrentTrack() which handles temporary tracks properly
+            val track = getCurrentTrack()
 
             // Convert nullable TrackItem to Variant_NullType_TrackItem
             val currentTrack: Variant_NullType_TrackItem? =
@@ -589,12 +711,45 @@ class TrackPlayerCore private constructor(
     fun getCurrentTrack(): TrackItem? {
         if (!::player.isInitialized) return null
         val currentMediaItem = player.currentMediaItem ?: return null
+
+        // If playing a temporary track, return that
+        if (currentTemporaryType != TemporaryType.NONE) {
+            val trackId = extractTrackId(currentMediaItem.mediaId)
+
+            when (currentTemporaryType) {
+                TemporaryType.PLAY_NEXT -> {
+                    return playNextStack.firstOrNull { it.id == trackId }
+                }
+
+                TemporaryType.UP_NEXT -> {
+                    return upNextQueue.firstOrNull { it.id == trackId }
+                }
+
+                else -> {}
+            }
+        }
+
+        // Otherwise return from original playlist
         return findTrack(currentMediaItem)
     }
 
+    private fun extractTrackId(mediaId: String): String =
+        if (mediaId.contains(':')) {
+            // Format: "playlistId:trackId"
+            mediaId.substring(mediaId.indexOf(':') + 1)
+        } else {
+            mediaId
+        }
+
     // Public method to play from a specific index (for Android Auto)
     fun playFromIndex(index: Int) {
         handler.post {
+            // Clear temporary tracks when jumping to specific index
+            playNextStack.clear()
+            upNextQueue.clear()
+            currentTemporaryType = TemporaryType.NONE
+            println("   🧹 Cleared temporary tracks")
+
             if (::player.isInitialized && index >= 0 && index < player.mediaItemCount) {
                 player.seekToDefaultPosition(index)
                 player.playWhenReady = true
@@ -602,6 +757,163 @@ class TrackPlayerCore private constructor(
         }
     }
 
+    // MARK: - Temporary Track Management
+
+    /**
+     * Add a track to the up-next queue (FIFO - first added plays first)
+     * Track will be inserted after currently playing track and any playNext tracks
+     */
+    fun addToUpNext(trackId: String) {
+        handler.post {
+            println("📋 TrackPlayerCore: addToUpNext($trackId)")
+
+            // Find the track from current playlist or all playlists
+            val track = findTrackById(trackId)
+            if (track == null) {
+                println("❌ TrackPlayerCore: Track $trackId not found")
+                return@post
+            }
+
+            // Add to end of upNext queue (FIFO)
+            upNextQueue.add(track)
+            println("   ✅ Added '${track.title}' to upNext queue (position: ${upNextQueue.size})")
+
+            // Rebuild the player queue if actively playing
+            if (::player.isInitialized && player.currentMediaItem != null) {
+                rebuildQueueFromCurrentPosition()
+            }
+        }
+    }
+
+    /**
+     * Add a track to play next (LIFO - last added plays first)
+     * Track will be inserted immediately after currently playing track
+     */
+    fun playNext(trackId: String) {
+        handler.post {
+            println("⏭️ TrackPlayerCore: playNext($trackId)")
+
+            // Find the track from current playlist or all playlists
+            val track = findTrackById(trackId)
+            if (track == null) {
+                println("❌ TrackPlayerCore: Track $trackId not found")
+                return@post
+            }
+
+            // Insert at beginning of playNext stack (LIFO)
+            playNextStack.add(0, track)
+            println("   ✅ Added '${track.title}' to playNext stack (position: 1)")
+
+            // Rebuild the player queue if actively playing
+            if (::player.isInitialized && player.currentMediaItem != null) {
+                rebuildQueueFromCurrentPosition()
+            }
+        }
+    }
+
+    /**
+     * Rebuild the ExoPlayer queue from current position with temporary tracks
+     * Order: [current] + [playNext stack] + [upNext queue] + [remaining original]
+     */
+    private fun rebuildQueueFromCurrentPosition() {
+        if (!::player.isInitialized) return
+
+        println("\n🔄 TrackPlayerCore: REBUILDING QUEUE FROM CURRENT POSITION")
+        println("   currentIndex: ${player.currentMediaItemIndex}")
+        println("   currentMediaItem: ${player.currentMediaItem?.mediaId}")
+        println("   playNextStack (${playNextStack.size}): ${playNextStack.map { "${it.id}:${it.title}" }}")
+        println("   upNextQueue (${upNextQueue.size}): ${upNextQueue.map { "${it.id}:${it.title}" }}")
+
+        val currentIndex = player.currentMediaItemIndex
+        if (currentIndex < 0) return
+
+        // Build new queue order:
+        // [playNext stack] + [upNext queue] + [remaining original tracks]
+        val newQueueTracks = mutableListOf<TrackItem>()
+
+        // Add playNext stack (LIFO - most recently added plays first)
+        // Stack is already in correct order since we insert at position 0
+        newQueueTracks.addAll(playNextStack)
+
+        // Add upNext queue (in order, FIFO)
+        newQueueTracks.addAll(upNextQueue)
+
+        // Add remaining original tracks
+        if (currentIndex + 1 < currentTracks.size) {
+            val remaining = currentTracks.subList(currentIndex + 1, currentTracks.size)
+            println("   remaining original (${remaining.size}): ${remaining.map { it.id }}")
+            newQueueTracks.addAll(remaining)
+        }
+
+        println("   New queue total: ${newQueueTracks.size} tracks")
+        println("   Queue order: ${newQueueTracks.map { it.id }}")
+
+        // Create MediaItems for new tracks
+        val playlistId = currentPlaylistId ?: ""
+        val newMediaItems =
+            newQueueTracks.map { track ->
+                val mediaId = if (playlistId.isNotEmpty()) "$playlistId:${track.id}" else track.id
+                println("   Creating MediaItem: mediaId=$mediaId, title=${track.title}")
+                track.toMediaItem(mediaId)
+            }
+
+        // Remove all items after current
+        val removedCount = player.mediaItemCount - currentIndex - 1
+        println("   Removing $removedCount items after current")
+        while (player.mediaItemCount > currentIndex + 1) {
+            player.removeMediaItem(currentIndex + 1)
+        }
+
+        // Add new items
+        player.addMediaItems(newMediaItems)
+
+        println("   ✅ Queue rebuilt. Player now has ${player.mediaItemCount} items")
+        for (i in 0 until player.mediaItemCount) {
+            println("      [$i]: ${player.getMediaItemAt(i).mediaId}")
+        }
+    }
+
+    /**
+     * Find a track by ID from current playlist or all playlists
+     */
+    private fun findTrackById(trackId: String): TrackItem? {
+        // First check current playlist
+        currentTracks.find { it.id == trackId }?.let { return it }
+
+        // Then check all playlists
+        val allPlaylists = playlistManager.getAllPlaylists()
+        for (playlist in allPlaylists) {
+            playlist.tracks.find { it.id == trackId }?.let { return it }
+        }
+
+        return null
+    }
+
+    /**
+     * Determine what type of track is currently playing
+     */
+    private fun determineCurrentTemporaryType(): TemporaryType {
+        val currentItem = player.currentMediaItem ?: return TemporaryType.NONE
+        val trackId =
+            if (currentItem.mediaId.contains(':')) {
+                currentItem.mediaId.substring(currentItem.mediaId.indexOf(':') + 1)
+            } else {
+                currentItem.mediaId
+            }
+
+        // Check if in playNext stack
+        if (playNextStack.any { it.id == trackId }) {
+            return TemporaryType.PLAY_NEXT
+        }
+
+        // Check if in upNext queue
+        if (upNextQueue.any { it.id == trackId }) {
+            return TemporaryType.UP_NEXT
+        }
+
+        return TemporaryType.NONE
+    }
+
     // Clean up resources
     fun destroy() {
         handler.post {
@@ -636,4 +948,84 @@ class TrackPlayerCore private constructor(
             NitroPlayerMediaBrowserService.getInstance()?.onPlaylistsUpdated()
         }
     }
+
+    // Set volume (0-100 range, converted to 0.0-1.0 for ExoPlayer)
+    fun setVolume(volume: Double): Boolean =
+        if (::player.isInitialized) {
+            handler.post {
+                // Clamp volume to 0-100 range
+                val clampedVolume = volume.coerceIn(0.0, 100.0)
+                // Convert to 0.0-1.0 range for ExoPlayer
+                val normalizedVolume = (clampedVolume / 100.0).toFloat()
+                player.volume = normalizedVolume
+                println("🔊 TrackPlayerCore: Volume set to $clampedVolume% (normalized: $normalizedVolume)")
+            }
+            true
+        } else {
+            println("⚠️ TrackPlayerCore: Cannot set volume - player not initialized")
+            false
+        }
+
+    /**
+     * Get the actual queue with temporary tracks
+     * Returns: [original_before_current] + [current] + [playNext_stack] + [upNext_queue] + [original_after_current]
+     */
+    fun getActualQueue(): List<TrackItem> {
+        // Check if we're already on the main thread
+        if (android.os.Looper.myLooper() == handler.looper) {
+            return getActualQueueInternal()
+        }
+
+        // Use CountDownLatch to wait for the result on the main thread
+        val latch = CountDownLatch(1)
+        var result: List<TrackItem>? = null
+
+        handler.post {
+            try {
+                result = getActualQueueInternal()
+            } finally {
+                latch.countDown()
+            }
+        }
+
+        try {
+            // Wait up to 5 seconds for the result
+            latch.await(5, TimeUnit.SECONDS)
+        } catch (e: InterruptedException) {
+            println("⚠️ TrackPlayerCore: Interrupted while waiting for actual queue")
+        }
+
+        return result ?: emptyList()
+    }
+
+    private fun getActualQueueInternal(): List<TrackItem> {
+        val queue = mutableListOf<TrackItem>()
+
+        if (!::player.isInitialized) return emptyList()
+
+        val currentIndex = player.currentMediaItemIndex
+        if (currentIndex < 0) return emptyList()
+
+        // Add tracks before current (original playlist)
+        if (currentIndex > 0 && currentIndex <= currentTracks.size) {
+            queue.addAll(currentTracks.subList(0, currentIndex))
+        }
+
+        // Add current track
+        getCurrentTrack()?.let { queue.add(it) }
+
+        // Add playNext stack (LIFO - most recently added plays first)
+        // Stack is already in correct order since we insert at position 0
+        queue.addAll(playNextStack)
+
+        // Add upNext queue (in order, FIFO)
+        queue.addAll(upNextQueue)
+
+        // Add remaining original tracks
+        if (currentIndex + 1 < currentTracks.size) {
+            queue.addAll(currentTracks.subList(currentIndex + 1, currentTracks.size))
+        }
+
+        return queue
+    }
 }

package/ios/HybridAudioRoutePicker.swift

@@ -1,53 +1,54 @@
-import Foundation
-import UIKit
 import AVKit
+import Foundation
 import NitroModules
+import UIKit
 
 class HybridAudioRoutePicker: HybridAudioRoutePickerSpec {
-    
-    // Approximate memory footprint of this instance's reference
-    private func getSizeOf(_ object: AnyObject) -> Int {
-        // For class instances, MemoryLayout reports the size of the reference (pointer)
-        return MemoryLayout.size(ofValue: object)
-    }
-    
-    var memorySize: Int {
-        return getSizeOf(self)
-    }
-    
-    func showRoutePicker() throws -> Void {
-        DispatchQueue.main.async {
-            // Create AVRoutePickerView
-            let routePickerView = AVRoutePickerView()
-            routePickerView.frame = CGRect(x: 0, y: 0, width: 44, height: 44)
-            routePickerView.tintColor = .systemBlue
-            routePickerView.activeTintColor = .systemBlue
-            
-            // Get the key window
-            guard let window = UIApplication.shared.connectedScenes
-                .compactMap({ $0 as? UIWindowScene })
-                .flatMap({ $0.windows })
-                .first(where: { $0.isKeyWindow }) else {
-                print("HybridAudioRoutePicker: Could not find key window")
-                return
-            }
-            
-            // Add the route picker to the window temporarily
-            window.addSubview(routePickerView)
-            
-            // Trigger the route picker button programmatically
-            for view in routePickerView.subviews {
-                if let button = view as? UIButton {
-                    button.sendActions(for: .touchUpInside)
-                    break
-                }
-            }
-            
-            // Remove the view after a short delay
-            DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
-                routePickerView.removeFromSuperview()
-            }
+
+  // Approximate memory footprint of this instance's reference
+  private func getSizeOf(_ object: AnyObject) -> Int {
+    // For class instances, MemoryLayout reports the size of the reference (pointer)
+    return MemoryLayout.size(ofValue: object)
+  }
+
+  var memorySize: Int {
+    return getSizeOf(self)
+  }
+
+  func showRoutePicker() throws {
+    DispatchQueue.main.async {
+      // Create AVRoutePickerView
+      let routePickerView = AVRoutePickerView()
+      routePickerView.frame = CGRect(x: 0, y: 0, width: 44, height: 44)
+      routePickerView.tintColor = .systemBlue
+      routePickerView.activeTintColor = .systemBlue
+
+      // Get the key window
+      guard
+        let window = UIApplication.shared.connectedScenes
+          .compactMap({ $0 as? UIWindowScene })
+          .flatMap({ $0.windows })
+          .first(where: { $0.isKeyWindow })
+      else {
+        print("HybridAudioRoutePicker: Could not find key window")
+        return
+      }
+
+      // Add the route picker to the window temporarily
+      window.addSubview(routePickerView)
+
+      // Trigger the route picker button programmatically
+      for view in routePickerView.subviews {
+        if let button = view as? UIButton {
+          button.sendActions(for: .touchUpInside)
+          break
         }
+      }
+
+      // Remove the view after a short delay
+      DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
+        routePickerView.removeFromSuperview()
+      }
     }
+  }
 }
-

package/ios/HybridTrackPlayer.swift

@@ -48,10 +48,26 @@ final class HybridTrackPlayer: HybridTrackPlayerSpec {
     core.seek(position: position)
   }
 
+  func addToUpNext(trackId: String) throws {
+    core.addToUpNext(trackId: trackId)
+  }
+
+  func playNext(trackId: String) throws {
+    core.playNext(trackId: trackId)
+  }
+
+  func getActualQueue() throws -> [TrackItem] {
+    return core.getActualQueue()
+  }
+
   func getState() throws -> PlayerState {
     return core.getState()
   }
 
+  func setRepeatMode(mode: RepeatMode) throws -> Bool {
+    return core.setRepeatMode(mode: mode)
+  }
+
   // MARK: - Configuration
 
   func configure(config: PlayerConfig) throws {
@@ -97,4 +113,10 @@ final class HybridTrackPlayer: HybridTrackPlayerSpec {
   func isAndroidAutoConnected() throws -> Bool {
     return false
   }
+
+  // MARK: - Volume Control
+
+  func setVolume(volume: Double) throws -> Bool {
+    return core.setVolume(volume: volume)
+  }
 }