react-native-audio-browser 0.0.1 → 0.1.0-next.1

package/android/src/main/java/com/audiobrowser/http/RequestConfigBuilder.kt

@@ -0,0 +1,251 @@
+package com.audiobrowser.http
+
+import com.audiobrowser.util.BrowserPathHelper
+import com.margelo.nitro.audiobrowser.ArtworkRequestConfig
+import com.margelo.nitro.audiobrowser.ImageContext
+import com.margelo.nitro.audiobrowser.MediaRequestConfig
+import com.margelo.nitro.audiobrowser.MediaTransformParams
+import com.margelo.nitro.audiobrowser.RequestConfig
+import com.margelo.nitro.audiobrowser.TransformableRequestConfig
+import java.net.URLEncoder
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import timber.log.Timber
+
+object RequestConfigBuilder {
+
+  suspend fun buildHttpRequest(config: RequestConfig): HttpClient.HttpRequest =
+    withContext(Dispatchers.Default) {
+
+      // Build final URL with query parameters
+      val url = buildUrl(config)
+
+      HttpClient.HttpRequest(
+        url = url,
+        method = config.method?.name ?: "GET",
+        headers = config.headers,
+        body = config.body,
+        contentType = config.contentType ?: HttpClient.DEFAULT_CONTENT_TYPE,
+        userAgent = config.userAgent ?: HttpClient.DEFAULT_USER_AGENT,
+      )
+    }
+
+  fun mergeConfig(base: RequestConfig, override: RequestConfig): RequestConfig {
+    return RequestConfig(
+      path = override.path ?: base.path,
+      method = override.method ?: base.method,
+      baseUrl = override.baseUrl ?: base.baseUrl,
+      headers = mergeHeaders(base.headers, override.headers),
+      query = mergeQuery(base.query, override.query),
+      body = override.body ?: base.body,
+      contentType = override.contentType ?: base.contentType,
+      userAgent = override.userAgent ?: base.userAgent,
+    )
+  }
+
+  suspend fun mergeConfig(
+    base: RequestConfig,
+    override: TransformableRequestConfig,
+  ): RequestConfig {
+    return mergeConfig(base, override, emptyMap())
+  }
+
+  suspend fun mergeConfig(
+    base: RequestConfig,
+    override: TransformableRequestConfig,
+    routeParams: Map<String, String>? = null,
+  ): RequestConfig {
+    // Apply transform function if provided
+    return override.transform?.let { transformFn ->
+      try {
+        transformFn.invoke(base, routeParams).await().await() // Transform result wins completely
+      } catch (e: Exception) {
+        Timber.e(e, "Failed to apply transform function, using base config")
+        base
+      }
+    } ?: mergeConfig(base, toRequestConfig(override)) // Only merge if no transform
+  }
+
+  suspend fun mergeConfig(
+    base: RequestConfig,
+    override: MediaRequestConfig,
+    routeParams: Map<String, String>? = null,
+  ): MediaRequestConfig {
+    // Apply transform function if provided - transform result wins completely
+    val finalConfig: RequestConfig =
+      override.transform?.let { transformFn ->
+        try {
+          Timber.d("Invoking media transform for URL: ${base.path}")
+          val transformed = transformFn.invoke(base, routeParams).await().await()
+          Timber.d(
+            "Media transform result: path=${transformed.path}, baseUrl=${transformed.baseUrl}, headers=${transformed.headers}, userAgent=${transformed.userAgent}"
+          )
+          transformed
+        } catch (e: Exception) {
+          Timber.e(e, "Failed to apply media transform function, using base config")
+          base
+        }
+      }
+        ?: RequestConfig(
+          path = override.path ?: base.path,
+          method = override.method ?: base.method,
+          baseUrl = override.baseUrl ?: base.baseUrl,
+          headers = mergeHeaders(base.headers, override.headers),
+          query = mergeQuery(base.query, override.query),
+          body = override.body ?: base.body,
+          contentType = override.contentType ?: base.contentType,
+          userAgent = override.userAgent ?: base.userAgent,
+        )
+
+    // Wrap the final RequestConfig in MediaRequestConfig to preserve resolve callback
+    return MediaRequestConfig(
+      resolve = override.resolve,
+      transform = override.transform,
+      method = finalConfig.method,
+      path = finalConfig.path,
+      baseUrl = finalConfig.baseUrl,
+      headers = finalConfig.headers,
+      query = finalConfig.query,
+      body = finalConfig.body,
+      contentType = finalConfig.contentType,
+      userAgent = finalConfig.userAgent,
+    )
+  }
+
+  /**
+   * Merges artwork request config with base config, applying transform with ImageContext.
+   * Used for artwork URL transformation where size hints are needed.
+   */
+  suspend fun mergeConfig(
+    base: RequestConfig,
+    override: ArtworkRequestConfig,
+    imageContext: ImageContext? = null,
+  ): ArtworkRequestConfig {
+    // Apply transform function if provided - transform result wins completely
+    val finalConfig: RequestConfig =
+      override.transform?.let { transformFn ->
+        try {
+          Timber.d("Invoking artwork transform for URL: ${base.path}")
+          val transformed = transformFn.invoke(MediaTransformParams(base, imageContext)).await().await()
+          Timber.d(
+            "Artwork transform result: path=${transformed.path}, baseUrl=${transformed.baseUrl}, headers=${transformed.headers}, userAgent=${transformed.userAgent}"
+          )
+          transformed
+        } catch (e: Exception) {
+          Timber.e(e, "Failed to apply artwork transform function, using base config")
+          base
+        }
+      }
+        ?: RequestConfig(
+          path = override.path ?: base.path,
+          method = override.method ?: base.method,
+          baseUrl = override.baseUrl ?: base.baseUrl,
+          headers = mergeHeaders(base.headers, override.headers),
+          query = mergeQuery(base.query, override.query),
+          body = override.body ?: base.body,
+          contentType = override.contentType ?: base.contentType,
+          userAgent = override.userAgent ?: base.userAgent,
+        )
+
+    // Wrap the final RequestConfig in ArtworkRequestConfig to preserve callbacks and query params
+    return ArtworkRequestConfig(
+      resolve = override.resolve,
+      transform = override.transform,
+      imageQueryParams = override.imageQueryParams,
+      method = finalConfig.method,
+      path = finalConfig.path,
+      baseUrl = finalConfig.baseUrl,
+      headers = finalConfig.headers,
+      query = finalConfig.query,
+      body = finalConfig.body,
+      contentType = finalConfig.contentType,
+      userAgent = finalConfig.userAgent,
+    )
+  }
+
+  fun toRequestConfig(artworkConfig: ArtworkRequestConfig): RequestConfig {
+    return RequestConfig(
+      path = artworkConfig.path,
+      method = artworkConfig.method,
+      baseUrl = artworkConfig.baseUrl,
+      headers = artworkConfig.headers,
+      query = artworkConfig.query,
+      body = artworkConfig.body,
+      contentType = artworkConfig.contentType,
+      userAgent = artworkConfig.userAgent,
+    )
+  }
+
+  fun toRequestConfig(transformableConfig: TransformableRequestConfig): RequestConfig {
+    return RequestConfig(
+      path = transformableConfig.path,
+      method = transformableConfig.method,
+      baseUrl = transformableConfig.baseUrl,
+      headers = transformableConfig.headers,
+      query = transformableConfig.query,
+      body = transformableConfig.body,
+      contentType = transformableConfig.contentType,
+      userAgent = transformableConfig.userAgent,
+    )
+  }
+
+  fun toRequestConfig(mediaConfig: MediaRequestConfig): RequestConfig {
+    return RequestConfig(
+      path = mediaConfig.path,
+      method = mediaConfig.method,
+      baseUrl = mediaConfig.baseUrl,
+      headers = mediaConfig.headers,
+      query = mediaConfig.query,
+      body = mediaConfig.body,
+      contentType = mediaConfig.contentType,
+      userAgent = mediaConfig.userAgent,
+    )
+  }
+
+  private fun mergeHeaders(
+    base: Map<String, String>?,
+    override: Map<String, String>?,
+  ): Map<String, String>? {
+    return when {
+      base == null -> override
+      override == null -> base
+      else -> base + override // Override wins for duplicate keys
+    }
+  }
+
+  private fun mergeQuery(
+    base: Map<String, String>?,
+    override: Map<String, String>?,
+  ): Map<String, String>? {
+    return when {
+      base == null -> override
+      override == null -> base
+      else -> base + override // Override wins for duplicate keys
+    }
+  }
+
+  internal fun buildUrl(config: RequestConfig): String {
+    val path = config.path ?: ""
+    val baseUrl = config.baseUrl
+
+    // Use BrowserPathHelper for consistent URL building
+    val url = BrowserPathHelper.buildUrl(baseUrl, path)
+
+    // Add query parameters if any
+    val queryString =
+      config.query?.let { query ->
+        if (query.isNotEmpty()) {
+          "?" +
+            query.entries.joinToString("&") { (key, value) ->
+              "${encodeUrlParam(key)}=${encodeUrlParam(value)}"
+            }
+        } else ""
+      } ?: ""
+
+    return "$url$queryString"
+  }
+
+  private fun encodeUrlParam(param: String): String {
+    return URLEncoder.encode(param, "UTF-8")
+  }
+}

