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

package/android/src/test/java/com/audiobrowser/http/RequestConfigBuilderTest.kt

@@ -0,0 +1,240 @@
+package com.audiobrowser.http
+
+import com.margelo.nitro.audiobrowser.HttpMethod
+import com.margelo.nitro.audiobrowser.RequestConfig
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.*
+import org.junit.Test
+
+class RequestConfigBuilderTest {
+
+  @Test
+  fun `buildHttpRequest should use defaults when config fields are null`() = runTest {
+    val config =
+      RequestConfig(
+        method = null,
+        path = null,
+        baseUrl = null,
+        headers = null,
+        query = null,
+        body = null,
+        contentType = null,
+        userAgent = null,
+      )
+
+    val result = RequestConfigBuilder.buildHttpRequest(config)
+
+    assertEquals("GET", result.method)
+    assertEquals("", result.url)
+    assertEquals(HttpClient.DEFAULT_USER_AGENT, result.userAgent)
+    assertEquals(HttpClient.DEFAULT_CONTENT_TYPE, result.contentType)
+    assertNull(result.body)
+  }
+
+  @Test
+  fun `buildHttpRequest should build correct URL with all components`() = runTest {
+    val config =
+      RequestConfig(
+        method = HttpMethod.GET,
+        path = "/albums",
+        baseUrl = "https://api.example.com",
+        headers = mapOf("Authorization" to "Bearer token"),
+        query = mapOf("limit" to "20", "offset" to "0"),
+        body = null,
+        contentType = "application/json",
+        userAgent = "MyApp/1.0",
+      )
+
+    val result = RequestConfigBuilder.buildHttpRequest(config)
+
+    assertEquals("GET", result.method)
+    assertEquals("https://api.example.com/albums?limit=20&offset=0", result.url)
+    assertEquals("Bearer token", result.headers?.get("Authorization"))
+    assertEquals("MyApp/1.0", result.userAgent)
+    assertEquals("application/json", result.contentType)
+  }
+
+  @Test
+  fun `buildHttpRequest should handle POST with body`() = runTest {
+    val config =
+      RequestConfig(
+        method = HttpMethod.POST,
+        path = "/users",
+        baseUrl = "https://api.example.com",
+        headers = null,
+        query = null,
+        body = """{"name":"John"}""",
+        contentType = "application/json",
+        userAgent = null,
+      )
+
+    val result = RequestConfigBuilder.buildHttpRequest(config)
+
+    assertEquals("POST", result.method)
+    assertEquals("""{"name":"John"}""", result.body)
+    assertEquals("application/json", result.contentType)
+  }
+
+  @Test
+  fun `mergeConfig should override base with specific values`() {
+    val base =
+      RequestConfig(
+        method = HttpMethod.GET,
+        path = "/base",
+        baseUrl = "https://base.com",
+        headers = mapOf("Base" to "value"),
+        query = mapOf("base" to "param"),
+        body = null,
+        contentType = "text/plain",
+        userAgent = "BaseAgent",
+      )
+
+    val override =
+      RequestConfig(
+        method = HttpMethod.POST,
+        path = "/override",
+        baseUrl = "https://override.com",
+        headers = mapOf("Override" to "value"),
+        query = mapOf("override" to "param"),
+        body = "body",
+        contentType = "application/json",
+        userAgent = "OverrideAgent",
+      )
+
+    val result = RequestConfigBuilder.mergeConfig(base, override)
+
+    assertEquals(HttpMethod.POST, result.method)
+    assertEquals("/override", result.path)
+    assertEquals("https://override.com", result.baseUrl)
+    assertEquals("body", result.body)
+    assertEquals("application/json", result.contentType)
+    assertEquals("OverrideAgent", result.userAgent)
+  }
+
+  @Test
+  fun `mergeConfig should preserve base values when override is null`() {
+    val base =
+      RequestConfig(
+        method = HttpMethod.PUT,
+        path = "/base",
+        baseUrl = "https://base.com",
+        headers = mapOf("Base" to "value"),
+        query = mapOf("base" to "param"),
+        body = "base-body",
+        contentType = "text/plain",
+        userAgent = "BaseAgent",
+      )
+
+    val override =
+      RequestConfig(
+        method = null,
+        path = null,
+        baseUrl = null,
+        headers = null,
+        query = null,
+        body = null,
+        contentType = null,
+        userAgent = null,
+      )
+
+    val result = RequestConfigBuilder.mergeConfig(base, override)
+
+    assertEquals(HttpMethod.PUT, result.method)
+    assertEquals("/base", result.path)
+    assertEquals("https://base.com", result.baseUrl)
+    assertEquals("base-body", result.body)
+    assertEquals("text/plain", result.contentType)
+    assertEquals("BaseAgent", result.userAgent)
+  }
+
+  @Test
+  fun `mergeConfig should merge headers and query parameters`() {
+    val base =
+      RequestConfig(
+        method = null,
+        path = null,
+        baseUrl = null,
+        headers = mapOf("Base-Header" to "base-value", "Shared" to "base-shared"),
+        query = mapOf("base-query" to "base-value", "shared" to "base-shared"),
+        body = null,
+        contentType = null,
+        userAgent = null,
+      )
+
+    val override =
+      RequestConfig(
+        method = null,
+        path = null,
+        baseUrl = null,
+        headers = mapOf("Override-Header" to "override-value", "Shared" to "override-shared"),
+        query = mapOf("override-query" to "override-value", "shared" to "override-shared"),
+        body = null,
+        contentType = null,
+        userAgent = null,
+      )
+
+    val result = RequestConfigBuilder.mergeConfig(base, override)
+
+    // Headers should be merged with override winning
+    assertEquals("base-value", result.headers!!["Base-Header"])
+    assertEquals("override-value", result.headers!!["Override-Header"])
+    assertEquals("override-shared", result.headers!!["Shared"]) // Override wins
+
+    // Query should be merged with override winning
+    assertEquals("base-value", result.query!!["base-query"])
+    assertEquals("override-value", result.query!!["override-query"])
+    assertEquals("override-shared", result.query!!["shared"]) // Override wins
+  }
+
+  @Test
+  fun `buildUrl should handle path normalization`() = runTest {
+    val configWithSlash =
+      RequestConfig(
+        method = null,
+        path = "/albums",
+        baseUrl = "https://api.example.com",
+        headers = null,
+        query = null,
+        body = null,
+        contentType = null,
+        userAgent = null,
+      )
+
+    val configWithoutSlash =
+      RequestConfig(
+        method = null,
+        path = "albums", // No leading slash
+        baseUrl = "https://api.example.com",
+        headers = null,
+        query = null,
+        body = null,
+        contentType = null,
+        userAgent = null,
+      )
+
+    val result1 = RequestConfigBuilder.buildHttpRequest(configWithSlash)
+    val result2 = RequestConfigBuilder.buildHttpRequest(configWithoutSlash)
+
+    assertEquals("https://api.example.com/albums", result1.url)
+    assertEquals("https://api.example.com/albums", result2.url) // Should add slash
+  }
+
+  @Test
+  fun `buildUrl should handle empty query parameters`() = runTest {
+    val config =
+      RequestConfig(
+        method = null,
+        path = "/albums",
+        baseUrl = "https://api.example.com",
+        headers = null,
+        query = emptyMap(), // Empty map
+        body = null,
+        contentType = null,
+        userAgent = null,
+      )
+
+    val result = RequestConfigBuilder.buildHttpRequest(config)
+
+    assertEquals("https://api.example.com/albums", result.url) // No query string
+  }
+}

