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

package/android/src/main/java/com/doublesymmetry/trackplayer/utils/AppForegroundTracker.kt

@@ -0,0 +1,35 @@
+package com.doublesymmetry.trackplayer.utils
+
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.ProcessLifecycleOwner
+import com.facebook.react.bridge.UiThreadUtil
+
+object AppForegroundTracker {
+    private var activityCount = 0
+
+    val foregrounded: Boolean
+        get() = activityCount > 0
+
+    val backgrounded: Boolean
+        get() = activityCount <= 0
+
+    fun start() {
+        UiThreadUtil.runOnUiThread {
+            ProcessLifecycleOwner.get().lifecycle.addObserver(Observer)
+        }
+    }
+
+    object Observer : DefaultLifecycleObserver {
+
+        override fun onResume(owner: LifecycleOwner) {
+            super.onResume(owner)
+            activityCount++
+        }
+
+        override fun onPause(owner: LifecycleOwner) {
+            super.onPause(owner)
+            activityCount--
+        }
+    }
+}

package/android/src/main/java/com/doublesymmetry/trackplayer/utils/BundleUtils.kt

@@ -0,0 +1,147 @@
+package com.doublesymmetry.trackplayer.utils
+
+import android.content.ContentResolver
+import android.content.Context
+import android.net.Uri
+import android.os.Bundle
+import android.support.v4.media.RatingCompat
+import androidx.media3.common.HeartRating
+import androidx.media3.common.PercentageRating
+import androidx.media3.common.Rating
+import androidx.media3.common.StarRating
+import androidx.media3.common.ThumbRating
+import com.doublesymmetry.trackplayer.R
+import com.facebook.react.views.imagehelper.ResourceDrawableIdHelper
+
+/**
+ * @author Milen Pivchev @mpivchev
+ */
+object BundleUtils {
+    fun getUri(context: Context, data: Bundle?, key: String?): Uri? {
+        if (!data!!.containsKey(key)) return null
+        val obj = data[key]
+        if (obj is String) {
+            // Remote or Local Uri
+            if (obj.trim { it <= ' ' }.isEmpty()) throw RuntimeException("$key: The URL cannot be empty")
+            return Uri.parse(obj as String?)
+        } else if (obj is Bundle) {
+            // require/import
+            val uri = obj.getString("uri")
+            val helper = ResourceDrawableIdHelper.instance
+            val id = helper.getResourceDrawableId(context, uri)
+            return if (id > 0) {
+                // In production, we can obtain the resource uri
+                val res = context.resources
+                Uri.Builder()
+                    .scheme(ContentResolver.SCHEME_ANDROID_RESOURCE)
+                    .authority(res.getResourcePackageName(id))
+                    .appendPath(res.getResourceTypeName(id))
+                    .appendPath(res.getResourceEntryName(id))
+                    .build()
+            } else {
+                // During development, the resources might come directly from the metro server
+                Uri.parse(uri)
+            }
+        }
+        return null
+    }
+
+    fun getRawResourceId(context: Context, data: Bundle, key: String?): Int {
+        if (!data.containsKey(key)) return 0
+        val obj = data[key] as? Bundle ?: return 0
+        var name = obj.getString("uri")
+        if (name.isNullOrEmpty()) return 0
+        name = name.lowercase().replace("-", "_")
+        return try {
+            name.toInt()
+        } catch (ex: NumberFormatException) {
+            context.resources.getIdentifier(name, "raw", context.packageName)
+        }
+    }
+
+    private fun getIcon(context: Context, options: Bundle, propertyName: String, defaultIcon: Int): Int {
+        if (!options.containsKey(propertyName)) return defaultIcon
+
+        val bundle = options.getBundle(propertyName) ?: return defaultIcon
+
+        val helper = ResourceDrawableIdHelper.getInstance()
+        val icon = helper.getResourceDrawableId(context, bundle.getString("uri"))
+        return if (icon == 0) defaultIcon else icon
+    }
+
+    fun getCustomIcon(context: Context, options: Bundle, propertyName: String, defaultIcon: Int): Int {
+        when (getIntOrNull(options, propertyName)) {
+            0 -> return R.drawable.hearte_24px
+            1 -> return R.drawable.heart_24px
+            2 -> return R.drawable.baseline_repeat_24
+            3 -> return R.drawable.baseline_repeat_one_24
+            4 -> return R.drawable.shuffle_24px
+            5 -> return R.drawable.ifl_24px
+        }
+        return getIcon(context, options, propertyName, defaultIcon)
+    }
+
+    fun getIconOrNull(context: Context, options: Bundle, propertyName: String): Int? {
+        if (!options.containsKey(propertyName)) return null
+
+        val bundle = options.getBundle(propertyName) ?: return null
+
+        val helper = ResourceDrawableIdHelper.instance
+        val icon = helper.getResourceDrawableId(context, bundle.getString("uri"))
+        return if (icon == 0) null else icon
+    }
+
+    fun getRating(data: Bundle?, key: String?, ratingType: Int): Rating? {
+        return if (!data!!.containsKey(key) || ratingType == RatingCompat.RATING_NONE) {
+            null
+        } else if (ratingType == RatingCompat.RATING_HEART) {
+            HeartRating(data.getBoolean(key, true))
+        } else if (ratingType == RatingCompat.RATING_THUMB_UP_DOWN) {
+            ThumbRating(data.getBoolean(key, true))
+        } else if (ratingType == RatingCompat.RATING_PERCENTAGE) {
+            PercentageRating(data.getFloat(key, 0f))
+        } else {
+            StarRating(5, data.getFloat(key, 0f))
+        }
+    }
+
+    fun setRating(data: Bundle, key: String?, rating: RatingCompat) {
+        if (!rating.isRated) return
+        val ratingType = rating.ratingStyle
+        when (ratingType) {
+            RatingCompat.RATING_HEART -> {
+                data.putBoolean(key, rating.hasHeart())
+            }
+            RatingCompat.RATING_THUMB_UP_DOWN -> {
+                data.putBoolean(key, rating.isThumbUp)
+            }
+            RatingCompat.RATING_PERCENTAGE -> {
+                data.putDouble(key, rating.percentRating.toDouble())
+            }
+            else -> {
+                data.putDouble(key, rating.starRating.toDouble())
+            }
+        }
+    }
+
+    fun getInt(data: Bundle?, key: String?, defaultValue: Int): Int {
+        val value = data!![key]
+        return if (value is Number) {
+            value.toInt()
+        } else defaultValue
+    }
+
+    fun getIntOrNull(data: Bundle?, key: String?): Int? {
+        val value = data!![key]
+        return if (value is Number) {
+            value.toInt()
+        } else null
+    }
+
+    fun getDoubleOrNull(data: Bundle?, key: String?): Double? {
+        val value = data!![key]
+        return if (value is Number) {
+            value.toDouble()
+        } else null
+    }
+}

