@wwdrew/expo-apple-music 1.0.0

package/android/src/main/java/expo/modules/applemusic/HistoryRestClient.kt

@@ -0,0 +1,60 @@
+package expo.modules.applemusic
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+/** History-domain Apple Music REST (recently played, heavy rotation). */
+internal class HistoryRestClient(
+  private val transport: AppleMusicRestTransport,
+) {
+  suspend fun getRecentlyPlayed(musicUserToken: String): List<Map<String, Any?>> =
+    withContext(Dispatchers.IO) {
+      val json =
+        transport.getJson(musicUserToken, "/v1/me/recent/played", mapOf("limit" to "10"))
+      mapTopLevelResourceArray(json) { AppleMusicJsonMapper.mapRecentlyPlayed(it) }
+    }
+
+  suspend fun getRecentlyPlayedTracks(musicUserToken: String, limit: Int): List<Map<String, Any?>> =
+    withContext(Dispatchers.IO) {
+      val json =
+        transport.getJson(
+          musicUserToken,
+          "/v1/me/recent/played/tracks",
+          mapOf("limit" to limit.toString()),
+        )
+      mapTopLevelResourceArray(json) { AppleMusicJsonMapper.mapSong(it) }
+    }
+
+  suspend fun getHeavyRotation(musicUserToken: String, limit: Int): List<Map<String, Any?>> =
+    withContext(Dispatchers.IO) {
+      val json =
+        transport.getJson(
+          musicUserToken,
+          "/v1/me/history/heavy-rotation",
+          mapOf("limit" to limit.toString()),
+        )
+      mapTopLevelResourceArray(json) { AppleMusicJsonMapper.mapRecentResource(it) }
+    }
+
+  suspend fun getRecentlyPlayedStations(musicUserToken: String, limit: Int): List<Map<String, Any?>> =
+    withContext(Dispatchers.IO) {
+      val json =
+        transport.getJson(
+          musicUserToken,
+          "/v1/me/recent/radio-stations",
+          mapOf("limit" to limit.toString()),
+        )
+      mapTopLevelResourceArray(json) { AppleMusicJsonMapper.mapStation(it) }
+    }
+
+  suspend fun getRecentlyAdded(musicUserToken: String, limit: Int, offset: Int): List<Map<String, Any?>> =
+    withContext(Dispatchers.IO) {
+      val json =
+        transport.getJson(
+          musicUserToken,
+          "/v1/me/library/recently-added",
+          mapOf("limit" to limit.toString(), "offset" to offset.toString()),
+        )
+      mapTopLevelResourceArray(json) { AppleMusicJsonMapper.mapRecentResource(it) }
+    }
+}

package/android/src/main/java/expo/modules/applemusic/LibraryIds.kt

@@ -0,0 +1,6 @@
+package expo.modules.applemusic
+
+internal object LibraryIds {
+  fun isLibraryId(itemId: String): Boolean =
+    itemId.startsWith("l.") || itemId.startsWith("i.") || itemId.startsWith("p.")
+}

package/android/src/main/java/expo/modules/applemusic/LibraryMutationsRestClient.kt

