Merge pull request #274 from adamint/dev

Add SpotifyRestAction, update kotlin to 1.4.32, rename com.adamratzman.spotify.endpoints.public to com.adamratzman.endpoints.pub

Author: adamint

build.gradle.kts

@@ -5,7 +5,7 @@ import org.jetbrains.kotlin.gradle.targets.js.webpack.KotlinWebpackOutput.Target
 
 plugins {
    // id("lt.petuska.npm.publish") version "1.1.2"
-    kotlin("multiplatform") version "1.4.31"
+    kotlin("multiplatform") version "1.4.32"
     `maven-publish`
     signing
     id("io.codearte.nexus-staging") version "0.22.0"
@@ -29,7 +29,7 @@ buildscript {
     }
     dependencies {
         classpath("com.android.tools.build:gradle:3.5.4")
-        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.4.31")
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.4.32")
     }
 }
 
@@ -216,8 +216,8 @@ kotlin {
             val korlibsVersion = "2.0.6"
             val sparkVersion = "2.9.3"
             val androidSpotifyAuthVersion = "1.2.3"
-            val androidCryptoVersion = "1.1.0-alpha03"
-            val coroutineMTVersion = "1.4.2-native-mt"
+            val androidCryptoVersion = "1.0.0-rc04"
+            val coroutineMTVersion = "1.4.3-native-mt"
 
             val commonMain by getting {
                 dependencies {

settings.gradle.kts

@@ -1,5 +1,5 @@
 pluginManagement {
-    val mainKotlinVersion = "1.4.31"
+    val mainKotlinVersion = "1.4.32"
 
     resolutionStrategy {
         eachPlugin {
@@ -29,4 +29,6 @@ pluginManagement {
 }
 
 rootProject.name = "spotify-web-api-kotlin"
-
+include("java-interop-basic-sample")
+findProject(":java-interop-basic-sample")?.name = "java-interop-basic"
+include("java-interop-sample")

src/androidMain/kotlin/com/adamratzman/spotify/utils/PlatformUtils.kt

@@ -5,6 +5,8 @@ import android.app.Activity
 import android.content.Context
 import android.util.Log
 import android.widget.Toast
+import com.soywiz.korio.async.runBlockingNoJs
+import kotlinx.coroutines.CoroutineScope
 import java.net.URLEncoder
 
 internal actual fun String.encodeUrl() = URLEncoder.encode(this, "UTF-8")!!
@@ -33,3 +35,7 @@ internal fun toast(context: Context?, message: String?, duration: Int = Toast.LE
 internal fun logToConsole(message: String) {
     Log.i("spotify-web-api-kotlin", message)
 }
+
+public actual fun <T> runBlockingOnJvmAndNative(block: suspend CoroutineScope.() -> T): T {
+    return runBlockingNoJs { block() }
+}

src/commonMain/kotlin/com.adamratzman.spotify/SpotifyApi.kt

@@ -13,16 +13,16 @@ import com.adamratzman.spotify.endpoints.client.ClientPlaylistApi
 import com.adamratzman.spotify.endpoints.client.ClientProfileApi
 import com.adamratzman.spotify.endpoints.client.ClientSearchApi
 import com.adamratzman.spotify.endpoints.client.ClientShowApi
-import com.adamratzman.spotify.endpoints.public.AlbumApi
-import com.adamratzman.spotify.endpoints.public.ArtistApi
-import com.adamratzman.spotify.endpoints.public.BrowseApi
-import com.adamratzman.spotify.endpoints.public.EpisodeApi
-import com.adamratzman.spotify.endpoints.public.FollowingApi
-import com.adamratzman.spotify.endpoints.public.PlaylistApi
-import com.adamratzman.spotify.endpoints.public.SearchApi
-import com.adamratzman.spotify.endpoints.public.ShowApi
-import com.adamratzman.spotify.endpoints.public.TrackApi
-import com.adamratzman.spotify.endpoints.public.UserApi
+import com.adamratzman.spotify.endpoints.pub.AlbumApi
+import com.adamratzman.spotify.endpoints.pub.ArtistApi
+import com.adamratzman.spotify.endpoints.pub.BrowseApi
+import com.adamratzman.spotify.endpoints.pub.EpisodeApi
+import com.adamratzman.spotify.endpoints.pub.FollowingApi
+import com.adamratzman.spotify.endpoints.pub.PlaylistApi
+import com.adamratzman.spotify.endpoints.pub.SearchApi
+import com.adamratzman.spotify.endpoints.pub.ShowApi
+import com.adamratzman.spotify.endpoints.pub.TrackApi
+import com.adamratzman.spotify.endpoints.pub.UserApi
 import com.adamratzman.spotify.http.CacheState
 import com.adamratzman.spotify.http.HttpConnection
 import com.adamratzman.spotify.http.HttpHeader
@@ -37,8 +37,8 @@ import com.adamratzman.spotify.models.serialization.nonstrictJson
 import com.adamratzman.spotify.models.serialization.toObject
 import com.adamratzman.spotify.utils.asList
 import com.adamratzman.spotify.utils.base64ByteEncode
-import kotlin.jvm.JvmOverloads
 import kotlinx.serialization.json.Json
+import kotlin.jvm.JvmOverloads
 
 /**
  * Represents an instance of the Spotify API client, with common
@@ -212,6 +212,20 @@ public sealed class SpotifyApi<T : SpotifyApi<T, B>, B : ISpotifyApiBuilder<T, B
         }
     }
 
+    /**
+     * Tests whether the current [token] is actually valid. By default, an endpoint is called *once* to verify
+     * validity.
+     *
+     * @param makeTestRequest Whether to also make an endpoint request to verify authentication.
+     *
+     * @return [TokenValidityResponse] containing whether this token is valid, and if not, an Exception explaining why
+     */
+    @JvmOverloads
+    public fun isTokenValidRestAction(makeTestRequest: Boolean = true): SpotifyRestAction<TokenValidityResponse> =
+        SpotifyRestAction {
+            isTokenValid(makeTestRequest)
+        }
+
     /**
      * If the method used to create the [token] supports token refresh and
      * the information in [token] is accurate, attempt to refresh the token
@@ -224,7 +238,18 @@ public sealed class SpotifyApi<T : SpotifyApi<T, B>, B : ISpotifyApiBuilder<T, B
         this@SpotifyApi.token = this
         spotifyApiOptions.onTokenRefresh?.invoke(this@SpotifyApi)
         spotifyApiOptions.afterTokenRefresh?.invoke(this@SpotifyApi)
-    } ?: throw SpotifyException.ReAuthenticationNeededException(IllegalStateException("The refreshTokenProducer is null."))
+    }
+        ?: throw SpotifyException.ReAuthenticationNeededException(IllegalStateException("The refreshTokenProducer is null."))
+
+    /**
+     * If the method used to create the [token] supports token refresh and
+     * the information in [token] is accurate, attempt to refresh the token
+     *
+     * @return The old access token if refresh was successful
+     * @throws BadRequestException if refresh fails
+     * @throws IllegalStateException if [SpotifyApiOptions.refreshTokenProducer] is null
+     */
+    public fun refreshTokenRestAction(): SpotifyRestAction<Token> = SpotifyRestAction { refreshToken() }
 
     public companion object {
         internal suspend fun testTokenValidity(api: GenericSpotifyApi) {
@@ -327,6 +352,22 @@ public sealed class SpotifyApi<T : SpotifyApi<T, B>, B : ISpotifyApiBuilder<T, B
 
             throw BadRequestException(response.body.toObject(AuthenticationError.serializer(), null, json))
         }
+
+        /**
+         *
+         * Get an application token (can only access public methods) that can be used to instantiate a new [SpotifyAppApi]
+         *
+         * @param clientId Spotify [client id](https://developer.spotify.com/documentation/general/guides/app-settings/)
+         * @param clientSecret Spotify [client secret](https://developer.spotify.com/documentation/general/guides/app-settings/)
+         * @param api The Spotify Api instance, or null if one doesn't exist yet
+         * @param json The json instance that will deserialize the response.
+         */
+        public fun getCredentialedTokenRestAction(
+            clientId: String,
+            clientSecret: String,
+            api: GenericSpotifyApi?,
+            json: Json = api?.spotifyApiOptions?.json ?: Json.Default
+        ): SpotifyRestAction<Token> = SpotifyRestAction { getCredentialedToken(clientId, clientSecret, api, json) }
     }
 }
 
@@ -501,18 +542,23 @@ public open class SpotifyClientApi(
      */
     public val player: ClientPlayerApi = ClientPlayerApi(this)
 
-    private lateinit var userIdBacking: String
+    private var userIdBacking: String? = null
 
     private suspend fun initiatizeUserIdBacking(): String {
         userIdBacking = users.getClientProfile().id
-        return userIdBacking
+        return userIdBacking!!
     }
 
     /**
      * The Spotify user id to which the api instance is connected
      */
     public suspend fun getUserId(): String =
-        if (::userIdBacking.isInitialized) userIdBacking else initiatizeUserIdBacking()
+        if (userIdBacking != null) userIdBacking!! else initiatizeUserIdBacking()
+
+    /**
+     * The Spotify user id to which the api instance is connected
+     */
+    public fun getUserIdRestAction(): SpotifyRestAction<String> = SpotifyRestAction { getUserId() }
 
     /**
      * Stop all automatic functions like refreshToken or clearCache and shut down the scheduled
@@ -574,6 +620,12 @@ public open class SpotifyClientApi(
      */
     public suspend fun hasScope(scope: SpotifyScope): Boolean? = hasScopes(scope)
 
+    /**
+     * Whether the current access token allows access to scope [scope]
+     */
+    public fun hasScopeRestAction(scope: SpotifyScope): SpotifyRestAction<Boolean?> =
+        SpotifyRestAction { hasScope(scope) }
+
     /**
      * Whether the current access token allows access to all of the provided scopes
      */
@@ -583,13 +635,21 @@ public open class SpotifyClientApi(
                 token.scopes?.contains(scope) == true &&
                 scopes.all { token.scopes?.contains(it) == true }
 
+    /**
+     * Whether the current access token allows access to all of the provided scopes
+     */
+    public fun hasScopesRestAction(scope: SpotifyScope, vararg scopes: SpotifyScope): SpotifyRestAction<Boolean?> =
+        SpotifyRestAction {
+            hasScopes(scope, *scopes)
+        }
+
     public companion object {
         private val defaultClientApiTokenRefreshProducer: suspend (GenericSpotifyApi) -> Token = { api ->
             api as SpotifyClientApi
 
             require(api.clientId != null) { "The client id is not set" }
 
-           refreshSpotifyClientToken(api.clientId, api.clientSecret, api.token.refreshToken, api.usesPkceAuth)
+            refreshSpotifyClientToken(api.clientId, api.clientSecret, api.token.refreshToken, api.usesPkceAuth)
         }
     }
 }
@@ -707,3 +767,21 @@ public suspend fun refreshSpotifyClientToken(
         )
     )
 }
+
+/**
+ * Refresh a Spotify client token
+ *
+ * @param clientId The Spotify application client id.
+ * @param clientSecret The Spotify application client secret (not needed for PKCE).
+ * @param refreshToken The refresh token.
+ * @param usesPkceAuth Whether this token was created using PKCE auth or not.
+ */
+public fun refreshSpotifyClientTokenRestAction(
+    clientId: String,
+    clientSecret: String?,
+    refreshToken: String?,
+    usesPkceAuth: Boolean
+): SpotifyRestAction<Token> =
+    SpotifyRestAction { refreshSpotifyClientToken(clientId, clientSecret, refreshToken, usesPkceAuth) }
+
+

src/commonMain/kotlin/com.adamratzman.spotify/SpotifyApiBuilder.kt

@@ -691,11 +691,24 @@ public class SpotifyApiBuilder(
         else buildCredentialed()
     }
 
+    /**
+     * Create a [SpotifyApi] instance with the given [SpotifyApiBuilder] parameters and the type -
+     * [AuthorizationType.CLIENT] for client authentication, or otherwise [AuthorizationType.APPLICATION]
+     */
+    public fun buildRestAction(type: AuthorizationType): SpotifyRestAction<GenericSpotifyApi> = SpotifyRestAction {
+        build(type)
+    }
+
     /**
      * Create a new [SpotifyAppApi] that only has access to *public* endpoints and data
      */
     public suspend fun buildPublic(): SpotifyAppApi = buildCredentialed()
 
+    /**
+    * Create a new [SpotifyAppApi] that only has access to *public* endpoints and data
+    */
+    public fun buildPublicRestAction(): SpotifyRestAction<SpotifyAppApi> = SpotifyRestAction{ buildPublic() }
+
     /**
      * Create a new [SpotifyAppApi] that only has access to *public* endpoints and data
      */
@@ -708,6 +721,11 @@ public class SpotifyApiBuilder(
         options(options)
     }.build()
 
+    /**
+     * Create a new [SpotifyAppApi] that only has access to *public* endpoints and data
+     */
+    public fun buildCredentialedRestAction(): SpotifyRestAction<SpotifyAppApi> = SpotifyRestAction { buildCredentialed() }
+
     /**
      * Create a new [SpotifyClientApi] that has access to public endpoints, in addition to endpoints
      * requiring scopes contained in the client authorization request
@@ -721,6 +739,12 @@ public class SpotifyApiBuilder(
         authorization(authorization)
         options(options)
     }.build()
+
+    /**
+     * Create a new [SpotifyClientApi] that has access to public endpoints, in addition to endpoints
+     * requiring scopes contained in the client authorization request
+     */
+    public fun buildClientRestAction(): SpotifyRestAction<SpotifyClientApi> = SpotifyRestAction { buildClient() }
 }
 
 /**
@@ -811,6 +835,13 @@ public interface ISpotifyApiBuilder<T : SpotifyApi<T, B>, B : ISpotifyApiBuilder
      * Build the [T] by provided information
      */
     public suspend fun build(enableDefaultTokenRefreshProducerIfNoneExists: Boolean = true): T
+
+    /**
+     * Build the [T] by provided information
+     */
+    public fun buildRestAction(enableDefaultTokenRefreshProducerIfNoneExists: Boolean = true): SpotifyRestAction<T> = SpotifyRestAction {
+        build(enableDefaultTokenRefreshProducerIfNoneExists)
+    }
 }
 
 /**