react-native-audio-browser 0.2.0-next.8 → 0.2.0

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

@@ -7,8 +7,7 @@ import android.os.Looper
  * Manages a sleep timer that calls a completion callback after a specified duration.
  *
  * The timer stores the expiration time as a timestamp and uses a Handler to schedule the completion
- * callback. Supports both time-based and end-of-track modes, plus an optional fade-out that starts
- * `fadeDuration` seconds before the deadline so silence lands exactly when the timer completes.
+ * callback. Supports both time-based and end-of-track modes.
  */
 open class SleepTimer {
   var time: Double? = null
@@ -18,7 +17,6 @@ open class SleepTimer {
     private set
 
   private var runnable: Runnable? = null
-  private var fadeRunnable: Runnable? = null
   private val handler = Handler(Looper.getMainLooper())
 
   val isRunning: Boolean
@@ -28,27 +26,15 @@ open class SleepTimer {
    * Sets a timer to complete after the specified number of seconds.
    *
    * @param seconds Number of seconds until the timer completes
-   * @param fadeDuration Seconds over which to fade out before completion; clamped to [seconds]
    */
-  fun sleepAfter(seconds: Double, fadeDuration: Double? = null) {
+  fun sleepAfter(seconds: Double) {
     stopTimer()
-    onFadeCancel()
     sleepWhenPlayedToEnd = false
 
     val runnable = Runnable { complete() }
     this.runnable = runnable
     handler.postDelayed(runnable, (seconds * 1000).toLong())
     time = System.currentTimeMillis() + (seconds * 1000)
-
-    if (fadeDuration != null && fadeDuration > 0) {
-      val fade = minOf(fadeDuration, seconds)
-      val fadeRunnable = Runnable {
-        this.fadeRunnable = null
-        onFadeStart(fade)
-      }
-      this.fadeRunnable = fadeRunnable
-      handler.postDelayed(fadeRunnable, ((seconds - fade) * 1000).toLong())
-    }
   }
 
   /**
@@ -57,7 +43,6 @@ open class SleepTimer {
    */
   fun sleepWhenPlayedToEnd() {
     stopTimer()
-    onFadeCancel()
     time = null
     sleepWhenPlayedToEnd = true
   }
@@ -70,7 +55,6 @@ open class SleepTimer {
   fun clear(): Boolean {
     val wasRunning = isRunning
     stopTimer()
-    onFadeCancel()
     time = null
     sleepWhenPlayedToEnd = false
     return wasRunning
@@ -81,23 +65,9 @@ open class SleepTimer {
     // Default implementation does nothing - override in subclass
   }
 
-  /** Override to begin fading the volume; the timer still completes at its deadline. */
-  open fun onFadeStart(durationSeconds: Double) {
-    // Default implementation does nothing - override in subclass
-  }
-
-  /** Override to handle a fade cancelled before completion — restore the volume. */
-  open fun onFadeCancel() {
-    // Default implementation does nothing - override in subclass
-  }
-
   private fun complete() {
     if (!isRunning) return
-    // Tear down without onFadeCancel: completion pauses first, then the completion handler
-    // restores the volume.
-    stopTimer()
-    time = null
-    sleepWhenPlayedToEnd = false
+    clear()
     onComplete()
   }
 
@@ -106,9 +76,5 @@ open class SleepTimer {
       handler.removeCallbacks(it)
       runnable = null
     }
-    fadeRunnable?.let {
-      handler.removeCallbacks(it)
-      fadeRunnable = null
-    }
   }
 }

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

@@ -7,24 +7,25 @@ import androidx.media3.datasource.DataSpec
 import androidx.media3.datasource.TransferListener
 import com.audiobrowser.util.BrowserPathHelper
 import com.margelo.nitro.audiobrowser.MediaRequestConfig
-import java.io.IOException
 import timber.log.Timber
 
 /**
  * A DataSource wrapper that defers media URL transformation to ExoPlayer's IO thread.
  *
  * ExoPlayer calls [MediaSource.Factory.createMediaSource] on the main thread during
- * `addMediaItem()`, but calls [DataSource.open] on a background IO thread when it needs to fetch
- * data. By deferring URL transformation (which may invoke a JS callback via `runBlocking`) to
- * [open], we avoid blocking the main thread and prevent deadlocks when the JS thread is occupied by
- * synchronous Nitro calls (e.g., `seekTo`).
+ * `addMediaItem()`, but calls [DataSource.open] on a background IO thread when it
+ * needs to fetch data. By deferring URL transformation (which may invoke a JS callback
+ * via `runBlocking`) to [open], we avoid blocking the main thread and prevent deadlocks
+ * when the JS thread is occupied by synchronous Nitro calls (e.g., `seekTo`).
  *
- * The transform is resolved once per track on the first [open] call (the manifest/media URL). The
- * resulting headers and user-agent are cached on the [Factory] and reused for subsequent requests
- * (segments, encryption keys) without calling the JS transform again.
+ * The transform is resolved once per track on the first [open] call (the manifest/media
+ * URL). The resulting headers and user-agent are cached on the [Factory] and reused for
+ * subsequent requests (segments, encryption keys) without calling the JS transform again.
  */
-class TransformingDataSource(private val upstream: DataSource, private val factory: Factory) :
-  DataSource {
+class TransformingDataSource(
+  private val upstream: DataSource,
+  private val factory: Factory,
+) : DataSource {
 
   companion object {
     private const val DEFAULT_USER_AGENT = "react-native-audio-browser"
@@ -35,28 +36,19 @@ class TransformingDataSource(private val upstream: DataSource, private val facto
   override fun open(dataSpec: DataSpec): Long {
     val originalUrl = dataSpec.uri.toString()
 
-    // The first open() resolves the transform and caches it on the Factory; subsequent opens
-    // (segments, keys, replays) reuse the cached headers/user-agent but keep their own URLs.
+    // Check if the Factory already has a cached transform result.
+    // The first DataSource to open() resolves the transform and caches it.
+    // All subsequent opens (segments, keys, replays) reuse the cached
+    // headers/user-agent but keep their original URLs.
     val cached = factory.cachedTransform
-    val (finalUrl, headers, userAgent) =
-      when {
-        cached == null -> resolveAndCache(originalUrl)
-        // Re-open of the same media URL (e.g. a retry after a network drop). By default reuse the
-        // resolved URL: re-emitting the schemeless original ("/listen/<id>/x.mp3") would hit the
-        // file data source -> FileNotFoundException. But if the previous media-URL load failed,
-        // re-resolve once (see the catch below): the URL/token may be stale. The fresh URL is still
-        // absolute, so that hazard stays avoided.
-        originalUrl == factory.cachedOriginalUrl ->
-          if (factory.reresolveOnNextMediaOpen) {
-            factory.reresolveOnNextMediaOpen = false
-            resolveAndCache(originalUrl)
-          } else {
-            cached
-          }
-        // A different URL (already-absolute HLS segment or key): reuse the cached headers but keep
-        // its own URL.
-        else -> Triple(originalUrl, cached.second, cached.third)
-      }
+    val (finalUrl, headers, userAgent) = if (cached == null) {
+      val resolved = resolveRequestConfig(originalUrl)
+      factory.cachedTransform = resolved
+      Timber.d("TransformingDataSource: resolved $originalUrl -> ${resolved.first}")
+      resolved
+    } else {
+      Triple(originalUrl, cached.second, cached.third)
+    }
 
     // Build merged headers including user-agent override
     val mergedHeaders = buildMap {
@@ -72,33 +64,19 @@ class TransformingDataSource(private val upstream: DataSource, private val facto
       dataSpec.buildUpon().setUri(finalUrl.toUri()).setHttpRequestHeaders(mergedHeaders).build()
 
     resolvedUri = transformedSpec.uri
-    return try {
-      upstream.open(transformedSpec)
-    } catch (e: IOException) {
-      // The media-URL load failed: if ExoPlayer retries, re-resolve so a stale URL/token is
-      // refreshed instead of replayed. Scoped to the media URL (segment/key failures keep their own
-      // URL). The flag lives on this item's Factory, so it stays correct when several tracks'
-      // factories are alive at once (a queue).
-      if (originalUrl == factory.cachedOriginalUrl) {
-        factory.reresolveOnNextMediaOpen = true
-      }
-      throw e
-    }
-  }
-
-  /** Resolves the transform for [originalUrl] and caches the result on the [Factory]. */
-  private fun resolveAndCache(originalUrl: String): Triple<String, Map<String, String>, String> {
-    val resolved = resolveRequestConfig(originalUrl)
-    factory.cachedTransform = resolved
-    factory.cachedOriginalUrl = originalUrl
-    Timber.d("TransformingDataSource: resolved $originalUrl -> ${resolved.first}")
-    return resolved
+    return upstream.open(transformedSpec)
   }
 
   override fun read(buffer: ByteArray, offset: Int, length: Int): Int {
     return upstream.read(buffer, offset, length)
   }
 
+  // Delegate to upstream so ExoPlayer can read icy-metaint and strip ICY/Shoutcast
+  // metadata. Without this, the metadata bytes are decoded as audio (chirping).
+  override fun getResponseHeaders(): Map<String, List<String>> {
+    return upstream.responseHeaders
+  }
+
   override fun addTransferListener(transferListener: TransferListener) {
     upstream.addTransferListener(transferListener)
   }
@@ -107,19 +85,6 @@ class TransformingDataSource(private val upstream: DataSource, private val facto
     return resolvedUri ?: upstream.uri
   }
 
-  /**
-   * Forward the upstream response headers. ExoPlayer's `ProgressiveMediaPeriod` reads these back
-   * through the data-source chain to parse `IcyHeaders` (the `icy-metaint` interval) and only then
-   * installs the `IcyDataSource` that emits in-stream ICY/Shoutcast song metadata via
-   * `Player.Listener.onMetadata`. The `DataSource` default returns an empty map, so without this
-   * override this transparent wrapper would swallow the ICY headers — playback keeps working but
-   * `onMetadata` never fires (live "now playing" song goes missing). Swallowing them also leaves
-   * the interleaved metadata bytes in the audio stream, where they decode as audible chirping.
-   */
-  override fun getResponseHeaders(): Map<String, List<String>> {
-    return upstream.responseHeaders
-  }
-
   override fun close() {
     upstream.close()
     resolvedUri = null
@@ -170,29 +135,19 @@ class TransformingDataSource(private val upstream: DataSource, private val facto
   ) : DataSource.Factory {
 
     /**
-     * Cached transform result (url, headers, userAgent) from the first open() call. Shared across
-     * all DataSource instances created by this factory. A new Factory is created per
-     * [MediaFactory.createMediaSource] call (per track), so the cache naturally resets on track
-     * transitions.
-     */
-    @Volatile internal var cachedTransform: Triple<String, Map<String, String>, String>? = null
-
-    /**
-     * The original (pre-transform) URL that [cachedTransform] was resolved from. Used to recognise
-     * a re-open of the same media URL (e.g. a retry) so it reuses the resolved URL instead of the
-     * raw original.
-     */
-    @Volatile internal var cachedOriginalUrl: String? = null
-
-    /**
-     * Set when a media-URL load fails so the next media-URL open re-runs the transform instead of
-     * replaying [cachedTransform] — recovers an expired short-lived URL/token across a retry.
-     * Self-clearing: consumed by the first re-resolve.
+     * Cached transform result (url, headers, userAgent) from the first open() call.
+     * Shared across all DataSource instances created by this factory.
+     * A new Factory is created per [MediaFactory.createMediaSource] call (per track),
+     * so the cache naturally resets on track transitions.
      */
-    @Volatile internal var reresolveOnNextMediaOpen: Boolean = false
+    @Volatile
+    internal var cachedTransform: Triple<String, Map<String, String>, String>? = null
 
     override fun createDataSource(): DataSource {
-      return TransformingDataSource(upstream = upstreamFactory.createDataSource(), factory = this)
+      return TransformingDataSource(
+        upstream = upstreamFactory.createDataSource(),
+        factory = this,
+      )
     }
   }
 }

package/android/src/main/java/com/audiobrowser/util/BrowserPathHelper.kt

@@ -32,12 +32,6 @@ object BrowserPathHelper {
   /** Offline error placeholder media ID */
   const val OFFLINE_PATH = "/__offline"
 
-  /** Generic browse error placeholder media ID */
-  const val ERROR_PATH = "/__error"
-
-  /** Browse Gate placeholder media ID (subscription/login/region block) */
-  const val GATE_PATH = "/__gate"
-
   // Query parameter name for contextual track identifiers
   private const val CONTEXTUAL_TRACK_PARAM = "__trackId"
 
@@ -158,22 +152,4 @@ object BrowserPathHelper {
     val normalizedPath = path.trimStart('/')
     return "$normalizedBase$normalizedPath"
   }
-
-  /**
-   * True if [segment] appears in [path] as a complete path segment — bounded on the left by the
-   * string start or `/`, and on the right by the string end or one of `/`, `?`, `#`.
-   */
-  fun containsSegment(path: String, segment: String): Boolean {
-    if (segment.isEmpty()) return false
-    var from = 0
-    while (true) {
-      val idx = path.indexOf(segment, from)
-      if (idx < 0) return false
-      val beforeOk = idx == 0 || path[idx - 1] == '/'
-      val end = idx + segment.length
-      val afterOk = end == path.length || path[end] == '/' || path[end] == '?' || path[end] == '#'
-      if (beforeOk && afterOk) return true
-      from = idx + 1
-    }
-  }
 }