@wwdrew/expo-apple-music 1.0.0

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

@@ -0,0 +1,118 @@
+package expo.modules.applemusic
+
+import android.content.Context
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import okhttp3.HttpUrl
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import org.json.JSONObject
+import java.util.concurrent.TimeUnit
+
+/** Shared HTTP adapter for Apple Music REST (see docs/ANDROID_IMPLEMENTATION.md). */
+internal interface AppleMusicRestTransport {
+  suspend fun request(
+    musicUserToken: String?,
+    method: AppleMusicHttpMethod,
+    path: String,
+    query: Map<String, String> = emptyMap(),
+    body: JSONObject? = null,
+  ): JSONObject
+
+  suspend fun getJson(
+    musicUserToken: String?,
+    path: String,
+    query: Map<String, String> = emptyMap(),
+  ): JSONObject
+}
+
+internal class OkHttpAppleMusicRestTransport(
+  private val context: Context,
+) : AppleMusicRestTransport {
+  private val http =
+    OkHttpClient.Builder()
+      .connectTimeout(30, TimeUnit.SECONDS)
+      .readTimeout(30, TimeUnit.SECONDS)
+      .build()
+
+  private fun pathRequiresMusicUserToken(path: String): Boolean = path.startsWith("/v1/me/")
+
+  override suspend fun request(
+    musicUserToken: String?,
+    method: AppleMusicHttpMethod,
+    path: String,
+    query: Map<String, String>,
+    body: JSONObject?,
+  ): JSONObject =
+    withContext(Dispatchers.IO) {
+      val developerToken = AndroidDeveloperToken.requireStored(context)
+      val userToken =
+        if (pathRequiresMusicUserToken(path)) {
+          requireMusicUserToken(musicUserToken)
+        } else {
+          musicUserToken?.trim()?.takeIf { it.isNotEmpty() }
+        }
+
+      val urlBuilder =
+        HttpUrl.Builder()
+          .scheme("https")
+          .host("api.music.apple.com")
+          .encodedPath(path)
+
+      query.forEach { (key, value) -> urlBuilder.addQueryParameter(key, value) }
+
+      val jsonMediaType = "application/json".toMediaType()
+      val requestBody = body?.toString()?.toRequestBody(jsonMediaType)
+
+      val requestBuilder =
+        Request.Builder()
+          .url(urlBuilder.build())
+          .header("Authorization", "Bearer $developerToken")
+
+      if (!userToken.isNullOrEmpty()) {
+        requestBuilder.header("Music-User-Token", userToken)
+      }
+
+      when (method) {
+        AppleMusicHttpMethod.GET -> requestBuilder.get()
+        AppleMusicHttpMethod.POST ->
+          requestBuilder.post(requestBody ?: "{}".toRequestBody(jsonMediaType))
+        AppleMusicHttpMethod.PUT ->
+          requestBuilder.put(requestBody ?: "{}".toRequestBody(jsonMediaType))
+        AppleMusicHttpMethod.DELETE ->
+          if (requestBody != null) {
+            requestBuilder.delete(requestBody)
+          } else {
+            requestBuilder.delete()
+          }
+      }
+
+      http.newCall(requestBuilder.build()).execute().use { response ->
+        val responseBody = response.body?.string().orEmpty()
+        if (!response.isSuccessful) {
+          if (response.code == 403) {
+            throw AppleMusicErrors.permissionDenied()
+          }
+          val message =
+            try {
+              JSONObject(responseBody).optJSONArray("errors")?.optJSONObject(0)?.optString("detail")
+            } catch (_: Exception) {
+              null
+            } ?: "Apple Music API error (${response.code})"
+          throw AppleMusicErrors.apiError(message)
+        }
+        if (responseBody.isEmpty()) {
+          return@withContext JSONObject()
+        }
+        return@withContext JSONObject(responseBody)
+      }
+    }
+
+  override suspend fun getJson(
+    musicUserToken: String?,
+    path: String,
+    query: Map<String, String>,
+  ): JSONObject = request(musicUserToken, AppleMusicHttpMethod.GET, path, query)
+}

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

