@javascriptcommon/react-native-track-player 1.2.23 → 4.1.4

package/android/src/main/java/com/{guichaguri/trackplayer/kotlinaudio/players → lovegaoshi/kotlinaudio/player}/QueuedAudioPlayer.kt

@@ -1,33 +1,57 @@
-package com.guichaguri.trackplayer.kotlinaudio.players
+@file: OptIn(UnstableApi::class) package com.lovegaoshi.kotlinaudio.player
 
 import android.content.Context
-import android.util.Log
-import com.doublesymmetry.kotlinaudio.players.BaseAudioPlayer
-import com.google.android.exoplayer2.C
-import com.google.android.exoplayer2.IllegalSeekPositionException
-import com.google.android.exoplayer2.source.MediaSource
-import com.guichaguri.trackplayer.kotlinaudio.models.*
+import androidx.annotation.OptIn
+import androidx.media3.common.C
+import androidx.media3.common.IllegalSeekPositionException
+import androidx.media3.common.MediaItem
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import com.lovegaoshi.kotlinaudio.models.*
 import java.util.*
 import kotlin.math.max
 import kotlin.math.min
 
 class QueuedAudioPlayer(
-    context: Context,
-    playerConfig: PlayerConfig = PlayerConfig(),
-    bufferConfig: BufferConfig? = null,
-    cacheConfig: CacheConfig? = null,
-    mediaSessionCallback: AAMediaSessionCallBack
-) : BaseAudioPlayer(context, playerConfig, bufferConfig, cacheConfig, mediaSessionCallback) {
-    private val queue = LinkedList<MediaSource>()
-    override val playerOptions = DefaultQueuedPlayerOptions(exoPlayer)
+    private val context: Context,
+    options: PlayerOptions = PlayerOptions()
+) : AudioPlayer(context, options) {
 
-//    val currentIndex
-//        get() = exoPlayer.currentMediaItemIndex
+    var parseEmbeddedArtwork: Boolean = false
 
-    val currentIndex = 0
+    private val queue = LinkedList<MediaItem>()
+
+    private fun parseAudioItem(audioItem: AudioItem): MediaItem {
+        return audioItem2MediaItem(audioItem, if (parseEmbeddedArtwork) context else null)
+    }
+
+    var repeatMode: RepeatMode
+        get() {
+            return when (exoPlayer.repeatMode) {
+                Player.REPEAT_MODE_ALL -> RepeatMode.ALL
+                Player.REPEAT_MODE_ONE -> RepeatMode.ONE
+                else -> RepeatMode.OFF
+            }
+        }
+        set(value) {
+            when (value) {
+                RepeatMode.ALL -> players().forEach { p -> p.repeatMode = Player.REPEAT_MODE_ALL }
+                RepeatMode.ONE -> players().forEach { p -> p.repeatMode = Player.REPEAT_MODE_ONE }
+                RepeatMode.OFF -> players().forEach { p -> p.repeatMode = Player.REPEAT_MODE_OFF }
+            }
+        }
+
+    val currentIndex
+        get() = exoPlayer.currentMediaItemIndex
+
+    var shuffleMode
+        get() = exoPlayer.shuffleModeEnabled
+        set(v) {
+            players().forEach{ p -> p.shuffleModeEnabled = v }
+        }
 
     override val currentItem: AudioItem?
-        get() = (queue.getOrNull(currentIndex)?.mediaItem?.localConfiguration?.tag as AudioItemHolder?)?.audioItem
+        get() = mediaItem2AudioItem(queue.getOrNull(currentIndex))
 
     val nextIndex: Int?
         get() {
@@ -42,26 +66,14 @@ class QueuedAudioPlayer(
         }
 
     val items: List<AudioItem>
-        get() = queue.map { (it.mediaItem.localConfiguration?.tag as AudioItemHolder).audioItem }
-
-    fun getQueueHead(): MediaSource? {
-        return if (queue.isNotEmpty()) {
-            queue.peek()
-        } else {
-            null
-        }
-    }
-
-    fun getQueueSize(): Int {
-        return queue.size
-    }
+        get() = queue.map { mediaItem2AudioItem(it)!! }
 
     val previousItems: List<AudioItem>
         get() {
             return if (queue.isEmpty()) emptyList()
             else queue
                 .subList(0, exoPlayer.currentMediaItemIndex)
-                .map { (it.mediaItem.localConfiguration?.tag as AudioItemHolder).audioItem }
+                .map { mediaItem2AudioItem(it)!! }
         }
 
     val nextItems: List<AudioItem>
@@ -69,7 +81,7 @@ class QueuedAudioPlayer(
             return if (queue.isEmpty()) emptyList()
             else queue
                 .subList(exoPlayer.currentMediaItemIndex, queue.lastIndex)
-                .map { (it.mediaItem.localConfiguration?.tag as AudioItemHolder).audioItem }
+                .map { mediaItem2AudioItem(it)!! }
         }
 
     val nextItem: AudioItem?
@@ -79,18 +91,19 @@ class QueuedAudioPlayer(
         get() = items.getOrNull(currentIndex - 1)
 
     override fun load(item: AudioItem, playWhenReady: Boolean) {
-        exoPlayer.playWhenReady = playWhenReady
         load(item)
+        exoPlayer.playWhenReady = playWhenReady
     }
 
     override fun load(item: AudioItem) {
         if (queue.isEmpty()) {
             add(item)
         } else {
-            val mediaSource = getMediaSourceFromAudioItem(item)
-            queue[currentIndex] = mediaSource
-            exoPlayer.addMediaSource(currentIndex + 1, mediaSource)
-            exoPlayer.removeMediaItem(currentIndex)
+            players().forEach { p ->
+                p.addMediaItem(currentIndex + 1, parseAudioItem(item))
+                p.removeMediaItem(currentIndex)
+                p.seekTo(currentIndex, C.TIME_UNSET)
+            }
             exoPlayer.prepare()
         }
     }
@@ -107,12 +120,11 @@ class QueuedAudioPlayer(
     /**
      * Add a single item to the queue. If the AudioPlayer has no item loaded, it will load the `item`.
      * @param item The [AudioItem] to add.
-     * @param playWhenReady Whether playback starts automatically.
      */
     fun add(item: AudioItem) {
-        val mediaSource = getMediaSourceFromAudioItem(item)
+        val mediaSource = parseAudioItem(item)
         queue.add(mediaSource)
-        exoPlayer.addMediaSource(mediaSource)
+        players().forEach { p -> p.addMediaItem(mediaSource) }
         exoPlayer.prepare()
     }
 
@@ -131,21 +143,22 @@ class QueuedAudioPlayer(
      * @param items The [AudioItem]s to add.
      */
     fun add(items: List<AudioItem>) {
-        val mediaSources = items.map { getMediaSourceFromAudioItem(it) }
+        val mediaSources = items.map { parseAudioItem(it) }
         queue.addAll(mediaSources)
-        exoPlayer.addMediaSources(mediaSources)
+        players().forEach { p -> p.addMediaItems(mediaSources) }
         exoPlayer.prepare()
     }
 
+
     /**
      * Add multiple items to the queue.
      * @param items The [AudioItem]s to add.
      * @param atIndex  Index to insert items at, if no items loaded this will not automatically start playback.
      */
     fun add(items: List<AudioItem>, atIndex: Int) {
-        val mediaSources = items.map { getMediaSourceFromAudioItem(it) }
+        val mediaSources = items.map { parseAudioItem(it) }
         queue.addAll(atIndex, mediaSources)
-        exoPlayer.addMediaSources(atIndex, mediaSources)
+        players().forEach { p -> p.addMediaItems(atIndex, mediaSources) }
         exoPlayer.prepare()
     }
 
@@ -155,7 +168,7 @@ class QueuedAudioPlayer(
      */
     fun remove(index: Int) {
         queue.removeAt(index)
-        exoPlayer.removeMediaItem(index)
+        players().forEach { p -> p.removeMediaItem(index) }
     }
 
     /**
@@ -163,10 +176,10 @@ class QueuedAudioPlayer(
      * @param indexes The indexes of the items to remove.
      */
     fun remove(indexes: List<Int>) {
-        var sorted = indexes.toList()
+        val sorted = indexes.toMutableList()
         // Sort the indexes in descending order so we can safely remove them one by one
         // without having the next index possibly newly pointing to another item than intended:
-        Collections.sort(sorted, Collections.reverseOrder());
+        sorted.sortDescending()
         sorted.forEach {
             remove(it)
         }
@@ -196,8 +209,8 @@ class QueuedAudioPlayer(
      * @param toIndex The index to move the item to. If the index is larger than the size of the queue, the item is moved to the end of the queue instead.
      */
     fun move(fromIndex: Int, toIndex: Int) {
-        exoPlayer.moveMediaItem(fromIndex, toIndex)
-        var item = queue[fromIndex]
+        players().forEach { p -> p.moveMediaItem(fromIndex, toIndex) }
+        val item = queue[fromIndex]
         queue.removeAt(fromIndex)
         queue.add(max(0, min(items.size, if (toIndex > fromIndex) toIndex else toIndex - 1)), item)
     }
@@ -227,14 +240,11 @@ class QueuedAudioPlayer(
 
     /**
      * Replaces item at index in queue.
-     * If updating current index, we update the notification metadata if [automaticallyUpdateNotificationMetadata] is true.
      */
     fun replaceItem(index: Int, item: AudioItem) {
-        val mediaSource = getMediaSourceFromAudioItem(item)
+        val mediaSource = parseAudioItem(item)
         queue[index] = mediaSource
-        if (index == currentIndex) {
-            updateNotificationMetadataIfAutomatic(item)
-        }
+        players().forEach { p -> p.replaceMediaItem(index, mediaSource) }
     }
 
     /**
@@ -245,7 +255,7 @@ class QueuedAudioPlayer(
         val lastIndex = queue.lastIndex + 1
         val fromIndex = currentIndex + 1
 
-        exoPlayer.removeMediaItems(fromIndex, lastIndex)
+        players().forEach { p -> p.removeMediaItems(fromIndex, lastIndex) }
         queue.subList(fromIndex, lastIndex).clear()
     }
 
@@ -253,7 +263,7 @@ class QueuedAudioPlayer(
      * Removes all the previous items, if any (the ones returned by [previous]).
      */
     fun removePreviousItems() {
-        exoPlayer.removeMediaItems(0, currentIndex)
+        players().forEach { p -> p.removeMediaItems(0, currentIndex) }
         queue.subList(0, currentIndex).clear()
     }
 

package/android/src/main/java/com/lovegaoshi/kotlinaudio/player/components/APMRenderersFactory.kt

@@ -0,0 +1,33 @@
+package com.lovegaoshi.kotlinaudio.player.components
+
+import android.content.Context
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.DefaultRenderersFactory
+import androidx.media3.exoplayer.audio.AudioSink
+import androidx.media3.exoplayer.audio.DefaultAudioSink
+import androidx.media3.exoplayer.audio.TeeAudioProcessor
+import com.lovegaoshi.kotlinaudio.processors.FFTEmitter
+import com.lovegaoshi.kotlinaudio.processors.TeeListener
+
+@UnstableApi
+class APMRenderersFactory(
+    context: Context,
+    sampleRate: Int = 4096,
+    emitter: FFTEmitter?
+) : DefaultRenderersFactory(context) {
+    val teeProcessor = TeeAudioProcessor(TeeListener(sampleRate, emitter))
+
+
+    override fun buildAudioSink(
+        context: Context,
+        enableFloatOutput: Boolean,
+        enableAudioTrackPlaybackParams: Boolean
+    ): AudioSink? {
+        return DefaultAudioSink.Builder(context)
+            .setEnableFloatOutput(enableFloatOutput)
+            .setEnableAudioTrackPlaybackParams(enableAudioTrackPlaybackParams)
+            .setAudioProcessors(arrayOf(teeProcessor))
+            .build()
+    }
+
+}

package/android/src/main/java/com/lovegaoshi/kotlinaudio/player/components/Buffer.kt

@@ -0,0 +1,34 @@
+package com.lovegaoshi.kotlinaudio.player.components
+
+import androidx.annotation.OptIn
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.DefaultLoadControl
+import androidx.media3.exoplayer.DefaultLoadControl.Builder
+import androidx.media3.exoplayer.DefaultLoadControl.DEFAULT_BACK_BUFFER_DURATION_MS
+import androidx.media3.exoplayer.DefaultLoadControl.DEFAULT_BUFFER_FOR_PLAYBACK_AFTER_REBUFFER_MS
+import androidx.media3.exoplayer.DefaultLoadControl.DEFAULT_BUFFER_FOR_PLAYBACK_MS
+import androidx.media3.exoplayer.DefaultLoadControl.DEFAULT_MAX_BUFFER_MS
+import androidx.media3.exoplayer.DefaultLoadControl.DEFAULT_MIN_BUFFER_MS
+import com.lovegaoshi.kotlinaudio.models.BufferOptions
+
+
+@OptIn(UnstableApi::class) fun setupBuffer(bufferConfig: BufferOptions): DefaultLoadControl {
+    bufferConfig.apply {
+        val multiplier =
+            DEFAULT_BUFFER_FOR_PLAYBACK_AFTER_REBUFFER_MS / DEFAULT_BUFFER_FOR_PLAYBACK_MS
+        val minBuffer =
+            if (minBuffer != null && minBuffer != 0) minBuffer else DEFAULT_MIN_BUFFER_MS
+        val maxBuffer =
+            if (maxBuffer != null && maxBuffer != 0) maxBuffer else DEFAULT_MAX_BUFFER_MS
+        val playBuffer =
+            if (playBuffer != null && playBuffer != 0) playBuffer else DEFAULT_BUFFER_FOR_PLAYBACK_MS
+        val backBuffer =
+            if (backBuffer != null && backBuffer != 0) backBuffer else DEFAULT_BACK_BUFFER_DURATION_MS
+
+        return Builder()
+            .setBufferDurationsMs(minBuffer, maxBuffer, playBuffer, playBuffer * multiplier)
+            .setBackBuffer(backBuffer, false)
+            .build()
+    }
+}
+

package/android/src/main/java/com/lovegaoshi/kotlinaudio/player/components/Cache.kt

@@ -0,0 +1,27 @@
+package com.lovegaoshi.kotlinaudio.player.components
+
+import android.content.Context
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.database.DatabaseProvider
+import androidx.media3.database.StandaloneDatabaseProvider
+import androidx.media3.datasource.cache.LeastRecentlyUsedCacheEvictor
+import androidx.media3.datasource.cache.SimpleCache
+import java.io.File
+
+@UnstableApi
+object Cache {
+    @Volatile
+    private var instance: SimpleCache? = null
+
+    fun initCache(context: Context, size: Long): SimpleCache {
+        val db: DatabaseProvider = StandaloneDatabaseProvider(context)
+
+        instance ?: synchronized(this) {
+            instance ?: SimpleCache(
+                File(context.cacheDir, "APM"), LeastRecentlyUsedCacheEvictor(size), db)
+                .also { instance = it }
+        }
+
+        return instance!!
+    }
+}

package/android/src/main/java/com/lovegaoshi/kotlinaudio/player/components/FocusManager.kt

@@ -0,0 +1,59 @@
+package com.lovegaoshi.kotlinaudio.player.components
+
+import android.content.Context
+import android.media.AudioManager
+import androidx.core.content.ContextCompat
+import androidx.media.AudioAttributesCompat
+import androidx.media.AudioFocusRequestCompat
+import androidx.media.AudioManagerCompat
+import com.lovegaoshi.kotlinaudio.models.PlayerOptions
+
+class FocusManager (
+    private val context: Context,
+    private val listener: AudioManager.OnAudioFocusChangeListener,
+    options: PlayerOptions
+) {
+    var hasAudioFocus = false
+    var alwaysPauseOnInterruption = options.alwaysPauseOnInterruption
+    private var focus: AudioFocusRequestCompat? = null
+
+    fun requestAudioFocus() {
+        if (hasAudioFocus) return
+
+        val manager = ContextCompat.getSystemService(context, AudioManager::class.java)
+
+        focus = AudioFocusRequestCompat.Builder(AudioManagerCompat.AUDIOFOCUS_GAIN)
+            .setOnAudioFocusChangeListener(listener)
+            .setAudioAttributes(
+                AudioAttributesCompat.Builder()
+                    .setUsage(AudioAttributesCompat.USAGE_MEDIA)
+                    .setContentType(AudioAttributesCompat.CONTENT_TYPE_MUSIC)
+                    .build()
+            )
+            .setWillPauseWhenDucked(alwaysPauseOnInterruption)
+            .build()
+
+        val result: Int = if (manager != null && focus != null) {
+            AudioManagerCompat.requestAudioFocus(manager, focus!!)
+        } else {
+            AudioManager.AUDIOFOCUS_REQUEST_FAILED
+        }
+
+        hasAudioFocus = (result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED)
+    }
+
+    fun abandonAudioFocusIfHeld() {
+        if (!hasAudioFocus) return
+
+        val manager = ContextCompat.getSystemService(context, AudioManager::class.java)
+
+        val result: Int = if (manager != null && focus != null) {
+            AudioManagerCompat.abandonAudioFocusRequest(manager, focus!!)
+        } else {
+            AudioManager.AUDIOFOCUS_REQUEST_FAILED
+        }
+
+        hasAudioFocus = (result != AudioManager.AUDIOFOCUS_REQUEST_GRANTED)
+    }
+
+}

package/android/src/main/java/com/lovegaoshi/kotlinaudio/player/components/MediaFactory.kt

@@ -0,0 +1,130 @@
+package com.lovegaoshi.kotlinaudio.player.components
+
+import android.content.Context
+import android.os.Build
+import androidx.annotation.OptIn
+import androidx.media3.common.MediaItem
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.datasource.DataSource
+import androidx.media3.datasource.DataSpec
+import androidx.media3.datasource.DefaultDataSource
+import androidx.media3.datasource.DefaultHttpDataSource
+import androidx.media3.datasource.RawResourceDataSource
+import androidx.media3.datasource.cache.CacheDataSource
+import androidx.media3.datasource.cache.SimpleCache
+import androidx.media3.exoplayer.dash.DashMediaSource
+import androidx.media3.exoplayer.dash.DefaultDashChunkSource
+import androidx.media3.exoplayer.drm.DrmSessionManagerProvider
+import androidx.media3.exoplayer.hls.HlsMediaSource
+import androidx.media3.exoplayer.smoothstreaming.DefaultSsChunkSource
+import androidx.media3.exoplayer.smoothstreaming.SsMediaSource
+import androidx.media3.exoplayer.source.DefaultMediaSourceFactory
+import androidx.media3.exoplayer.source.MediaSource
+import androidx.media3.exoplayer.source.ProgressiveMediaSource
+import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy
+import androidx.media3.extractor.DefaultExtractorsFactory
+import com.lovegaoshi.kotlinaudio.utils.isUriLocalFile
+import androidx.core.net.toUri
+
+
+@OptIn(UnstableApi::class)
+class MediaFactory (
+    private val context: Context,
+    private val cache: SimpleCache?
+) : MediaSource.Factory{
+
+    private val mediaFactory = DefaultMediaSourceFactory(context)
+
+    override fun setDrmSessionManagerProvider(drmSessionManagerProvider: DrmSessionManagerProvider): MediaSource.Factory {
+        return mediaFactory.setDrmSessionManagerProvider(drmSessionManagerProvider)
+    }
+
+    override fun setLoadErrorHandlingPolicy(loadErrorHandlingPolicy: LoadErrorHandlingPolicy): MediaSource.Factory {
+        return mediaFactory.setLoadErrorHandlingPolicy(loadErrorHandlingPolicy)
+    }
+
+    override fun getSupportedTypes(): IntArray {
+        return mediaFactory.supportedTypes
+    }
+
+    override fun createMediaSource(mediaItem: MediaItem): MediaSource {
+
+        val userAgent = mediaItem.mediaMetadata.extras?.getString("user-agent")
+        val headers = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            mediaItem.mediaMetadata.extras?.getSerializable("headers", HashMap::class.java)
+        } else {
+            mediaItem.mediaMetadata.extras?.getSerializable("headers")
+        }
+        val resourceId = mediaItem.mediaMetadata.extras?.getInt("resource-id")
+        // HACK: why are these capitalized?
+        val resourceType = mediaItem.mediaMetadata.extras?.getString("type")?.lowercase()
+        val uri = mediaItem.mediaMetadata.extras?.getString("uri")!!.toUri()
+        val factory: DataSource.Factory = when {
+            resourceId != 0 && resourceId != null -> {
+                val raw = RawResourceDataSource(context)
+                raw.open(DataSpec(uri))
+                DataSource.Factory { raw }
+            }
+            isUriLocalFile(uri) -> {
+                DefaultDataSource.Factory(context)
+            }
+            else -> {
+                val tempFactory = DefaultHttpDataSource.Factory().apply {
+                    setUserAgent(userAgent)
+                    setAllowCrossProtocolRedirects(true)
+
+                    headers?.let {
+                        setDefaultRequestProperties(it as HashMap<String, String>)
+                    }
+                }
+
+                enableCaching(tempFactory)
+            }
+        }
+
+        return when (resourceType) {
+            "dash" -> createDashSource(mediaItem, factory)
+            "hls" -> createHlsSource(mediaItem, factory)
+            "smoothstreaming" -> createSsSource(mediaItem, factory)
+            else -> createProgressiveSource(mediaItem, factory)
+        }
+    }
+
+    private fun createDashSource(mediaItem: MediaItem, factory: DataSource.Factory?): MediaSource {
+        return DashMediaSource.Factory(DefaultDashChunkSource.Factory(factory!!), factory)
+            .createMediaSource(mediaItem)
+    }
+
+    private fun createHlsSource(mediaItem: MediaItem, factory: DataSource.Factory?): MediaSource {
+        return HlsMediaSource.Factory(factory!!)
+            .createMediaSource(mediaItem)
+    }
+
+    private fun createSsSource(mediaItem: MediaItem, factory: DataSource.Factory?): MediaSource {
+        return SsMediaSource.Factory(DefaultSsChunkSource.Factory(factory!!), factory)
+            .createMediaSource(mediaItem)
+    }
+
+    private fun createProgressiveSource(
+        mediaItem: MediaItem,
+        factory: DataSource.Factory
+    ): ProgressiveMediaSource {
+        return ProgressiveMediaSource.Factory(
+            factory, DefaultExtractorsFactory()
+                .setConstantBitrateSeekingEnabled(true)
+        )
+            .createMediaSource(mediaItem)
+    }
+
+    private fun enableCaching(factory: DataSource.Factory): DataSource.Factory {
+        return if (cache == null) {
+            factory
+        } else {
+            CacheDataSource.Factory().apply {
+                setCache(cache!!)
+                setUpstreamDataSourceFactory(factory)
+                setFlags(CacheDataSource.FLAG_IGNORE_CACHE_ON_ERROR)
+            }
+        }
+    }
+}