Merge pull request #238 from adamint/feature/native-targets

Kotlin/Native (MacOS, Windows, Linux) targets

Author: adamint

README.md

@@ -40,8 +40,6 @@ repositories {
 implementation("com.adamratzman:spotify-api-kotlin-core:3.4.03")
 ```
 
-Note that images and profiles are not supported on the Kotlin/JS target.
-
 ### Android
 **If you declare any release types not named debug or release, you may see "Could not resolve com.adamratzman:spotify-api-kotlin-android:VERSION". You need to do the following for each release type not named debug or release:**
 ```
@@ -78,6 +76,17 @@ If you have a question, you can:
 2. Join our [Discord server](https://discord.gg/G6vqP3S)
 3. Contact me using **Adam#9261** on [Discord](https://discordapp.com)
 
+## Unsupported features on each platform:
+| Feature                     | JVM                | Android            | JS                 | Native (Mac/Windows/Linux) |
+|-----------------------------|--------------------|--------------------|--------------------|----------------------------|
+| Images (Playlist covers)    | :heavy_check_mark: | :heavy_check_mark: | Unsupported        | Unsupported                |
+| getSpotifyPkceCodeChallenge | :heavy_check_mark: | :heavy_check_mark: | Unsupported        | Unsupported                |
+| Edit client playlist        | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | Unsupported                |
+| Remove playlist tracks      | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | Unsupported                |
+
+Please feel free to open an issue/discussion on GitHub or Discord if you need access to one of these features 
+or have an interest in implementing one, as direction can be provided.
+
 ## Creating a new api instance
 To decide which api you need (SpotifyAppApi, SpotifyClientApi, SpotifyImplicitGrantApi), you can refer 
 to the sections below or the [Spotify authorization guide](https://developer.spotify.com/documentation/general/guides/authorization-guide/). In general:

build.gradle.kts

@@ -146,17 +146,30 @@ kotlin {
         }
     }
 
+    val hostOs = System.getProperty("os.name")
+    val isMingwX64 = hostOs.startsWith("Windows")
+    val nativeTarget = when {
+        hostOs == "Mac OS X" -> macosX64("native")
+        hostOs == "Linux" -> linuxX64("native")
+        isMingwX64 -> mingwX64("native")
+        else -> throw GradleException("Host OS is not supported in Kotlin/Native.")
+    }
+
+
     targets {
         sourceSets {
-            val coroutineVersion = "1.4.2"
+            val coroutineVersion = "1.4.2-native-mt"
             val serializationVersion = "1.0.1"
             val ktorVersion = "1.4.1"
+            val kotlinxDatetimeVersion = "0.1.1"
 
             val commonMain by getting {
                 dependencies {
                     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutineVersion")
                     implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:$serializationVersion")
                     implementation("io.ktor:ktor-client-core:$ktorVersion")
+                    implementation("org.jetbrains.kotlinx:kotlinx-datetime:$kotlinxDatetimeVersion")
+                    implementation("com.autodesk:coroutineworker:0.6.2")
                 }
             }
             val commonTest by getting {
@@ -221,6 +234,17 @@ kotlin {
                 }
             }
 
+            val nativeMain by getting {
+                dependencies {
+                    implementation("io.ktor:ktor-client-curl:$ktorVersion")
+                }
+            }
+            val nativeTest by getting {
+                dependencies {
+
+                }
+            }
+
             all {
                 languageSettings.useExperimentalAnnotation("kotlin.Experimental")
             }
@@ -260,8 +284,9 @@ publishing {
 
 signing {
     if (project.hasProperty("signing.keyId")
-            && project.hasProperty("signing.password")
-            && project.hasProperty("signing.secretKeyRingFile")) {
+        && project.hasProperty("signing.password")
+        && project.hasProperty("signing.secretKeyRingFile")
+    ) {
         sign(publishing.publications)
     }
 }

src/androidMain/kotlin/com/adamratzman/spotify/http/Endpoints.kt

@@ -11,8 +11,8 @@ internal actual fun String.encodeUrl() = URLEncoder.encode(this, "UTF-8")!!
 internal actual fun String.base64ByteEncode(): String {
     return if (VERSION.SDK_INT >= VERSION_CODES.O) {
         java.util.Base64.getUrlEncoder()
-                .withoutPadding()
-                .encodeToString(toByteArray())
+            .withoutPadding()
+            .encodeToString(toByteArray())
     } else {
         Base64.encodeToString(toByteArray(), Base64.DEFAULT)
     }

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

@@ -1,13 +1,4 @@
 /* Spotify Web API, Kotlin Wrapper; MIT License, 2017-2021; Original author: Adam Ratzman */
 package com.adamratzman.spotify.utils
 
-import android.annotation.SuppressLint
-import java.text.SimpleDateFormat
-import java.util.Date
-
 public actual fun getCurrentTimeMs(): Long = System.currentTimeMillis()
-
-@SuppressLint("SimpleDateFormat")
-internal actual fun formatDate(format: String, date: Long): String {
-        return SimpleDateFormat(format).format(Date(date))
-}

src/commonMain/kotlin/com.adamratzman.spotify/endpoints/public/BrowseApi.kt

@@ -101,9 +101,7 @@ public class BrowseApi(api: GenericSpotifyApi) : SpotifyEndpoint(api) {
         endpointBuilder("/browse/featured-playlists").with("limit", limit).with("offset", offset).with(
             "market",
             market?.name
-        ).with("locale", locale).with("timestamp", timestamp?.let {
-            formatDate("yyyy-MM-dd'T'HH:mm:ss", it)
-        }).toString()
+        ).with("locale", locale).with("timestamp", timestamp?.let { formatDate(it) }).toString()
     ).toObject(FeaturedPlaylists.serializer(), api, json)
 
     /**
@@ -183,7 +181,7 @@ public class BrowseApi(api: GenericSpotifyApi) : SpotifyEndpoint(api) {
             limit
         ).with("offset", offset)
             .with("market", market?.name).toString()
-    ).toPagingObject(SimplePlaylist.serializer(), "playlists", endpoint = this, json = json)
+    ).toPagingObject((SimplePlaylist.serializer()), "playlists", endpoint = this, json = json)
 
     /**
      * Create a playlist-style listening experience based on seed artists, tracks and genres.

src/commonMain/kotlin/com.adamratzman.spotify/http/HttpConnection.kt

@@ -95,9 +95,9 @@ public class HttpConnection constructor(
 
                 if (respCode == 502 && retryIf502) {
                     api?.logger?.logError(
-                            false,
-                            "Received 502 (Invalid response) for URL $url and $this (${response.readText()})\nRetrying..",
-                            null
+                        false,
+                        "Received 502 (Invalid response) for URL $url and $this (${response.readText()})\nRetrying..",
+                        null
                     )
                     return@let execute(additionalHeaders, retryIf502 = false)
                 } else if (respCode == 502 && !retryIf502) {
@@ -108,9 +108,9 @@ public class HttpConnection constructor(
                     val ratelimit = response.headers["Retry-After"]!!.toLong() + 1L
                     if (api?.spotifyApiOptions?.retryWhenRateLimited == true) {
                         api.logger.logError(
-                                false,
-                                "The request ($url) was ratelimited for $ratelimit seconds at ${getCurrentTimeMs()}",
-                                null
+                            false,
+                            "The request ($url) was ratelimited for $ratelimit seconds at ${getCurrentTimeMs()}",
+                            null
                         )
 
                         delay(ratelimit * 1000)
@@ -120,7 +120,7 @@ public class HttpConnection constructor(
 
                 val body = response.readText()
                 if (respCode == 401 && body.contains("access token") &&
-                        api != null && api.spotifyApiOptions.automaticRefresh
+                    api != null && api.spotifyApiOptions.automaticRefresh
                 ) {
                     api.refreshToken()
                     val newAdditionalHeaders = additionalHeaders?.toMutableList() ?: mutableListOf()
@@ -129,26 +129,38 @@ public class HttpConnection constructor(
                 }
 
                 return HttpResponse(
-                        responseCode = respCode,
-                        body = body,
-                        headers = response.headers.entries().map { (key, value) ->
-                            HttpHeader(
-                                    key,
-                                    value.getOrNull(0) ?: "null"
-                            )
-                        }
+                    responseCode = respCode,
+                    body = body,
+                    headers = response.headers.entries().map { (key, value) ->
+                        HttpHeader(
+                            key,
+                            value.getOrNull(0) ?: "null"
+                        )
+                    }
                 )
             }
         } catch (e: CancellationException) {
             throw e
         } catch (e: ResponseException) {
             val errorBody = e.response.readText()
             try {
-                val error = errorBody.toObject(ErrorResponse.serializer(), api, api?.spotifyApiOptions?.json ?: nonstrictJson).error
+                val error = errorBody.toObject(
+                    ErrorResponse.serializer(),
+                    api,
+                    api?.spotifyApiOptions?.json ?: nonstrictJson
+                ).error
                 throw BadRequestException(error.copy(reason = (error.reason ?: "") + " URL: $url"))
             } catch (ignored: ParseException) {
-                val error = errorBody.toObject(AuthenticationError.serializer(), api, api?.spotifyApiOptions?.json ?: nonstrictJson)
-                throw AuthenticationException(error)
+                try {
+                    val error = errorBody.toObject(
+                        AuthenticationError.serializer(),
+                        api,
+                        api?.spotifyApiOptions?.json ?: nonstrictJson
+                    )
+                    throw AuthenticationException(error)
+                } catch (ignored: ParseException) {
+                    throw e
+                }
             }
         }
     }

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

@@ -20,7 +20,7 @@ public class SpotifyUriException(message: String) : SpotifyException.BadRequestE
 
 private fun String.matchType(type: String, allowColon: Boolean): String? {
     val uriContent = "[^:]".takeUnless { allowColon } ?: "."
-    val typeRegex = "^spotify:(?:.*:)*$type:($uriContent*)(?::.*)*$|^([^:]+)$".toRegex()
+    val typeRegex = "^spotify:(?:.*:)?$type:($uriContent*)(?::.*)*$|^([^:]+)\$".toRegex()
     val match = typeRegex.matchEntire(this)?.groupValues ?: return null
     return match[1].takeIf { it.isNotBlank() || match[2].isEmpty() } ?: match[2].takeIf { it.isNotEmpty() }
 }
@@ -41,7 +41,10 @@ private fun String.remove(type: String, allowColon: Boolean): String {
 
 private class SimpleUriSerializer<T : SpotifyUri>(val ctor: (String) -> T) : KSerializer<T> {
     override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("SimpleUri", PrimitiveKind.STRING)
-    override fun deserialize(decoder: Decoder): T = ctor(decoder.decodeString())
+    override fun deserialize(decoder: Decoder): T {
+        val str = decoder.decodeString()
+        return ctor(str)
+    }
     override fun serialize(encoder: Encoder, value: T) = encoder.encodeString(value.uri)
 }
 
@@ -150,7 +153,9 @@ public sealed class CollectionUri(input: String, type: String, allowColon: Boole
     @Serializer(forClass = CollectionUri::class)
     public companion object : KSerializer<CollectionUri> {
         override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("CollectionUri", PrimitiveKind.STRING)
-        override fun deserialize(decoder: Decoder): CollectionUri = CollectionUri(decoder.decodeString())
+        override fun deserialize(decoder: Decoder): CollectionUri {
+            return CollectionUri(decoder.decodeString())
+        }
         override fun serialize(encoder: Encoder, value: CollectionUri): Unit = encoder.encodeString(value.uri)
 
         public operator fun invoke(input: String): CollectionUri {
@@ -235,6 +240,7 @@ public class ArtistUri(input: String) : SpotifyUri(input, "artist") {
  */
 @Serializable
 public class UserUri(input: String) : SpotifyUri(input, "user") {
+
     @Serializer(forClass = UserUri::class)
     public companion object : KSerializer<UserUri> by SimpleUriSerializer(::UserUri)
 }

src/commonMain/kotlin/com.adamratzman.spotify/models/serialization/SerializationUtils.kt

@@ -18,12 +18,13 @@ import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonElement
 import kotlinx.serialization.json.JsonObject
 
-internal val nonstrictJson = Json {
-    isLenient = true
-    ignoreUnknownKeys = true
-    allowSpecialFloatingPointValues = true
-    useArrayPolymorphism = true
-}
+internal val nonstrictJson =
+    Json {
+        isLenient = true
+        ignoreUnknownKeys = true
+        allowSpecialFloatingPointValues = true
+        useArrayPolymorphism = true
+    }
 
 internal inline fun <reified T : Any> String.toObjectNullable(
     serializer: KSerializer<T>,
@@ -78,20 +79,24 @@ internal fun <T : Any> String.toPagingObject(
     skipInnerNameFirstIfPossible: Boolean = true
 ): NullablePagingObject<T> {
     if (innerObjectName != null || (arbitraryInnerNameAllowed && !skipInnerNameFirstIfPossible)) {
-        val map = this.parseJson {
-            val t = (String.serializer() to NullablePagingObject.serializer(tSerializer))
-            json.decodeFromString(MapSerializer(t.first, t.second), this)
+        val jsonObjectRoot = (json.parseToJsonElement(this) as JsonObject)
+        val jsonElement =
+            innerObjectName?.let { jsonObjectRoot[it] } ?: jsonObjectRoot.keys.firstOrNull()?.let { jsonObjectRoot[it] }
+            ?: throw SpotifyException.ParseException("Json element was null for class $tClazz (json $this)")
+        val objectString = jsonElement.toString()
+
+        val map = objectString.parseJson {
+            json.decodeFromString(NullablePagingObject.serializer(tSerializer), this)
         }
-        return (map[innerObjectName] ?: if (arbitraryInnerNameAllowed) map.keys.firstOrNull()?.let { map[it] }
-            ?: error("") else error(""))
-            .apply {
-                this.endpoint = endpoint
-                this.itemClazz = tClazz
-                this.items.map { obj ->
-                    if (obj is NeedsApi) obj.api = endpoint.api
-                    if (obj is PagingObjectBase<*, *>) obj.endpoint = endpoint
-                }
+
+        return map.apply {
+            this.endpoint = endpoint
+            this.itemClazz = tClazz
+            this.items.map { obj ->
+                if (obj is NeedsApi) obj.api = endpoint.api
+                if (obj is PagingObjectBase<*, *>) obj.endpoint = endpoint
             }
+        }
     }
 
     return try {
@@ -261,7 +266,7 @@ internal fun <T> String.parseJson(producer: String.() -> T): T =
         producer(this)
     } catch (e: Exception) {
         throw SpotifyException.ParseException(
-            "Unable to parse $this",
+            "Unable to parse $this (${e.message})",
             e
         )
     }

src/commonMain/kotlin/com.adamratzman.spotify/utils/Platform.kt

@@ -7,7 +7,8 @@ package com.adamratzman.spotify.utils
 public enum class Platform {
     JVM,
     ANDROID,
-    JS
+    JS,
+    NATIVE
 }
 
 public expect val platform: Platform

src/commonMain/kotlin/com.adamratzman.spotify/utils/Utils.kt

@@ -3,6 +3,9 @@ package com.adamratzman.spotify.utils
 
 import com.adamratzman.spotify.SpotifyException
 import com.adamratzman.spotify.models.ResultEnum
+import kotlinx.datetime.Instant
+import kotlinx.datetime.TimeZone
+import kotlinx.datetime.toLocalDateTime
 import kotlinx.serialization.json.JsonElement
 
 public expect fun getCurrentTimeMs(): Long
@@ -22,4 +25,5 @@ internal suspend inline fun <T> catch(crossinline function: suspend () -> T): T?
 internal fun <T : ResultEnum> Array<T>.match(identifier: String) =
     firstOrNull { it.retrieveIdentifier().toString().equals(identifier, true) }
 
-internal expect fun formatDate(format: String, date: Long): String
+internal fun formatDate(date: Long): String =
+    Instant.fromEpochMilliseconds(date).toLocalDateTime(TimeZone.currentSystemDefault()).toString()