remove redundant PlayerState enum

Signed-off-by: Adam Ratzman <adam@adamratzman.com>

Author: adamint

src/commonMain/kotlin/com.adamratzman.spotify/endpoints/client/ClientPlayerApi.kt

@@ -13,6 +13,7 @@ import com.adamratzman.spotify.models.CursorBasedPagingObject
 import com.adamratzman.spotify.models.Device
 import com.adamratzman.spotify.models.PlayHistory
 import com.adamratzman.spotify.models.PlayableUri
+import com.adamratzman.spotify.models.ResultEnum
 import com.adamratzman.spotify.models.serialization.mapToJsonString
 import com.adamratzman.spotify.models.serialization.toCursorBasedPagingObject
 import com.adamratzman.spotify.models.serialization.toInnerObject
@@ -295,20 +296,22 @@ public class ClientPlayerApi(api: GenericSpotifyApi) : SpotifyEndpoint(api) {
      *
      * **[Api Reference](https://developer.spotify.com/documentation/web-api/reference/player/set-repeat-mode-on-users-playback/)**
      */
-    public enum class PlayerRepeatState {
+    public enum class PlayerRepeatState(public val identifier: String): ResultEnum {
         /**
          * Repeat the current track
          */
-        TRACK,
+        TRACK("track"),
 
         /**
          * Repeat the current context
          */
-        CONTEXT,
+        CONTEXT("context"),
 
         /**
          * Will turn repeat off
          */
-        OFF;
+        OFF("off");
+
+        override fun retrieveIdentifier(): String = identifier
     }
 }

src/commonMain/kotlin/com.adamratzman.spotify/models/PagingObjects.kt

@@ -74,7 +74,6 @@ public class NullablePagingObject<T : Any>(
         return pagingObject
     }
 
-    override fun get(index: Int): T? = items[index]
     override fun iterator(): Iterator<T?> = items.iterator()
     override fun listIterator(): ListIterator<T?> = items.listIterator()
     override fun listIterator(index: Int): ListIterator<T?> = items.listIterator(index)
@@ -96,7 +95,7 @@ public data class PagingObject<T : Any>(
     override val previous: String? = null,
     override val total: Int = 0
 ) : AbstractPagingObject<T, PagingObject<T>>() {
-    override fun get(index: Int): T = items[index]
+    override fun get(index: Int): T = super.get(index)!!
 
     override fun iterator(): Iterator<T> = items.iterator()
     override fun listIterator(): ListIterator<T> = items.listIterator()
@@ -332,7 +331,7 @@ public data class CursorBasedPagingObject<T : Any>(
         return pagingObjects.distinctBy { it.href }
     }
 
-    override fun get(index: Int): T = items[index]
+    override fun get(index: Int): T = super.get(index)!!
     override fun iterator(): Iterator<T> = items.iterator()
     override fun listIterator(): ListIterator<T> = items.listIterator()
     override fun listIterator(index: Int): ListIterator<T> = items.listIterator(index)
@@ -505,6 +504,7 @@ public abstract class PagingObjectBase<T : Any, Z : PagingObjectBase<T, Z>> : Li
     override fun indexOf(element: T?): Int = items.indexOf(element)
     override fun isEmpty(): Boolean = items.isEmpty()
     override fun lastIndexOf(element: T?): Int = items.lastIndexOf(element)
+    override fun get(index: Int): T? = items[index]
 }
 
 internal fun Any.instantiateLateinitsIfPagingObjects(api: GenericSpotifyApi) = when (this) {

src/commonMain/kotlin/com.adamratzman.spotify/models/Player.kt

@@ -1,6 +1,7 @@
 /* Spotify Web API, Kotlin Wrapper; MIT License, 2017-2021; Original author: Adam Ratzman */
 package com.adamratzman.spotify.models
 
+import com.adamratzman.spotify.endpoints.client.ClientPlayerApi
 import com.adamratzman.spotify.utils.getExternalUrls
 import com.adamratzman.spotify.utils.match
 import kotlinx.serialization.SerialName
@@ -20,9 +21,17 @@ public data class PlayHistoryContext(
     @SerialName("external_urls") private val externalUrlsString: Map<String, String>,
     val href: String,
     val uri: SpotifyUri,
-    val type: String
+    @SerialName("type") val typeString: String
 ) {
+    val type: ContextType? get() = ContextType.values().find { it.spotifyType == typeString }
     val externalUrls: List<ExternalUrl> get() = getExternalUrls(externalUrlsString)
+
+    public enum class ContextType(public val spotifyType: String) {
+        ARTIST("artist"),
+        PLAYLIST("playlist"),
+        ALBUM("album"),
+        SHOW("show")
+    }
 }
 
 /**
@@ -111,18 +120,7 @@ public data class CurrentlyPlayingContext(
     @SerialName("repeat_state") val repeatStateString: String,
     val context: Context? = null
 ) {
-    val repeatState: RepeatState get() = RepeatState.values().match(repeatStateString)!!
-}
-
-/**
- * How and if playback is repeating
- */
-public enum class RepeatState(public val identifier: String) : ResultEnum {
-    OFF("off"),
-    TRACK("track"),
-    CONTEXT("context");
-
-    override fun retrieveIdentifier(): String = identifier
+    val repeatState: ClientPlayerApi.PlayerRepeatState get() = ClientPlayerApi.PlayerRepeatState.values().match(repeatStateString)!!
 }
 
 /**

src/commonMain/kotlin/com.adamratzman.spotify/models/Track.kt

@@ -13,6 +13,7 @@ import kotlinx.serialization.Serializable
  * identified by their ISO 3166-1 alpha-2 code.
  * @param discNumber The disc number (usually 1 unless the album consists of more than one disc).
  * @param durationMs The track length in milliseconds.
+ * @property length The track length in milliseconds. Alias of [durationMs]
  * @param explicit Whether or not the track has explicit lyrics ( true = yes it does; false = no it does not OR unknown).
  * @param href A link to the Web API endpoint providing full details of the track.
  * @param id The Spotify ID for the track.
@@ -60,6 +61,8 @@ public data class SimpleTrack(
 
     val externalIds: List<ExternalId> get() = externalIdsString.map { ExternalId(it.key, it.value) }
 
+    val length: Int get() = durationMs
+
     /**
      * Converts this [SimpleTrack] into a full [Track] object with the given
      * market
@@ -82,6 +85,7 @@ public data class SimpleTrack(
  * given market. Otherwise false.
  * @param discNumber The disc number (usually 1 unless the album consists of more than one disc).
  * @param durationMs The track length in milliseconds.
+ * @property length The track length in milliseconds. Alias of [durationMs]
  * @param explicit Whether or not the track has explicit lyrics ( true = yes it does; false = no it does not OR unknown).
  * @param href A link to the Web API endpoint providing full details of the track.
  * @param id The Spotify ID for the track.
@@ -139,6 +143,8 @@ public data class Track(
 
     val externalIds: List<ExternalId> get() = externalIdsString.map { ExternalId(it.key, it.value) }
 
+    val length: Int get() = durationMs
+
     override fun getMembersThatNeedApiInstantiation(): List<NeedsApi?> = artists + album + linkedTrack + this
 }
 

src/commonTest/kotlin/com.adamratzman/spotify/priv/ClientPlayerApiTest.kt

@@ -2,12 +2,21 @@ package com.adamratzman.spotify.priv
 
 import com.adamratzman.spotify.SpotifyClientApi
 import com.adamratzman.spotify.buildSpotifyApi
+import com.adamratzman.spotify.endpoints.client.ClientPlayerApi
+import com.adamratzman.spotify.models.CollectionUri
+import com.adamratzman.spotify.models.PlayHistoryContext
+import com.adamratzman.spotify.models.PlayableUri
 import com.adamratzman.spotify.models.SpotifyTrackUri
-import com.adamratzman.spotify.models.Track
 import com.adamratzman.spotify.runBlockingTest
+import kotlinx.coroutines.delay
 import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
 import kotlin.test.assertTrue
+import kotlin.time.ExperimentalTime
+import kotlin.time.measureTime
 
+@ExperimentalTime
 class ClientPlayerApiTest {
     lateinit var api: SpotifyClientApi
 
@@ -37,32 +46,126 @@ class ClientPlayerApiTest {
                 playableUrisToPlay = listOf(SpotifyTrackUri("spotify:track:6WcinC5nKan2DMFUfjVerX")),
                 deviceId = device.id
             )
+            delay(1000)
             val getCurrentContext = suspend { api.player.getCurrentContext() }
             var context = getCurrentContext()
             assertTrue(context != null && context.isPlaying && context.track?.id == "6WcinC5nKan2DMFUfjVerX")
             api.player.pause()
             context = getCurrentContext()!!
 
-            assertTrue(!context.isPlaying && context.track?.id != null)
+            assertTrue(!context.isPlaying)
+            assertNotNull(context.track?.id)
 
             val playlist = api.playlists.getPlaylist("37i9dQZF1DXcBWIGoYBM5M")!!
             api.player.startPlayback(
                 collectionUri = playlist.uri
             )
+            delay(1000)
             context = getCurrentContext()
             assertTrue(context != null && context.isPlaying && context.track?.id == playlist.tracks.items.first().track!!.id)
             api.player.pause()
+        }
+    }
+
+    @Test
+    fun testGetRecentlyPlayed() {
+        runBlockingTest {
+            if (!testPrereq()) return@runBlockingTest
+            api.player.getRecentlyPlayed()
+        }
+    }
 
+    @Test
+    fun testGetCurrentlyPlaying() {
+        runBlockingTest {
+            if (!testPrereq()) return@runBlockingTest
+            val device = api.player.getDevices().first()
 
+            val trackId = "7lPN2DXiMsVn7XUKtOW1CS"
+            api.player.startPlayback(
+                playableUrisToPlay = listOf(PlayableUri("spotify:track:$trackId")),
+                deviceId = device.id
+            )
+            delay(1000)
+            val currentlyPlayingObjectTrack = api.player.getCurrentlyPlaying()
+            assertNotNull(currentlyPlayingObjectTrack)
+            assertTrue(currentlyPlayingObjectTrack.isPlaying && currentlyPlayingObjectTrack.context == null)
+
+            val playlistId = "3DhwYIoAZ8mXlxiBkCuOx7"
+            api.player.startPlayback(collectionUri = CollectionUri("spotify:playlist:3DhwYIoAZ8mXlxiBkCuOx7"))
+            delay(1000)
+            val currentlyPlayingObjectPlaylist = api.player.getCurrentlyPlaying()
+            assertNotNull(currentlyPlayingObjectPlaylist)
+            assertTrue(currentlyPlayingObjectPlaylist.isPlaying)
+            assertEquals(playlistId, currentlyPlayingObjectPlaylist.context?.uri?.id)
+            assertEquals(PlayHistoryContext.ContextType.PLAYLIST, currentlyPlayingObjectPlaylist.context?.type)
+
+            api.player.pause()
         }
     }
 
     @Test
-    fun testGetRecentlyPlayed() {
+    fun testSeek() {
         runBlockingTest {
             if (!testPrereq()) return@runBlockingTest
             val device = api.player.getDevices().first()
-            api.player.getRecentlyPlayed()
+
+            val trackId = "7lPN2DXiMsVn7XUKtOW1CS"
+            val track = api.tracks.getTrack(trackId)!!
+            api.player.startPlayback(
+                playableUrisToPlay = listOf(PlayableUri("spotify:track:$trackId")),
+                deviceId = device.id
+            )
+            api.player.pause()
+
+            val skipTo = track.length / 2
+            val delay = measureTime {
+                api.player.seek(skipTo.toLong())
+                api.player.resume()
+            }.inMilliseconds
+
+            val waitTime = 3000
+            delay(waitTime.toLong())
+            assertTrue(api.player.getCurrentlyPlaying()!!.progressMs!! >= waitTime - delay)
+            api.player.skipForward()
+        }
+    }
+
+    @Test
+    fun testSetPlaybackOptions() {
+        runBlockingTest {
+            if (!testPrereq()) return@runBlockingTest
+            val device = api.player.getDevices().first()
+            api.player.setRepeatMode(ClientPlayerApi.PlayerRepeatState.OFF, device.id)
+            api.player.setVolume(50, device.id)
+            val context = api.player.getCurrentContext()!!
+            assertEquals(ClientPlayerApi.PlayerRepeatState.OFF, context.repeatState)
+
+        }
+    }
+
+    @Test
+    fun testSkipForwardBackward() {
+        runBlockingTest {
+            if (!testPrereq()) return@runBlockingTest
+            val device = api.player.getDevices().first()
+
+            val playlist = api.playlists.getPlaylist("37i9dQZF1DXcBWIGoYBM5M")!!
+            api.player.startPlayback(
+                collectionUri = playlist.uri,
+                deviceId = device.id
+            )
+            delay(1000)
+
+            api.player.skipForward()
+            delay(500)
+            assertEquals(playlist.tracks[1].track!!.id, api.player.getCurrentlyPlaying()!!.track.id)
+
+            api.player.skipBehind()
+            delay(500)
+            assertEquals(playlist.tracks[0].track!!.id, api.player.getCurrentlyPlaying()!!.track.id)
+
+            api.player.pause()
         }
     }