package/android/src/test/java/com/audiobrowser/player/PlaybackProgressUpdateManagerTest.kt

@@ -0,0 +1,146 @@
+package com.audiobrowser.player
+
+import com.margelo.nitro.audiobrowser.PlaybackState
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.advanceTimeBy
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class PlaybackProgressUpdateManagerTest {
+
+  @Before
+  fun setup() {
+    Dispatchers.setMain(UnconfinedTestDispatcher())
+  }
+
+  @After
+  fun tearDown() {
+    Dispatchers.resetMain()
+  }
+
+  @Test
+  fun `setUpdateInterval before playback does not emit events`() = runTest {
+    var callCount = 0
+    val manager = PlaybackProgressUpdateManager { callCount++ }
+
+    manager.setUpdateInterval(0.1)
+
+    advanceTimeBy(500)
+    assertEquals(0, callCount)
+    manager.stop()
+  }
+
+  @Test
+  fun `setUpdateInterval while running restarts with new interval`() = runTest {
+    var callCount = 0
+    val manager = PlaybackProgressUpdateManager { callCount++ }
+
+    manager.setUpdateInterval(0.1)
+    manager.start()
+
+    advanceTimeBy(350)
+    assertTrue("Expected events while running, got $callCount", callCount > 0)
+
+    val countBefore = callCount
+    manager.setUpdateInterval(0.2) // different value — should restart
+    advanceTimeBy(500)
+    assertTrue("Expected more events after interval change", callCount > countBefore)
+
+    manager.stop()
+  }
+
+  @Test
+  fun `start begins emitting, stop ceases emitting`() = runTest {
+    var callCount = 0
+    val manager = PlaybackProgressUpdateManager { callCount++ }
+
+    manager.setUpdateInterval(0.1)
+    manager.start()
+
+    advanceTimeBy(350)
+    assertTrue("Expected events after start", callCount > 0)
+
+    manager.stop()
+    val countAfterStop = callCount
+
+    advanceTimeBy(500)
+    assertEquals(countAfterStop, callCount)
+  }
+
+  @Test
+  fun `start without interval does nothing`() = runTest {
+    var callCount = 0
+    val manager = PlaybackProgressUpdateManager { callCount++ }
+
+    manager.start()
+
+    advanceTimeBy(500)
+    assertEquals(0, callCount)
+  }
+
+  @Test
+  fun `playing state starts timer, paused stops it`() = runTest {
+    var callCount = 0
+    val manager = PlaybackProgressUpdateManager { callCount++ }
+
+    manager.setUpdateInterval(0.1)
+    manager.onPlaybackStateChanged(PlaybackState.PLAYING)
+
+    advanceTimeBy(350)
+    assertTrue("Expected events when playing", callCount > 0)
+
+    manager.onPlaybackStateChanged(PlaybackState.PAUSED)
+    val countAfterPause = callCount
+
+    advanceTimeBy(500)
+    assertEquals(countAfterPause, callCount)
+  }
+
+  @Test
+  fun `loading and buffering states also start timer`() = runTest {
+    var callCount = 0
+    val manager = PlaybackProgressUpdateManager { callCount++ }
+
+    manager.setUpdateInterval(0.1)
+
+    manager.onPlaybackStateChanged(PlaybackState.LOADING)
+    advanceTimeBy(350)
+    assertTrue("Expected events when loading", callCount > 0)
+
+    manager.onPlaybackStateChanged(PlaybackState.STOPPED)
+    val afterStop = callCount
+
+    manager.onPlaybackStateChanged(PlaybackState.BUFFERING)
+    advanceTimeBy(350)
+    assertTrue("Expected events when buffering", callCount > afterStop)
+
+    manager.stop()
+  }
+
+  @Test
+  fun `setting nil interval stops timer`() = runTest {
+    var callCount = 0
+    val manager = PlaybackProgressUpdateManager { callCount++ }
+
+    manager.setUpdateInterval(0.1)
+    manager.start()
+
+    advanceTimeBy(350)
+    assertTrue("Expected events before clearing", callCount > 0)
+
+    manager.setUpdateInterval(null)
+    val afterNil = callCount
+
+    advanceTimeBy(500)
+    assertEquals(afterNil, callCount)
+  }
+}

