@5stones/react-native-audio-browser 0.1.0

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

@@ -0,0 +1,163 @@
+package com.audiobrowser.player
+
+import androidx.media3.common.C
+import androidx.media3.exoplayer.DefaultLoadControl
+import androidx.media3.exoplayer.LoadControl
+import androidx.media3.exoplayer.analytics.PlayerId
+import androidx.media3.exoplayer.source.TrackGroupArray
+import androidx.media3.exoplayer.trackselection.ExoTrackSelection
+import androidx.media3.exoplayer.upstream.Allocator
+import androidx.media3.exoplayer.upstream.DefaultAllocator
+import timber.log.Timber
+
+/**
+ * Buffer configuration for DynamicLoadControl.
+ *
+ * @property minBufferMs Minimum duration of media that the player will attempt to buffer.
+ * @property maxBufferMs Maximum duration of media that the player will attempt to buffer.
+ * @property bufferForPlaybackMs Duration of media that must be buffered for playback to start.
+ * @property bufferForPlaybackAfterRebufferMs Duration of media that must be buffered for playback
+ *   to resume after a rebuffer.
+ * @property backBufferMs Duration of media to keep in the buffer behind the current position.
+ */
+data class BufferConfig(
+  val minBufferMs: Int = DefaultLoadControl.DEFAULT_MIN_BUFFER_MS,
+  val maxBufferMs: Int = DefaultLoadControl.DEFAULT_MAX_BUFFER_MS,
+  val bufferForPlaybackMs: Int = DefaultLoadControl.DEFAULT_BUFFER_FOR_PLAYBACK_MS,
+  val bufferForPlaybackAfterRebufferMs: Int =
+    DefaultLoadControl.DEFAULT_BUFFER_FOR_PLAYBACK_AFTER_REBUFFER_MS,
+  val backBufferMs: Int = 0,
+)
+
+/**
+ * A LoadControl implementation that allows runtime buffer configuration changes.
+ *
+ * Unlike wrapping DefaultLoadControl, this implementation has its own mutable buffer thresholds
+ * that can be changed at any time during playback. This allows adaptive buffer management (via
+ * AutomaticBufferManager) to take effect immediately.
+ *
+ * Thread safety: LoadControl methods are called from ExoPlayer's internal playback thread, while
+ * [updateBufferConfig] is typically called from the main thread. The @Volatile annotation ensures
+ * visibility across threads.
+ */
+class DynamicLoadControl(initialConfig: BufferConfig = BufferConfig()) : LoadControl {
+
+  private val allocator = DefaultAllocator(true, C.DEFAULT_BUFFER_SEGMENT_SIZE)
+
+  // Track startup timing
+  @Volatile private var prepareStartTimeMs: Long = 0
+  @Volatile private var playbackStarted: Boolean = false
+
+  // Mutable buffer thresholds - can be updated at runtime
+  @Volatile private var minBufferUs: Long = initialConfig.minBufferMs * 1000L
+
+  @Volatile private var maxBufferUs: Long = initialConfig.maxBufferMs * 1000L
+
+  @Volatile private var bufferForPlaybackUs: Long = initialConfig.bufferForPlaybackMs * 1000L
+
+  @Volatile
+  private var bufferForPlaybackAfterRebufferUs: Long =
+    initialConfig.bufferForPlaybackAfterRebufferMs * 1000L
+
+  @Volatile private var backBufferUs: Long = initialConfig.backBufferMs * 1000L
+
+  @Volatile private var currentConfig: BufferConfig = initialConfig
+
+  /**
+   * Updates the buffer configuration at runtime.
+   *
+   * The new configuration takes effect immediately for future buffering decisions. Already-buffered
+   * data is not affected.
+   *
+   * @param config The new buffer configuration to apply.
+   */
+  fun updateBufferConfig(config: BufferConfig) {
+    if (config == currentConfig) return
+
+    Timber.d(
+      "Updating buffer config: playBuffer=%dms -> %dms, rebufferBuffer=%dms -> %dms",
+      currentConfig.bufferForPlaybackMs,
+      config.bufferForPlaybackMs,
+      currentConfig.bufferForPlaybackAfterRebufferMs,
+      config.bufferForPlaybackAfterRebufferMs,
+    )
+
+    currentConfig = config
+    minBufferUs = config.minBufferMs * 1000L
+    maxBufferUs = config.maxBufferMs * 1000L
+    bufferForPlaybackUs = config.bufferForPlaybackMs * 1000L
+    bufferForPlaybackAfterRebufferUs = config.bufferForPlaybackAfterRebufferMs * 1000L
+    backBufferUs = config.backBufferMs * 1000L
+  }
+
+  /** Gets the current buffer configuration. */
+  fun getBufferConfig(): BufferConfig = currentConfig
+
+  /** Resets the buffer configuration to defaults. */
+  fun resetToDefaults() {
+    updateBufferConfig(BufferConfig())
+  }
+
+  override fun getAllocator(playerId: PlayerId): Allocator = allocator
+
+  override fun getBackBufferDurationUs(playerId: PlayerId): Long = backBufferUs
+
+  override fun retainBackBufferFromKeyframe(playerId: PlayerId): Boolean = false
+
+  override fun shouldContinueLoading(parameters: LoadControl.Parameters): Boolean {
+    return parameters.bufferedDurationUs < maxBufferUs
+  }
+
+  override fun shouldStartPlayback(parameters: LoadControl.Parameters): Boolean {
+    val bufferedDurationUs = parameters.bufferedDurationUs
+    val targetUs =
+      adjustForPlaybackSpeed(
+        if (parameters.rebuffering) bufferForPlaybackAfterRebufferUs else bufferForPlaybackUs,
+        parameters.playbackSpeed,
+      )
+    val shouldStart = bufferedDurationUs >= targetUs
+    if (shouldStart && !parameters.rebuffering) {
+      logStartupTime(bufferedDurationUs / 1000)
+    }
+    return shouldStart
+  }
+
+  private fun adjustForPlaybackSpeed(bufferUs: Long, playbackSpeed: Float): Long {
+    return if (playbackSpeed > 1) (bufferUs * playbackSpeed).toLong() else bufferUs
+  }
+
+  private fun logStartupTime(bufferedDurationMs: Long) {
+    if (!playbackStarted && prepareStartTimeMs > 0) {
+      val startupTimeMs = System.currentTimeMillis() - prepareStartTimeMs
+      Timber.d(
+        "Playback started: %dms startup time, %dms buffer",
+        startupTimeMs,
+        bufferedDurationMs,
+      )
+      playbackStarted = true
+    }
+  }
+
+  override fun onPrepared(playerId: PlayerId) {
+    allocator.reset()
+    prepareStartTimeMs = System.currentTimeMillis()
+    playbackStarted = false
+  }
+
+  override fun onTracksSelected(
+    parameters: LoadControl.Parameters,
+    trackGroups: TrackGroupArray,
+    trackSelections: Array<out ExoTrackSelection?>,
+  ) {
+    // Required by LoadControl interface - buffer config is managed via updateBufferConfig()
+  }
+
+  override fun onStopped(playerId: PlayerId) {
+    // Required by LoadControl interface
+  }
+
+  override fun onReleased(playerId: PlayerId) {
+    // Reset allocator when released
+    allocator.reset()
+  }
+}

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

