@5stones/react-native-audio-browser 0.1.6 → 0.3.0

package/ios/Player/RetryManager.swift

@@ -12,39 +12,31 @@ import os.log
 class RetryManager {
   private let logger = Logger(subsystem: "com.audiobrowser", category: "RetryManager")
 
-  /// Retry policy configuration
   enum Policy {
     case disabled
     case infinite
     case limited(maxRetries: Int)
   }
 
-  /// Default maximum duration to keep retrying before giving up (in milliseconds).
   private static let defaultMaxRetryDurationMs: Double = 120_000 // 2 minutes
 
-  /// Maximum duration to keep retrying before giving up (in seconds).
-  /// This prevents surprising playback resumption after long periods offline.
+  /// Prevents surprising playback resumption after long periods offline.
   private var maxRetryDuration: TimeInterval = defaultMaxRetryDurationMs / 1000
 
   private var policy: Policy = .disabled
   private var attemptCount = 0
   private var firstRetryTime: Date?
 
-  /// Network monitor for accelerating retries when connectivity is restored
   weak var networkMonitor: NetworkMonitor?
-
-  /// Flag to track if we're waiting for network (for cleanup on reset)
   private var isWaitingForNetwork = false
+  /// Invalidates in-flight retries when reset() is called (e.g. track change)
+  private var generation: Int = 0
 
-  /// Callback to check if we should retry (typically checks playWhenReady)
   var shouldRetry: () -> Bool = { true }
-
-  /// Callback to trigger reload
   var onRetry: ((Bool) -> Void)?
 
   // MARK: - Configuration
 
-  /// Updates the retry policy from the Nitro config type
   func updatePolicy(from config: Variant_Bool_RetryConfig?) {
     guard let config else {
       policy = .disabled
@@ -61,7 +53,6 @@ class RetryManager {
     case let .second(retryConfig):
       let maxRetries = Int(retryConfig.maxRetries)
       policy = .limited(maxRetries: maxRetries)
-      // Use configured duration or default
       let durationMs = retryConfig.maxRetryDurationMs ?? Self.defaultMaxRetryDurationMs
       maxRetryDuration = durationMs / 1000
       logger.debug("Retry policy: limited to \(maxRetries) retries, max duration \(self.maxRetryDuration)s")
@@ -70,9 +61,7 @@ class RetryManager {
 
   // MARK: - Exponential Backoff
 
-  /// Calculates delay for current attempt using exponential backoff.
   /// Delays: 1s -> 1.5s -> 2.3s -> 3.4s -> 5s (capped)
-  /// Returns delay in seconds.
   private func calculateDelaySeconds() -> Double {
     let baseDelay = 1.0
     let multiplier = 1.5
@@ -83,8 +72,6 @@ class RetryManager {
 
   // MARK: - Error Classification
 
-  /// Classifies whether an error is retryable or permanent.
-  /// Only clearly transient network errors are retried.
   func isRetryable(_ error: Error?) -> Bool {
     guard let error else { return false }
 
@@ -113,34 +100,25 @@ class RetryManager {
 
   // MARK: - Retry Management
 
-  /// Resets retry count. Call when track changes.
   func reset() {
     attemptCount = 0
     firstRetryTime = nil
     isWaitingForNetwork = false
-    logger.debug("Retry count reset")
+    generation += 1
+    logger.debug("Retry count reset (generation \(self.generation))")
   }
 
-  /// Attempts a retry if policy allows.
-  /// Returns true if retry was scheduled, false if max retries exceeded or disabled.
-  ///
-  /// If a network monitor is configured and the device is offline, the retry will
-  /// trigger immediately when connectivity is restored instead of waiting for the
-  /// full backoff delay.
   func attemptRetry(startFromCurrentTime: Bool) async -> Bool {
-    // Check if retry is disabled
     if case .disabled = policy {
       logger.debug("Retry disabled, not retrying")
       return false
     }
 
-    // Check if we should retry (e.g., playWhenReady is true)
     guard shouldRetry() else {
       logger.debug("shouldRetry returned false, not retrying")
       return false
     }
 
-    // Check max retries for limited policy
     if case let .limited(maxRetries) = policy {
       if attemptCount >= maxRetries {
         logger.info("Max retries (\(maxRetries)) exceeded, giving up")
@@ -148,7 +126,6 @@ class RetryManager {
       }
     }
 
-    // Track when we started retrying
     if firstRetryTime == nil {
       firstRetryTime = Date()
     }
@@ -162,10 +139,9 @@ class RetryManager {
       }
     }
 
-    // Schedule retry with exponential backoff
     let delaySeconds = calculateDelaySeconds()
-    attemptCount += 1
-    logger.info("Scheduling retry #\(self.attemptCount) after \(delaySeconds)s")
+    let currentGeneration = generation
+    logger.info("Scheduling retry after \(delaySeconds)s")
 
     // Race between: backoff delay OR network restored (if offline)
     let waitCancelled = await waitForDelayOrNetworkRestored(delaySeconds: delaySeconds)
@@ -175,13 +151,18 @@ class RetryManager {
       return false
     }
 
-    // Double-check we should still retry after the delay
+    // Check if reset() was called while we were waiting
+    guard generation == currentGeneration else {
+      logger.debug("Retry invalidated by reset (generation changed)")
+      return false
+    }
+
     guard shouldRetry() else {
       logger.debug("shouldRetry returned false after delay, cancelling retry")
       return false
     }
 
-    // Check duration again after waiting (in case we waited a long time for network)
+    // Re-check duration — we may have waited a long time for network restoration
     if let startTime = firstRetryTime {
       let elapsed = Date().timeIntervalSince(startTime)
       if elapsed >= maxRetryDuration {
@@ -190,7 +171,7 @@ class RetryManager {
       }
     }
 
-    // Trigger the retry
+    attemptCount += 1
     logger.info("Executing retry #\(self.attemptCount)")
     onRetry?(startFromCurrentTime)
     return true
@@ -198,12 +179,10 @@ class RetryManager {
 
   // MARK: - Network-Aware Waiting
 
-  /// Waits for either the backoff delay to elapse OR network to be restored (if offline).
   /// Returns true if cancelled, false if ready to retry.
   private func waitForDelayOrNetworkRestored(delaySeconds: Double) async -> Bool {
     let isOffline = !(networkMonitor?.isOnline ?? true)
 
-    // If online or no monitor, just do a simple sleep
     guard isOffline, let monitor = networkMonitor else {
       do {
         let nanoseconds = UInt64(delaySeconds * 1_000_000_000)
@@ -216,66 +195,48 @@ class RetryManager {
 
     logger.debug("Device is offline, will retry immediately when connectivity is restored")
 
-    // Race between sleep and network restoration
     return await withTaskGroup(of: Bool.self, returning: Bool.self) { group in
-      // Task 1: Sleep for backoff delay
       group.addTask {
         do {
           let nanoseconds = UInt64(delaySeconds * 1_000_000_000)
           try await Task.sleep(nanoseconds: nanoseconds)
-          return false // Sleep completed, ready to retry
+          return false
         } catch {
-          return true // Sleep cancelled
+          return true
         }
       }
 
-      // Task 2: Wait for network restoration
       group.addTask { [weak self] in
         await self?.waitForNetworkRestored(monitor: monitor) ?? true
       }
 
-      // Return when either completes
       let result = await group.next() ?? true
       group.cancelAll()
       return result
     }
   }
 
-  /// Waits until network connectivity is restored.
   /// Returns false when network is restored, true if cancelled.
   @MainActor
   private func waitForNetworkRestored(monitor: NetworkMonitor) async -> Bool {
-    // If already online, return immediately
     if monitor.isOnline {
       return false
     }
 
     isWaitingForNetwork = true
+    defer { isWaitingForNetwork = false }
 
-    // Set up listener for network restoration
-    let previousHandler = monitor.onChanged
-
-    // Use withCheckedContinuation to wait for network
-    let result: Bool = await withCheckedContinuation { continuation in
-      var hasResumed = false
+    logger.debug("Device is offline, polling for network restoration")
 
-      monitor.onChanged = { [weak self] isOnline in
-        // Always call previous handler to maintain JS callback
-        previousHandler?(isOnline)
-
-        guard !hasResumed else { return }
-
-        if isOnline {
-          hasResumed = true
-          self?.logger.info("Network restored, accelerating retry")
-          // Restore original handler
-          monitor.onChanged = previousHandler
-          continuation.resume(returning: false) // Network restored, ready to retry
-        }
+    while !monitor.isOnline {
+      do {
+        try await Task.sleep(nanoseconds: 500_000_000) // 0.5s poll
+      } catch {
+        return true // Task cancelled
       }
     }
 
-    isWaitingForNetwork = false
-    return result
+    logger.info("Network restored, accelerating retry")
+    return false
   }
 }

package/ios/Player/SleepTimerManager.swift

@@ -39,7 +39,7 @@ class SleepTimerManager {
   var onComplete: (() -> Void)?
 
   /// Callback invoked when the sleep timer state changes
-  var onChanged: ((SleepTimerState?) -> Void)?
+  var onChanged: ((SleepTimerState) -> Void)?
 
   // MARK: - Public Methods
 
@@ -52,7 +52,7 @@ class SleepTimerManager {
     if !hasSleepTimer { return false }
     sleepTimerTime = -1
     willSleepWhenCurrentItemReachesEnd = false
-    onChanged?(nil)
+    onChanged?(.first(NullType.null))
     return true
   }
 
@@ -88,7 +88,7 @@ class SleepTimerManager {
     sleepTimerJob = job
     sleepTimerTime = Date().timeIntervalSince1970 + seconds
     DispatchQueue.main.asyncAfter(deadline: .now() + seconds, execute: job)
-    onChanged?(get())
+    if let state = get() { onChanged?(state) }
   }
 
   /// Sets the timer to stop playback when the current track ends.
@@ -96,16 +96,14 @@ class SleepTimerManager {
     assertMainThread()
     let changed = !willSleepWhenCurrentItemReachesEnd
     willSleepWhenCurrentItemReachesEnd = true
-    if changed {
-      onChanged?(get())
-    }
+    if changed, let state = get() { onChanged?(state) }
   }
 
   /// Called when the current track changes. Resets end-of-track timer.
   func onTrackChanged() {
     if willSleepWhenCurrentItemReachesEnd {
       willSleepWhenCurrentItemReachesEnd = false
-      onChanged?(nil)
+      onChanged?(.first(NullType.null))
     }
   }
 
@@ -127,7 +125,7 @@ class SleepTimerManager {
   private func complete() {
     sleepTimerTime = -1
     willSleepWhenCurrentItemReachesEnd = false
-    onChanged?(nil)
+    onChanged?(.first(NullType.null))
     onComplete?()
   }
 

package/ios/RemoteCommand/RemoteCommandController.swift

@@ -107,6 +107,12 @@ class RemoteCommandController {
     commands.forEach { self.disable(command: $0) }
   }
 
+  /// Disables all currently enabled remote commands and removes their targets.
+  func disableAll() {
+    disable(commands: enabledCommands)
+    enabledCommands.removeAll()
+  }
+
   /**
    Enables a remote command by setting it up with the provided handler.
    Removes any existing target before adding the new one to prevent duplicate handlers.

package/ios/Tests/SimpleRouterTests.swift

@@ -0,0 +1,139 @@
+import Testing
+
+@testable import AudioBrowserTestable
+
+private struct TestRoute: RouteEntry {
+  let path: String
+}
+
+private func match(_ path: String, _ patterns: [String]) -> (route: TestRoute, match: RouteMatch)? {
+  let router = SimpleRouter()
+  let routes = patterns.map { TestRoute(path: $0) }
+  return router.findBestMatch(path: path, routes: routes)
+}
+
+// MARK: - exact matches
+
+@Test func matchesASimplePath() {
+  let result = match("/artists", ["/artists"])
+  #expect(result != nil)
+  #expect(result!.route.path == "/artists")
+  #expect(result!.match.params.isEmpty)
+}
+
+@Test func matchesMultiSegmentPaths() {
+  let result = match("/artists/top/rated", ["/artists/top/rated"])
+  #expect(result != nil)
+  #expect(result!.route.path == "/artists/top/rated")
+}
+
+@Test func returnsNilWhenNoRouteMatches() {
+  #expect(match("/unknown", ["/artists"]) == nil)
+}
+
+@Test func returnsNilWhenSegmentCountDiffers() {
+  #expect(match("/artists/123", ["/artists"]) == nil)
+}
+
+@Test func returnsNilWhenRoutesAreEmpty() {
+  #expect(match("/artists", []) == nil)
+}
+
+@Test func treatsTrailingSlashesTheSameAsWithout() {
+  let result = match("/artists/", ["/artists"])
+  #expect(result != nil)
+  #expect(result!.route.path == "/artists")
+}
+
+// MARK: - parameter extraction
+
+@Test func extractsASingleParameter() {
+  let result = match("/artists/123", ["/artists/{id}"])
+  #expect(result != nil)
+  #expect(result!.match.params == ["id": "123"])
+}
+
+@Test func extractsMultipleParameters() {
+  let result = match("/artists/123/albums/456", ["/artists/{artistId}/albums/{albumId}"])
+  #expect(result != nil)
+  #expect(result!.match.params == ["artistId": "123", "albumId": "456"])
+}
+
+// MARK: - single wildcard
+
+@Test func matchesAnySingleSegment() {
+  #expect(match("/artists/anything", ["/artists/*"]) != nil)
+}
+
+@Test func doesNotExtractWildcardValueIntoParams() {
+  let result = match("/artists/anything", ["/artists/*"])
+  #expect(result!.match.params.isEmpty)
+}
+
+// MARK: - tail wildcard
+
+@Test func matchesWithNoRemainingSegmentsAndHasNoTailParam() {
+  let result = match("/files", ["/files/**"])
+  #expect(result != nil)
+  #expect(result!.match.params.isEmpty)
+}
+
+@Test func matchesWithRemainingSegmentsAndCapturesTail() {
+  let result = match("/files/a/b/c", ["/files/**"])
+  #expect(result != nil)
+  #expect(result!.match.params == ["tail": "a/b/c"])
+}
+
+@Test func matchesWithASingleRemainingSegment() {
+  let result = match("/files/readme.txt", ["/files/**"])
+  #expect(result != nil)
+  #expect(result!.match.params == ["tail": "readme.txt"])
+}
+
+@Test func returnsNilWhenPrefixSegmentsDoNotMatch() {
+  #expect(match("/other/a/b", ["/files/**"]) == nil)
+}
+
+@Test func worksWithParametersBeforeTailWildcard() {
+  let result = match("/api/v1/users/list", ["/api/{version}/**"])
+  #expect(result != nil)
+  #expect(result!.match.params == ["version": "v1", "tail": "users/list"])
+}
+
+@Test func matchesAnyPathWithBareTailWildcardPattern() {
+  let result = match("/any/path/here", ["/**"])
+  #expect(result != nil)
+  #expect(result!.match.params == ["tail": "any/path/here"])
+}
+
+// MARK: - specificity
+
+@Test func prefersConstantSegmentsOverParameters() {
+  let result = match("/artists/top", ["/artists/{id}", "/artists/top"])
+  #expect(result!.route.path == "/artists/top")
+}
+
+@Test func prefersParametersOverWildcards() {
+  let result = match("/artists/123", ["/artists/*", "/artists/{id}"])
+  #expect(result!.route.path == "/artists/{id}")
+}
+
+@Test func prefersExactMatchOverTailWildcard() {
+  let result = match("/api/v1", ["/api/**", "/api/{version}"])
+  #expect(result!.route.path == "/api/{version}")
+}
+
+@Test func computesCorrectSpecificityForTailWildcardPatterns() {
+  // Regression test for issue #27: specificity must account for
+  // segment types before the ** wildcard.
+  let result = match("/api/v1/users", ["/api/v1/**"])
+  // constant "api" (1000) + constant "v1" (1000) + tail(1) + 3 segments = 2004
+  #expect(result!.match.specificity == 2004)
+}
+
+@Test func prefersConstantPrefixOverParameterPrefixInTailWildcards() {
+  // Second part of issue #27: with correct specificity, the constant
+  // prefix should beat the parameter prefix.
+  let result = match("/api/v1/users", ["/api/{version}/**", "/api/v1/**"])
+  #expect(result!.route.path == "/api/v1/**")
+}