react-native-queue-player 1.1.2 → 2.0.0

package/ios/Cast/Core/LocalMediaServer.swift

@@ -17,8 +17,8 @@ import Network
 /// Backends call `acquire(sessionId:)` for a `MediaServerHandle`; the
 /// listener starts on first acquire and stops when the last handle
 /// closes. Range / HEAD / Content-Length are handled by the responder.
-// Thread-safe singleton: all mutable state is guarded by `lock` / `listenerLock`,
-// so it is safe to capture in the listener's `@Sendable` dispatch closures.
+/// Thread-safe singleton: all mutable state is guarded by `lock`, so it is
+/// safe to capture in the listener's `@Sendable` dispatch closures.
 final class LocalMediaServer: @unchecked Sendable {
   /// Process-wide singleton — only the Chromecast / DLNA / Sonos
   /// backends acquire handles; AirPlay-only apps never touch this and
@@ -32,7 +32,6 @@ final class LocalMediaServer: @unchecked Sendable {
   private var boundPort: UInt16 = 0
   private var refCount = 0
   private let registry = MediaTokenRegistry()
-  private var addressMonitor: LocalAddressMonitor?
   /// Live accepted connections, tracked so `stop()` can cancel any
   /// in-flight transfer. Keyed by identity; each self-removes on finish.
   private var connections: [ObjectIdentifier: MediaHTTPConnection] = [:]
@@ -43,62 +42,51 @@ final class LocalMediaServer: @unchecked Sendable {
   // acquiring async task suspends instead of busy-waiting a cooperative thread.
   private var readinessWaiters: [CheckedContinuation<Void, Never>] = []
 
-  // `lifecycleListener` is read from acquire/release (which may run on
-  // any thread the consumer routes calls through) and set from caller
-  // code on app init. Reads + writes go through this dedicated lock so
-  // a concurrent set during a refcount flip doesn't race the read.
-  private let listenerLock = NSLock()
-  private var _lifecycleListener: ((Bool) -> Void)?
-
-  var lifecycleListener: ((Bool) -> Void)? {
-    get {
-      listenerLock.lock(); defer { listenerLock.unlock() }
-      return _lifecycleListener
-    }
-    set {
-      listenerLock.lock()
-      _lifecycleListener = newValue
-      listenerLock.unlock()
-    }
-  }
-
-  private func fireLifecycle(_ active: Bool) {
-    listenerLock.lock()
-    let cb = _lifecycleListener
-    listenerLock.unlock()
-    cb?(active)
-  }
-
   /// OS-assigned port. `nil` when the listener is not bound.
   var serverPortOrNil: Int? {
     lock.lock(); defer { lock.unlock() }
     return boundPort == 0 ? nil : Int(boundPort)
   }
 
-  /// LAN IPv4 address for receivers to reach. Prefers the attached
-  /// `LocalAddressMonitor`'s cached value; falls back to a synchronous
-  /// `getifaddrs` lookup so the first cast attempt after app launch
-  /// doesn't fail just because the monitor's first path-update
-  /// callback hasn't fired yet.
+  /// LAN IPv4 address for receivers to reach: the first IPv4 on an `en*`
+  /// interface, looked up with `getifaddrs` on every read; `nil` when
+  /// there is none.
   var currentLanAddress: String? {
-    if let cached = addressMonitor?.currentAddress { return cached }
-    return LocalAddressMonitor.firstWifiIPv4()
+    Self.firstWifiIPv4()
   }
 
-  func attachAddressMonitor(_ monitor: LocalAddressMonitor) {
-    addressMonitor = monitor
-  }
-
-  func addAddressChangeListener(
-    _ listener: @escaping (String?) -> Void
-  ) -> LocalAddressMonitor.Subscription? {
-    addressMonitor?.addListener(listener)
+  /// The first IPv4 address on an `en*` interface (Wi-Fi), from a
+  /// synchronous `getifaddrs` scan; `nil` when no such interface has one.
+  /// Cellular addresses can't reach a LAN receiver, so other interfaces
+  /// are ignored.
+  private static func firstWifiIPv4() -> String? {
+    var ifaddrPtr: UnsafeMutablePointer<ifaddrs>?
+    guard getifaddrs(&ifaddrPtr) == 0, let first = ifaddrPtr else { return nil }
+    defer { freeifaddrs(ifaddrPtr) }
+    var ptr: UnsafeMutablePointer<ifaddrs>? = first
+    while let current = ptr {
+      defer { ptr = current.pointee.ifa_next }
+      let name = String(cString: current.pointee.ifa_name)
+      guard name.hasPrefix("en") else { continue }
+      guard let sa = current.pointee.ifa_addr else { continue }
+      guard sa.pointee.sa_family == UInt8(AF_INET) else { continue }
+      var hostBuf = [CChar](repeating: 0, count: Int(NI_MAXHOST))
+      let result = getnameinfo(
+        sa, socklen_t(sa.pointee.sa_len),
+        &hostBuf, socklen_t(hostBuf.count),
+        nil, 0, NI_NUMERICHOST
+      )
+      if result == 0 {
+        let host = String(cString: hostBuf)
+        if !host.isEmpty && host != "0.0.0.0" { return host }
+      }
+    }
+    return nil
   }
 
   func acquire(sessionId: String) async -> MediaServerHandle {
     if takeRefCountWasFirst() {
       await startAndWait()
-      fireLifecycle(true)
     }
     return MediaServerHandle(server: self, sessionId: sessionId)
   }
@@ -122,7 +110,6 @@ final class LocalMediaServer: @unchecked Sendable {
     lock.unlock()
     if last {
       stop()
-      fireLifecycle(false)
     }
   }
 
@@ -130,10 +117,6 @@ final class LocalMediaServer: @unchecked Sendable {
     registry.register(sessionId: sessionId, fileURL: fileURL, contentType: contentType)
   }
 
-  func revoke(_ token: String) {
-    registry.revoke(token)
-  }
-
   // MARK: - Listener lifecycle
 
   /// Start the listener (if not already bound) and suspend, bounded, until it
@@ -186,7 +169,8 @@ final class LocalMediaServer: @unchecked Sendable {
     // Bind every interface (Wi-Fi LAN, etc.) on an OS-assigned port — the
     // Cast receiver fetches URLs over the LAN, so unlike a loopback proxy
     // this listener must accept en0 connections. URLs handed to receivers
-    // scope the host to the active Wi-Fi address via `LocalAddressMonitor`;
+    // go through `MediaServerHandle.register(fileURL:lanAddress:contentType:)`
+    // with the host from `currentLanAddress` (the first IPv4 on an `en*` interface);
     // tokens are 32 hex chars (high entropy), so the LAN-reachable surface
     // can't be enumerated. `allowLocalEndpointReuse` avoids bind churn when
     // a prior listener's socket is still in TIME_WAIT.
@@ -238,7 +222,12 @@ final class LocalMediaServer: @unchecked Sendable {
   }
 
   private func accept(_ conn: NWConnection) {
-    let responder = MediaHTTPConnection(connection: conn, registry: registry) { [weak self] in
+    let responder = MediaHTTPConnection(
+      connection: conn,
+      resolve: { [registry] token in
+        registry.resolve(token).map { .file($0.fileURL, contentType: $0.contentType) }
+      }
+    ) { [weak self] in
       self?.untrack(conn)
     }
     // Track BEFORE start(): the responder's finish callback (-> untrack)

package/ios/Cast/Core/LocalNetworkPermissionProbe.swift

@@ -51,15 +51,17 @@ final class LocalNetworkPermissionProbe {
 
   init() {}
 
-  /// Snapshot of the most recently resolved permission state. Returns
-  /// `.undetermined` if no probe has resolved yet, or if the cached
-  /// result has expired past the TTL.
+  /// The most recently resolved permission state, or `.undetermined` if no
+  /// probe has resolved yet.
+  ///
+  /// Deliberately not TTL-gated. The TTL governs whether
+  /// `requestPermission()` re-probes; expiring the *answer* as well would
+  /// report `.undetermined` for a user who granted access a minute ago, and any
+  /// consumer rule of the form "granted suppresses the prompt" would then
+  /// invert — re-prompting exactly the people who already said yes.
   var cachedState: CastLocalNetworkPermission {
     stateLock.lock(); defer { stateLock.unlock() }
-    if let at = _cachedAt, Date().timeIntervalSince(at) < Self.cacheTTLSeconds {
-      return _cachedState
-    }
-    return .undetermined
+    return _cachedState
   }
 
   /// Trigger the probe. Returns immediately with a `Promise` that
@@ -215,6 +217,15 @@ fileprivate final class ProbeRun {
 
   private func handleBrowserState(_ state: NWBrowser.State) {
     switch state {
+    case .waiting(let error):
+      // Denial surfaces here, not in `.failed`: refusing local-network access
+      // leaves the browser waiting with kDNSServiceErr_PolicyDenied (-65570).
+      // `.waiting` is also the ordinary "no connectivity yet" state, so only
+      // the error code decides — anything else stays unresolved and lets the
+      // timeout or a later state settle it.
+      if Self.isLocalNetworkDeniedError(error) {
+        resolve(.denied)
+      }
     case .failed(let error):
       if Self.isLocalNetworkDeniedError(error) {
         resolve(.denied)
@@ -252,14 +263,24 @@ fileprivate final class ProbeRun {
     for p in resolvedPromises { p.resolve(withResult: state) }
   }
 
-  /// Detect the LNA-denied error code. Network.framework surfaces it
-  /// as a POSIX `EACCES` wrapped in `NWError.posix(.EACCES)`. Other
-  /// failure modes (no Wi-Fi, system error) fall through to
-  /// `.undetermined`.
+  /// Detect the local-network-denied error.
+  ///
+  /// A denied browse reports `kDNSServiceErr_PolicyDenied` (-65570) as
+  /// `NWError.dns`, which is the form that actually arrives on the `.waiting`
+  /// path. `NWError.posix(.EACCES)` is kept for the listener side, which
+  /// reports the same refusal as a POSIX error. Everything else (no Wi-Fi,
+  /// system error) is not a denial and falls through.
   static func isLocalNetworkDeniedError(_ error: NWError) -> Bool {
     if case .posix(let code) = error, code == .EACCES {
       return true
     }
+    if case .dns(let code) = error, code == Self.dnsPolicyDenied {
+      return true
+    }
     return false
   }
+
+  /// `kDNSServiceErr_PolicyDenied`. Spelled out rather than imported so the
+  /// probe does not pull in dnssd for one constant.
+  private static let dnsPolicyDenied: DNSServiceErrorType = -65570
 }

package/ios/Cast/Core/MediaServerHandle.swift

@@ -26,10 +26,6 @@ final class MediaServerHandle {
     return URL(string: "http://\(lanAddress):\(port)/media/\(token)")
   }
 
-  func revoke(_ token: String) {
-    server?.revoke(token)
-  }
-
   func close() {
     lock.lock()
     if closed {

package/ios/Cast/Core/MediaTokenRegistry.swift

@@ -28,12 +28,6 @@ final class MediaTokenRegistry {
     return entries[token]
   }
 
-  func revoke(_ token: String) {
-    lock.lock()
-    entries.removeValue(forKey: token)
-    lock.unlock()
-  }
-
   func revokeAll(sessionId: String) {
     lock.lock()
     entries = entries.filter { $0.value.sessionId != sessionId }

package/ios/CastManager.swift

@@ -30,6 +30,7 @@ class CastManager: HybridCastManagerSpec {
   private var nextListenerId: Int64 = 0
   private let listenerLock = NSLock()
 
+  private let connectLock = NSLock()
   /// Pending JS `connect()` promise for an in-flight Chromecast attempt.
   /// Resolved from `handleSessionLifecycle(.connected)` once the route is
   /// live, rejected on `.error` — the same contract as the Android
@@ -37,7 +38,6 @@ class CastManager: HybridCastManagerSpec {
   /// receiver is actually attached. Guarded by `connectLock`: installed
   /// on the JS thread in `connect`, cleared on the main thread from the
   /// session lifecycle handler.
-  private let connectLock = NSLock()
   private var pendingChromecastConnect: Promise<Void>?
 
   override init() {