add common upload methods for playlists (fixes #254, #255)

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

Author: adamint

README.md

@@ -90,8 +90,6 @@ If you have a question, you can:
 ## 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                |
 
@@ -182,7 +180,7 @@ hash the code verifier using the SHA256 algorithm. Then, base64url encode the ha
 the code challenge used to authorize the user.
 
 This library contains helpful methods that can be used to simplify the PKCE authorization process.
-This includes `getSpotifyPkceCodeChallenge` (not available in the Kotlin/JS target), which SHA256 hashes and base64url encodes the code 
+This includes `getSpotifyPkceCodeChallenge`, which SHA256 hashes and base64url encodes the code 
 challenge, and `getPkceAuthorizationUrl`, which allows you to generate an easy authorization url for PKCE flow.
 
 Please see the [spotifyClientPkceApi builder docs](https://adamint.github.io/spotify-web-api-kotlin-docs/spotify-web-api-kotlin/com.adamratzman.spotify/spotify-client-pkce-api.html) for a full list of available builders.

build.gradle.kts

@@ -175,16 +175,22 @@ kotlin {
         sourceSets {
             val coroutineVersion = "1.4.2-native-mt"
             val serializationVersion = "1.0.1"
-            val ktorVersion = "1.5.0"
-            val klockVersion = "2.0.3"
+            val ktorVersion = "1.5.1"
+            val korlibsVersion = "2.0.6"
 
             val commonMain by getting {
                 dependencies {
-                    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutineVersion")
+                    implementation ("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutineVersion"){
+                        version {
+                            strictly(coroutineVersion)
+                        }
+                    }
                     implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:$serializationVersion")
                     implementation("io.ktor:ktor-client-core:$ktorVersion")
-                    implementation("com.soywiz.korlibs.klock:klock:$klockVersion")
-                    implementation("com.soywiz.korlibs.krypto:krypto:2.0.6")
+                    implementation("com.soywiz.korlibs.klock:klock:$korlibsVersion")
+                    implementation("com.soywiz.korlibs.krypto:krypto:$korlibsVersion")
+                    implementation("com.soywiz.korlibs.korim:korim:$korlibsVersion")
+
                 }
             }
 

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

@@ -2,11 +2,6 @@
 package com.adamratzman.spotify.utils
 
 import android.annotation.SuppressLint
-import android.graphics.Bitmap
-import android.graphics.BitmapFactory
-import android.util.Base64
-import java.io.ByteArrayOutputStream
-import java.net.URL
 import java.net.URLEncoder
 import java.text.SimpleDateFormat
 import java.util.Date
@@ -18,32 +13,11 @@ internal actual fun formatDate(format: String, date: Long): String {
     return SimpleDateFormat(format).format(Date(date))
 }
 
-internal actual fun encodeBufferedImageToBase64String(image: BufferedImage): String {
-    val byteArrayOutputStream = ByteArrayOutputStream()
-    image.compress(Bitmap.CompressFormat.PNG, 100, byteArrayOutputStream)
-    val byteArray: ByteArray = byteArrayOutputStream.toByteArray()
-    return Base64.encodeToString(byteArray, Base64.DEFAULT)
-}
-
-internal actual fun convertFileToBufferedImage(file: File): BufferedImage = BitmapFactory.decodeFile(file.absolutePath)
-
-internal actual fun convertLocalImagePathToBufferedImage(path: String): BufferedImage = BitmapFactory.decodeFile(path)
-
-internal actual fun convertUrlPathToBufferedImage(url: String): BufferedImage {
-    return URL(url).openConnection().getInputStream().use { inputStream ->
-        BitmapFactory.decodeStream(inputStream)
-    }
-}
-
 /**
  * Actual platform that this program is run on.
  */
 public actual val currentApiPlatform: Platform = Platform.ANDROID
 
 public actual typealias ConcurrentHashMap<K, V> = java.util.concurrent.ConcurrentHashMap<K, V>
 
-public actual typealias BufferedImage = Bitmap // TODO
-
-public actual typealias File = java.io.File
-
 public actual fun <K, V> ConcurrentHashMap<K, V>.asList(): List<Pair<K, V>> = toList()

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

@@ -7,6 +7,7 @@ import com.adamratzman.spotify.http.HttpRequestMethod
 import com.adamratzman.spotify.models.Token
 import com.adamratzman.spotify.models.serialization.nonstrictJson
 import com.adamratzman.spotify.models.serialization.toObject
+import com.adamratzman.spotify.utils.urlEncodeBase64String
 import com.soywiz.krypto.SHA256
 import io.ktor.client.features.ServerResponseException
 import io.ktor.utils.io.core.toByteArray
@@ -80,11 +81,8 @@ public fun getPkceAuthorizationUrl(
  */
 public fun getSpotifyPkceCodeChallenge(codeVerifier: String): String {
     if (codeVerifier.length !in 43..128) throw IllegalArgumentException("Code verifier must be between 43 and 128 characters long")
-
-    var sha256 = SHA256.digest(codeVerifier.toByteArray()).base64
-    while (sha256.endsWith("=")) sha256 = sha256.removeSuffix("=")
-
-    return sha256.replace("/", "_").replace("+", "-")
+    val sha256 = SHA256.digest(codeVerifier.toByteArray()).base64
+    return sha256.urlEncodeBase64String()
 }
 
 // ==============================================

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

@@ -17,13 +17,13 @@ import com.adamratzman.spotify.models.serialization.mapToJsonString
 import com.adamratzman.spotify.models.serialization.toNonNullablePagingObject
 import com.adamratzman.spotify.models.serialization.toObject
 import com.adamratzman.spotify.utils.BufferedImage
-import com.adamratzman.spotify.utils.File
+import com.adamratzman.spotify.utils.convertBufferedImageToBase64JpegString
 import com.adamratzman.spotify.utils.convertFileToBufferedImage
 import com.adamratzman.spotify.utils.convertLocalImagePathToBufferedImage
 import com.adamratzman.spotify.utils.convertUrlPathToBufferedImage
-import com.adamratzman.spotify.utils.encodeBufferedImageToBase64String
 import com.adamratzman.spotify.utils.encodeUrl
 import com.adamratzman.spotify.utils.jsonMap
+import com.soywiz.korio.file.VfsFile
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.JsonArray
@@ -334,7 +334,8 @@ public class ClientPlaylistApi(api: GenericSpotifyApi) : PlaylistApi(api) {
      * @param playlist the id or uri for the playlist.
      * @param imagePath Optionally specify the full local path to the image
      * @param imageUrl Optionally specify a URL to the image
-     * @param imageFile Optionally specify the image [File]
+     * @param imageFile Optionally specify the image [VfsFile]. Note that in each platform, there is a [toVfs] method to convert
+     * the platform's file type to a [VfsFile]. For example, `java.util.File.toVfs()` will return a [VfsFile].
      * @param image Optionally specify the image's [BufferedImage] object
      * @param imageData Optionally specify the Base64-encoded image data yourself
      *
@@ -343,16 +344,16 @@ public class ClientPlaylistApi(api: GenericSpotifyApi) : PlaylistApi(api) {
     public suspend fun uploadClientPlaylistCover(
         playlist: String,
         imagePath: String? = null,
-        imageFile: File? = null,
+        imageFile: VfsFile? = null,
         image: BufferedImage? = null,
         imageData: String? = null,
         imageUrl: String? = null
     ) {
         val data = imageData ?: when {
-            image != null -> encodeBufferedImageToBase64String(image)
-            imageFile != null -> encodeBufferedImageToBase64String(convertFileToBufferedImage(imageFile))
-            imageUrl != null -> encodeBufferedImageToBase64String(convertUrlPathToBufferedImage(imageUrl))
-            imagePath != null -> encodeBufferedImageToBase64String(convertLocalImagePathToBufferedImage(imagePath))
+            image != null -> convertBufferedImageToBase64JpegString(image)
+            imageFile != null -> convertBufferedImageToBase64JpegString(convertFileToBufferedImage(imageFile))
+            imageUrl != null -> convertBufferedImageToBase64JpegString(convertUrlPathToBufferedImage(imageUrl))
+            imagePath != null -> convertBufferedImageToBase64JpegString(convertLocalImagePathToBufferedImage(imagePath))
             else -> throw IllegalArgumentException("No cover image was specified")
         }
         put(

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

@@ -73,12 +73,12 @@ public data class SpotifyPublicUser(
  * @param href Will always be null, per the Spotify documentation,
  * until the Web API is updated to support this.
  *
- * @param total -1 if the user object does not contain followers, otherwise the amount of followers the user has
+ * @param total Null or -1 if the user object does not contain followers, otherwise the amount of followers the user has
  */
 @Serializable
 public data class Followers(
     val href: String? = null,
-    @SerialName("total") val total: Int
+    @SerialName("total") val total: Int? = null
 )
 
 @Serializable

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

@@ -5,4 +5,12 @@ import com.soywiz.krypto.encoding.Base64
 import io.ktor.utils.io.core.toByteArray
 
 internal fun String.base64ByteEncode() = Base64.encode(toByteArray())
+
+public fun String.urlEncodeBase64String(): String {
+    var result = this
+    while (result.endsWith("=")) result = result.removeSuffix("=")
+
+    return result.replace("/", "_").replace("+", "-")
+}
+
 internal expect fun String.encodeUrl(): String

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

@@ -1,8 +1,29 @@
 /* Spotify Web API, Kotlin Wrapper; MIT License, 2017-2021; Original author: Adam Ratzman */
 package com.adamratzman.spotify.utils
 
-internal expect fun encodeBufferedImageToBase64String(image: BufferedImage): String
+import com.soywiz.korim.bitmap.Bitmap
+import com.soywiz.korim.format.jpg.JPEG
+import com.soywiz.korio.file.VfsFile
+import com.soywiz.korio.file.std.UrlVfs
+import com.soywiz.korio.file.std.localVfs
+import com.soywiz.krypto.encoding.Base64
+import io.ktor.utils.io.core.String
 
-internal expect fun convertFileToBufferedImage(file: File): BufferedImage
-internal expect fun convertUrlPathToBufferedImage(url: String): BufferedImage
-internal expect fun convertLocalImagePathToBufferedImage(path: String): BufferedImage
+/**
+ * Represents an image. Please use convertXToBufferedImage and convertBufferedImageToX methods to read and write [BufferedImage]
+ */
+public typealias BufferedImage = Bitmap
+
+public fun convertBufferedImageToBase64JpegString(image: BufferedImage): String {
+    return Base64.encode(JPEG.encode(image))
+}
+
+public suspend fun convertUrlPathToBufferedImage(url: String): BufferedImage {
+    return JPEG.decode(UrlVfs(url))
+}
+
+public suspend fun convertLocalImagePathToBufferedImage(path: String): BufferedImage {
+    return JPEG.decode(localVfs(path))
+}
+
+public suspend fun convertFileToBufferedImage(file: VfsFile): BufferedImage = JPEG.decode(file.readBytes())

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

@@ -12,7 +12,3 @@ public expect class ConcurrentHashMap<K, V>() {
 }
 
 public expect fun <K, V> ConcurrentHashMap<K, V>.asList(): List<Pair<K, V>>
-
-public expect class BufferedImage
-
-public expect class File

src/commonMain/kotlin/com.soywiz.korim.format.jpg/JPEG.kt

@@ -0,0 +1,33 @@
+/* Spotify Web API, Kotlin Wrapper; MIT License, 2017-2021; Original author: Adam Ratzman */
+package com.soywiz.korim.format.jpg
+
+import com.soywiz.korim.format.ImageData
+import com.soywiz.korim.format.ImageDecodingProps
+import com.soywiz.korim.format.ImageEncodingProps
+import com.soywiz.korim.format.ImageFormat
+import com.soywiz.korim.format.ImageFrame
+import com.soywiz.korim.format.ImageInfo
+import com.soywiz.korio.stream.SyncStream
+import com.soywiz.korio.stream.readAll
+import com.soywiz.korio.stream.writeBytes
+
+public object JPEG : ImageFormat("jpg", "jpeg") {
+    override fun decodeHeader(s: SyncStream, props: ImageDecodingProps): ImageInfo? = try {
+        val info = JPEGDecoder.decodeInfo(s.readAll())
+        ImageInfo().apply {
+            this.width = info.width
+            this.height = info.height
+            this.bitsPerPixel = 24
+        }
+    } catch (e: Throwable) {
+        null
+    }
+
+    override fun readImage(s: SyncStream, props: ImageDecodingProps): ImageData {
+        return ImageData(listOf(ImageFrame(JPEGDecoder.decode(s.readAll()))))
+    }
+
+    override fun writeImage(image: ImageData, s: SyncStream, props: ImageEncodingProps) {
+        s.writeBytes(JPEGEncoder.encode(image.mainBitmap.toBMP32(), quality = (props.quality * 100).toInt()))
+    }
+}