react-native-mp3-player 1.0.0

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

@@ -0,0 +1,295 @@
+@file: OptIn(UnstableApi::class) package com.lovegaoshi.kotlinaudio.player
+
+import android.content.Context
+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
+import timber.log.Timber
+
+class QueuedAudioPlayer(
+    private val context: Context,
+    options: PlayerOptions = PlayerOptions()
+) : AudioPlayer(context, options) {
+
+    var parseEmbeddedArtwork: Boolean = false
+
+    private val queue = LinkedList<MediaItem>()
+
+    private fun parseAudioItem(audioItem: AudioItem, skipSavingEmbeddedArtwork: Boolean = false): MediaItem {
+        return audioItem2MediaItem(audioItem, if (parseEmbeddedArtwork && !skipSavingEmbeddedArtwork) context else null, skipSavingEmbeddedArtwork)
+    }
+
+    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() = mediaItem2AudioItem(queue.getOrNull(currentIndex))
+
+    val nextIndex: Int?
+        get() {
+            return if (exoPlayer.nextMediaItemIndex == C.INDEX_UNSET) null
+            else exoPlayer.nextMediaItemIndex
+        }
+
+    val previousIndex: Int?
+        get() {
+            return if (exoPlayer.previousMediaItemIndex == C.INDEX_UNSET) null
+            else exoPlayer.previousMediaItemIndex
+        }
+
+    val items: List<AudioItem>
+        get() = queue.map { mediaItem2AudioItem(it)!! }
+
+    val previousItems: List<AudioItem>
+        get() {
+            return if (queue.isEmpty()) emptyList()
+            else queue
+                .subList(0, exoPlayer.currentMediaItemIndex)
+                .map { mediaItem2AudioItem(it)!! }
+        }
+
+    val nextItems: List<AudioItem>
+        get() {
+            return if (queue.isEmpty()) emptyList()
+            else queue
+                .subList(exoPlayer.currentMediaItemIndex, queue.lastIndex)
+                .map { mediaItem2AudioItem(it)!! }
+        }
+
+    val nextItem: AudioItem?
+        get() = items.getOrNull(currentIndex + 1)
+
+    val previousItem: AudioItem?
+        get() = items.getOrNull(currentIndex - 1)
+
+    override fun load(item: AudioItem, playWhenReady: Boolean) {
+        load(item)
+        exoPlayer.playWhenReady = playWhenReady
+    }
+
+    override fun load(item: AudioItem) {
+        if (queue.isEmpty()) {
+            add(item)
+        } else {
+            players().forEach { p ->
+                p.replaceMediaItem(currentIndex, parseAudioItem(item))
+                p.seekTo(currentIndex, C.TIME_UNSET)
+            }
+            exoPlayer.prepare()
+        }
+    }
+
+    /**
+     * 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.
+     */
+    fun add(item: AudioItem, playWhenReady: Boolean) {
+        exoPlayer.playWhenReady = playWhenReady
+        add(item)
+    }
+
+    /**
+     * 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.
+     */
+    fun add(item: AudioItem) {
+        val mediaSource = parseAudioItem(item)
+        queue.add(mediaSource)
+        players().forEach { p -> p.addMediaItem(mediaSource) }
+        exoPlayer.prepare()
+    }
+
+    /**
+     * Add multiple items to the queue. If the AudioPlayer has no item loaded, it will load the first item in the list.
+     * @param items The [AudioItem]s to add.
+     * @param playWhenReady Whether playback starts automatically.
+     */
+    fun add(items: List<AudioItem>, playWhenReady: Boolean) {
+        exoPlayer.playWhenReady = playWhenReady
+        add(items)
+    }
+
+    /**
+     * Add multiple items to the queue. If the AudioPlayer has no item loaded, it will load the first item in the list.
+     * @param items The [AudioItem]s to add.
+     */
+    fun add(items: List<AudioItem>) {
+        try {
+            // disable embedded artwork extraction for multiple items to prevent blocking I/O operations
+            timber.log.Timber.tag("RNTP").d("QueuedAudioPlayer.add: Parsing ${items.size} items with skipSavingEmbeddedArtwork=true")
+            val mediaSources = items.map { parseAudioItem(it, skipSavingEmbeddedArtwork = true) }
+            
+            timber.log.Timber.tag("RNTP").d("QueuedAudioPlayer.add: Adding ${mediaSources.size} media sources to queue")
+            queue.addAll(mediaSources)
+            
+            timber.log.Timber.tag("RNTP").d("QueuedAudioPlayer.add: Adding media items to all players")
+            players().forEach { p -> p.addMediaItems(mediaSources) }
+            
+            timber.log.Timber.tag("RNTP").d("QueuedAudioPlayer.add: Calling exoPlayer.prepare()")
+            exoPlayer.prepare()
+            
+            timber.log.Timber.tag("RNTP").d("QueuedAudioPlayer.add: Successfully completed")
+        } catch (exception: Exception) {
+            timber.log.Timber.tag("RNTP").e(exception, "QueuedAudioPlayer.add: Error adding items")
+            throw exception
+        }
+    }
+
+
+    /**
+     * 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) {
+        // disable embedded artwork extraction for multiple items to prevent blocking I/O operations
+        val mediaSources = items.map { parseAudioItem(it, skipSavingEmbeddedArtwork = true) }
+        queue.addAll(atIndex, mediaSources)
+        players().forEach { p -> p.addMediaItems(atIndex, mediaSources) }
+        exoPlayer.prepare()
+    }
+
+    /**
+     * Remove an item from the queue.
+     * @param index The index of the item to remove.
+     */
+    fun remove(index: Int) {
+        queue.removeAt(index)
+        players().forEach { p -> p.removeMediaItem(index) }
+    }
+
+    /**
+     * Remove items from the queue.
+     * @param indexes The indexes of the items to remove.
+     */
+    fun remove(indexes: List<Int>) {
+        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:
+        sorted.sortDescending()
+        sorted.forEach {
+            remove(it)
+        }
+    }
+
+    /**
+     * Skip to the next item in the queue, which may depend on the current repeat mode.
+     * Does nothing if there is no next item to skip to.
+     */
+    fun next() {
+        exoPlayer.seekToNextMediaItem()
+        exoPlayer.prepare()
+    }
+
+    /**
+     * Skip to the previous item in the queue, which may depend on the current repeat mode.
+     * Does nothing if there is no previous item to skip to.
+     */
+    fun previous() {
+        exoPlayer.seekToPreviousMediaItem()
+        exoPlayer.prepare()
+    }
+
+    /**
+     * Move an item in the queue from one position to another.
+     * @param fromIndex The index of the item ot move.
+     * @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) {
+        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)
+    }
+
+    /**
+     * Jump to an item in the queue.
+     * @param index the index to jump to
+     * @param playWhenReady Whether playback starts automatically.
+     */
+    fun jumpToItem(index: Int, playWhenReady: Boolean) {
+        exoPlayer.playWhenReady = playWhenReady
+        jumpToItem(index)
+    }
+
+    /**
+     * Jump to an item in the queue.
+     * @param index the index to jump to
+     */
+    fun jumpToItem(index: Int) {
+        try {
+            exoPlayer.seekTo(index, C.TIME_UNSET)
+            exoPlayer.prepare()
+        } catch (e: IllegalSeekPositionException) {
+            throw Error("This item index $index does not exist. The size of the queue is ${queue.size} items.")
+        }
+    }
+
+    /**
+     * Replaces item at index in queue.
+     */
+    fun replaceItem(index: Int, item: AudioItem) {
+        val mediaSource = parseAudioItem(item)
+        queue[index] = mediaSource
+        players().forEach { p -> p.replaceMediaItem(index, mediaSource) }
+    }
+
+    /**
+     * Removes all the upcoming items, if any (the ones returned by [next]).
+     */
+    fun removeUpcomingItems() {
+        if (queue.lastIndex == -1 || currentIndex == -1) return
+        val lastIndex = queue.lastIndex + 1
+        val fromIndex = currentIndex + 1
+
+        players().forEach { p -> p.removeMediaItems(fromIndex, lastIndex) }
+        queue.subList(fromIndex, lastIndex).clear()
+    }
+
+    /**
+     * Removes all the previous items, if any (the ones returned by [previous]).
+     */
+    fun removePreviousItems() {
+        players().forEach { p -> p.removeMediaItems(0, currentIndex) }
+        queue.subList(0, currentIndex).clear()
+    }
+
+    override fun destroy() {
+        queue.clear()
+        super.destroy()
+    }
+
+    override fun clear() {
+        queue.clear()
+        super.clear()
+    }
+}

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,47 @@
+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 timber.log.Timber
+import java.io.File
+
+@UnstableApi
+object Cache {
+    @Volatile
+    private var instance: SimpleCache? = null
+
+    fun initCache(context: Context, size: Long): SimpleCache {
+        Timber.tag("RNTP").d("initCache called with size: $size")
+        
+        return instance ?: synchronized(this) {
+            instance ?: try {
+                val cacheDir = File(context.cacheDir, "APM")
+                Timber.tag("RNTP").d("Creating cache directory: ${cacheDir.absolutePath}")
+                
+                if (!cacheDir.exists()) {
+                    val created = cacheDir.mkdirs()
+                    Timber.tag("RNTP").d("Cache directory created: $created")
+                }
+                
+                val db: DatabaseProvider = StandaloneDatabaseProvider(context)
+                Timber.tag("RNTP").d("Created database provider")
+                
+                val evictor = LeastRecentlyUsedCacheEvictor(size)
+                Timber.tag("RNTP").d("Created cache evictor with size: $size")
+                
+                val cache = SimpleCache(cacheDir, evictor, db)
+                Timber.tag("RNTP").d("Created SimpleCache successfully")
+                
+                instance = cache
+                cache
+            } catch (e: Exception) {
+                Timber.tag("RNTP").e(e, "Failed to create cache")
+                throw e
+            }
+        }
+    }
+}

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,165 @@
+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
+import timber.log.Timber
+
+
+@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>)
+                    }
+                }
+
+                // Only enable caching if cache is actually available
+                if (cache != null) {
+                    enableCaching(tempFactory)
+                } else {
+                    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 {
+        // Add detailed debugging to understand the NPE
+        Timber.tag("RNTP").d("enableCaching called - cache is: ${cache}")
+        
+        if (cache == null) {
+            Timber.tag("RNTP").d("Cache is null in enableCaching, returning original factory")
+            return factory
+        }
+        
+        // Validate cache is properly initialized
+        try {
+            val cacheKeys = cache.keys
+            Timber.tag("RNTP").d("Cache appears valid - keys count: ${cacheKeys.size}")
+        } catch (e: Exception) {
+            Timber.tag("RNTP").e(e, "Cache validation failed, returning original factory")
+            return factory
+        }
+        
+        Timber.tag("RNTP").d("Cache is not null, attempting to create CacheDataSource.Factory")
+        
+        return try {
+            val cacheFactory = CacheDataSource.Factory()
+            Timber.tag("RNTP").d("Created CacheDataSource.Factory, setting cache")
+            
+            cacheFactory.setCache(cache)
+            Timber.tag("RNTP").d("Set cache successfully, setting upstream factory")
+            
+            cacheFactory.setUpstreamDataSourceFactory(factory)
+            Timber.tag("RNTP").d("Set upstream factory, setting flags")
+            
+            cacheFactory.setFlags(CacheDataSource.FLAG_IGNORE_CACHE_ON_ERROR)
+            Timber.tag("RNTP").d("Cache setup completed successfully")
+            
+            cacheFactory
+        } catch (e: Exception) {
+            // If cache setup fails, fall back to original factory
+            Timber.tag("RNTP").e(e, "Failed to setup cache at step, using original factory")
+            factory
+        }
+    }
+}