package/android/src/main/java/com/doublesymmetry/trackplayer/utils/CoilBitmapLoader.kt

@@ -0,0 +1,65 @@
+package com.doublesymmetry.trackplayer.utils
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.drawable.BitmapDrawable
+import android.net.Uri
+import android.os.Build
+import androidx.media3.common.util.BitmapLoader
+import androidx.media3.common.util.Util.isBitmapFactorySupportedMimeType
+import androidx.media3.common.util.UnstableApi
+import coil.ImageLoader
+import coil.request.ImageRequest
+import com.lovegaoshi.kotlinaudio.utils.getEmbeddedBitmap
+import com.google.common.util.concurrent.ListenableFuture
+import jp.wasabeef.transformers.coil.CropSquareTransformation
+import kotlinx.coroutines.MainScope
+import kotlinx.coroutines.guava.future
+import java.io.IOException
+import javax.inject.Inject
+
+// https://github.com/androidx/media/issues/121
+
+@UnstableApi
+class CoilBitmapLoader @Inject constructor(
+    private val context: Context,
+    private val cropSquare: Boolean = false,
+) : BitmapLoader {
+
+    private val scope = MainScope()
+    private val imageLoader = ImageLoader(context)
+
+    override fun supportsMimeType(mimeType: String): Boolean {
+        return isBitmapFactorySupportedMimeType(mimeType)
+    }
+
+    override fun decodeBitmap(data: ByteArray): ListenableFuture<Bitmap> {
+        val bitmap = BitmapFactory.decodeByteArray(data,  /* offset= */0, data.size)
+        return scope.future {
+            bitmap ?: throw IOException("Unable to decode bitmap")
+        }
+    }
+
+    override fun loadBitmap(uri: Uri): ListenableFuture<Bitmap> = scope.future {
+        val bitmap: Bitmap?
+        val parsedUri = uri.toString()
+        if (parsedUri.startsWith("file://")) {
+            bitmap = getEmbeddedBitmap(parsedUri.substring(7))
+        } else {
+            var imgrequest = ImageRequest.Builder(context)
+                .data(uri)
+                .allowHardware(false)
+            // HACK: header implementation should be done via parsed data from uri
+
+            if (Build.MANUFACTURER == "samsung" || cropSquare) {
+                imgrequest = imgrequest.transformations(CropSquareTransformation())
+            }
+            val response = imageLoader.execute(imgrequest.build())
+            bitmap = (response.drawable as? BitmapDrawable)?.bitmap
+
+        }
+        bitmap ?: Bitmap.createBitmap(1, 1, Bitmap.Config.RGB_565)
+
+    }
+}

