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

package/ios/Extension/Track+AVPlayer.swift

@@ -26,26 +26,25 @@ extension Track {
   /// Uses Kingfisher for caching and efficient image loading
   func loadArtwork() async -> UIImage? {
     // Try artworkSource first (has more detailed config), then fall back to artwork string
+    // Skip SF Symbol strings - those require SFSymbolRenderer and can't be loaded as URLs
     let artworkUrlString: String?
     let artworkHeaders: [String: String]?
 
     if let source = artworkSource {
       artworkUrlString = source.uri
       artworkHeaders = source.headers
-    } else {
+    } else if let artwork, !SFSymbolRenderer.isSFSymbol(artwork) {
       artworkUrlString = artwork
       artworkHeaders = nil
+    } else {
+      artworkUrlString = nil
+      artworkHeaders = nil
     }
 
     guard let urlString = artworkUrlString, let url = URL(string: urlString) else {
       return nil
     }
 
-    if url.isFileURL {
-      return UIImage(contentsOfFile: url.path)
-    }
-
-    // Build Kingfisher options with headers if provided
     var options: KingfisherOptionsInfo = []
     if let headers = artworkHeaders, !headers.isEmpty {
       let modifier = AnyModifier { request in

package/ios/Extension/TrackMetadata+AVFoundation.swift

@@ -122,7 +122,7 @@ extension TrackMetadata {
       mediaType: nil,
       creationDate: creationDate,
       creationYear: creationYear,
-      url: nil
+      url: nil,
     )
   }
 }

package/ios/HybridAudioBrowser.swift

@@ -48,12 +48,6 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
     }
   }
 
-  // MARK: - Internal Callbacks (for CarPlay/external controllers)
-
-  /// Called when notifyContentChanged is invoked, allowing CarPlay to refresh its templates.
-  /// Set by CarPlayController during setup.
-  var onExternalContentChanged: ((String) -> Void)?
-
   // MARK: - Multi-Listener Emitters
 
   /// Emitters allow multiple listeners for each event type, avoiding callback hijacking
@@ -114,8 +108,8 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
 
   public var configuration: NativeBrowserConfiguration = .init(
     path: nil, request: nil, media: nil, artwork: nil, routes: nil,
-    singleTrack: nil, androidControllerOfflineError: nil, carPlayUpNextButton: nil,
-    carPlayNowPlayingButtons: nil, formatNavigationError: nil,
+    singleTrack: nil, handleTrackLoad: nil, androidControllerOfflineError: nil,
+    carPlayUpNextButton: nil, carPlayNowPlayingButtons: nil, formatNavigationError: nil,
   ) {
     didSet {
       browserManager.config = BrowserConfig(from: configuration)
@@ -175,7 +169,6 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
   public var onRemoteJumpBackward: (RemoteJumpBackwardEvent) -> Void = { _ in }
   public var onRemoteJumpForward: (RemoteJumpForwardEvent) -> Void = { _ in }
   public var onRemoteLike: () -> Void = {}
-  public var onRemoteLoad: (RemoteLoadEvent) -> Void = { _ in }
   public var onRemoteNext: () -> Void = {}
   public var onRemotePause: () -> Void = {}
   public var onRemotePlay: () -> Void = {}
@@ -194,7 +187,6 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
   public var handleRemoteJumpBackward: ((RemoteJumpBackwardEvent) -> Void)?
   public var handleRemoteJumpForward: ((RemoteJumpForwardEvent) -> Void)?
   public var handleRemoteLike: (() -> Void)?
-  public var handleRemoteLoad: ((RemoteLoadEvent) -> Void)?
   public var handleRemoteNext: (() -> Void)?
   public var handleRemotePause: (() -> Void)?
   public var handleRemotePlay: (() -> Void)?
@@ -228,6 +220,7 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
       setupVolumeObserver()
     }
   }