package/android/src/main/java/com/audiobrowser/model/PlaybackMetadata.kt

@@ -0,0 +1,80 @@
+package com.audiobrowser.model
+
+import androidx.media3.common.MediaMetadata
+import androidx.media3.common.Metadata
+import androidx.media3.extractor.metadata.icy.IcyInfo
+import com.margelo.nitro.audiobrowser.TimedMetadata
+
+data class PlaybackMetadata(
+  var title: String? = null,
+  var artist: String? = null,
+  var album: String? = null,
+  var date: String? = null,
+  var genre: String? = null,
+) {
+  companion object {
+    /**
+     * Creates PlaybackMetadata from raw Metadata entries.
+     * Handles ICY streams specially, uses Media3's unified approach for everything else.
+     */
+    fun from(metadata: Metadata): PlaybackMetadata? {
+      // Try ICY first (streaming-specific)
+      fromIcy(metadata)?.let { return it }
+
+      // Use Media3's unified approach for ID3, Vorbis, QuickTime, etc.
+      val builder = MediaMetadata.Builder()
+      for (i in 0 until metadata.length()) {
+        metadata[i].populateMediaMetadata(builder)
+      }
+      return fromMediaMetadata(builder.build())
+    }
+
+    /** Shoutcast / Icecast metadata (ICY protocol) https://cast.readme.io/docs/icy */
+    private fun fromIcy(metadata: Metadata): PlaybackMetadata? {
+      for (i in 0 until metadata.length()) {
+        when (val entry = metadata[i]) {
+          is IcyInfo -> {
+            if (entry.title != null) {
+              return PlaybackMetadata(title = entry.title)
+            }
+          }
+        }
+      }
+      return null
+    }
+
+    /** Converts Media3's unified MediaMetadata to PlaybackMetadata. */
+    private fun fromMediaMetadata(mediaMetadata: MediaMetadata): PlaybackMetadata? {
+      val title = mediaMetadata.title?.toString()
+      val artist = mediaMetadata.artist?.toString()
+      val album = mediaMetadata.albumTitle?.toString()
+      val genre = mediaMetadata.genre?.toString()
+
+      // Use recordingYear first (more specific), fall back to releaseYear
+      val date = (mediaMetadata.recordingYear ?: mediaMetadata.releaseYear)?.toString()
+
+      // Return null if no meaningful data
+      if (title == null && artist == null && album == null && genre == null && date == null) {
+        return null
+      }
+
+      return PlaybackMetadata(
+        title = title,
+        artist = artist,
+        album = album,
+        date = date,
+        genre = genre,
+      )
+    }
+  }
+
+  fun toNitro(): TimedMetadata {
+    return TimedMetadata(
+      title = title,
+      artist = artist,
+      album = album,
+      date = date,
+      genre = genre,
+    )
+  }
+}