package/android/src/main/java/com/doublesymmetry/trackplayer/utils/MediaItemBuilder.kt

@@ -0,0 +1,41 @@
+package com.doublesymmetry.trackplayer.utils
+
+import android.net.Uri
+import android.os.Bundle
+import androidx.media3.common.MediaItem
+import androidx.media3.common.MediaMetadata
+
+fun buildMediaItem(
+    title: String? = null,
+    subtitle: String? = null,
+    mediaId: String,
+    isPlayable: Boolean,
+    subtitleConfigurations: List<MediaItem.SubtitleConfiguration> = mutableListOf(),
+    album: String? = null,
+    artist: String? = null,
+    genre: String? = null,
+    sourceUri: Uri? = null,
+    imageUri: Uri? = null,
+    extras: Bundle? = null
+): MediaItem {
+    val metadata =
+        MediaMetadata.Builder()
+            .setAlbumTitle(album)
+            .setTitle(title)
+            .setSubtitle(subtitle)
+            .setArtist(artist)
+            .setGenre(genre)
+            .setIsBrowsable(!isPlayable)
+            .setIsPlayable(isPlayable)
+            .setArtworkUri(imageUri)
+            .setMediaType(if (isPlayable) MediaMetadata.MEDIA_TYPE_MUSIC else MediaMetadata.MEDIA_TYPE_FOLDER_MIXED)
+            .setExtras(extras)
+            .build()
+
+    return MediaItem.Builder()
+        .setMediaId(mediaId)
+        .setSubtitleConfigurations(subtitleConfigurations)
+        .setMediaMetadata(metadata)
+        .setUri(sourceUri)
+        .build()
+}

package/android/src/main/java/com/doublesymmetry/trackplayer/utils/RejectionException.kt

@@ -0,0 +1,11 @@
+package com.doublesymmetry.trackplayer.utils
+
+import com.facebook.react.bridge.Promise
+
+/**
+ * @author Jonathan Puckey @puckey
+ */
+data class RejectionException(
+    override val message: String,
+    val code : String
+) : Exception(message)

package/android/src/main/java/com/doublesymmetry/trackplayer/video/TrackPlayerVideoView.kt

@@ -0,0 +1,42 @@
+package com.doublesymmetry.trackplayer.video
+
+import android.content.Context
+import android.widget.FrameLayout
+import androidx.media3.ui.PlayerView
+import androidx.media3.ui.AspectRatioFrameLayout
+import com.doublesymmetry.trackplayer.service.MusicService
+
+/**
+ * A simple wrapper that surfaces the ExoPlayer instance managed by RN Track Player
+ * inside a Media3 [PlayerView] so that React Native can render the video track.
+ */
+class TrackPlayerVideoView(context: Context) : FrameLayout(context) {
+    private val playerView: PlayerView = PlayerView(context).apply {
+        useController = false
+        layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+    }
+
+    init {
+        addView(playerView)
+    }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        // Get the ExoPlayer instance from the running MusicService if available
+        playerView.player = MusicService.instance?.audioPlayer?.exoPlayer
+    }
+
+    override fun onDetachedFromWindow() {
+        playerView.player = null
+        super.onDetachedFromWindow()
+    }
+
+    fun setResizeMode(mode: String?) {
+        when (mode) {
+            "cover" -> playerView.resizeMode = AspectRatioFrameLayout.RESIZE_MODE_ZOOM
+            "stretch" -> playerView.resizeMode = AspectRatioFrameLayout.RESIZE_MODE_FILL
+            "none" -> playerView.resizeMode = AspectRatioFrameLayout.RESIZE_MODE_FIXED_WIDTH
+            else -> playerView.resizeMode = AspectRatioFrameLayout.RESIZE_MODE_FIT // contain default
+        }
+    }
+}

