spotify auth wrapper

Signed-off-by: Adam Ratzman <[email protected]>

Author: adamint

build.gradle.kts

@@ -176,6 +176,10 @@ kotlin {
             val serializationVersion = "1.0.1"
             val ktorVersion = "1.5.1"
             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 commonMain by getting {
                 dependencies {
@@ -209,7 +213,7 @@ kotlin {
             val jvmTest by getting {
                 dependencies {
                     implementation(kotlin("test-junit"))
-                    implementation("com.sparkjava:spark-core:2.9.3")
+                    implementation("com.sparkjava:spark-core:$sparkVersion")
                     runtimeOnly(kotlin("reflect"))
                 }
             }
@@ -228,10 +232,6 @@ kotlin {
             val jsTest by getting {
                 dependencies {
                     implementation(kotlin("test-js"))
-
-                   // implementation("io.kotest:kotest-assertions-core-js:4.3.2")
-                   // implementation("io.kotest:kotest-framework-api-js:4.3.2")
-                   // implementation("io.kotest:kotest-framework-engine-js:4.3.2")
                 }
             }
 
@@ -242,14 +242,16 @@ kotlin {
                 }
 
                 dependencies {
+                    implementation("com.spotify.android:auth:$androidSpotifyAuthVersion")
                     implementation("io.ktor:ktor-client-okhttp:$ktorVersion")
+                    implementation("androidx.security:security-crypto:$androidCryptoVersion")
                 }
             }
 
             val androidTest by getting {
                 dependencies {
                     implementation(kotlin("test-junit"))
-                    implementation("com.sparkjava:spark-core:2.9.3")
+                    implementation("com.sparkjava:spark-core:$sparkVersion")
                     runtimeOnly(kotlin("reflect"))
                 }
             }
@@ -258,8 +260,6 @@ kotlin {
                 dependsOn(commonMain)
 
                 dependencies {
-                    val coroutineMTVersion = "1.4.2-native-mt"
-
                     implementation ("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutineMTVersion") {
                         version {
                             strictly(coroutineMTVersion)

src/androidMain/kotlin/com/adamratzman/spotify/auth/AbstractSpotifyLoginActivity.kt

@@ -0,0 +1,77 @@
+package com.adamratzman.spotify.auth
+
+import android.app.Activity
+import android.content.Intent
+import android.os.Bundle
+import com.adamratzman.spotify.SpotifyException
+import com.adamratzman.spotify.SpotifyImplicitGrantApi
+import com.adamratzman.spotify.SpotifyScope
+import com.adamratzman.spotify.models.Token
+import com.adamratzman.spotify.spotifyImplicitGrantApi
+import com.spotify.sdk.android.auth.AuthorizationClient
+import com.spotify.sdk.android.auth.AuthorizationRequest
+import com.spotify.sdk.android.auth.AuthorizationResponse
+
+public abstract class AbstractSpotifyLoginActivity : Activity() {
+    public abstract val state: Int
+    public abstract val clientId: String
+    public abstract val redirectUri: String
+    public abstract val useDefaultRedirectHandler: Boolean
+    public abstract fun getRequestingScopes(): List<SpotifyScope>
+
+    public abstract fun onSuccessfulAuthentication(spotifyApi: SpotifyImplicitGrantApi)
+    public abstract fun onAuthenticationFailed(errorMessage: String)
+    public open fun redirectAfterOnSuccessAuthentication() {
+        if (useDefaultRedirectHandler && SpotifyDefaultAuthHelper.activityBack != null) {
+            startActivity(Intent(this, SpotifyDefaultAuthHelper.activityBack))
+            SpotifyDefaultAuthHelper.activityBack = null
+        }
+        finish()
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        triggerLoginActivity()
+    }
+
+    public fun triggerLoginActivity() {
+        val authorizationRequest =
+            AuthorizationRequest.Builder(clientId, AuthorizationResponse.Type.TOKEN, redirectUri)
+                .setScopes(getRequestingScopes().map { it.uri }.toTypedArray())
+                .setState(state.toString())
+                .build()
+        AuthorizationClient.openLoginActivity(this, state, authorizationRequest)
+    }
+
+    override fun onActivityResult(requestCode: Int, resultCode: Int, intent: Intent?) {
+        super.onActivityResult(requestCode, resultCode, intent)
+        if (requestCode == state) {
+            val response = AuthorizationClient.getResponse(resultCode, intent)
+            when (response.type) {
+                AuthorizationResponse.Type.TOKEN -> {
+                    val token = Token(
+                        response.accessToken,
+                        response.type.name,
+                        response.expiresIn
+                    )
+                    val api = spotifyImplicitGrantApi(
+                        clientId = clientId,
+                        token = token
+                    ) {
+                        refreshTokenProducer = { throw SpotifyException.ReAuthenticationNeededException() }
+                    }
+
+                    onSuccessfulAuthentication(api)
+                    redirectAfterOnSuccessAuthentication()
+                }
+                //AuthorizationResponse.Type.CODE -> TODO()
+                //AuthorizationResponse.Type.UNKNOWN -> TODO()
+                AuthorizationResponse.Type.ERROR -> onAuthenticationFailed(response.error)
+                AuthorizationResponse.Type.EMPTY -> onAuthenticationFailed(response.error)
+            }
+            finish()
+        }
+
+    }
+}

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

@@ -222,7 +222,7 @@ public sealed class SpotifyApi<T : SpotifyApi<T, B>, B : ISpotifyApiBuilder<T, B
     public suspend fun refreshToken(): Token = spotifyApiOptions.refreshTokenProducer?.invoke(this)?.apply {
         this@SpotifyApi.token = this
         spotifyApiOptions.onTokenRefresh?.let { it(this@SpotifyApi) }
-    } ?: throw IllegalStateException("The refreshTokenProducer is null.")
+    } ?: throw SpotifyException.ReAuthenticationNeededException(IllegalStateException("The refreshTokenProducer is null."))
 
     public companion object {
         internal suspend fun testTokenValidity(api: GenericSpotifyApi) {

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

@@ -45,4 +45,9 @@ public sealed class SpotifyException(message: String, cause: Throwable? = null)
     }
 
     public class TimeoutException(message: String, cause: Throwable? = null) : SpotifyException(message, cause)
+
+    /**
+     * Exception signifying that re-authentication via spotify-auth is necessary. Thrown by default when refreshTokenProducer is null.
+     */
+    public class ReAuthenticationNeededException(cause: Throwable? = null) : SpotifyException("Re-authentication is needed.", cause)
 }

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

@@ -13,7 +13,7 @@ import kotlinx.serialization.Transient
  *
  * @param accessToken An access token that can be provided in subsequent calls,
  * for example to Spotify Web API services.
- * @param tokenType How the access token may be used: always “Bearer”.
+ * @param tokenType How the access token may be used: always Bearer”.
  * @param expiresIn The time period (in seconds) for which the access token is valid.
  * @param refreshToken A token that can be sent to the Spotify Accounts service in place of an authorization code,
  * null if the token was created using a method that does not support token refresh