@@ -0,0 +1,57 @@
+package expo.modules.applemusic
+
+import android.content.Context
+
+/**
+ * Snapshot of stored developer JWT (see docs/AUTH.md).
+ * Music user tokens are app-owned in JS; native may cache the last token for playback SDK (see [MusicKitAuthStorage]).
+ */
+internal data class AuthenticatedSession(
+  val developerToken: String?,
+) {
+  val hasDeveloperToken: Boolean
+    get() = !developerToken.isNullOrBlank()
+
+  companion object {
+    fun load(context: Context): AuthenticatedSession =
+      AuthenticatedSession(
+        developerToken = MusicKitAuthStorage.getDeveloperToken(context),
+      )
+  }
+}
+
+/**
+ * In-memory session snapshot for native playback and REST storefront cache.
+ * Music user tokens are app-owned in JS; native keeps the last token from authorize
+ * or bridge calls for playback SDK + storefront (see [MusicKitAuthStorage]).
+ */
+internal object AuthenticatedSessionCache {
+  @Volatile
+  var storefrontId: String? = null
+
+  @Volatile
+  var musicUserToken: String? = null
+
+  fun rememberMusicUserToken(token: String?) {
+    val trimmed = token?.trim()?.takeIf { it.isNotEmpty() }
+    if (trimmed != musicUserToken) {
+      musicUserToken = trimmed
+      storefrontId = null
+    }
+  }
+
+  fun invalidate() {
+    storefrontId = null
+    musicUserToken = null
+  }
+}
+
+/** Token for playback SDK + `/v1/me/storefront`; updates session cache when explicit. */
+internal fun resolvePlaybackMusicUserToken(context: Context, explicit: String?): String {
+  explicit?.trim()?.takeIf { it.isNotEmpty() }?.let {
+    MusicKitAuthStorage.saveMusicUserToken(context, it)
+    return it
+  }
+  MusicKitAuthStorage.getMusicUserToken(context)?.let { return it }
+  throw AppleMusicErrors.missingMusicUserToken()
+}

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

@@ -0,0 +1,55 @@
+package expo.modules.applemusic
+
+/** Standard bridge response envelopes (keys match iOS and TypeScript). */
+internal object BridgeResponses {
+  fun storefront(id: String): Map<String, Any?> = mapOf("id" to id)
+
+  fun catalogSearch(result: AndroidCatalogService.SearchResult): Map<String, Any?> =
+    mapOf(
+      "songs" to result.songs,
+      "albums" to result.albums,
+      "artists" to result.artists,
+      "playlists" to result.playlists,
+      "stations" to result.stations,
+      "musicVideos" to result.musicVideos,
+    )
+
+  fun catalogCharts(result: AndroidCatalogService.ChartsResult): Map<String, Any?> =
+    mapOf(
+      "songs" to result.songs,
+      "albums" to result.albums,
+      "playlists" to result.playlists,
+      "musicVideos" to result.musicVideos,
+    )
+
+  fun songs(items: List<Map<String, Any?>>): Map<String, Any?> = mapOf("songs" to items)
+
+  fun albums(items: List<Map<String, Any?>>): Map<String, Any?> = mapOf("albums" to items)
+
+  fun artists(items: List<Map<String, Any?>>): Map<String, Any?> = mapOf("artists" to items)
+
+  fun playlists(items: List<Map<String, Any?>>): Map<String, Any?> = mapOf("playlists" to items)
+
+  fun musicVideos(items: List<Map<String, Any?>>): Map<String, Any?> = mapOf("musicVideos" to items)
+
+  fun librarySearch(result: AndroidLibraryService.LibrarySearchResult): Map<String, Any?> =
+    mapOf(
+      "songs" to result.songs,
+      "albums" to result.albums,
+      "artists" to result.artists,
+      "playlists" to result.playlists,
+      "musicVideos" to result.musicVideos,
+    )
+
+  fun stations(items: List<Map<String, Any?>>): Map<String, Any?> = mapOf("stations" to items)
+
+  fun recentlyPlayedResources(items: List<Map<String, Any?>>): Map<String, Any?> =
+    mapOf("recentlyPlayedItems" to items)
+
+  fun recentItems(items: List<Map<String, Any?>>): Map<String, Any?> = mapOf("items" to items)
+
+  fun recommendations(items: List<Map<String, Any?>>): Map<String, Any?> =
+    mapOf("recommendations" to items)
+
+  fun replaySummaries(items: List<Map<String, Any?>>): Map<String, Any?> = mapOf("summaries" to items)
+}

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