package/android/src/main/java/com/doublesymmetry/trackplayer/video/TrackPlayerVideoViewManager.kt

@@ -0,0 +1,18 @@
+package com.doublesymmetry.trackplayer.video
+
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+
+class TrackPlayerVideoViewManager : SimpleViewManager<TrackPlayerVideoView>() {
+    override fun getName() = "RNTrackPlayerVideoView"
+
+    override fun createViewInstance(reactContext: ThemedReactContext): TrackPlayerVideoView {
+        return TrackPlayerVideoView(reactContext)
+    }
+
+    @ReactProp(name = "resizeMode")
+    fun setResizeMode(view: TrackPlayerVideoView, mode: String?) {
+        view.setResizeMode(mode)
+    }
+}

package/android/src/main/java/com/lovegaoshi/kotlinaudio/event/EventHolder.kt

@@ -0,0 +1,30 @@
+package com.lovegaoshi.kotlinaudio.event
+
+class EventHolder internal constructor(private val playerEventHolder: PlayerEventHolder) {
+    val audioItemTransition
+        get() = playerEventHolder.audioItemTransition
+
+    val onAudioFocusChanged
+        get() = playerEventHolder.onAudioFocusChanged
+
+    val onCommonMetadata
+        get() = playerEventHolder.onCommonMetadata
+
+    val onTimedMetadata
+        get() = playerEventHolder.onTimedMetadata
+
+    val onPlayerActionTriggeredExternally
+        get() = playerEventHolder.onPlayerActionTriggeredExternally
+
+    val playbackEnd
+        get() = playerEventHolder.playbackEnd
+
+    val playWhenReadyChange
+        get() = playerEventHolder.playWhenReadyChange
+
+    val stateChange
+        get() = playerEventHolder.stateChange
+
+    val playbackError
+        get() = playerEventHolder.playbackError
+}

package/android/src/main/java/com/lovegaoshi/kotlinaudio/event/PlayerEventHolder.kt