package/android/src/main/java/com/audiobrowser/model/PlayerSetupOptions.kt

@@ -0,0 +1,101 @@
+package com.audiobrowser.model
+
+import androidx.media3.exoplayer.DefaultLoadControl
+import com.margelo.nitro.audiobrowser.AndroidAudioContentType
+import com.margelo.nitro.audiobrowser.AndroidPlayerWakeMode
+import com.margelo.nitro.audiobrowser.PartialSetupPlayerOptions
+import com.margelo.nitro.audiobrowser.Variant_Boolean_AndroidAudioOffloadSettings
+import com.margelo.nitro.audiobrowser.Variant_Boolean_RetryConfig
+
+/**
+ * Audio offload preferences for power-efficient playback. When this object exists, offload is
+ * considered enabled.
+ */
+data class AudioOffloadOptions(
+  val gaplessSupportRequired: Boolean = true,
+  val rateChangeSupportRequired: Boolean = true,
+)
+
+/** Retry policy for load errors (network failures, timeouts, etc.) */
+sealed class RetryPolicy {
+  /** Use ExoPlayer's default behavior (limited retries, surfaces errors) */
+  data object Default : RetryPolicy()
+
+  /** Retry indefinitely with exponential backoff */
+  data class Infinite(val maxRetryDurationMs: Long? = null) : RetryPolicy()
+
+  /** Retry up to maxRetries times with exponential backoff */
+  data class Limited(val maxRetries: Int, val maxRetryDurationMs: Long? = null) : RetryPolicy()
+}
+
+/**
+ * Setup options for the AudioBrowser that are applied once during player initialization. These
+ * options configure the audio engine and system-level behavior.
+ */
+data class PlayerSetupOptions(
+  // Android-specific options (all under android.* in JS)
+  var minBuffer: Double = DefaultLoadControl.DEFAULT_MIN_BUFFER_MS.toDouble(),
+  var audioContentType: AndroidAudioContentType = AndroidAudioContentType.MUSIC,
+  var maxBuffer: Double = DefaultLoadControl.DEFAULT_MAX_BUFFER_MS.toDouble(),
+  var playBuffer: Double = DefaultLoadControl.DEFAULT_BUFFER_FOR_PLAYBACK_MS.toDouble(),
+  var rebufferBuffer: Double? = null,
+  var backBuffer: Double = DefaultLoadControl.DEFAULT_BACK_BUFFER_DURATION_MS.toDouble(),
+  var maxCacheSize: Double = 0.0,
+  var handleAudioBecomingNoisy: Boolean = true,
+  var wakeMode: AndroidPlayerWakeMode = AndroidPlayerWakeMode.NONE,
+  var audioOffload: AudioOffloadOptions? = null,
+  var retryPolicy: RetryPolicy = RetryPolicy.Default,
+) {
+  /**
+   * Whether automatic buffer management is enabled. True when rebufferBuffer is not explicitly set
+   * (null).
+   */
+  val automaticBuffer: Boolean
+    get() = rebufferBuffer == null
+
+  fun update(options: PartialSetupPlayerOptions) {
+    // Android-specific options
+    options.android?.let { android ->
+      android.minBuffer?.let { minBuffer = it }
+      android.maxBuffer?.let { maxBuffer = it }
+      android.playBuffer?.let { playBuffer = it }
+      android.rebufferBuffer?.let { rebufferBuffer = it.asSecondOrNull() }
+      android.backBuffer?.let { backBuffer = it }
+      android.maxCacheSize?.let { maxCacheSize = it }
+      android.handleAudioBecomingNoisy?.let { handleAudioBecomingNoisy = it }
+      android.audioContentType?.let { audioContentType = it }
+      android.wakeMode?.let { wakeMode = it }
+      android.audioOffload?.let {
+        audioOffload =
+          when (android.audioOffload) {
+            is Variant_Boolean_AndroidAudioOffloadSettings.First -> {
+              if (android.audioOffload.value) AudioOffloadOptions() else null
+            }
+            is Variant_Boolean_AndroidAudioOffloadSettings.Second -> {
+              val settings = android.audioOffload.value
+              AudioOffloadOptions(
+                gaplessSupportRequired = settings.gaplessSupportRequired ?: false,
+                rateChangeSupportRequired = settings.rateChangeSupportRequired ?: false,
+              )
+            }
+          }
+      }
+    }
+
+    // Top-level cross-platform options
+    options.retry?.let {
+      retryPolicy =
+        when (it) {
+          is Variant_Boolean_RetryConfig.First -> {
+            if (it.value) RetryPolicy.Infinite() else RetryPolicy.Default
+          }
+          is Variant_Boolean_RetryConfig.Second -> {
+            RetryPolicy.Limited(
+              maxRetries = it.value.maxRetries.toInt(),
+              maxRetryDurationMs = it.value.maxRetryDurationMs?.toLong(),
+            )
+          }
+        }
+    }
+  }
+}