@@ -0,0 +1,306 @@
+package expo.modules.applemusic
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.json.JSONArray
+import org.json.JSONObject
+
+/** Catalog-domain Apple Music REST (search, resources, charts). */
+internal class CatalogRestClient(
+  private val transport: AppleMusicRestTransport,
+  private val storefront: StorefrontRestClient,
+) {
+  data class CatalogSearchResult(
+    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 stations: List<Map<String, Any?>>,
+    val musicVideos: List<Map<String, Any?>>,
+  )
+
+  suspend fun catalogSearch(
+    term: String,
+    types: List<String>,
+    limit: Int,
+    offset: Int,
+  ): CatalogSearchResult =
+    withContext(Dispatchers.IO) {
+      val storefrontId = storefront.getCatalogStorefront()
+      val typeParam =
+        types
+          .mapNotNull { catalogSearchTypeParam(it) }
+          .distinct()
+          .joinToString(",")
+          .ifEmpty { "songs,albums" }
+
+      val json =
+        transport.getJson(
+          null,
+          "/v1/catalog/$storefrontId/search",
+          mapOf(
+            "term" to term,
+            "types" to typeParam,
+            "limit" to limit.toString(),
+            "offset" to offset.toString(),
+          ),
+        )
+
+      val results = json.optJSONObject("results") ?: JSONObject()
+      CatalogSearchResult(
+        songs =
+          mapResourceArray(results.optJSONObject("songs")?.optJSONArray("data")) {
+            AppleMusicJsonMapper.mapSong(it)
+          },
+        albums =
+          mapResourceArray(results.optJSONObject("albums")?.optJSONArray("data")) {
+            AppleMusicJsonMapper.mapAlbum(it)
+          },
+        artists =
+          mapResourceArray(results.optJSONObject("artists")?.optJSONArray("data")) {
+            AppleMusicJsonMapper.mapArtist(it)
+          },
+        playlists =
+          mapResourceArray(results.optJSONObject("playlists")?.optJSONArray("data")) {
+            AppleMusicJsonMapper.mapPlaylist(it)
+          },
+        stations =
+          mapResourceArray(results.optJSONObject("stations")?.optJSONArray("data")) {
+            AppleMusicJsonMapper.mapStation(it)
+          },
+        musicVideos =
+          mapResourceArray(results.optJSONObject("music-videos")?.optJSONArray("data")) {
+            AppleMusicJsonMapper.mapMusicVideo(it)
+          },
+      )
+    }
+
+  suspend fun getCatalogSong(id: String): Map<String, Any?> =
+    getCatalogResource("/songs/$id") { AppleMusicJsonMapper.mapSong(it) }
+
+  suspend fun getCatalogAlbum(id: String): Map<String, Any?> =
+    getCatalogResource("/albums/$id") { AppleMusicJsonMapper.mapAlbum(it) }
+
+  suspend fun getCatalogArtist(id: String): Map<String, Any?> =
+    getCatalogResource("/artists/$id") { AppleMusicJsonMapper.mapArtist(it) }
+
+  suspend fun getCatalogPlaylist(id: String): Map<String, Any?> =
+    getCatalogResource("/playlists/$id") { AppleMusicJsonMapper.mapPlaylist(it) }
+
+  suspend fun getCatalogStation(id: String): Map<String, Any?> =
+    getCatalogResource("/stations/$id") { AppleMusicJsonMapper.mapStation(it) }
+
+  suspend fun getCatalogMusicVideo(id: String): Map<String, Any?> =
+    getCatalogResource("/music-videos/$id") { AppleMusicJsonMapper.mapMusicVideo(it) }
+
+  suspend fun getCatalogResources(type: String, ids: List<String>): List<Map<String, Any?>> =
+    withContext(Dispatchers.IO) {
+      val trimmed = ids.map { it.trim() }.filter { it.isNotEmpty() }
+      if (trimmed.isEmpty()) {
+        return@withContext emptyList()
+      }
+      val storefrontId = storefront.getCatalogStorefront()
+      val json =
+        transport.getJson(
+          null,
+          "/v1/catalog/$storefrontId/$type",
+          mapOf("ids" to trimmed.joinToString(",")),
+        )
+      val data = requireDataArray(json)
+      buildList {
+        for (i in 0 until data.length()) {
+          val resource = data.getJSONObject(i)
+          mapCatalogResource(type, resource)?.let { add(it) }
+        }
+      }
+    }
+
+  private fun mapCatalogResource(type: String, resource: JSONObject): Map<String, Any?>? {
+    val apiType = resource.optString("type", "")
+    return when (type) {
+      "songs" ->
+        if (apiType.contains("song")) AppleMusicJsonMapper.mapSong(resource) else null
+      "albums" ->
+        if (apiType.contains("album")) AppleMusicJsonMapper.mapAlbum(resource) else null
+      "artists" ->
+        if (apiType.contains("artist")) AppleMusicJsonMapper.mapArtist(resource) else null
+      "playlists" ->
+        if (apiType.contains("playlist")) AppleMusicJsonMapper.mapPlaylist(resource) else null
+      "stations" ->
+        if (apiType.contains("station")) AppleMusicJsonMapper.mapStation(resource) else null
+      "music-videos" ->
+        if (apiType.contains("music-video")) AppleMusicJsonMapper.mapMusicVideo(resource) else null
+      else -> null
+    }
+  }
+
+  suspend fun getCatalogAlbumTracks(
+    albumId: String,
+    limit: Int,
+    offset: Int,
+  ): List<Map<String, Any?>> =
+    getCatalogRelationship(
+      pathSuffix = "/albums/$albumId/tracks",
+      limit = limit,
+      offset = offset,
+      typeContains = "song",
+      mapper = AppleMusicJsonMapper::mapSong,
+    )
+
+  suspend fun getCatalogArtistAlbums(
+    artistId: String,
+    limit: Int,
+    offset: Int,
+  ): List<Map<String, Any?>> =
+    getCatalogRelationship(
+      pathSuffix = "/artists/$artistId/albums",
+      limit = limit,
+      offset = offset,
+      typeContains = "album",
+      mapper = AppleMusicJsonMapper::mapAlbum,
+    )
+
+  suspend fun getCatalogPlaylistTracks(
+    playlistId: String,
+    limit: Int,
+    offset: Int,
+  ): List<Map<String, Any?>> =
+    getCatalogRelationship(
+      pathSuffix = "/playlists/$playlistId/tracks",
+      limit = limit,
+      offset = offset,
+      typeContains = "song",
+      mapper = AppleMusicJsonMapper::mapSong,
+    )
+
+  data class CatalogChartsResult(
+    val songs: List<Map<String, Any?>>,
+    val albums: List<Map<String, Any?>>,
+    val playlists: List<Map<String, Any?>>,
+    val musicVideos: List<Map<String, Any?>>,
+  )
+
+  suspend fun getCatalogCharts(
+    types: List<String>,
+    limit: Int,
+    offset: Int,
+    genre: String?,
+    chart: String?,
+  ): CatalogChartsResult =
+    withContext(Dispatchers.IO) {
+      val storefrontId = storefront.getCatalogStorefront()
+      val typeParam =
+        types
+          .mapNotNull { catalogChartTypeParam(it) }
+          .distinct()
+          .joinToString(",")
+          .ifEmpty { "songs,albums" }
+
+      val query =
+        buildMap {
+          put("types", typeParam)
+          put("limit", limit.toString())
+          put("offset", offset.toString())
+          genre?.takeIf { it.isNotBlank() }?.let { put("genre", it) }
+          chart?.takeIf { it.isNotBlank() }?.let { put("chart", it) }
+        }
+
+      val json = transport.getJson(
+          null,
+          "/v1/catalog/$storefrontId/charts", query)
+      val results = json.optJSONObject("results") ?: JSONObject()
+      CatalogChartsResult(
+        songs = parseChartsEntries(results, "songs", "song", AppleMusicJsonMapper::mapSong),
+        albums = parseChartsEntries(results, "albums", "album", AppleMusicJsonMapper::mapAlbum),
+        playlists = parseChartsEntries(results, "playlists", "playlist", AppleMusicJsonMapper::mapPlaylist),
+        musicVideos =
+          parseChartsEntries(results, "music-videos", "music-video", AppleMusicJsonMapper::mapMusicVideo),
+      )
+    }
+
+  private suspend fun getCatalogRelationship(
+    pathSuffix: String,
+    limit: Int,
+    offset: Int,
+    typeContains: String,
+    mapper: (JSONObject) -> Map<String, Any?>,
+  ): List<Map<String, Any?>> =
+    withContext(Dispatchers.IO) {
+      val storefrontId = storefront.getCatalogStorefront()
+      val json =
+        transport.getJson(
+          null,
+          "/v1/catalog/$storefrontId$pathSuffix",
+          mapOf(
+            "limit" to limit.toString(),
+            "offset" to offset.toString(),
+          ),
+        )
+      val data = requireDataArray(json)
+      buildList {
+        for (i in 0 until data.length()) {
+          val resource = data.getJSONObject(i)
+          if (resource.optString("type", "").contains(typeContains)) {
+            add(mapper(resource))
+          }
+        }
+      }
+    }
+
+  private suspend fun getCatalogResource(
+    pathSuffix: String,
+    mapper: (JSONObject) -> Map<String, Any?>,
+  ): Map<String, Any?> =
+    withContext(Dispatchers.IO) {
+      val storefrontId = storefront.getCatalogStorefront()
+      val json = transport.getJson(
+          null,
+          "/v1/catalog/$storefrontId$pathSuffix")
+      val data = requireDataArray(json)
+      if (data.length() == 0) {
+        throw AppleMusicErrors.itemNotFound("Catalog item", false)
+      }
+      mapper(data.getJSONObject(0))
+    }
+
+  private fun parseChartsEntries(
+    results: JSONObject,
+    resultsKey: String,
+    typeContains: String,
+    mapper: (JSONObject) -> Map<String, Any?>,
+  ): List<Map<String, Any?>> {
+    val charts = results.optJSONArray(resultsKey) ?: return emptyList()
+    return buildList {
+      for (i in 0 until charts.length()) {
+        val chart = charts.optJSONObject(i) ?: continue
+        val data = chart.optJSONArray("data") ?: continue
+        for (j in 0 until data.length()) {
+          val resource = data.getJSONObject(j)
+          if (resource.optString("type", "").contains(typeContains)) {
+            add(mapper(resource))
+          }
+        }
+      }
+    }
+  }
+
+  private fun catalogChartTypeParam(type: String): String? =
+    when (type) {
+      "songs" -> "songs"
+      "albums" -> "albums"
+      "playlists" -> "playlists"
+      "music-videos" -> "music-videos"
+      else -> null
+    }
+
+  private fun catalogSearchTypeParam(type: String): String? =
+    when (type) {
+      "songs" -> "songs"
+      "albums" -> "albums"
+      "artists" -> "artists"
+      "playlists" -> "playlists"
+      "stations" -> "stations"
+      "music-videos" -> "music-videos"
+      else -> null
+    }
+}

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