@@ -0,0 +1,95 @@
+package expo.modules.applemusic
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.json.JSONArray
+import org.json.JSONObject
+
+/** Library write/mutation Apple Music REST. */
+internal class LibraryMutationsRestClient(
+  private val transport: AppleMusicRestTransport,
+) {
+  suspend fun addToLibrary(musicUserToken: String, resourceIds: Map<String, List<String>>): Unit =
+    withContext(Dispatchers.IO) {
+      transport.request(
+          musicUserToken,
+          AppleMusicHttpMethod.POST,
+        "/v1/me/library",
+        query = buildIdsQuery(resourceIds),
+      )
+    }
+
+  suspend fun createLibraryPlaylist(
+    musicUserToken: String,
+    name: String,
+    description: String?,
+    isPublic: Boolean,
+    tracks: List<Map<String, String>>?,
+  ): Map<String, Any?> =
+    withContext(Dispatchers.IO) {
+      val attributes =
+        JSONObject()
+          .put("name", name)
+          .put("isPublic", isPublic)
+      if (!description.isNullOrBlank()) {
+        attributes.put(
+          "description",
+          JSONObject().put("standard", description),
+        )
+      }
+
+      val payload = JSONObject().put("attributes", attributes)
+      if (!tracks.isNullOrEmpty()) {
+        val trackData = JSONArray()
+        tracks.forEach { track ->
+          trackData.put(
+            JSONObject()
+              .put("id", track["id"])
+              .put("type", track["type"]),
+          )
+        }
+        payload.put(
+          "relationships",
+          JSONObject().put(
+            "tracks",
+            JSONObject().put("data", trackData),
+          ),
+        )
+      }
+
+      val json =
+        transport.request(
+          musicUserToken,
+          AppleMusicHttpMethod.POST,
+          "/v1/me/library/playlists",
+          body = payload,
+        )
+      val data = requireDataArray(json)
+      if (data.length() == 0) {
+        throw AppleMusicErrors.apiError("Create playlist returned no data")
+      }
+      AppleMusicJsonMapper.mapPlaylist(data.getJSONObject(0))
+    }
+
+  suspend fun addTracksToLibraryPlaylist(
+    musicUserToken: String,
+    playlistId: String,
+    tracks: List<Map<String, String>>,
+  ): Unit =
+    withContext(Dispatchers.IO) {
+      val trackData = JSONArray()
+      tracks.forEach { track ->
+        trackData.put(
+          JSONObject()
+            .put("id", track["id"])
+            .put("type", track["type"]),
+        )
+      }
+      transport.request(
+          musicUserToken,
+          AppleMusicHttpMethod.POST,
+        "/v1/me/library/playlists/$playlistId/tracks",
+        body = JSONObject().put("data", trackData),
+      )
+    }
+}

package/android/src/main/java/expo/modules/applemusic/LibraryRestClient.kt