@@ -0,0 +1,124 @@
+package com.lovegaoshi.kotlinaudio.event
+
+import androidx.annotation.OptIn
+import androidx.media3.common.MediaMetadata
+import androidx.media3.common.Metadata
+import androidx.media3.common.util.UnstableApi
+import com.lovegaoshi.kotlinaudio.models.*
+import kotlinx.coroutines.MainScope
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.launch
+
+class PlayerEventHolder {
+    private val coroutineScope = MainScope()
+
+    private var _stateChange = MutableSharedFlow<AudioPlayerState>(1)
+    var stateChange = _stateChange.asSharedFlow()
+
+    private var _playbackEnd = MutableSharedFlow<PlaybackEndedReason?>(1)
+    var playbackEnd = _playbackEnd.asSharedFlow()
+
+    private var _playbackError = MutableSharedFlow<PlaybackError>(1)
+    var playbackError = _playbackError.asSharedFlow()
+
+    private var _playWhenReadyChange = MutableSharedFlow<PlayWhenReadyChangeData>(1)
+    /**
+     * Use these events to track when [com.lovegaoshi.kotlinaudio.players.BaseAudioPlayer.playWhenReady]
+     * changes.
+     */
+    var playWhenReadyChange = _playWhenReadyChange.asSharedFlow()
+
+    private var _audioItemTransition = MutableSharedFlow<AudioItemTransitionReason?>(1)
+
+    /**
+     * Use these events to track when and why an [AudioItem] transitions to another.
+     *
+     * Examples of an audio transition include changes to [AudioItem] queue, an [AudioItem] on repeat, skipping an [AudioItem], or simply when the [AudioItem] has finished.
+     */
+    var audioItemTransition = _audioItemTransition.asSharedFlow()
+
+    private var _positionChanged = MutableSharedFlow<PositionChangedReason?>(1)
+    var positionChanged = _positionChanged.asSharedFlow()
+
+    private var _onAudioFocusChanged = MutableSharedFlow<FocusChangeData>(1)
+    var onAudioFocusChanged = _onAudioFocusChanged.asSharedFlow()
+
+    private var _onCommonMetadata = MutableSharedFlow<MediaMetadata>(1)
+    var onCommonMetadata = _onCommonMetadata.asSharedFlow()
+
+    private var _onTimedMetadata = MutableSharedFlow<Metadata>(1)
+    var onTimedMetadata = _onTimedMetadata.asSharedFlow()
+
+    private var _onPlayerActionTriggeredExternally = MutableSharedFlow<MediaSessionCallback>()
+
+    /**
+     * Use these events to track whenever a player action has been triggered from an outside source.
+     *
+     * The sources can be: media buttons on headphones, Android Wear, Android Auto, Google Assistant, media notification, etc.
+     *
+     * For this observable to send events, set [interceptPlayerActionsTriggeredExternally][com.lovegaoshi.kotlinaudio.models.PlayerConfig.interceptPlayerActionsTriggeredExternally] to true.
+    */
+    var onPlayerActionTriggeredExternally = _onPlayerActionTriggeredExternally.asSharedFlow()
+
+    internal fun updateAudioPlayerState(state: AudioPlayerState) {
+        coroutineScope.launch {
+            _stateChange.emit(state)
+        }
+    }
+
+    internal fun updatePlaybackEndedReason(reason: PlaybackEndedReason) {
+        coroutineScope.launch {
+            _playbackEnd.emit(reason)
+        }
+    }
+
+    internal fun updatePlayWhenReadyChange(playWhenReadyChange: PlayWhenReadyChangeData) {
+        coroutineScope.launch {
+            _playWhenReadyChange.emit(playWhenReadyChange)
+        }
+    }
+
+    internal fun updateAudioItemTransition(reason: AudioItemTransitionReason) {
+        coroutineScope.launch {
+            _audioItemTransition.emit(reason)
+        }
+    }
+
+    internal fun updatePositionChangedReason(reason: PositionChangedReason) {
+        coroutineScope.launch {
+            _positionChanged.emit(reason)
+        }
+    }
+
+    internal fun updateOnAudioFocusChanged(isPaused: Boolean, isPermanent: Boolean) {
+        coroutineScope.launch {
+            _onAudioFocusChanged.emit(FocusChangeData(isPaused, isPermanent))
+        }
+    }
+
+    internal fun updateOnCommonMetadata(metadata: MediaMetadata) {
+        coroutineScope.launch {
+            _onCommonMetadata.emit(metadata)
+        }
+    }
+
+    @OptIn(UnstableApi::class)
+    internal fun updateOnTimedMetadata(metadata: Metadata) {
+        coroutineScope.launch {
+            _onTimedMetadata.emit(metadata)
+        }
+    }
+
+    internal fun updatePlaybackError(error: PlaybackError) {
+        coroutineScope.launch {
+            _playbackError.emit(error)
+        }
+    }
+
+    internal fun updateOnPlayerActionTriggeredExternally(callback: MediaSessionCallback) {
+        coroutineScope.launch {
+            _onPlayerActionTriggeredExternally.emit(callback)
+        }
+    }
+}

package/android/src/main/java/com/lovegaoshi/kotlinaudio/models/AudioContentType.kt

@@ -0,0 +1,10 @@
+package com.lovegaoshi.kotlinaudio.models
+
+enum class AudioContentType {
+    MUSIC,
+    SPEECH,
+    SONIFICATION,
+    MOVIE,
+    UNKNOWN
+}
+

package/android/src/main/java/com/lovegaoshi/kotlinaudio/models/AudioItem.kt

