react-native-audio-browser 0.2.0-next.17 → 0.2.0-next.19

package/android/build.gradle

@@ -199,6 +199,7 @@ dependencies {
   implementation("androidx.media3:media3-exoplayer-dash:${media3Version}")
   implementation("androidx.media3:media3-exoplayer-smoothstreaming:${media3Version}")
   implementation("androidx.media3:media3-common:${media3Version}")
+  implementation("androidx.media3:media3-datasource-okhttp:${media3Version}")
 
   implementation "com.google.guava:guava:33.0.0-android"
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-guava:1.8.0"
@@ -243,4 +244,4 @@ if (isNewArchitectureEnabled()) {
     libraryName = "AudioBrowser"
     codegenJavaPackageName = "com.audiobrowser"
   }
-}
+}

package/android/src/main/java/com/audiobrowser/AudioBrowser.kt

@@ -93,13 +93,17 @@ import java.util.concurrent.atomic.AtomicReference
 import kotlin.coroutines.resume
 import kotlin.coroutines.resumeWithException
 import kotlin.coroutines.suspendCoroutine
+import kotlin.time.Duration.Companion.seconds
 import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.MainScope
+import kotlinx.coroutines.async
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.cancelChildren
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeoutOrNull
 import timber.log.Timber
 
 @Keep
@@ -503,121 +507,48 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
 
   override fun getFormattedNavigationError(): FormattedNavigationError? = formattedNavigationError
 