@@ -0,0 +1,152 @@
+package expo.modules.applemusic
+
+import com.apple.android.music.playback.model.MediaPlayerException
+import expo.modules.applemusic.bridge.registerAuthBridge
+import expo.modules.applemusic.bridge.registerCatalogBridge
+import expo.modules.applemusic.bridge.registerHistoryBridge
+import expo.modules.applemusic.bridge.registerLibraryBridge
+import expo.modules.applemusic.bridge.registerLibraryMutationsBridge
+import expo.modules.applemusic.bridge.registerPlayerBridge
+import expo.modules.applemusic.bridge.registerRatingsBridge
+import expo.modules.applemusic.bridge.registerRecommendationsBridge
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.activityresult.AppContextActivityResultLauncher
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+
+class ExpoAppleMusicModule : Module() {
+  private lateinit var authLauncher: AppContextActivityResultLauncher<MusicKitAuthInput, MusicKitAuthOutput>
+  private var playbackObserver: AndroidPlaybackObserver? = null
+
+  private val moduleScope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+
+  private val reactContext
+    get() = requireNotNull(appContext.reactContext) { "React Application Context is null" }
+
+  private val playbackController: AndroidPlaybackController
+    get() =
+      AndroidPlaybackController.getInstance(reactContext).also { controller ->
+        if (controller.playbackErrorHandler == null) {
+          controller.playbackErrorHandler = { error, operation ->
+            emitPlaybackError(error, operation)
+          }
+        }
+      }
+
+  private val catalogService: AndroidCatalogService
+    get() = AndroidCatalogService(reactContext)
+
+  private val libraryService: AndroidLibraryService
+    get() = AndroidLibraryService(reactContext)
+
+  private val historyService: AndroidHistoryService
+    get() = AndroidHistoryService(reactContext)
+
+  private val subscriptionService: AndroidSubscriptionService
+    get() = AndroidSubscriptionService(reactContext)
+
+  private val queueService: AndroidQueueService
+    get() = AndroidQueueService(reactContext, playbackController)
+
+  private val ratingsService: AndroidRatingsService
+    get() = AndroidRatingsService(reactContext)
+
+  private val libraryMutationsService: AndroidLibraryMutationsService
+    get() = AndroidLibraryMutationsService(reactContext)
+
+  private val recommendationsService: AndroidRecommendationsService
+    get() = AndroidRecommendationsService(reactContext)
+
+  override fun definition() = ModuleDefinition {
+    Name("ExpoAppleMusic")
+
+    Events(
+      "onPlaybackStateChange",
+      "onCurrentSongChange",
+      "onPlaybackTimeUpdate",
+      "onPlaybackError",
+    )
+
+    OnStartObserving {
+      val observer = AndroidPlaybackObserver(reactContext)
+      observer.delegate =
+        object : AndroidPlaybackObserverDelegate {
+          override fun onPlaybackStateChange(body: Map<String, Any?>) {
+            sendEvent("onPlaybackStateChange", body)
+          }
+
+          override fun onCurrentSongChange(body: Map<String, Any?>) {
+            sendEvent("onCurrentSongChange", body)
+          }
+
+          override fun onPlaybackTimeUpdate(playbackTime: Double) {
+            sendEvent("onPlaybackTimeUpdate", mapOf("playbackTime" to playbackTime))
+          }
+
+          override fun onPlaybackError(body: Map<String, Any?>) {
+            sendEvent("onPlaybackError", body)
+          }
+        }
+      observer.startObserving()
+      playbackObserver = observer
+    }
+
+    OnStopObserving {
+      playbackObserver?.stopObserving()
+      playbackObserver = null
+    }
+
+    RegisterActivityContracts {
+      authLauncher =
+        registerForActivityResult(
+          MusicKitAuthContract {
+            appContext.throwingActivity
+          },
+        )
+    }
+
+    registerAuthBridge(
+      reactContext = { reactContext },
+      authLauncher = { authLauncher },
+      subscriptionService = { subscriptionService },
+      libraryService = { libraryService },
+    )
+    registerCatalogBridge { catalogService }
+    registerLibraryBridge { libraryService }
+    registerHistoryBridge { historyService }
+    registerPlayerBridge(
+      moduleScope = moduleScope,
+      playbackController = { playbackController },
+      queueService = { queueService },
+      emitPlaybackError = ::emitPlaybackError,
+      emitPlaybackTimeUpdate = { time ->
+        sendEvent("onPlaybackTimeUpdate", mapOf("playbackTime" to time))
+      },
+    )
+    registerRatingsBridge { ratingsService }
+    registerLibraryMutationsBridge { libraryMutationsService }
+    registerRecommendationsBridge { recommendationsService }
+  }
+
+  private fun emitPlaybackError(error: Exception, operation: String) {
+    val code =
+      when (error) {
+        is MediaPlayerException -> error.errorCode
+        is CodedException -> error.code
+        else -> 0
+      }
+    sendEvent(
+      "onPlaybackError",
+      mapOf(
+        "message" to (error.message ?: "Playback error"),
+        "code" to code,
+        "domain" to error.javaClass.simpleName,
+        "operation" to operation,
+      ),
+    )
+  }
+}