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

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

@@ -0,0 +1,103 @@
+package com.audiobrowser.browser
+
+import com.margelo.nitro.audiobrowser.ResolvedTrack
+import com.margelo.nitro.audiobrowser.Track
+import com.margelo.nitro.audiobrowser.TrackStyle
+import kotlinx.serialization.Serializable
+
+/**
+ * JSON serializable models for parsing API responses. These will be converted to Nitro types after
+ * parsing.
+ */
+@Serializable
+data class JsonResolvedTrack(
+  val url: String,
+  val title: String,
+  val subtitle: String? = null,
+  val icon: String? = null,
+  val artwork: String? = null,
+  val artist: String? = null,
+  val album: String? = null,
+  val description: String? = null,
+  val genre: String? = null,
+  val duration: Double? = null,
+  val children: List<JsonTrack>? = null,
+  val src: String? = null,
+  val style: String? = null,
+  val childrenStyle: String? = null,
+  val groupTitle: String? = null,
+  val live: Boolean? = null,
+)
+
+@Serializable
+data class JsonTrack(
+  val url: String? = null,
+  val title: String,
+  val subtitle: String? = null,
+  val icon: String? = null,
+  val artwork: String? = null,
+  val artist: String? = null,
+  val album: String? = null,
+  val description: String? = null,
+  val genre: String? = null,
+  val duration: Double? = null,
+  val src: String? = null,
+  val style: String? = null,
+  val childrenStyle: String? = null,
+  val groupTitle: String? = null,
+  val live: Boolean? = null,
+)
+
+/** Convert JSON models to Nitro types */
+private fun String?.toTrackStyle(): TrackStyle? {
+  return when (this?.lowercase()) {
+    "list" -> TrackStyle.LIST
+    "grid" -> TrackStyle.GRID
+    else -> null
+  }
+}
+
+fun JsonResolvedTrack.toNitro(): ResolvedTrack {
+  return ResolvedTrack(
+    url = url,
+    children = children?.map { it.toNitro() }?.toTypedArray(),
+    title = title,
+    subtitle = subtitle,
+    artwork = artwork,
+    artworkSource = null,
+    artworkCarPlayTinted = null,
+    artist = artist,
+    album = album,
+    description = description,
+    genre = genre,
+    duration = duration,
+    src = src,
+    style = style.toTrackStyle(),
+    childrenStyle = childrenStyle.toTrackStyle(),
+    favorited = null,
+    groupTitle = groupTitle,
+    live = live,
+  )
+}
+
+fun JsonTrack.toNitro(): Track {
+  return Track(
+    url = url,
+    title = title,
+    subtitle = subtitle,
+    artwork = artwork,
+    artworkSource = null,
+    artworkCarPlayTinted = null,
+    artist = artist,
+    album = album,
+    description = description,
+    genre = genre,
+    duration = duration,
+    src = src,
+    style = style.toTrackStyle(),
+    childrenStyle = childrenStyle.toTrackStyle(),
+    favorited = null,
+    groupTitle = groupTitle,
+    live = live,
+  )
+}

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

@@ -0,0 +1,9 @@
+package com.audiobrowser.browser
+
+/**
+ * Represents a successful route match with extracted parameters and specificity score.
+ *
+ * @param params Extracted path parameters (e.g., {id} → "123")
+ * @param specificity Score for route priority - higher means more specific
+ */
+data class RouteMatch(val params: Map<String, String>, val specificity: Int)

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