@@ -0,0 +1,195 @@
+package expo.modules.applemusic
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.json.JSONArray
+import org.json.JSONObject
+
+/** Library-domain Apple Music REST (user collection reads + playback id resolution). */
+internal class LibraryRestClient(
+  private val transport: AppleMusicRestTransport,
+) {
+  suspend fun getLibraryPlaylists(musicUserToken: String, limit: Int, offset: Int): List<Map<String, Any?>> =
+    withContext(Dispatchers.IO) {
+      val json =
+        transport.getJson(
+          musicUserToken,
+          "/v1/me/library/playlists",
+          mapOf("limit" to limit.toString(), "offset" to offset.toString()),
+        )
+      mapTopLevelResourceArray(json) { AppleMusicJsonMapper.mapPlaylist(it) }
+    }
+
+  suspend fun getLibrarySongs(musicUserToken: String, limit: Int, offset: Int): List<Map<String, Any?>> =
+    withContext(Dispatchers.IO) {
+      val json =
+        transport.getJson(
+          musicUserToken,
+          "/v1/me/library/songs",
+          mapOf("limit" to limit.toString(), "offset" to offset.toString()),
+        )
+      mapTopLevelResourceArray(json) { AppleMusicJsonMapper.mapSong(it) }
+    }
+
+  suspend fun getPlaylistTracks(musicUserToken: String, playlistId: String): List<Map<String, Any?>> =
+    withContext(Dispatchers.IO) {
+      val json = transport.getJson(
+          musicUserToken,
+          "/v1/me/library/playlists/$playlistId/tracks")
+      val data = requireDataArray(json)
+      buildList {
+        for (i in 0 until data.length()) {
+          val resource = data.getJSONObject(i)
+          if (resource.optString("type", "").contains("song")) {
+            add(AppleMusicJsonMapper.mapSong(resource))
+          }
+        }
+      }
+    }
+
+  private fun librarySearchTypeParam(type: String): String? =
+    when (type) {
+      "library-songs", "songs" -> "library-songs"
+      "library-albums", "albums" -> "library-albums"
+      "library-artists", "artists" -> "library-artists"
+      "library-playlists", "playlists" -> "library-playlists"
+      "library-music-videos", "music-videos", "musicVideos" -> "library-music-videos"
+      else -> null
+    }
+
+  suspend fun getLibraryArtists(musicUserToken: String, limit: Int, offset: Int): List<Map<String, Any?>> =
+    withContext(Dispatchers.IO) {
+      val json =
+        transport.getJson(
+          musicUserToken,
+          "/v1/me/library/artists",
+          mapOf("limit" to limit.toString(), "offset" to offset.toString()),
+        )
+      mapTopLevelResourceArray(json) { AppleMusicJsonMapper.mapArtist(it) }
+    }
+
+  suspend fun getLibraryAlbums(musicUserToken: String, limit: Int, offset: Int): List<Map<String, Any?>> =
+    withContext(Dispatchers.IO) {
+      val json =
+        transport.getJson(
+          musicUserToken,
+          "/v1/me/library/albums",
+          mapOf("limit" to limit.toString(), "offset" to offset.toString()),
+        )
+      mapTopLevelResourceArray(json) { AppleMusicJsonMapper.mapAlbum(it) }
+    }
+
+  data class LibrarySearchResult(
+    val songs: List<Map<String, Any?>>,
+    val albums: List<Map<String, Any?>>,
+    val artists: List<Map<String, Any?>>,
+    val playlists: List<Map<String, Any?>>,
+    val musicVideos: List<Map<String, Any?>>,
+  )
+
+  suspend fun getLibraryMusicVideos(musicUserToken: String, limit: Int, offset: Int): List<Map<String, Any?>> =
+    withContext(Dispatchers.IO) {
+      val json =
+        transport.getJson(
+          musicUserToken,
+          "/v1/me/library/music-videos",
+          mapOf("limit" to limit.toString(), "offset" to offset.toString()),
+        )
+      mapTopLevelResourceArray(json) { AppleMusicJsonMapper.mapMusicVideo(it) }
+    }
+
+  suspend fun searchLibrary(
+    musicUserToken: String,
+    term: String,
+    types: List<String>,
+    limit: Int,
+    offset: Int,
+  ): LibrarySearchResult =
+    withContext(Dispatchers.IO) {
+      val typeParam =
+        types
+          .mapNotNull { librarySearchTypeParam(it) }
+          .distinct()
+          .sorted()
+          .joinToString(",")
+          .ifEmpty { "library-songs,library-albums" }
+
+      val json =
+        transport.getJson(
+          musicUserToken,
+          "/v1/me/library/search",
+          mapOf(
+            "term" to term,
+            "types" to typeParam,
+            "limit" to limit.toString(),
+            "offset" to offset.toString(),
+          ),
+        )
+
+      val results = json.optJSONObject("results") ?: JSONObject()
+      LibrarySearchResult(
+        songs =
+          mapResourceArray(results.optJSONObject("library-songs")?.optJSONArray("data")) {
+            AppleMusicJsonMapper.mapSong(it)
+          },
+        albums =
+          mapResourceArray(results.optJSONObject("library-albums")?.optJSONArray("data")) {
+            AppleMusicJsonMapper.mapAlbum(it)
+          },
+        artists =
+          mapResourceArray(results.optJSONObject("library-artists")?.optJSONArray("data")) {
+            AppleMusicJsonMapper.mapArtist(it)
+          },
+        playlists =
+          mapResourceArray(results.optJSONObject("library-playlists")?.optJSONArray("data")) {
+            AppleMusicJsonMapper.mapPlaylist(it)
+          },
+        musicVideos =
+          mapResourceArray(results.optJSONObject("library-music-videos")?.optJSONArray("data")) {
+            AppleMusicJsonMapper.mapMusicVideo(it)
+          },
+      )
+    }
+
+  suspend fun probeLibraryAccess(musicUserToken: String): Boolean =
+    withContext(Dispatchers.IO) {
+      try {
+        transport.getJson(
+          musicUserToken,
+          "/v1/me/library/songs", mapOf("limit" to "1"))
+        true
+      } catch (_: Exception) {
+        false
+      }
+    }
+
+  suspend fun resolveCatalogPlaybackId(musicUserToken: String, libraryId: String, mediaType: String): String =
+    withContext(Dispatchers.IO) {
+      val path =
+        when (mediaType) {
+          "song" -> "/v1/me/library/songs/$libraryId"
+          "album" -> "/v1/me/library/albums/$libraryId"
+          "playlist" -> "/v1/me/library/playlists/$libraryId"
+          else -> throw AppleMusicErrors.unknownMediaType(mediaType)
+        }
+      val json = transport.getJson(musicUserToken, path)
+      val resource = json.getJSONArray("data").getJSONObject(0)
+      AppleMusicJsonMapper.catalogPlaybackId(resource)
+        ?: throw AppleMusicErrors.itemNotFound(mediaType.replaceFirstChar { it.uppercase() }, true)
+    }
+
+  suspend fun resolveLibrarySongCatalogIds(musicUserToken: String, playlistId: String): List<String> =
+    withContext(Dispatchers.IO) {
+      val json = transport.getJson(
+          musicUserToken,
+          "/v1/me/library/playlists/$playlistId/tracks")
+      val data = requireDataArray(json)
+      buildList {
+        for (i in 0 until data.length()) {
+          val resource = data.getJSONObject(i)
+          if (!resource.optString("type", "").contains("song")) continue
+          AppleMusicJsonMapper.catalogPlaybackId(resource)?.let { add(it) }
+        }
+      }
+    }
+}