package/android/src/main/java/com/audiobrowser/model/PlayerUpdateOptions.kt

@@ -0,0 +1,125 @@
+package com.audiobrowser.model
+
+import com.margelo.nitro.audiobrowser.AndroidUpdateOptions
+import com.margelo.nitro.audiobrowser.AppKilledPlaybackBehavior
+import com.margelo.nitro.audiobrowser.NativeUpdateOptions
+import com.margelo.nitro.audiobrowser.NotificationButtonLayout
+import com.margelo.nitro.audiobrowser.PlayerCapabilities
+import com.margelo.nitro.audiobrowser.RatingType as NitroRatingType
+import com.margelo.nitro.audiobrowser.UpdateOptions
+import com.margelo.nitro.audiobrowser.Variant_NullType_Double
+import com.margelo.nitro.audiobrowser.Variant_NullType_NotificationButtonLayout
+
+/**
+ * Update options for the AudioBrowser that can be changed at runtime. These options control player
+ * behavior and capabilities that can be modified during playback.
+ */
+data class PlayerUpdateOptions(
+  // Jump intervals
+  var forwardJumpInterval: Double = 15.0,
+  var backwardJumpInterval: Double = 15.0,
+  var progressUpdateEventInterval: Double? = null,
+
+  // Player capabilities - most enabled by default, only false values disable
+  // Exceptions: bookmark, jumpForward, jumpBackward default to false
+  var capabilities: PlayerCapabilities = PlayerCapabilities(
+    play = null, pause = null, stop = null, seekTo = null,
+    skipToNext = null, skipToPrevious = null,
+    jumpForward = false, jumpBackward = false,
+    favorite = null,
+    shuffleMode = null, repeatMode = null, playbackRate = null
+  ),
+
+  // Notification button layout (null = derive from capabilities)
+  var notificationButtons: NotificationButtonLayout? = null,
+
+  // Android-specific runtime options (all under android.* in JS)
+  var ratingType: NitroRatingType? = null,
+  var appKilledPlaybackBehavior: AppKilledPlaybackBehavior =
+    AppKilledPlaybackBehavior.STOP_PLAYBACK_AND_REMOVE_NOTIFICATION,
+  var skipSilence: Boolean = false,
+  var shuffle: Boolean = false,
+) {
+  fun updateFromBridge(options: NativeUpdateOptions) {
+    options.forwardJumpInterval?.let { forwardJumpInterval = it }
+    options.backwardJumpInterval?.let { backwardJumpInterval = it }
+
+    options.progressUpdateEventInterval?.let { variant ->
+      progressUpdateEventInterval =
+        when (variant) {
+          is Variant_NullType_Double.First -> null
+          is Variant_NullType_Double.Second -> variant.value
+        }
+    }
+
+    options.capabilities?.let { newCaps ->
+      capabilities = mergeCapabilities(capabilities, newCaps)
+    }
+
+    // Update Android-specific options
+    options.android?.let { androidOptions ->
+      // Convert rating type
+      androidOptions.ratingType?.let { ratingType = it }
+
+      androidOptions.appKilledPlaybackBehavior?.let { appKilledPlaybackBehavior = it }
+
+      // Update boolean options
+      androidOptions.skipSilence?.let { skipSilence = it }
+
+      androidOptions.shuffle?.let { shuffle = it }
+
+      // Handle notificationButtons - variant allows distinguishing undefined from null
+      androidOptions.notificationButtons?.let { variant ->
+        notificationButtons =
+          when (variant) {
+            is Variant_NullType_NotificationButtonLayout.First -> null
+            is Variant_NullType_NotificationButtonLayout.Second -> variant.value
+          }
+      }
+    }
+  }
+
+  fun toNitro(): UpdateOptions {
+    // Create Android options
+    val androidOptions =
+      AndroidUpdateOptions(
+        appKilledPlaybackBehavior = appKilledPlaybackBehavior,
+        skipSilence = skipSilence,
+        shuffle = shuffle,
+        ratingType = ratingType,
+        notificationButtons =
+          notificationButtons?.let { Variant_NullType_NotificationButtonLayout.create(it) },
+      )
+
+    return UpdateOptions(
+      android = androidOptions,
+      forwardJumpInterval = forwardJumpInterval,
+      backwardJumpInterval = backwardJumpInterval,
+      progressUpdateEventInterval =
+        progressUpdateEventInterval?.let { Variant_NullType_Double.create(it) },
+      capabilities = capabilities,
+      iosPlaybackRates = null, // iOS-only option
+    )
+  }
+
+  /** Merge incoming capabilities with existing - only explicitly set values override */
+  private fun mergeCapabilities(
+    existing: PlayerCapabilities,
+    incoming: PlayerCapabilities
+  ): PlayerCapabilities {
+    return PlayerCapabilities(
+      play = incoming.play ?: existing.play,
+      pause = incoming.pause ?: existing.pause,
+      stop = incoming.stop ?: existing.stop,
+      seekTo = incoming.seekTo ?: existing.seekTo,
+      skipToNext = incoming.skipToNext ?: existing.skipToNext,
+      skipToPrevious = incoming.skipToPrevious ?: existing.skipToPrevious,
+      jumpForward = incoming.jumpForward ?: existing.jumpForward,
+      jumpBackward = incoming.jumpBackward ?: existing.jumpBackward,
+      favorite = incoming.favorite ?: existing.favorite,
+      shuffleMode = incoming.shuffleMode ?: existing.shuffleMode,
+      repeatMode = incoming.repeatMode ?: existing.repeatMode,
+      playbackRate = incoming.playbackRate ?: existing.playbackRate
+    )
+  }
+}