@@ -0,0 +1,150 @@
+package com.audiobrowser.browser
+
+/**
+ * Simple route matcher for path patterns with parameter extraction.
+ *
+ * Supports patterns like:
+ * - /artists - exact match
+ * - /artists/{id} - parameter extraction
+ * - /artists/{id}/albums - multiple segments with parameters
+ * - /artists/* - wildcard match (matches any single segment)
+ * - /files/** - tail wildcard (matches remaining path segments)
+ *
+ * Route specificity rules:
+ * - More path segments = higher specificity
+ * - Constant segments > parameter segments > wildcards > tail wildcards
+ * - Most specific route wins
+ */
+class SimpleRouter {
+
+  /**
+   * Finds the best matching route for the given path.
+   *
+   * @param path The incoming path to match (e.g., "/artists/123")
+   * @param routes Map of route patterns to match against
+   * @return Pair of (route pattern, match result) or null if no match
+   */
+  fun <T> findBestMatch(path: String, routes: Map<String, T>): Pair<String, RouteMatch>? {
+    return routes.keys
+      .mapNotNull { pattern -> matchPattern(pattern, path)?.let { match -> pattern to match } }
+      .maxByOrNull { (_, match) -> match.specificity }
+  }
+
+  /**
+   * Attempts to match a single pattern against a path.
+   *
+   * @param pattern Route pattern (e.g., "/artists/{id}", "/files/&#42;", "/api/&#42;&#42;")
+   * @param path Incoming path (e.g., "/artists/123")
+   * @return RouteMatch if successful, null otherwise
+   */
+  private fun matchPattern(pattern: String, path: String): RouteMatch? {
+    val patternSegments = pattern.split('/').filter { it.isNotEmpty() }
+    val pathSegments = path.split('/').filter { it.isNotEmpty() }
+
+    val params = mutableMapOf<String, String>()
+    var constantSegments = 0
+    var parameterSegments = 0
+    var wildcardSegments = 0
+    var hasTailWildcard = false
+
+    // Check for tail wildcard at end
+    if (patternSegments.isNotEmpty() && patternSegments.last() == "**") {
+      hasTailWildcard = true
+
+      // For tail wildcard, pattern must have <= path segments
+      if (patternSegments.size - 1 > pathSegments.size) {
+        return null
+      }
+
+      // Match all segments except the tail wildcard
+      for (i in 0 until patternSegments.size - 1) {
+        if (!matchSingleSegment(patternSegments[i], pathSegments[i], params)) {
+          return null
+        }
+        updateSegmentCounts(
+          patternSegments[i],
+          constantSegments,
+          parameterSegments,
+          wildcardSegments,
+        )
+      }
+
+      // Capture remaining path segments as "tail" parameter
+      if (pathSegments.size > patternSegments.size - 1) {
+        val remainingSegments = pathSegments.drop(patternSegments.size - 1)
+        params["tail"] = remainingSegments.joinToString("/")
+      }
+    } else {
+      // Normal matching - must have same number of segments
+      if (patternSegments.size != pathSegments.size) {
+        return null
+      }
+
+      for (i in patternSegments.indices) {
+        if (!matchSingleSegment(patternSegments[i], pathSegments[i], params)) {
+          return null
+        }
+        val (constCount, paramCount, wildcardCount) =
+          updateSegmentCounts(
+            patternSegments[i],
+            constantSegments,
+            parameterSegments,
+            wildcardSegments,
+          )
+        constantSegments = constCount
+        parameterSegments = paramCount
+        wildcardSegments = wildcardCount
+      }
+    }
+
+    // Specificity calculation (higher = more specific):
+    // - Constants: 1000 points each
+    // - Parameters: 100 points each
+    // - Single wildcards: 10 points each
+    // - Tail wildcard: 1 point
+    // - Base path length: segments count
+    val specificity =
+      (constantSegments * 1000) +
+        (parameterSegments * 100) +
+        (wildcardSegments * 10) +
+        (if (hasTailWildcard) 1 else 0) +
+        patternSegments.size
+
+    return RouteMatch(params, specificity)
+  }
+
+  private fun matchSingleSegment(
+    patternSegment: String,
+    pathSegment: String,
+    params: MutableMap<String, String>,
+  ): Boolean {
+    return when {
+      // Parameter segment: {paramName}
+      patternSegment.startsWith('{') && patternSegment.endsWith('}') -> {
+        val paramName = patternSegment.substring(1, patternSegment.length - 1)
+        params[paramName] = pathSegment
+        true
+      }
+      // Single wildcard: *
+      patternSegment == "*" -> true
+      // Constant segment: must match exactly
+      patternSegment == pathSegment -> true
+      // Mismatch
+      else -> false
+    }
+  }
+
+  private fun updateSegmentCounts(
+    patternSegment: String,
+    constantSegments: Int,
+    parameterSegments: Int,
+    wildcardSegments: Int,
+  ): Triple<Int, Int, Int> {
+    return when {
+      patternSegment.startsWith('{') && patternSegment.endsWith('}') ->
+        Triple(constantSegments, parameterSegments + 1, wildcardSegments)
+      patternSegment == "*" -> Triple(constantSegments, parameterSegments, wildcardSegments + 1)
+      else -> Triple(constantSegments + 1, parameterSegments, wildcardSegments)
+    }
+  }
+}

package/android/src/main/java/com/audiobrowser/extension/EnumExtensions.kt

@@ -0,0 +1,5 @@
+package com.audiobrowser.extension
+
+inline fun <reified T : Enum<T>, V> ((T) -> V).find(value: V): T? {
+  return enumValues<T>().firstOrNull { this(it) == value }
+}

package/android/src/main/java/com/audiobrowser/extension/NumberExt.kt

@@ -0,0 +1,13 @@
+package com.audiobrowser.extension
+
+class NumberExt {
+  companion object {
+    fun Number.toSeconds(): Double {
+      return this.toDouble() / 1000
+    }
+
+    fun Number.toMilliseconds(): Long {
+      return (this.toDouble() * 1000).toLong()
+    }
+  }
+}

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

