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

package/android/build.gradle

@@ -1,4 +1,17 @@
+buildscript {
+    repositories {
+        mavenLocal()
+        mavenCentral()
+        google()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:7.4.2'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.8.10"
+    }
+}
+
 apply plugin: 'com.android.library'
+apply plugin: 'org.jetbrains.kotlin.android'
 
 def safeExtGet(prop, fallback) {
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
@@ -7,12 +20,13 @@ def safeExtGet(prop, fallback) {
 android {
     compileSdkVersion safeExtGet('compileSdkVersion', 28)
     buildToolsVersion safeExtGet('buildToolsVersion', '28.0.3')
- 
+
     compileOptions {
         targetCompatibility JavaVersion.VERSION_1_8
         sourceCompatibility JavaVersion.VERSION_1_8
     }
 
+    def agpVersion = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION
     defaultConfig {
         minSdkVersion safeExtGet('minSdkVersion', 16)
         targetSdkVersion safeExtGet('targetSdkVersion', 28)
@@ -22,13 +36,56 @@ android {
 }
 
 dependencies {
-    implementation "com.facebook.react:react-native:${safeExtGet('reactNativeVersion', '+')}"
 
     // All support libs must use the same version
     implementation 'androidx.work:work-runtime:2.7.1'
-    implementation "androidx.core:core:1.7.0"
-    implementation "androidx.media:media:1.5.0"
     implementation "androidx.localbroadcastmanager:localbroadcastmanager:1.1.0"
     implementation "com.github.bumptech.glide:glide:4.13.2"
 
+//    implementation 'com.github.lovegaoshi:KotlinAudio:v2.0.0-rc7-podverse-13'
+
+
+    implementation "com.facebook.react:react-native:+"
+
+    // Make sure we're using androidx
+    implementation "androidx.core:core-ktx:1.7.0"
+    implementation "androidx.localbroadcastmanager:localbroadcastmanager:1.1.0"
+    implementation "androidx.lifecycle:lifecycle-process:2.6.1"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.3"
+    implementation 'androidx.media:media:1.6.0'
+
+
+
+
+    implementation "androidx.car.app:app:1.4.0"
+
+
+    implementation 'io.coil-kt:coil:1.4.0'
+    implementation 'androidx.media:media:1.6.0'
+    api 'com.google.android.exoplayer:exoplayer:2.18.1'
+    api 'com.google.android.exoplayer:extension-mediasession:2.18.1'
+    api 'com.jakewharton.timber:timber:5.0.1'
+
+    implementation 'androidx.test:rules:1.4.0'
+
+    // Asynchronous Testing
+    androidTestImplementation('org.awaitility:awaitility:4.2.0') {
+        transitive = false
+    }
+    androidTestImplementation('org.awaitility:awaitility-kotlin:4.2.0') {
+        transitive = false
+    }
+
+    // (Required) Writing and executing Unit Tests on the JUnit Platform
+    androidTestImplementation("androidx.test:runner:1.4.0")
+    androidTestImplementation("org.junit.jupiter:junit-jupiter-api:5.8.2")
+    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.8.2")
+
+    // (Optional) If you need "Parameterized Tests"
+    testImplementation("org.junit.jupiter:junit-jupiter-params:5.8.2")
+
+    // The instrumentation test companion libraries
+    androidTestImplementation("de.mannodermaus.junit5:android-test-core:1.3.0")
+    androidTestRuntimeOnly("de.mannodermaus.junit5:android-test-runner:1.3.0")
+
 }

package/android/src/main/AndroidManifest.xml

@@ -9,12 +9,10 @@
     <application>
 
         <!-- The main service, handles playback, playlists and media buttons -->
-        <service android:name=".service.MusicService"
-            android:enabled="true"
-            android:foregroundServiceType="mediaPlayback"
-            android:exported="true">
+        <service android:name="com.guichaguri.trackplayer.service.MusicService" android:enabled="true" android:exported="true" android:foregroundServiceType="mediaPlayback">
             <intent-filter>
                 <action android:name="android.intent.action.MEDIA_BUTTON" />
+                <action android:name="android.media.browse.MediaBrowserService" />
             </intent-filter>
         </service>
 

package/android/src/main/java/com/guichaguri/trackplayer/{service/HeadlessJsMediaService.java → HeadlessJsMediaService.java}

@@ -1,4 +1,11 @@
-package com.guichaguri.trackplayer.service;
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.guichaguri.trackplayer;
 
 import android.annotation.SuppressLint;
 import android.content.BroadcastReceiver;
@@ -6,12 +13,14 @@ import android.content.Context;
 import android.content.Intent;
 import android.os.IBinder;
 import android.os.PowerManager;
-
+import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.media.MediaBrowserServiceCompat;
 import com.facebook.infer.annotation.Assertions;
+import com.facebook.react.ReactHost;
 import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint;
 import com.facebook.react.jstasks.HeadlessJsTaskConfig;
 import com.facebook.react.jstasks.HeadlessJsTaskContext;
 import com.facebook.react.jstasks.HeadlessJsTaskEventListener;
@@ -35,17 +44,21 @@ import java.util.concurrent.CopyOnWriteArraySet;
  * {@link BroadcastReceiver#onReceive}, to make sure the device doesn't go to sleep before the
  * service is started.
  */
+
 public abstract class HeadlessJsMediaService extends MediaBrowserServiceCompat implements HeadlessJsTaskEventListener {
 
     private final Set<Integer> mActiveTasks = new CopyOnWriteArraySet<>();
-    private static @Nullable PowerManager.WakeLock sWakeLock;
-
+    public static @Nullable PowerManager.WakeLock sWakeLock;
 
+    private boolean initialized = false;
 
     @Override
     public int onStartCommand(Intent intent, int flags, int startId) {
+        super.onStartCommand(intent, flags, startId);
         HeadlessJsTaskConfig taskConfig = getTaskConfig(intent);
-        if (taskConfig != null) {
+        if (!initialized && taskConfig != null) {
+            // HACK: ensure headlessJsMediaService tasks are only registered once.
+            initialized = true;
             startTask(taskConfig);
             return START_REDELIVER_INTENT;
         }
@@ -98,20 +111,10 @@ public abstract class HeadlessJsMediaService extends MediaBrowserServiceCompat i
      */
     protected void startTask(final HeadlessJsTaskConfig taskConfig) {
         UiThreadUtil.assertOnUiThread();
-        acquireWakeLockNow(this);
-        final ReactInstanceManager reactInstanceManager =
-                getReactNativeHost().getReactInstanceManager();
-        ReactContext reactContext = reactInstanceManager.getCurrentReactContext();
+        // acquireWakeLockNow(this);
+        ReactContext reactContext = getReactContext();
         if (reactContext == null) {
-            reactInstanceManager.addReactInstanceEventListener(
-                    new ReactInstanceEventListener() {
-                        @Override
-                        public void onReactContextInitialized(ReactContext reactContext) {
-                            invokeStartTask(reactContext, taskConfig);
-                            reactInstanceManager.removeReactInstanceEventListener(this);
-                        }
-                    });
-            reactInstanceManager.createReactContextInBackground();
+            createReactContextAndScheduleTask(taskConfig);
         } else {
             invokeStartTask(reactContext, taskConfig);
         }
@@ -123,12 +126,9 @@ public abstract class HeadlessJsMediaService extends MediaBrowserServiceCompat i
         headlessJsTaskContext.addTaskEventListener(this);
 
         UiThreadUtil.runOnUiThread(
-                new Runnable() {
-                    @Override
-                    public void run() {
-                        int taskId = headlessJsTaskContext.startTask(taskConfig);
-                        mActiveTasks.add(taskId);
-                    }
+                () -> {
+                    int taskId = headlessJsTaskContext.startTask(taskConfig);
+                    mActiveTasks.add(taskId);
                 });
     }
 
@@ -136,14 +136,11 @@ public abstract class HeadlessJsMediaService extends MediaBrowserServiceCompat i
     public void onDestroy() {
         super.onDestroy();
 
-        if (getReactNativeHost().hasInstance()) {
-            ReactInstanceManager reactInstanceManager = getReactNativeHost().getReactInstanceManager();
-            ReactContext reactContext = reactInstanceManager.getCurrentReactContext();
-            if (reactContext != null) {
-                HeadlessJsTaskContext headlessJsTaskContext =
-                        HeadlessJsTaskContext.getInstance(reactContext);
-                headlessJsTaskContext.removeTaskEventListener(this);
-            }
+        ReactContext reactContext = getReactContext();
+        if (reactContext != null) {
+            HeadlessJsTaskContext headlessJsTaskContext =
+                    HeadlessJsTaskContext.getInstance(reactContext);
+            headlessJsTaskContext.removeTaskEventListener(this);
         }
         if (sWakeLock != null) {
             sWakeLock.release();
@@ -156,7 +153,7 @@ public abstract class HeadlessJsMediaService extends MediaBrowserServiceCompat i
     @Override
     public void onHeadlessJsTaskFinish(int taskId) {
         mActiveTasks.remove(taskId);
-        if (mActiveTasks.size() == 0) {
+        if (mActiveTasks.isEmpty()) {
             stopSelf();
         }
     }
@@ -171,4 +168,58 @@ public abstract class HeadlessJsMediaService extends MediaBrowserServiceCompat i
     protected ReactNativeHost getReactNativeHost() {
         return ((ReactApplication) getApplication()).getReactNativeHost();
     }
+
+    /**
+     * Get the {@link ReactHost} used by this app. By default, assumes {@link #getApplication()}
+     * is an instance of {@link ReactApplication} and calls {@link
+     * ReactApplication#getReactHost()}.
+     * This method assumes it is called in new architecture and returns null if not.
+     */
+    protected ReactHost getReactHost() {
+        return ((ReactApplication) getApplication()).getReactHost();
+    }
+
+    @SuppressLint("VisibleForTests")
+    protected ReactContext getReactContext() {
+        if (DefaultNewArchitectureEntryPoint.getBridgelessEnabled()) {
+            ReactHost reactHost = getReactHost();
+            Assertions.assertNotNull(reactHost, "React host is null in newArchitecture");
+            return reactHost.getCurrentReactContext();
+        }
+
+        final ReactInstanceManager reactInstanceManager =
+                getReactNativeHost().getReactInstanceManager();
+        return reactInstanceManager.getCurrentReactContext();
+    }
+
+
+    private void createReactContextAndScheduleTask(final HeadlessJsTaskConfig taskConfig) {
+
+        if (DefaultNewArchitectureEntryPoint.getBridgelessEnabled()) { // new arch
+            final ReactHost reactHost = getReactHost();
+            reactHost.addReactInstanceEventListener(
+                    new ReactInstanceEventListener() {
+                        @Override
+                        public void onReactContextInitialized(@NonNull ReactContext reactContext) {
+                            invokeStartTask(reactContext, taskConfig);
+                            reactHost.removeReactInstanceEventListener(this);
+                        }
+                    }
+            );
+            reactHost.start();
+        } else { // old arch
+            final ReactInstanceManager reactInstanceManager =
+                    getReactNativeHost().getReactInstanceManager();
+
+            reactInstanceManager.addReactInstanceEventListener(
+                    new ReactInstanceEventListener() {
+                        @Override
+                        public void onReactContextInitialized(@NonNull ReactContext reactContext) {
+                            invokeStartTask(reactContext, taskConfig);
+                            reactInstanceManager.removeReactInstanceEventListener(this);
+                        }
+                    });
+            reactInstanceManager.createReactContextInBackground();
+        }
+    }
 }

package/android/src/main/java/com/guichaguri/trackplayer/TrackPlayer.kt

@@ -0,0 +1,25 @@
+package com.guichaguri.trackplayer
+
+import android.view.View
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ReactShadowNode
+import com.facebook.react.uimanager.ViewManager
+import com.guichaguri.trackplayer.module.MusicModule
+
+/**
+ * TrackPlayer
+ * https://github.com/react-native-kit/react-native-track-player
+ * @author Guichaguri
+ */
+class TrackPlayer : ReactPackage {
+
+    override fun createViewManagers(
+        reactContext: ReactApplicationContext
+    ): MutableList<ViewManager<View, ReactShadowNode<*>>> = mutableListOf()
+
+    override fun createNativeModules(
+        reactContext: ReactApplicationContext
+    ): MutableList<NativeModule> = listOf(MusicModule(reactContext)).toMutableList()
+}

package/android/src/main/java/com/guichaguri/trackplayer/extensions/AudioPlayerStateExt.kt

@@ -0,0 +1,19 @@
+package com.guichaguri.trackplayer.extensions
+
+import com.guichaguri.trackplayer.kotlinaudio.models.AudioPlayerState
+import com.guichaguri.trackplayer.model.State
+
+val AudioPlayerState.asLibState: State
+    get() {
+        return when(this) {
+            AudioPlayerState.LOADING -> State.Loading
+            AudioPlayerState.READY -> State.Ready
+            AudioPlayerState.BUFFERING -> State.Buffering
+            AudioPlayerState.PAUSED -> State.Paused
+            AudioPlayerState.PLAYING -> State.Playing
+            AudioPlayerState.IDLE -> State.None
+            AudioPlayerState.ENDED -> State.Ended
+            AudioPlayerState.ERROR -> State.Error
+            AudioPlayerState.STOPPED -> State.Stopped
+        }
+    }

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

@@ -0,0 +1,30 @@
+package com.guichaguri.trackplayer.kotlinaudio.event
+
+class EventHolder internal constructor(private val notificationEventHolder: NotificationEventHolder, private val playerEventHolder: PlayerEventHolder) {
+    val audioItemTransition
+        get() = playerEventHolder.audioItemTransition
+
+    val notificationStateChange
+        get() = notificationEventHolder.notificationStateChange
+
+    val onAudioFocusChanged
+        get() = playerEventHolder.onAudioFocusChanged
+
+    val onPlaybackMetadata
+        get() = playerEventHolder.onPlaybackMetadata
+
+    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/guichaguri/trackplayer/kotlinaudio/event/NotificationEventHolder.kt

@@ -0,0 +1,20 @@
+package com.guichaguri.trackplayer.kotlinaudio.event
+
+import com.guichaguri.trackplayer.kotlinaudio.models.NotificationState
+import kotlinx.coroutines.MainScope
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.launch
+
+class NotificationEventHolder {
+    private val coroutineScope = MainScope()
+
+    private var _notificationStateChange = MutableSharedFlow<NotificationState>(1)
+    var notificationStateChange = _notificationStateChange.asSharedFlow()
+
+    internal fun updateNotificationState(state: NotificationState) {
+        coroutineScope.launch {
+            _notificationStateChange.emit(state)
+        }
+    }
+}

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

@@ -0,0 +1,111 @@
+package com.guichaguri.trackplayer.kotlinaudio.event
+
+// import com.doublesymmetry.kotlinaudio.models.*
+import com.guichaguri.trackplayer.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.doublesymmetry.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 _onPlaybackMetadata = MutableSharedFlow<PlaybackMetadata>(1)
+    var onPlaybackMetadata = _onPlaybackMetadata.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.doublesymmetry.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 updateOnPlaybackMetadata(metadata: PlaybackMetadata) {
+        coroutineScope.launch {
+            _onPlaybackMetadata.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/guichaguri/trackplayer/kotlinaudio/models/AAMediaSessionCallback.kt

@@ -0,0 +1,10 @@
+package com.guichaguri.trackplayer.kotlinaudio.models
+
+import android.os.Bundle
+
+interface AAMediaSessionCallBack {
+    fun handlePlayFromMediaId(mediaId: String?, extras: Bundle?)
+    fun handlePlayFromSearch(query: String?, extras: Bundle?)
+    fun handleSkipToQueueItem(id: Long)
+    fun handleCustomActions(action: String?, extras: Bundle?)
+}

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

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

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

@@ -0,0 +1,66 @@
+package com.guichaguri.trackplayer.kotlinaudio.models
+
+import android.graphics.Bitmap
+
+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?
+    var artworkBitmap: Bitmap?
+}
+
+data class AudioItemOptions(
+    val headers: MutableMap<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");
+}
+
+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 val artwork: String? = null,
+    override val duration: Long = -1,
+    override val options: AudioItemOptions? = null,
+    override var artworkBitmap: Bitmap? = null
+) : AudioItem
+
+class AudioItemHolder(
+    var audioItem: AudioItem
+) {
+    var artworkBitmap: Bitmap? = null
+}

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

@@ -0,0 +1,33 @@
+package com.guichaguri.trackplayer.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.doublesymmetry.kotlinaudio.players.QueuedAudioPlayer.next]
+     * or [QueuedAudioPlayer.previous][com.doublesymmetry.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)
+}

package/android/src/main/java/com/guichaguri/trackplayer/kotlinaudio/models/AudioPlayerState.kt

@@ -0,0 +1,30 @@
+package com.guichaguri.trackplayer.kotlinaudio.models
+
+enum class AudioPlayerState {
+    /** The current [AudioItem] is being loaded for playback. */
+    LOADING,
+
+    /** The current [AudioItem] is loaded, and the player is ready to start playing. */
+    READY,
+
+    /** The current [AudioItem] is currently buffering. */
+    BUFFERING,
+
+    /** The player is paused. */
+    PAUSED,
+
+    /** The player is stopped. */
+    STOPPED,
+
+    /** The player is playing. */
+    PLAYING,
+
+    /** No [AudioItem] is loaded and the player is doing nothing. */
+    IDLE,
+
+    /** The player has finished playing all the [AudioItem]s. TODO: Add additional info */
+    ENDED,
+
+    /** The player stopped playing due to an error. */
+    ERROR
+}