package/android/src/main/java/expo/modules/applemusic/MusicKitAuthContract.kt

@@ -0,0 +1,78 @@
+package expo.modules.applemusic
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import com.apple.android.sdk.authentication.AuthenticationFactory
+import com.apple.android.sdk.authentication.TokenError
+import com.apple.android.sdk.authentication.TokenResult
+import expo.modules.kotlin.activityresult.AppContextActivityResultContract
+import java.io.Serializable
+
+internal data class MusicKitAuthInput(
+  val developerToken: String,
+  val startScreenMessage: String? = null,
+  val hideStartScreen: Boolean = false,
+) : Serializable
+
+internal data class MusicKitAuthOutput(
+  val status: String,
+  val musicUserToken: String? = null,
+) : Serializable
+
+internal class MusicKitAuthContract(
+  private val contextProvider: () -> Context,
+) : AppContextActivityResultContract<MusicKitAuthInput, MusicKitAuthOutput> {
+  override fun createIntent(context: Context, input: MusicKitAuthInput): Intent {
+    val manager = AuthenticationFactory.createAuthenticationManager(context)
+    val builder =
+      manager
+        .createIntentBuilder(input.developerToken)
+        .setHideStartScreen(input.hideStartScreen)
+
+    if (!input.hideStartScreen) {
+      val message = input.startScreenMessage?.trim()
+      if (!message.isNullOrEmpty()) {
+        builder.setStartScreenMessage(message)
+      }
+    }
+
+    return builder.build()
+  }
+
+  override fun parseResult(
+    input: MusicKitAuthInput,
+    resultCode: Int,
+    intent: Intent?,
+  ): MusicKitAuthOutput {
+    // SDK cancel paths: upsell X (USER_CANCELLED intent), Apple Music back (no intent / empty token).
+    if (intent == null) {
+      return MusicKitAuthOutput(status = "denied")
+    }
+
+    val manager = AuthenticationFactory.createAuthenticationManager(contextProvider())
+    return mapTokenResult(manager.handleTokenResult(intent))
+  }
+
+  private fun mapTokenResult(result: TokenResult): MusicKitAuthOutput {
+    if (result.isError) {
+      val status =
+        when (result.error) {
+          TokenError.USER_CANCELLED -> "denied"
+          TokenError.NO_SUBSCRIPTION, TokenError.SUBSCRIPTION_EXPIRED -> "restricted"
+          TokenError.TOKEN_FETCH_ERROR -> "unknown"
+          // handleTokenResult() uses UNKNOWN when the intent has no token or error extras.
+          TokenError.UNKNOWN -> "denied"
+        }
+      return MusicKitAuthOutput(status = status)
+    }
+
+    val token = result.musicUserToken
+    if (token.isNullOrBlank()) {
+      // Apple Music cancel can return RESULT_OK with an empty music_user_token extra.
+      return MusicKitAuthOutput(status = "denied")
+    }
+
+    return MusicKitAuthOutput(status = "authorized", musicUserToken = token)
+  }
+}