@@ -0,0 +1,177 @@
+package com.audiobrowser.player
+
+import android.content.Context
+import android.net.Uri
+import androidx.core.net.toUri
+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.exoplayer.drm.DrmSessionManagerProvider
+import androidx.media3.exoplayer.source.DefaultMediaSourceFactory
+import androidx.media3.exoplayer.source.MediaSource
+import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy
+import androidx.media3.extractor.DefaultExtractorsFactory
+import com.audiobrowser.model.RetryPolicy
+import com.margelo.nitro.audiobrowser.MediaRequestConfig
+import timber.log.Timber
+
+class MediaFactory(
+  private val context: Context,
+  private val cache: SimpleCache?,
+  private val retryPolicy: RetryPolicy,
+  private val shouldRetry: () -> Boolean,
+  private val isOnline: () -> Boolean = { true },
+  private val onRetryPending: ((isNetworkError: Boolean) -> Unit)? = null,
+  private val transferListener: TransferListener? = null,
+  private val getRequestConfig: (originalUrl: String) -> MediaRequestConfig?,
+) : MediaSource.Factory {
+
+  companion object {
+    private const val DEFAULT_USER_AGENT = "react-native-audio-browser"
+  }
+
+  private val extractorsFactory =
+    DefaultExtractorsFactory()
+      // TODO: reconsider whether this should be enabled by default:
+      .setConstantBitrateSeekingEnabled(true)
+
+  // Store reference to custom retry policy so we can reset it on track changes
+  private val customRetryPolicy: RetryLoadErrorHandlingPolicy? =
+    when (retryPolicy) {
+      is RetryPolicy.Default -> null
+      is RetryPolicy.Infinite ->
+        RetryLoadErrorHandlingPolicy(
+          maxRetries = null,
+          maxRetryDurationMs = retryPolicy.maxRetryDurationMs,
+          shouldRetry = shouldRetry,
+          isOnline = isOnline,
+          onRetryPending = onRetryPending,
+        )
+      is RetryPolicy.Limited ->
+        RetryLoadErrorHandlingPolicy(
+          maxRetries = retryPolicy.maxRetries,
+          maxRetryDurationMs = retryPolicy.maxRetryDurationMs,
+          shouldRetry = shouldRetry,
+          isOnline = isOnline,
+          onRetryPending = onRetryPending,
+        )
+    }
+
+  private val mediaFactory =
+    DefaultMediaSourceFactory(context, extractorsFactory).apply {
+      customRetryPolicy?.let { setLoadErrorHandlingPolicy(it) }
+    }
+
+  /** Resets the retry timer. Call when track changes. */
+  fun resetRetryTimer() {
+    customRetryPolicy?.reset()
+  }
+
+  override fun setDrmSessionManagerProvider(
+    drmSessionManagerProvider: DrmSessionManagerProvider
+  ): MediaSource.Factory {
+    return mediaFactory.setDrmSessionManagerProvider(drmSessionManagerProvider)
+  }
+
+  override fun setLoadErrorHandlingPolicy(
+    loadErrorHandlingPolicy: LoadErrorHandlingPolicy
+  ): MediaSource.Factory {
+    return mediaFactory.setLoadErrorHandlingPolicy(loadErrorHandlingPolicy)
+  }
+
+  override fun getSupportedTypes(): IntArray {
+    return mediaFactory.supportedTypes
+  }
+
+  /**
+   * Get the final request configuration for a media URL. Returns the URL, headers, and user-agent
+   * to use for streaming.
+   */
+  private fun getMediaRequestConfig(
+    originalUrl: String
+  ): Triple<String, Map<String, String>, String> {
+    return try {
+      val requestConfig = getRequestConfig(originalUrl)
+      Timber.d(
+        "Got media request config for URL '$originalUrl': path=${requestConfig?.path}, baseUrl=${requestConfig?.baseUrl}, headers=${requestConfig?.headers}, userAgent=${requestConfig?.userAgent}"
+      )
+      if (requestConfig != null) {
+        val path = requestConfig.path ?: ""
+        val baseUrl = requestConfig.baseUrl
+
+        // Build URL using the helper to ensure proper slash handling
+        val url = com.audiobrowser.util.BrowserPathHelper.buildUrl(baseUrl, path)
+
+        // Add query parameters if any
+        val finalUrl =
+          if (requestConfig.query?.isNotEmpty() == true) {
+            val uri = Uri.parse(url).buildUpon()
+            requestConfig.query.forEach { (key, value) -> uri.appendQueryParameter(key, value) }
+            uri.build().toString()
+          } else {
+            url
+          }
+
+        val headers = requestConfig.headers ?: emptyMap()
+        val userAgent = requestConfig.userAgent ?: DEFAULT_USER_AGENT
+
+        Triple(finalUrl, headers, userAgent)
+      } else {
+        Triple(originalUrl, emptyMap(), DEFAULT_USER_AGENT)
+      }
+    } catch (e: Exception) {
+      Timber.e(e, "Error getting media request config for URL: $originalUrl")
+      Triple(originalUrl, emptyMap(), DEFAULT_USER_AGENT)
+    }
+  }
+
+  override fun createMediaSource(mediaItem: MediaItem): MediaSource {
+    val originalUri = mediaItem.localConfiguration?.uri
+    val (finalUrl, headers, userAgent) = getMediaRequestConfig(originalUri!!.toString())
+
+    Timber.d("Media URL: $originalUri -> $finalUrl")
+    Timber.d("Media headers: $headers")
+    Timber.d("Media user-agent: $userAgent")
+
+    // DefaultDataSource.Factory handles all URI schemes (file://, content://, http://, https://,
+    // etc.)
+    // by routing to the appropriate implementation. We provide a configured HTTP factory for remote
+    // URLs.
+    val httpFactory =
+      DefaultHttpDataSource.Factory().apply {
+        setUserAgent(userAgent)
+        setAllowCrossProtocolRedirects(true)
+        if (headers.isNotEmpty()) {
+          setDefaultRequestProperties(headers)
+        }
+        // Connect transfer listener for bandwidth measurement
+        transferListener?.let { setTransferListener(it) }
+      }
+    val factory: DataSource.Factory = DefaultDataSource.Factory(context, httpFactory)
+
+    // Create a new MediaItem with the transformed URL if it changed
+    val finalMediaItem =
+      if (finalUrl != originalUri.toString()) {
+        Timber.d("Creating new MediaItem with transformed URL: $finalUrl")
+        mediaItem.buildUpon().setUri(finalUrl.toUri()).build()
+      } else {
+        mediaItem
+      }
+
+    // Configure data source factory with optional caching
+    val dataSourceFactory =
+      cache?.let {
+        CacheDataSource.Factory()
+          .setCache(it)
+          .setUpstreamDataSourceFactory(factory)
+          .setFlags(CacheDataSource.FLAG_IGNORE_CACHE_ON_ERROR)
+      } ?: factory
+
+    // Use DefaultMediaSourceFactory which supports HLS, DASH, and progressive media
+    return mediaFactory.setDataSourceFactory(dataSourceFactory).createMediaSource(finalMediaItem)
+  }
+}