package/android/src/test/resources/robolectric.properties

@@ -0,0 +1 @@
+sdk=34

package/ios/Bridge.h

@@ -0,0 +1,8 @@
+//
+//  Bridge.h
+//  audio-browser
+//
+//  Created by puckey on 10/12/2025
+//
+
+#pragma once

package/ios/Browser/BrowserConfig.swift

@@ -0,0 +1,111 @@
+import Foundation
+import NitroModules
+import os.log
+
+/// Flattened browser configuration (matches Kotlin BrowserConfig).
+///
+/// This is a convenience wrapper around NativeBrowserConfiguration that
+/// provides easier access to configuration properties.
+struct BrowserConfig {
+  /// Base HTTP request configuration
+  let request: TransformableRequestConfig?
+
+  /// Media URL transformation configuration
+  let media: MediaRequestConfig?
+
+  /// Artwork URL transformation configuration
+  let artwork: ArtworkRequestConfig?
+
+  /// Routes as array with flattened entries
+  /// Includes __tabs__, __search__, and __default__ special routes
+  let routes: [NativeRouteEntry]?
+
+  /// Behavior: single track playback vs queue expansion
+  let singleTrack: Bool
+
+  /// Behavior: show offline error in Android Auto controller
+  let androidControllerOfflineError: Bool
+
+  // MARK: - CarPlay Options
+
+  /// Enable the "Up Next" button on CarPlay Now Playing screen
+  let carPlayUpNextButton: Bool
+
+  /// Custom buttons for CarPlay Now Playing screen (e.g., .repeat, .favorite)
+  let carPlayNowPlayingButtons: [CarPlayNowPlayingButton]
+
+  /// Custom handler for track load events (overrides default load behavior)
+  let handleTrackLoad: ((_ event: TrackLoadEvent) -> Promise<Promise<Void>>)?
+
+  /// Callback to customize navigation error display (for i18n)
+  /// Used by CarPlay and available via `useFormattedNavigationError()` for app UI.
+  let formatNavigationError: ((_ params: FormatNavigationErrorParams) -> Promise<FormattedNavigationError?>)?
+
+  init(
+    request: TransformableRequestConfig? = nil,
+    media: MediaRequestConfig? = nil,
+    artwork: ArtworkRequestConfig? = nil,
+    routes: [NativeRouteEntry]? = nil,
+    singleTrack: Bool = false,
+    handleTrackLoad: ((_ event: TrackLoadEvent) -> Promise<Promise<Void>>)? = nil,
+    androidControllerOfflineError: Bool = true,
+    carPlayUpNextButton: Bool = true,
+    carPlayNowPlayingButtons: [CarPlayNowPlayingButton] = [],
+    formatNavigationError: ((_ params: FormatNavigationErrorParams) -> Promise<FormattedNavigationError?>)? = nil,
+  ) {
+    self.request = request
+    self.media = media
+    self.artwork = artwork
+    self.routes = routes
+    self.singleTrack = singleTrack
+    self.handleTrackLoad = handleTrackLoad
+    self.androidControllerOfflineError = androidControllerOfflineError
+    self.carPlayUpNextButton = carPlayUpNextButton
+    self.carPlayNowPlayingButtons = carPlayNowPlayingButtons
+    self.formatNavigationError = formatNavigationError
+  }
+
+  /// Create from NativeBrowserConfiguration
+  init(from config: NativeBrowserConfiguration) {
+    request = config.request
+    media = config.media
+    artwork = config.artwork
+    routes = config.routes
+    singleTrack = config.singleTrack ?? false
+    handleTrackLoad = config.handleTrackLoad
+    androidControllerOfflineError = config.androidControllerOfflineError ?? true
+    carPlayUpNextButton = config.carPlayUpNextButton ?? true
+    carPlayNowPlayingButtons = config.carPlayNowPlayingButtons ?? []
+    formatNavigationError = config.formatNavigationError
+  }
+
+  // MARK: - Track Load Handler
+
+  private static let logger = Logger(subsystem: "com.audiobrowser", category: "BrowserConfig")
+
+  /// Awaits the handleTrackLoad callback using the double-Promise pattern required by Nitro.
+  ///
+  /// Nitro wraps value-returning JS callbacks in Promise<T> for thread safety, so a JS callback
+  /// returning Promise<void> becomes Promise<Promise<Void>> on the native side. Both layers
+  /// must be awaited to properly wait for the JS work to complete.
+  ///
+  /// - Returns: true if the handler was present and invoked, false if not configured
+  func awaitTrackLoadHandler(event: TrackLoadEvent) async -> Bool {
+    guard let handler = handleTrackLoad else { return false }
+    do {
+      // MainActor: Nitro bridge call must be on main thread (C++ noexcept)
+      nonisolated(unsafe) let _handler = handler
+      nonisolated(unsafe) let _event = event
+      let outerPromise = await MainActor.run { _handler(_event) }
+      let innerPromise = try await outerPromise.await()
+      try await innerPromise.await()
+    } catch {
+      Self.logger.error("handleTrackLoad failed: \(error.localizedDescription)")
+    }
+    return true
+  }
+}
+
+// MARK: - NativeRouteEntry + RouteEntry conformance
+
+extension NativeRouteEntry: RouteEntry {}