package/android/src/main/java/expo/modules/applemusic/MusicKitAuthStorage.kt

@@ -0,0 +1,76 @@
+package expo.modules.applemusic
+
+import android.content.Context
+
+internal object MusicKitAuthStorage {
+  private const val PREFS_NAME = "expo.modules.applemusic.auth"
+  private const val KEY_DEVELOPER_TOKEN = "developerToken"
+  private const val KEY_MUSIC_USER_TOKEN = "musicUserToken"
+
+  fun saveDeveloperToken(context: Context, token: String) {
+    context
+      .getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+      .edit()
+      .putString(KEY_DEVELOPER_TOKEN, token)
+      .apply()
+    invalidateSession(context)
+  }
+
+  /** Persists for native playback SDK (iOS [MusicKitAuthStorage] parity); JS still owns long-term storage. */
+  fun saveMusicUserToken(context: Context, token: String) {
+    val trimmed = token.trim()
+    context
+      .getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+      .edit()
+      .putString(KEY_MUSIC_USER_TOKEN, trimmed)
+      .apply()
+    AuthenticatedSessionCache.rememberMusicUserToken(trimmed)
+  }
+
+  fun getMusicUserToken(context: Context): String? {
+    AuthenticatedSessionCache.musicUserToken?.let { return it }
+    val stored =
+      context
+        .getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+        .getString(KEY_MUSIC_USER_TOKEN, null)
+        ?.trim()
+        ?.takeIf { it.isNotEmpty() }
+    if (stored != null) {
+      AuthenticatedSessionCache.rememberMusicUserToken(stored)
+    }
+    return stored
+  }
+
+  private fun invalidateSession(context: Context) {
+    AuthenticatedSessionCache.invalidate()
+    context
+      .getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+      .edit()
+      .remove(KEY_MUSIC_USER_TOKEN)
+      .apply()
+    AndroidPlaybackController.resetInstance()
+  }
+
+  fun getDeveloperToken(context: Context): String? =
+    context
+      .getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+      .getString(KEY_DEVELOPER_TOKEN, null)
+
+  fun clearDeveloperToken(context: Context) {
+    context
+      .getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+      .edit()
+      .remove(KEY_DEVELOPER_TOKEN)
+      .apply()
+    invalidateSession(context)
+  }
+
+  fun clearAll(context: Context) {
+    context
+      .getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+      .edit()
+      .clear()
+      .apply()
+    invalidateSession(context)
+  }
+}

package/android/src/main/java/expo/modules/applemusic/MusicKitTokenProvider.kt

@@ -0,0 +1,13 @@
+package expo.modules.applemusic
+
+import android.content.Context
+import com.apple.android.sdk.authentication.TokenProvider
+
+internal class MusicKitTokenProvider(
+  private val context: Context,
+) : TokenProvider {
+  override fun getDeveloperToken(): String = AndroidDeveloperToken.requireStored(context)
+
+  override fun getUserToken(): String =
+    MusicKitAuthStorage.getMusicUserToken(context).orEmpty()
+}

package/android/src/main/java/expo/modules/applemusic/PaginationOptions.kt

@@ -0,0 +1,14 @@
+package expo.modules.applemusic
+
+internal data class PaginationOptions(
+  val limit: Int,
+  val offset: Int,
+) {
+  companion object {
+    fun fromMap(options: Map<String, Any?>): PaginationOptions {
+      val limit = (options["limit"] as? Number)?.toInt()?.coerceAtLeast(1) ?: 25
+      val offset = (options["offset"] as? Number)?.toInt()?.coerceAtLeast(0) ?: 0
+      return PaginationOptions(limit, offset)
+    }
+  }
+}