@@ -0,0 +1,118 @@
+package com.lovegaoshi.kotlinaudio.models
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.os.Bundle
+import androidx.core.net.toUri
+import androidx.media3.common.MediaItem
+import androidx.media3.common.MediaMetadata
+import com.lovegaoshi.kotlinaudio.utils.getEmbeddedBitmapArray
+import com.lovegaoshi.kotlinaudio.utils.saveMediaCoverToPng
+import java.util.UUID
+
+
+data class DefaultAudioItem(
+    override var audioUrl: String,
+
+    /**
+     * Set to [MediaType.DEFAULT] by default.
+     */
+    override val type: MediaType = MediaType.DEFAULT,
+
+    override var artist: String? = null,
+    override var title: String? = null,
+    override var albumTitle: String? = null,
+    override var artwork: String? = null,
+    override val duration: Long? = null,
+    override val options: AudioItemOptions? = null,
+    override val mediaId: String? = null,
+) : AudioItem
+
+class AudioItemHolder(
+    var audioItem: AudioItem
+) {
+    var artworkBitmap: Bitmap? = null
+}
+
+interface AudioItem {
+    var audioUrl: String
+    val type: MediaType
+    var artist: String?
+    var title: String?
+    var albumTitle: String?
+    val artwork: String?
+    val duration: Long?
+    val options: AudioItemOptions?
+    val mediaId: String?
+}
+
+data class AudioItemOptions(
+    val headers: HashMap<String, String>? = null,
+    val userAgent: String? = null,
+    val resourceId: Int? = null
+)
+
+enum class MediaType(val value: String) {
+    /**
+     * The default media type. Should be used for streams over HTTP or files
+     */
+    DEFAULT("default"),
+
+    /**
+     * The DASH media type for adaptive streams. Should be used with DASH manifests.
+     */
+    DASH("dash"),
+
+    /**
+     * The HLS media type for adaptive streams. Should be used with HLS playlists.
+     */
+    HLS("hls"),
+
+    /**
+     * The SmoothStreaming media type for adaptive streams. Should be used with SmoothStreaming manifests.
+     */
+    SMOOTH_STREAMING("smoothstreaming");
+}
+
+
+
+fun audioItem2MediaItem(audioItem: AudioItem, context: Context? = null): MediaItem {
+    return MediaItem.Builder()
+        .setMediaId(audioItem.mediaId ?: UUID.randomUUID().toString())
+        .setUri(audioItem.audioUrl)
+        .setMediaMetadata(
+            MediaMetadata.Builder()
+            .setTitle(audioItem.title)
+            .setArtist(audioItem.artist)
+            .setArtworkUri((
+                if (context != null && audioItem.audioUrl.startsWith("file://")) {
+                    saveMediaCoverToPng(
+                        audioItem.audioUrl,
+                        context.contentResolver,
+                        audioItem.mediaId ?: audioItem.audioUrl
+                    )
+                        ?: audioItem.artwork
+                }
+                else audioItem.artwork)?.toUri())
+            .setArtworkData(if (audioItem.audioUrl.startsWith("file://")) getEmbeddedBitmapArray(
+                audioItem.audioUrl.substring(7)) else null, MediaMetadata.PICTURE_TYPE_MEDIA)
+            .setExtras(Bundle().apply {
+                audioItem.options?.headers?.let {
+                    putSerializable("headers", audioItem.options!!.headers)
+                }
+                audioItem.options?.userAgent?.let {
+                    putString("user-agent", it)
+                }
+                audioItem.options?.resourceId?.let {
+                    putInt("resource-id", it)
+                }
+                putString("type", audioItem.type.toString())
+                putString("uri", audioItem.audioUrl)
+            }).build())
+        .setTag(audioItem)
+        .build()
+}
+
+fun mediaItem2AudioItem(item: MediaItem?): AudioItem? {
+    return item?.localConfiguration?.tag as AudioItem?
+}

package/android/src/main/java/com/lovegaoshi/kotlinaudio/models/AudioItemTransitionReason.kt

@@ -0,0 +1,33 @@
+package com.lovegaoshi.kotlinaudio.models
+
+/**
+ * Use these events to track when and why an [AudioItem] transitions to another.
+ * Examples of an audio transition include changes to [AudioItem] queue, an [AudioItem] on repeat, skipping an [AudioItem], or simply when the [AudioItem] has finished.
+ */
+sealed class AudioItemTransitionReason(val oldPosition: Long) {
+    /**
+     * Playback has automatically transitioned to the next [AudioItem].
+     *
+     * This reason also indicates a transition caused by another player.
+     */
+    class AUTO(oldPosition: Long) : AudioItemTransitionReason(oldPosition)
+
+    /**
+     * A seek to another [AudioItem] has occurred. Usually triggered when calling
+     * [QueuedAudioPlayer.next][com.lovegaoshi.kotlinaudio.players.QueuedAudioPlayer.next]
+     * or [QueuedAudioPlayer.previous][com.lovegaoshi.kotlinaudio.players.QueuedAudioPlayer.previous].
+     */
+    class SEEK_TO_ANOTHER_AUDIO_ITEM(oldPosition: Long) : AudioItemTransitionReason(oldPosition)
+
+    /**
+     * The [AudioItem] has been repeated.
+     */
+    class REPEAT(oldPosition: Long) : AudioItemTransitionReason(oldPosition)
+
+    /**
+     * The current [AudioItem] has changed because of a change in the queue. This can either be if
+     * the [AudioItem] previously being played has been removed, or when the queue becomes non-empty
+     * after being empty.
+     */
+    class QUEUE_CHANGED(oldPosition: Long) : AudioItemTransitionReason(oldPosition)
+}