+
   public var onIosOutputChanged: (IosOutput) -> Void = { _ in } {
     didSet {
       setupRouteChangeObserver()
@@ -238,11 +231,30 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
 
   override public init() {
     super.init()
-    HybridAudioBrowser.shared = self
+
+    // Clean up the previous instance (e.g., on JS runtime reload).
+    // The old HybridAudioBrowser may still be retained by the global
+    // playerAndConfiguredBrowser OnceValue, so we must explicitly stop
+    // its player to prevent two audio streams running simultaneously.
+    onMainActor {
+      HybridAudioBrowser.shared?.player?.destroy()
+      playerAndConfiguredBrowser.reset()
+      HybridAudioBrowser.shared = self
+    }
     setupEmitterToNitroForwarding()
     setupBrowserCallbacks()
   }
 
+  deinit {
+    // Safety net: ensure the AVPlayer is stopped if this instance is deallocated.
+    let player = self.player
+    if Thread.isMainThread {
+      MainActor.assumeIsolated { player?.destroy() }
+    } else {
+      DispatchQueue.main.async { MainActor.assumeIsolated { player?.destroy() } }
+    }
+  }
+
   /// Returns the TrackPlayer instance, if setup has been called.
   func getPlayer() -> TrackPlayer? {
     player
@@ -327,13 +339,16 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
     let defaultFormatted = defaultFormattedError(navError)
     if let formatter = browserManager.config.formatNavigationError {
       let params = FormatNavigationErrorParams(error: navError, defaultFormatted: defaultFormatted, path: path)
-      formatter(params)
-        .then { [weak self] customDisplay in
-          self?.lastFormattedNavigationError = customDisplay ?? defaultFormatted
-        }
-        .catch { [weak self] _ in
-          self?.lastFormattedNavigationError = defaultFormatted
-        }
+      // Dispatch to main thread for the Nitro bridge call to avoid C++ noexcept crashes
+      DispatchQueue.main.async { [weak self] in
+        formatter(params)
+          .then { customDisplay in
+            self?.lastFormattedNavigationError = customDisplay ?? defaultFormatted
+          }
+          .catch { _ in
+            self?.lastFormattedNavigationError = defaultFormatted
+          }
+      }
     } else {
       lastFormattedNavigationError = defaultFormatted
     }
@@ -375,21 +390,15 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
     }
   }
 
-  /// Centralizes handleRemoteLoad interception logic.
-  /// If handleRemoteLoad is set, calls it (intercepted). Otherwise runs defaultBehavior.
-  /// Always fires onRemoteLoad afterward.
+  /// Centralizes handleTrackLoad interception logic.
+  /// If handleTrackLoad is set on config, awaits it (intercepted). Otherwise runs defaultBehavior.
   ///
   /// - Returns: true if the handler intercepted, false if defaultBehavior ran
   @discardableResult
-  private func handleLoad(track: Track, queue: [Track], startIndex: Double, defaultBehavior: () -> Void) -> Bool {
-    let event = RemoteLoadEvent(track: track, queue: queue, startIndex: startIndex)
-    if let handler = handleRemoteLoad {
-      handler(event)
-      onRemoteLoad(event)
-      return true
-    }
-    defaultBehavior()
-    onRemoteLoad(event)
+  private func handleLoadAsync(track: Track, queue: [Track], startIndex: Double, defaultBehavior: () async -> Void) async -> Bool {
+    let event = TrackLoadEvent(track: track, queue: queue, startIndex: startIndex)
+    if await browserManager.config.awaitTrackLoadHandler(event: event) { return true }
+    await defaultBehavior()
     return false
   }
 
@@ -412,9 +421,17 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
       if let index = existingIndex {
         logger.debug("Queue already from \(parentPath), skipping to index \(index)")
         let queue: [Track] = onMainActor { player?.tracks ?? [] }
-        handleLoad(track: track, queue: queue, startIndex: Double(index)) {
-          onMainActor {
-            try? player?.skipTo(index, playWhenReady: true)
+        Task {
+          await handleLoadAsync(track: track, queue: queue, startIndex: Double(index)) {
+            do {
+              try onMainActor {
+                try player?.skipTo(index, playWhenReady: true)
+              }
+            } catch {
+              // NOTE: because we have a throwing closure here, the thrown error
+              // can't be propogated up. Log it out instead.
+              logger.error("Failed to skip to track at index \(index): \(error)")
+            }
           }
         }
         return
@@ -425,7 +442,7 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
           // Expand the queue from the contextual URL
           if let expanded = try await browserManager.expandQueueFromContextualUrl(url) {
             let (tracks, startIndex) = expanded
-            handleLoad(track: track, queue: tracks, startIndex: Double(startIndex)) {
+            await handleLoadAsync(track: track, queue: tracks, startIndex: Double(startIndex)) {
               // Replace queue and start at the selected track (auto-play)
               onMainActor {
                 player?.setQueue(tracks, initialIndex: startIndex, playWhenReady: true, sourcePath: parentPath)
@@ -433,7 +450,7 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
             }
           } else {
             // Fallback: just load the single track (auto-play)
-            handleLoad(track: track, queue: [track], startIndex: 0) {
+            await handleLoadAsync(track: track, queue: [track], startIndex: 0) {
               onMainActor {
                 player?.load(track, playWhenReady: true)
               }
@@ -442,7 +459,7 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
         } catch {
           logger.error("Error expanding queue: \(error.localizedDescription)")
           // Fallback to single track (auto-play) - playback errors reported via TrackPlayer callbacks
-          handleLoad(track: track, queue: [track], startIndex: 0) {
+          await handleLoadAsync(track: track, queue: [track], startIndex: 0) {
             onMainActor {
               player?.load(track, playWhenReady: true)
             }
@@ -452,9 +469,11 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
     }
     // If track has src, it's playable - load and auto-play
     else if track.src != nil {
-      handleLoad(track: track, queue: [track], startIndex: 0) {
-        onMainActor {
-          player?.load(track, playWhenReady: true)
+      Task {
+        await handleLoadAsync(track: track, queue: [track], startIndex: 0) {
+          onMainActor {
+            player?.load(track, playWhenReady: true)
+          }
         }
       }
     }
@@ -497,7 +516,6 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
     browserManager.invalidateContentCache(path)
 
     // Notify external controllers (CarPlay) that content changed
-    onExternalContentChanged?(path)
     externalContentChangedEmitter.emit(path)
 
     // Re-resolve the path if it's the current browser path
@@ -828,9 +846,10 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
         favorited: favorited,
         groupTitle: track.groupTitle,
         live: track.live,
+        imageRow: track.imageRow,
       )
       // Update the track in the player's queue so getActiveTrack() returns correct state
-      player?.setTrack(at: index, updatedTrack)
+      player?.replace(index, updatedTrack)
       favoriteChangedEmitter.emit(FavoriteChangedEvent(track: updatedTrack, favorited: favorited))
       // Fire active track changed so useActiveTrack() hook updates UI
       let position = player?.currentTime ?? 0
@@ -911,7 +930,7 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
         album: track.album,
         artist: override?.artist ?? track.artist,
         duration: track.duration,
-        artwork: track.artwork,
+        artwork: nowPlayingArtwork(for: track),
         description: track.description,
         mediaId: track.src ?? track.url,
         genre: track.genre,
@@ -920,6 +939,15 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
     }
   }
 
+  /// Returns the artwork URI suitable for JS consumption.
+  /// Prefers the resolved artworkSource URI (e.g. file:// for rendered SF Symbols).
+  /// Falls back to the raw artwork string only if it's not an SF Symbol (which JS can't load).
+  private func nowPlayingArtwork(for track: Track) -> String? {
+    if let uri = track.artworkSource?.uri { return uri }
+    guard let artwork = track.artwork else { return nil }
+    return SFSymbolRenderer.isSFSymbol(artwork) ? nil : artwork
+  }
+
   /// Applies the current now playing metadata (with override if set) to NowPlayingInfoCenter and notifies JS.
   @MainActor
   private func applyNowPlayingMetadata() {
@@ -932,7 +960,7 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
       album: track.album,
       artist: override?.artist ?? track.artist,
       duration: track.duration,
-      artwork: track.artwork,
+      artwork: nowPlayingArtwork(for: track),
       description: track.description,
       mediaId: track.src ?? track.url,
       genre: track.genre,
@@ -989,7 +1017,7 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
     routeChangeObserver = NotificationCenter.default.addObserver(
       forName: AVAudioSession.routeChangeNotification,
       object: nil,
-      queue: .main
+      queue: .main,
     ) { [weak self] _ in
       guard let self, let output = self.getCurrentOutput() else { return }
       self.onIosOutputChanged(output)
@@ -1038,15 +1066,21 @@ public class HybridAudioBrowser: HybridAudioBrowserSpec, @unchecked Sendable {
       guard let windowScene = UIApplication.shared.connectedScenes
         .compactMap({ $0 as? UIWindowScene })
         .first(where: { $0.activationState == .foregroundActive }),
-        let window = windowScene.windows.first(where: { $0.isKeyWindow })
+        let window = windowScene.windows.first(where: { $0.isKeyWindow }),
+        var topController = window.rootViewController
       else {
         self?.logger.debug("openIosOutputPicker: Could not find active window scene")
         return
       }
 
+      // Walk up to the topmost presented view controller
+      while let presented = topController.presentedViewController {
+        topController = presented
+      }
+
       let routePicker = AVRoutePickerView(frame: .zero)
       routePicker.isHidden = true
-      window.addSubview(routePicker)
+      topController.view.addSubview(routePicker)
 
       // Find the button inside AVRoutePickerView and trigger it
       for subview in routePicker.subviews {
@@ -1296,6 +1330,33 @@ extension HybridAudioBrowser: TrackPlayerCallbacks {
     }
   }
 
+  /// Handles an INPlayMediaIntent by searching for the given term and starting playback.
+  ///
+  /// Host apps should call this from their `INPlayMediaIntentHandling` implementation.
+  /// Uses the browser's search route to find tracks, then queues and plays them.
+  ///
+  /// - Parameters:
+  ///   - searchTerm: The search query from Siri.
+  ///   - completion: Called with `true` if tracks were found and queued, `false` otherwise.
+  public func handlePlayMediaIntent(searchTerm: String, completion: @escaping @Sendable (Bool) -> Void) {
+    Task {
+      do {
+        let resolved = try await self.browserManager.search(searchTerm)
+        guard let tracks = resolved.children, !tracks.isEmpty else {
+          completion(false)
+          return
+        }
+        await MainActor.run {
+          self.getPlayer()?.setQueue(tracks, initialIndex: 0, playWhenReady: true)
+        }
+        completion(true)
+      } catch {
+        self.logger.error("handlePlayMediaIntent failed: \(error.localizedDescription)")
+        completion(false)
+      }
+    }
+  }
+
   public func remoteLike() {
     if let handler = handleRemoteLike {
       handler()

package/ios/Model/MediaURL.swift

@@ -45,7 +45,8 @@ struct MediaURL {
       allowed.formUnion(.urlQueryAllowed)
       allowed.formUnion(.urlFragmentAllowed)
       if let encoded = string.addingPercentEncoding(withAllowedCharacters: allowed),
-         let url = URL(string: encoded) {
+         let url = URL(string: encoded)
+      {
         return url
       }
     }

package/ios/Player/PlayingStateManager.swift

@@ -2,6 +2,7 @@ import Foundation
 import NitroModules
 
 /// Manages the playing state (playing and buffering flags) and notifies when they change.
+@MainActor
 class PlayingStateManager {
   private(set) var playing: Bool = false
   private(set) var buffering: Bool = false

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?()
   }