package/android/src/main/java/expo/modules/applemusic/RatingsRestClient.kt

@@ -0,0 +1,72 @@
+package expo.modules.applemusic
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.json.JSONObject
+
+/** Ratings and favorites Apple Music REST. */
+internal class RatingsRestClient(
+  private val transport: AppleMusicRestTransport,
+) {
+  suspend fun getRating(musicUserToken: String, resourceType: String, id: String): Map<String, Any?>? =
+    withContext(Dispatchers.IO) {
+      try {
+        val json = transport.getJson(
+          musicUserToken,
+          "/v1/me/ratings/$resourceType/$id")
+        AppleMusicJsonMapper.mapRating(json)
+      } catch (error: expo.modules.kotlin.exception.CodedException) {
+        if (error.message?.contains("(404)") == true) {
+          return@withContext null
+        }
+        throw error
+      }
+    }
+
+  suspend fun setRating(musicUserToken: String, resourceType: String, id: String, value: Int): Map<String, Any?> =
+    withContext(Dispatchers.IO) {
+      val body =
+        JSONObject()
+          .put("type", "rating")
+          .put(
+            "attributes",
+            JSONObject().put("value", value),
+          )
+      val json =
+        transport.request(
+          musicUserToken,
+          AppleMusicHttpMethod.PUT,
+          "/v1/me/ratings/$resourceType/$id",
+          body = body,
+        )
+      AppleMusicJsonMapper.mapRating(json)
+        ?: throw AppleMusicErrors.apiError("Invalid Apple Music API response")
+    }
+
+  suspend fun clearRating(musicUserToken: String, resourceType: String, id: String): Unit =
+    withContext(Dispatchers.IO) {
+      transport.request(
+          musicUserToken,
+          AppleMusicHttpMethod.DELETE, "/v1/me/ratings/$resourceType/$id")
+    }
+
+  suspend fun addToFavorites(musicUserToken: String, resourceIds: Map<String, List<String>>): Unit =
+    withContext(Dispatchers.IO) {
+      transport.request(
+          musicUserToken,
+          AppleMusicHttpMethod.POST,
+        "/v1/me/favorites",
+        query = buildIdsQuery(resourceIds),
+      )
+    }
+
+  suspend fun removeFromFavorites(musicUserToken: String, resourceIds: Map<String, List<String>>): Unit =
+    withContext(Dispatchers.IO) {
+      transport.request(
+          musicUserToken,
+          AppleMusicHttpMethod.DELETE,
+        "/v1/me/favorites",
+        query = buildIdsQuery(resourceIds),
+      )
+    }
+}

package/android/src/main/java/expo/modules/applemusic/RecommendationsRestClient.kt

@@ -0,0 +1,37 @@
+package expo.modules.applemusic
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+/** Recommendations and Replay Apple Music REST. */
+internal class RecommendationsRestClient(
+  private val transport: AppleMusicRestTransport,
+) {
+  suspend fun getRecommendations(musicUserToken: String, ids: List<String>?): List<Map<String, Any?>> =
+    withContext(Dispatchers.IO) {
+      val query =
+        if (!ids.isNullOrEmpty()) {
+          mapOf("ids" to ids.joinToString(","))
+        } else {
+          emptyMap()
+        }
+      val json = transport.getJson(
+          musicUserToken,
+          "/v1/me/recommendations", query)
+      mapTopLevelResourceArray(json) { AppleMusicJsonMapper.mapRecommendation(it) }
+    }
+
+  suspend fun getReplay(musicUserToken: String, year: Int?): List<Map<String, Any?>> =
+    withContext(Dispatchers.IO) {
+      val query =
+        if (year != null) {
+          mapOf("filter[year]" to year.toString())
+        } else {
+          emptyMap()
+        }
+      val json = transport.getJson(
+          musicUserToken,
+          "/v1/me/music-summaries", query)
+      mapTopLevelResourceArray(json) { AppleMusicJsonMapper.mapReplaySummary(it) }
+    }
+}