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

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

@@ -0,0 +1,134 @@
+package com.audiobrowser.browser
+
+import com.margelo.nitro.audiobrowser.CarPlaySiriListButtonPosition
+import com.margelo.nitro.audiobrowser.ImageRowItem
+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 JsonImageRowItem(
+  val url: String? = null,
+  val artwork: String? = null,
+  val title: String,
+)
+
+@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,
+  val carPlaySiriListButton: String? = 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,
+  val imageRow: List<JsonImageRowItem>? = null,
+)
+
+/** Convert JSON models to Nitro types */
+private fun String?.toTrackStyle(): TrackStyle? {
+  return when (this?.lowercase()) {
+    "list" -> TrackStyle.LIST
+    "grid" -> TrackStyle.GRID
+    else -> null
+  }
+}
+
+private fun String?.toCarPlaySiriListButtonPosition(): CarPlaySiriListButtonPosition? {
+  return when (this?.lowercase()) {
+    "top" -> CarPlaySiriListButtonPosition.TOP
+    "bottom" -> CarPlaySiriListButtonPosition.BOTTOM
+    else -> null
+  }
+}
+
+private fun JsonImageRowItem.toNitro(): ImageRowItem {
+  return ImageRowItem(
+    url = url,
+    artwork = artwork,
+    artworkSource = null,
+    title = title,
+  )
+}
+
+fun JsonResolvedTrack.toNitro(): ResolvedTrack {
+  return ResolvedTrack(
+    url = url,
+    children = children?.map { it.toNitro() }?.toTypedArray(),
+    carPlaySiriListButton = carPlaySiriListButton.toCarPlaySiriListButtonPosition(),
+    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,
+    imageRow = null,
+  )
+}
+
+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,
+    imageRow = imageRow?.map { it.toNitro() }?.toTypedArray(),
+  )
+}

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,154 @@
+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
+        }
+        val (constCount, paramCount, wildcardCount) =
+          updateSegmentCounts(
+            patternSegments[i],
+            constantSegments,
+            parameterSegments,
+            wildcardSegments,
+          )
+        constantSegments = constCount
+        parameterSegments = paramCount
+        wildcardSegments = wildcardCount
+      }
+
+      // 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/browser/TrackLoadHandler.kt

@@ -0,0 +1,45 @@
+package com.audiobrowser.browser
+
+import com.margelo.nitro.audiobrowser.TrackLoadEvent
+import com.margelo.nitro.audiobrowser.Track
+import com.margelo.nitro.core.Promise
+import timber.log.Timber
+
+/**
+ * Handles track load interception using the double-Promise pattern required by Nitro.
+ *
+ * If the handler is present, awaits it and returns [intercepted]. Otherwise runs [default].
+ *
+ * Nitro wraps value-returning JS callbacks in Promise<T> for thread safety, so a JS callback
+ * returning Promise<void> becomes Promise<Promise<Unit>> on the native side. Both layers
+ * must be awaited to properly wait for the JS work to complete.
+ *
+ * @param handler The handleTrackLoad callback from NativeBrowserConfiguration, or null
+ * @param track The track being loaded
+ * @param queue The resolved queue of tracks
+ * @param startIndex The index of the track in the queue
+ * @param intercepted Value to return when the handler is present and invoked
+ * @param defaultBehavior Value to return when no handler is configured
+ * @return Result of [intercepted] if handler was invoked, result of [defaultBehavior] otherwise
+ */
+suspend fun <T> handleTrackLoad(
+  handler: ((event: TrackLoadEvent) -> Promise<Promise<Unit>>)?,
+  track: Track,
+  queue: Array<Track>,
+  startIndex: Double,
+  intercepted: () -> T,
+  defaultBehavior: suspend () -> T,
+): T {
+  if (handler != null) {
+    val event = TrackLoadEvent(track, queue, startIndex)
+    try {
+      val outerPromise = handler(event)
+      val innerPromise = outerPromise.await()
+      innerPromise.await()
+    } catch (e: Exception) {
+      Timber.e(e, "handleTrackLoad failed")
+    }
+    return intercepted()
+  }
+  return defaultBehavior()
+}

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