-  /** Creates a default formatted error from a NavigationError */
-  private fun defaultFormattedError(error: NavigationError): FormattedNavigationError {
-    val title =
-      when (error.code) {
-        NavigationErrorType.CONTENT_NOT_FOUND -> "Content Not Found"
-        NavigationErrorType.NETWORK_ERROR -> "Network Error"
-        NavigationErrorType.HTTP_ERROR -> {
-          // Use system-localized HTTP status text (e.g., "Not Found", "Service Unavailable")
-          error.statusCode?.let { httpStatusText(it.toInt()) } ?: "Server Error"
-        }
-        NavigationErrorType.CALLBACK_ERROR -> "Error"
-        NavigationErrorType.UNKNOWN_ERROR -> "Error"
-        // Not a failure — a container that resolved with no children. Neutral copy. See ADR 0001.
-        NavigationErrorType.EMPTY_CONTENT -> "Nothing here"
-        NavigationErrorType.TIMEOUT -> "Couldn't load"
-      }
-    // Omit an empty message so it renders as title-only (e.g. the empty-content case).
-    return FormattedNavigationError(title, error.message.takeIf { it.isNotEmpty() })
-  }
-
-  /** Returns localized HTTP status text for the given status code */
-  private fun httpStatusText(statusCode: Int): String {
-    return when (statusCode) {
-      400 -> "Bad Request"
-      401 -> "Unauthorized"
-      403 -> "Forbidden"
-      404 -> "Not Found"
-      405 -> "Method Not Allowed"
-      408 -> "Request Timeout"
-      429 -> "Too Many Requests"
-      500 -> "Internal Server Error"
-      502 -> "Bad Gateway"
-      503 -> "Service Unavailable"
-      504 -> "Gateway Timeout"
-      else -> "Server Error"
+  /**
+   * Resolves a navigation error to its display form: the app's `formatNavigationError` for the
+   * given [path] when one is configured, else the built-in default. Shared by [setNavigationError]
+   * and the Android Auto empty tile so in-app and in-car copy cannot drift (ADR 0001).
+   */
+  internal suspend fun resolveFormattedError(
+    error: NavigationError,
+    path: String,
+  ): FormattedNavigationError {
+    val default = defaultFormattedError(error)
+    val formatter = _configuration.formatNavigationError ?: return default
+    return formattedOrDefault(mainScope, default) {
+      formatter(FormatNavigationErrorParams(error, default, path)).await()
     }
   }
 
-  private fun setNavigationError(
-    code: NavigationErrorType,
-    message: String,
-    path: String,
-    statusCode: Double? = null,
-    statusCodeSuccess: Boolean? = null,
-  ) {
-    val navError = NavigationError(code, message, statusCode, statusCodeSuccess)
+  private fun setNavigationError(navError: NavigationError, path: String) {
     navigationError = navError
     onNavigationError(NavigationErrorEvent(navigationError))
 
-    // Format the error (async if using JS callback, sync for defaults)
-    val defaultFormatted = defaultFormattedError(navError)
-    val formatter = _configuration.formatNavigationError
-    if (formatter != null) {
-      mainScope.launch {
-        try {
-          val params = FormatNavigationErrorParams(navError, defaultFormatted, path)
-          val customFormatted = formatter(params).await()
-          formattedNavigationError = customFormatted ?: defaultFormatted
-        } catch (e: Exception) {
-          formattedNavigationError = defaultFormatted
-        }
-        onFormattedNavigationError(formattedNavigationError)
-      }
-    } else {
-      formattedNavigationError = defaultFormatted
-      onFormattedNavigationError(formattedNavigationError)
+    // No formatter means no hop, and the field and event land in this turn: a same-turn
+    // getFormattedNavigationError, or a clearNavigationError right after, must not race a
+    // launch that has yet to run.
+    if (_configuration.formatNavigationError == null) {
+      val default = defaultFormattedError(navError)
+      formattedNavigationError = default
+      onFormattedNavigationError(default)
+      return
+    }
+
+    mainScope.launch {
+      val formatted = resolveFormattedError(navError, path)
+      formattedNavigationError = formatted
+      onFormattedNavigationError(formatted)
     }
   }
 
-  /** Maps common browser exceptions to navigation errors */
+  /** Raises the navigation error [e] maps to, for a failed navigation to [path]. */
   private fun handleBrowserException(e: Exception, path: String, logContext: String) {
-    when (e) {
-      is HttpStatusException -> {
-        Timber.e(e, "HTTP error $logContext")
-        setNavigationError(
-          NavigationErrorType.HTTP_ERROR,
-          e.message ?: "Server error",
-          path,
-          e.statusCode.toDouble(),
-          e.statusCode in 200..299,
-        )
-      }
-      is NetworkException -> {
-        Timber.e(e, "Network error $logContext")
-        setNavigationError(
-          NavigationErrorType.NETWORK_ERROR,
-          e.message ?: "Network request failed",
-          path,
-        )
-      }
-      is ContentNotFoundException -> {
-        Timber.e(e, "Content not found $logContext")
-        setNavigationError(
-          NavigationErrorType.CONTENT_NOT_FOUND,
-          e.message ?: "Content not found",
-          path,
-        )
-      }
-      is CallbackException -> {
-        Timber.e(e, "Callback error $logContext")
-        setNavigationError(
-          NavigationErrorType.CALLBACK_ERROR,
-          e.message ?: "An error occurred",
-          path,
-        )
-      }
-      else -> {
-        Timber.e(e, "Unexpected error $logContext")
-        setNavigationError(
-          NavigationErrorType.UNKNOWN_ERROR,
-          e.message ?: "An unexpected error occurred",
-          path,
-        )
-      }
-    }
+    val navError = navigationErrorFor(e)
+    Timber.e(e, "${navError.code} $logContext")
+    setNavigationError(navError, path)
   }
 
   private fun clearNavigationError() {
@@ -769,7 +700,18 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
   override fun search(query: String): Promise<Array<Track>> {
     return Promise.async(mainScope) {
       Timber.d("Searching for: $query")
-      val searchResults = browserManager.search(query)
+      // Rejects with the error the browse surface would raise, but leaves the navigation error
+      // itself unset: a search is not a navigation, and its failure must not replace the
+      // displayed page's state (mirrors HybridAudioBrowser.search).
+      val searchResults =
+        try {
+          browserManager.search(query)
+        } catch (e: CancellationException) {
+          throw e
+        } catch (e: Exception) {
+          Timber.e(e, "Search failed for query: $query")
+          throw NavigationErrorException(navigationErrorFor(e))
+        }
       // Flattened, not `children`: a resolved page carries its rows in
       // `sections` (ADR 0010) and search builds exactly one untitled section,
       // so `children` is always null here and this returned nothing at all.
@@ -1626,3 +1568,115 @@ private fun NativeRouteEntry.strippingJSCallbacks() =
     media = media?.strippingJSCallbacks(),
     artwork = artwork?.strippingJSCallbacks(),
   )
+
+/**
+ * Ceiling on the app's `formatNavigationError` hop. Same budget [Player.awaitBrowser] gives the JS
+ * side, the only other JS wait a browse serve already blocks on.
+ */
+private val FORMATTER_TIMEOUT = 10.seconds
+
+/**
+ * The navigation error an exception raises. Shared by [AudioBrowser]'s failed navigations, the
+ * rejection [AudioBrowser.search] hands JS, and the Android Auto browse-error tile, so one failure
+ * is named one way wherever it surfaces.
+ */
+internal fun navigationErrorFor(e: Exception): NavigationError =
+  when (e) {
+    is HttpStatusException ->
+      NavigationError(
+        NavigationErrorType.HTTP_ERROR,
+        e.message ?: "Server error",
+        e.statusCode.toDouble(),
+        e.statusCode in 200..299,
+      )
+    is NetworkException ->
+      NavigationError(
+        NavigationErrorType.NETWORK_ERROR,
+        e.message ?: "Network request failed",
+        null,
+        null,
+      )
+    is ContentNotFoundException ->
+      NavigationError(
+        NavigationErrorType.CONTENT_NOT_FOUND,
+        e.message ?: "Content not found",
+        null,
+        null,
+      )
+    is CallbackException ->
+      NavigationError(
+        NavigationErrorType.CALLBACK_ERROR,
+        e.message ?: "An error occurred",
+        null,
+        null,
+      )
+    else ->
+      NavigationError(
+        NavigationErrorType.UNKNOWN_ERROR,
+        e.message ?: "An unexpected error occurred",
+        null,
+        null,
+      )
+  }
+
+/** Carries a [NavigationError] across a rejected Promise, whose JS error keeps its message. */
+class NavigationErrorException(val error: NavigationError) : Exception(error.message)
+
+/**
+ * The built-in display copy for a navigation error, and the fallback when the app's is unusable.
+ */
+internal fun defaultFormattedError(error: NavigationError): FormattedNavigationError {
+  val title =
+    when (error.code) {
+      NavigationErrorType.CONTENT_NOT_FOUND -> "Content Not Found"
+      NavigationErrorType.NETWORK_ERROR -> "Network Error"
+      NavigationErrorType.HTTP_ERROR -> {
+        // Use system-localized HTTP status text (e.g., "Not Found", "Service Unavailable")
+        error.statusCode?.let { httpStatusText(it.toInt()) } ?: "Server Error"
+      }
+      NavigationErrorType.CALLBACK_ERROR -> "Error"
+      NavigationErrorType.UNKNOWN_ERROR -> "Error"
+      // Not a failure — a container that resolved with no children. Neutral copy. See ADR 0001.
+      NavigationErrorType.EMPTY_CONTENT -> "Nothing here"
+      NavigationErrorType.TIMEOUT -> "Couldn't load"
+    }
+  // Omit an empty message so it renders as title-only (e.g. the empty-content case).
+  return FormattedNavigationError(title, error.message.takeIf { it.isNotEmpty() })
+}
+
+/**
+ * The formatter hop's fallback rule: the app's answer when it produces one, [default] when it
+ * answers null, throws, or outruns [FORMATTER_TIMEOUT]. Kept off the JS edge so the rule is
+ * exercisable without a Nitro Promise.
+ *
+ * The hop runs in [scope] and is awaited through its [kotlinx.coroutines.Deferred], because Nitro's
+ * `Promise.await` parks in a plain `suspendCoroutine`: cancelling it does not unpark it. Awaiting
+ * the Deferred is cancellable, so the timeout leaves the orphan to finish unobserved instead of
+ * holding the caller open until JS answers — which for a browse serve would be forever.
+ */
+internal suspend fun formattedOrDefault(
+  scope: CoroutineScope,
+  default: FormattedNavigationError,
+  format: suspend () -> FormattedNavigationError?,
+): FormattedNavigationError {
+  val hop = scope.async { runCatching { format() }.getOrNull() }
+  return withTimeoutOrNull(FORMATTER_TIMEOUT) { hop.await() } ?: default
+}
+
+/** Returns localized HTTP status text for the given status code */
+private fun httpStatusText(statusCode: Int): String {
+  return when (statusCode) {
+    400 -> "Bad Request"
+    401 -> "Unauthorized"
+    403 -> "Forbidden"
+    404 -> "Not Found"
+    405 -> "Method Not Allowed"
+    408 -> "Request Timeout"
+    429 -> "Too Many Requests"
+    500 -> "Internal Server Error"
+    502 -> "Bad Gateway"
+    503 -> "Service Unavailable"
+    504 -> "Gateway Timeout"
+    else -> "Server Error"
+  }
+}

package/android/src/main/java/com/audiobrowser/browser/BrowserManager.kt

@@ -877,6 +877,8 @@ class BrowserManager {
    *
    * @param query The search query string
    * @return Array of playable tracks, or null if no results or search not configured
+   * @throws Exception when the search itself fails — a zero-result page means "found nothing",
+   *   never "couldn't ask"
    */
   suspend fun searchPlayable(query: String): Array<Track>? {
     return searchPlayable(
@@ -900,6 +902,8 @@ class BrowserManager {
    *
    * @param params The structured search parameters
    * @return Array of playable tracks, or null if no results or search not configured
+   * @throws Exception when the search itself fails — a zero-result page means "found nothing",
+   *   never "couldn't ask"
    */
   suspend fun searchPlayable(params: SearchParams): Array<Track>? {
     val searchResults = search(params)
@@ -937,6 +941,8 @@ class BrowserManager {
    *
    * @param query The search query string
    * @return ResolvedTrack containing search results as children
+   * @throws Exception when the search itself fails — a zero-result page means "found nothing",
+   *   never "couldn't ask"
    */
   suspend fun search(query: String): ResolvedTrack {
     return search(
@@ -960,6 +966,8 @@ class BrowserManager {
    *
    * @param params The structured search parameters
    * @return ResolvedTrack containing search results as children
+   * @throws Exception when the search itself fails — a zero-result page means "found nothing",
+   *   never "couldn't ask"
    */
   suspend fun search(params: SearchParams): ResolvedTrack {
     Timber.d("Executing fresh search for: ${params.query} (mode=${params.mode})")
@@ -1020,36 +1028,10 @@ class BrowserManager {
 
       return searchResolvedTrack
     } catch (e: Exception) {
+      // Propagates, like the iOS `search`: a caller that cannot tell a failed search from one
+      // that found nothing renders a server error as "No results found".
       Timber.e(e, "Error during search for query: ${params.query}")
-
-      // Return empty search result on error
-      val emptySearchResult =
-        ResolvedTrack(
-          id = null,
-          path = searchPath,
-          title = "Search: ${params.query}",
-          sections = arrayOf(untitledSection(emptyArray())),
-          children = null,
-          carPlaySiriListButton = null,
-          artwork = null,
-          artworkSource = null,
-          request = null,
-          artist = null,
-          albumPath = null,
-          description = null,
-          subtitle = null,
-          album = null,
-          genre = null,
-          duration = null,
-          src = null,
-          style = null,
-          disabled = null,
-          favorited = null,
-          live = null,
-          icyCharset = null,
-        )
-
-      return emptySearchResult
+      throw e
     }
   }
 

package/android/src/main/java/com/audiobrowser/player/CrossOriginHeaderStripper.kt

@@ -0,0 +1,77 @@
+package com.audiobrowser.player
+
+import okhttp3.HttpUrl
+import okhttp3.Interceptor
+import okhttp3.Request
+import okhttp3.Response
+
+/**
+ * Drops the caller's headers once a redirect leaves the origin.
+ *
+ * OkHttp does this for `Authorization` alone — RetryAndFollowUpInterceptor.buildRedirectRequest is
+ * a single `removeHeader("Authorization")` — so every other configured header, an `X-Api-Key` say,
+ * still reaches whatever host the first one named. iOS forwards none across a hop and web clears
+ * them too; this brings Android in line.
+ *
+ * Installed as a **network** interceptor, which runs once per hop. `chain.call().request()` is the
+ * call's original request, so the comparison is always against the URL the credential was addressed
+ * to rather than the hop before.
+ *
+ * Scoped to the redirect hop, and only that. An HLS segment or key fetch is its own Call, already
+ * addressed to the absolute CDN URL, and [TransformingDataSource] deliberately re-applies the
+ * config's headers to it — authenticated segments are a supported shape, and web does the same
+ * through Shaka's request filter. So this closes the leak of handing a credential to a host the
+ * caller never named; it is not a rule that the credential stays on one origin.
+ */
+internal object CrossOriginHeaderStripper : Interceptor {
+
+  /**
+   * Headers that describe the transport rather than the caller. OkHttp and media3 set these per hop
+   * — `Range` carries the seek, `Host` and `Connection` are the connection's own — so the request
+   * breaks without them. Everything else on a media request came from the media config, and is the
+   * caller's to send only to the host it addressed.
+   *
+   * `Icy-MetaData` is media3's, not the caller's: `ProgressiveMediaPeriod` asks for Shoutcast
+   * metadata through `ICY_METADATA_HEADERS` on the DataSpec — the same channel
+   * [TransformingDataSource] puts the config's headers on, so nothing downstream can tell them
+   * apart. Dropping it on a hop costs the station's `icy-metaint`, so `IcyDataSource` is never
+   * installed and `onMetadata` stops firing: live "now playing" disappears on exactly the
+   * redirecting streams this interceptor exists for, and the interleaved metadata bytes stay in the
+   * audio as audible chirping. It is a request for a response format, never a credential.
+   */
+  private val TRANSPORT_HEADERS =
+    setOf(
+      "accept",
+      "accept-encoding",
+      "connection",
+      "content-length",
+      "host",
+      "icy-metadata",
+      "range",
+      "transfer-encoding",
+      "user-agent",
+    )
+
+  override fun intercept(chain: Interceptor.Chain): Response {
+    val request = chain.request()
+    val addressed = chain.call().request().url
+    return chain.proceed(
+      if (sameOrigin(addressed, request.url)) request else stripCallerHeaders(request)
+    )
+  }
+
+  /** Scheme, host and port — the same origin test `followMediaRedirect` applies on web. */
+  internal fun sameOrigin(a: HttpUrl, b: HttpUrl): Boolean =
+    a.scheme == b.scheme && a.host == b.host && a.port == b.port
+
+  /** The request with every caller-supplied header removed. */
+  internal fun stripCallerHeaders(request: Request): Request =
+    request
+      .newBuilder()
+      .apply {
+        request.headers.names().forEach { name ->
+          if (name.lowercase() !in TRANSPORT_HEADERS) removeHeader(name)
+        }
+      }
+      .build()
+}

package/android/src/main/java/com/audiobrowser/player/MediaFactory.kt

@@ -4,10 +4,10 @@ import android.content.Context
 import androidx.media3.common.MediaItem
 import androidx.media3.datasource.DataSource
 import androidx.media3.datasource.DefaultDataSource
-import androidx.media3.datasource.DefaultHttpDataSource
 import androidx.media3.datasource.TransferListener
 import androidx.media3.datasource.cache.CacheDataSource
 import androidx.media3.datasource.cache.SimpleCache
+import androidx.media3.datasource.okhttp.OkHttpDataSource
 import androidx.media3.exoplayer.drm.DrmSessionManagerProvider
 import androidx.media3.exoplayer.source.DefaultMediaSourceFactory
 import androidx.media3.exoplayer.source.MediaSource
@@ -16,6 +16,8 @@ import androidx.media3.extractor.DefaultExtractorsFactory
 import com.audiobrowser.model.RetryPolicy
 import com.margelo.nitro.audiobrowser.MediaRequestConfig
 import java.io.IOException
+import java.util.concurrent.TimeUnit
+import okhttp3.OkHttpClient
 
 class MediaFactory(
   private val context: Context,
@@ -31,6 +33,20 @@ class MediaFactory(
 
   companion object {
     private const val DEFAULT_USER_AGENT = "react-native-audio-browser"
+
+    /**
+     * The client media requests go out on. One per process so connections are reused; not
+     * `HttpClient`'s browse client, whose read timeout is sized for JSON and would cut a long media
+     * read short. The timeouts are media3's own defaults, so stall detection and
+     * [RetryLoadErrorHandlingPolicy] behave as they did before.
+     */
+    private val mediaHttpClient: OkHttpClient by lazy {
+      OkHttpClient.Builder()
+        .connectTimeout(8, TimeUnit.SECONDS)
+        .readTimeout(8, TimeUnit.SECONDS)
+        .addNetworkInterceptor(CrossOriginHeaderStripper)
+        .build()
+    }
   }
 
   private val extractorsFactory =
@@ -95,17 +111,19 @@ class MediaFactory(
     // ExoPlayer's IO thread. This prevents deadlocks when the JS thread is blocked by
     // synchronous Nitro calls (e.g., seekTo) while a media transform callback needs the
     // JS thread to resolve.
+
+    // OkHttp rather than DefaultHttpDataSource, for how each treats a redirect.
+    // DefaultHttpDataSource re-applies the request headers on every hop, handing
+    // an Authorization header to whatever host the first one named. OkHttp drops
+    // that one header itself, and [CrossOriginHeaderStripper] drops the rest.
     val httpFactory =
-      DefaultHttpDataSource.Factory().apply {
-        // Deliberately NOT setUserAgent(): DefaultHttpDataSource applies the factory
-        // user-agent as a FINAL setRequestProperty("User-Agent", …) that runs after —
-        // and overrides — the per-request DataSpec headers. That would clobber the
-        // User-Agent TransformingDataSource sets per request (the whole point of the
-        // per-request userAgent override). Supplying the same value as a default
-        // request property keeps the default for un-overridden requests while letting
-        // the per-request DataSpec header win.
+      OkHttpDataSource.Factory(mediaHttpClient).apply {
+        // Deliberately NOT setUserAgent(): it is applied last via addHeader(),
+        // which appends, so a request already carrying one would send two. As a
+        // default request property it is merged under dataSpec.httpRequestHeaders
+        // and applied with header(), letting TransformingDataSource's per-request
+        // override win.
         setDefaultRequestProperties(mapOf("User-Agent" to DEFAULT_USER_AGENT))
-        setAllowCrossProtocolRedirects(true)
         // Connect transfer listener for bandwidth measurement
         transferListener?.let { setTransferListener(it) }
       }