@@ -0,0 +1,171 @@
+package com.audiobrowser.http
+
+import java.io.IOException
+import java.util.concurrent.TimeUnit
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonElement
+import okhttp3.Headers
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.logging.HttpLoggingInterceptor
+import timber.log.Timber
+
+class HttpClient {
+  companion object {
+    const val DEFAULT_USER_AGENT = "react-native-audio-browser"
+    const val DEFAULT_CONTENT_TYPE = "application/json"
+    private const val TIMEOUT_SECONDS = 30L
+  }
+
+  val json = Json {
+    ignoreUnknownKeys = true
+    isLenient = true
+  }
+
+  private val loggingInterceptor =
+    HttpLoggingInterceptor { message -> Timber.d(message) }
+      .apply { level = HttpLoggingInterceptor.Level.BODY }
+
+  private val client =
+    OkHttpClient.Builder()
+      .addInterceptor(loggingInterceptor)
+      .connectTimeout(TIMEOUT_SECONDS, TimeUnit.SECONDS)
+      .readTimeout(TIMEOUT_SECONDS, TimeUnit.SECONDS)
+      .writeTimeout(TIMEOUT_SECONDS, TimeUnit.SECONDS)
+      .build()
+
+  data class HttpRequest(
+    val url: String,
+    val method: String = "GET",
+    val headers: Map<String, String>? = null,
+    val body: String? = null,
+    val contentType: String = DEFAULT_CONTENT_TYPE,
+    val userAgent: String = DEFAULT_USER_AGENT,
+  )
+
+  data class HttpResponse(
+    val code: Int,
+    val body: String,
+    val headers: Map<String, String>,
+    /** HTTP reason phrase (e.g., "Not Found", "Service Unavailable") */
+    val message: String,
+  ) {
+    val isSuccessful: Boolean
+      get() = code in 200..299
+  }
+
+  suspend fun request(httpRequest: HttpRequest): Result<HttpResponse> =
+    withContext(Dispatchers.IO) {
+      try {
+        val url =
+          httpRequest.url.toHttpUrlOrNull()
+            ?: return@withContext Result.failure(
+              IllegalArgumentException("Invalid URL: ${httpRequest.url}")
+            )
+
+        val requestBuilder = Request.Builder().url(url)
+
+        // Add headers
+        val headers =
+          Headers.Builder()
+            .apply {
+              httpRequest.headers?.forEach { (name, value) -> add(name, value) }
+              // Set User-Agent (userAgent parameter takes precedence over headers)
+              add("User-Agent", httpRequest.userAgent)
+            }
+            .build()
+        requestBuilder.headers(headers)
+
+        // Add body for non-GET requests
+        when (httpRequest.method.uppercase()) {
+          "GET" -> {
+            /* No body for GET */
+          }
+          "POST",
+          "PUT",
+          "PATCH" -> {
+            val body = httpRequest.body ?: ""
+            val mediaType = httpRequest.contentType.toMediaType()
+            requestBuilder.method(httpRequest.method, body.toRequestBody(mediaType))
+          }
+          "DELETE" -> {
+            val mediaType = httpRequest.contentType.toMediaType()
+            requestBuilder.delete(httpRequest.body?.toRequestBody(mediaType))
+          }
+          else -> {
+            return@withContext Result.failure(
+              IllegalArgumentException("Unsupported HTTP method: ${httpRequest.method}")
+            )
+          }
+        }
+
+        val request = requestBuilder.build()
+        val response = client.newCall(request).execute()
+
+        val responseBody = response.body?.string() ?: ""
+        val responseHeaders = response.headers.toMap()
+
+        Result.success(
+          HttpResponse(
+            code = response.code,
+            body = responseBody,
+            headers = responseHeaders,
+            message = response.message,
+          )
+        )
+      } catch (e: IOException) {
+        Timber.e(e, "HTTP request failed")
+        Result.failure(e)
+      } catch (e: Exception) {
+        Timber.e(e, "Unexpected error during HTTP request")
+        Result.failure(e)
+      }
+    }
+
+  suspend inline fun <reified T> requestJson(httpRequest: HttpRequest): Result<T> {
+    return request(httpRequest).mapCatching { response ->
+      if (!response.isSuccessful) {
+        throw HttpException(response.code, response.body, response.message)
+      }
+      json.decodeFromString<T>(response.body)
+    }
+  }
+
+  suspend fun requestJsonElement(httpRequest: HttpRequest): Result<JsonElement> {
+    return request(httpRequest).mapCatching { response ->
+      if (!response.isSuccessful) {
+        throw HttpException(response.code, response.body, response.message)
+      }
+      json.parseToJsonElement(response.body)
+    }
+  }
+
+  class HttpException(
+    val code: Int,
+    val responseBody: String,
+    /** HTTP reason phrase (e.g., "Not Found", "Service Unavailable") */
+    val reasonPhrase: String,
+  ) : Exception(formatMessage(code, responseBody, reasonPhrase)) {
+    companion object {
+      private fun formatMessage(code: Int, responseBody: String, reasonPhrase: String): String {
+        // Try to extract error message from JSON response: { "error": "message" }
+        try {
+          val json = org.json.JSONObject(responseBody)
+          val errorMessage = json.optString("error", null)
+          if (!errorMessage.isNullOrBlank()) {
+            return errorMessage
+          }
+        } catch (_: Exception) {
+          // Not valid JSON, fall through
+        }
+        // Fall back to HTTP reason phrase
+        return reasonPhrase
+      }
+    }
+  }
+}

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")
+  }
+}