react-native-queue-player 1.0.0

package/ios/Cast/Core/ChromecastBackend.swift

@@ -0,0 +1,259 @@
+import Foundation
+#if canImport(GoogleCast)
+import GoogleCast
+#endif
+
+/// Owns the iOS Chromecast surface — discovery, session, transport,
+/// receiver state observation. Single instance created by
+/// `CastManager` and held for the lifetime of the HybridObject.
+/// `CastManager` wires its listeners into the backend's typed callback
+/// slots; nothing routes through NSNotificationCenter.
+///
+/// The backend is the SoT for: discovered receivers, the current
+/// `GCKCastSession`, and the `RemoteMediaObserver` that translates
+/// receiver state into callbacks. `CastManagerImpl` wires its
+/// listeners into the backend's callback slots.
+final class ChromecastBackend: NSObject {
+
+  /// Called when the receiver list changes (discovery deltas).
+  var onReceiversChanged: (([CastReceiver]) -> Void)?
+
+  /// Called when the session lifecycle changes:
+  ///  - `.connected(route)` — session attached, receiver ready
+  ///  - `.disconnected(reason)` — session ended cleanly or
+  ///    suspended; `reason` is a stable string
+  ///  - `.error(reason)` — connect/resume failed
+  var onSessionLifecycle: ((ChromecastSessionLifecycle) -> Void)?
+
+  // MARK: - Internal state
+
+  #if canImport(GoogleCast)
+  private let discoveryAdapter = ChromecastDiscoveryAdapter()
+  private let sessionAdapter = ChromecastSessionAdapter()
+  private var discoveryAttached = false
+  private var sessionAttached = false
+  private var currentDevices: [GCKDevice] = []
+  private var cachedReceivers: [CastReceiver] = []
+  private var currentSession: GCKCastSession?
+  /// Live `ChromecastSession` minted in `handleSessionConnected`,
+  /// cleared in `handleSessionDisconnected`. The actual receiver-side
+  /// `LocalMediaServer` handle lives on the session — the backend
+  /// just plumbs the GCK boundary.
+  private var activeChromecastSession: ChromecastSession?
+  #endif
+
+  override init() {
+    super.init()
+    #if canImport(GoogleCast)
+    // Wire adapter callbacks to internal handlers.
+    discoveryAdapter.onUpdate = { [weak self] devices in
+      self?.handleDeviceListUpdate(devices)
+    }
+    sessionAdapter.onConnected = { [weak self] session in
+      self?.handleSessionConnected(session)
+    }
+    sessionAdapter.onDisconnected = { [weak self] reason in
+      self?.handleSessionDisconnected(reason: reason)
+    }
+    sessionAdapter.onError = { [weak self] reason in
+      self?.handleSessionError(reason: reason)
+    }
+    // Receiver-side volume push from the session manager (fires
+    // independently of MediaStatus, so pre-load volume changes still
+    // surface). Forwarded into the active ChromecastSession via its
+    // `acceptDeviceVolume` API; the session dedups internally.
+    sessionAdapter.onVolumeChanged = { [weak self] volume, _ in
+      self?.activeChromecastSession?.acceptDeviceVolume(volume)
+    }
+    #endif
+  }
+
+  // MARK: - Discovery
+
+  func startDiscovery() {
+    #if canImport(GoogleCast)
+    guard Thread.isMainThread else {
+      DispatchQueue.main.async { self.startDiscovery() }
+      return
+    }
+    let manager = GCKCastContext.sharedInstance().discoveryManager
+    if !discoveryAttached {
+      manager.add(discoveryAdapter)
+      discoveryAttached = true
+      // Seed snapshot from any already-cached devices.
+      discoveryAdapter.didUpdateDeviceList()
+    }
+    manager.startDiscovery()
+    #endif
+  }
+
+  func stopDiscovery() {
+    #if canImport(GoogleCast)
+    guard Thread.isMainThread else {
+      DispatchQueue.main.async { self.stopDiscovery() }
+      return
+    }
+    let manager = GCKCastContext.sharedInstance().discoveryManager
+    manager.stopDiscovery()
+    if discoveryAttached {
+      manager.remove(discoveryAdapter)
+      discoveryAttached = false
+    }
+    #endif
+  }
+
+  func getReceivers() -> [CastReceiver] {
+    #if canImport(GoogleCast)
+    return cachedReceivers
+    #else
+    return []
+    #endif
+  }
+
+  // MARK: - Session lifecycle
+
+  /// Connect to a receiver by id (the namespaced form
+  /// `chromecast:<unique-id>`). Resolves async — caller observes
+  /// `onSessionLifecycle` for the outcome.
+  func connect(receiverId: String) {
+    #if canImport(GoogleCast)
+    guard Thread.isMainThread else {
+      DispatchQueue.main.async { self.connect(receiverId: receiverId) }
+      return
+    }
+    // Strip "chromecast:" prefix to get the Cast SDK unique id.
+    let prefix = "chromecast:"
+    let uniqueId = receiverId.hasPrefix(prefix)
+      ? String(receiverId.dropFirst(prefix.count))
+      : receiverId
+
+    let manager = GCKCastContext.sharedInstance().sessionManager
+    if !sessionAttached {
+      manager.add(sessionAdapter)
+      sessionAttached = true
+    }
+    guard let device = currentDevices.first(where: { $0.uniqueID == uniqueId }) else {
+      onSessionLifecycle?(.error(reason: "receiver-not-found"))
+      return
+    }
+    let started = manager.startSession(with: device)
+    if !started {
+      onSessionLifecycle?(.error(reason: "start-session-rejected"))
+    }
+    #else
+    onSessionLifecycle?(.error(reason: "google-cast-not-linked"))
+    #endif
+  }
+
+  func disconnect() {
+    #if canImport(GoogleCast)
+    guard Thread.isMainThread else {
+      DispatchQueue.main.async { self.disconnect() }
+      return
+    }
+    let manager = GCKCastContext.sharedInstance().sessionManager
+    manager.endSessionAndStopCasting(true)
+    #endif
+  }
+
+  // MARK: - Transport
+
+  func setVolume(_ value: Double) {
+    #if canImport(GoogleCast)
+    let clamped = max(0.0, min(1.0, value))
+    currentSession?.setDeviceVolume(Float(clamped))
+    #endif
+  }
+
+  func play() {
+    #if canImport(GoogleCast)
+    currentSession?.remoteMediaClient?.play()
+    #endif
+  }
+
+  func pause() {
+    #if canImport(GoogleCast)
+    currentSession?.remoteMediaClient?.pause()
+    #endif
+  }
+
+  func stop() {
+    #if canImport(GoogleCast)
+    currentSession?.remoteMediaClient?.stop()
+    #endif
+  }
+
+  func seekTo(positionMs: Int64) {
+    #if canImport(GoogleCast)
+    let opts = GCKMediaSeekOptions()
+    opts.interval = TimeInterval(positionMs) / 1000.0
+    opts.resumeState = .unchanged
+    currentSession?.remoteMediaClient?.seek(with: opts)
+    #endif
+  }
+
+  // MARK: - Internal handlers
+
+  #if canImport(GoogleCast)
+  private func handleDeviceListUpdate(_ devices: [GCKDevice]) {
+    currentDevices = devices
+    cachedReceivers = devices.map { ChromecastReceiverMapper.mapToReceiver($0) }
+    onReceiversChanged?(cachedReceivers)
+  }
+
+  private func handleSessionConnected(_ session: GCKCastSession) {
+    currentSession = session
+    let castSession = ChromecastSession(session: session)
+    activeChromecastSession = castSession
+
+    let route = CastRoute(
+      castProtocol: .chromecast,
+      receiverId: "chromecast:\(session.device.uniqueID)",
+      name: session.device.friendlyName ?? session.device.deviceID,
+      iconHint: .tv,
+      capabilities: CastReceiverCapabilities(
+        supportsRemoteVolume: true,
+        streamingModel: .pullurl,
+        requiresPairing: false
+      ),
+      protocolVersion: ""
+    )
+    onSessionLifecycle?(.connected(route: route, session: castSession))
+  }
+
+  private func handleSessionDisconnected(reason: String) {
+    let session = activeChromecastSession
+    activeChromecastSession = nil
+    currentSession = nil
+    // Notify consumers BEFORE closing the session so they get a chance
+    // to read final `last*` snapshots / unregister from the router
+    // while the session's listener slots are still wired.
+    onSessionLifecycle?(.disconnected(reason: normalize(reason: reason)))
+    session?.close()
+  }
+
+  private func handleSessionError(reason: String) {
+    let session = activeChromecastSession
+    activeChromecastSession = nil
+    currentSession = nil
+    onSessionLifecycle?(.error(reason: reason))
+    session?.close()
+  }
+  #endif
+
+  private func normalize(reason: String) -> String {
+    if reason.hasPrefix("suspended:") { return "networkLoss" }
+    if reason.hasPrefix("ended") { return "ended" }
+    return reason
+  }
+}
+
+/// Outcomes of a session-lifecycle event. The `route` describes the
+/// receiver for picker UI; the `session` (only on `.connected`) is the
+/// live `CastSessionRemotePlayer` the rest of the lib drives transport
+/// against.
+enum ChromecastSessionLifecycle {
+  case connected(route: CastRoute, session: CastSessionRemotePlayer)
+  case disconnected(reason: String)
+  case error(reason: String)
+}

package/ios/Cast/Core/LocalAddressMonitor.swift

@@ -0,0 +1,110 @@
+import Foundation
+import Network
+
+/// Wraps `NWPathMonitor` to publish the local IPv4 address over the
+/// `.wifi` interface. Cellular addresses can't reach a LAN receiver,
+/// so they are intentionally ignored — Chromecast / DLNA / AirPlay
+/// targets are all wifi-local by design.
+final class LocalAddressMonitor {
+
+  typealias Listener = (String?) -> Void
+
+  final class Subscription {
+    fileprivate let id: UUID
+    fileprivate weak var owner: LocalAddressMonitor?
+    fileprivate init(id: UUID, owner: LocalAddressMonitor) {
+      self.id = id
+      self.owner = owner
+    }
+    func remove() { owner?.removeListener(id: id) }
+  }
+
+  private let monitor = NWPathMonitor(requiredInterfaceType: .wifi)
+  private let queue = DispatchQueue(label: "LocalAddressMonitor")
+  private let lock = NSLock()
+  private var listeners: [UUID: Listener] = [:]
+  private var running = false
+
+  private let addressLock = NSLock()
+  private var _currentAddress: String?
+  var currentAddress: String? {
+    addressLock.lock(); defer { addressLock.unlock() }
+    return _currentAddress
+  }
+
+  func start() {
+    lock.lock()
+    if running { lock.unlock(); return }
+    running = true
+    lock.unlock()
+    monitor.pathUpdateHandler = { [weak self] path in
+      guard let self = self else { return }
+      let addr: String? = (path.status == .satisfied) ? Self.firstWifiIPv4() : nil
+      self.addressLock.lock()
+      let changed: Bool = (addr != self._currentAddress)
+      self._currentAddress = addr
+      self.addressLock.unlock()
+      if changed {
+        self.dispatch(addr)
+      }
+    }
+    monitor.start(queue: queue)
+  }
+
+  func stop() {
+    lock.lock()
+    if !running { lock.unlock(); return }
+    running = false
+    lock.unlock()
+    monitor.cancel()
+  }
+
+  func addListener(_ listener: @escaping Listener) -> Subscription {
+    let id = UUID()
+    lock.lock()
+    listeners[id] = listener
+    lock.unlock()
+    return Subscription(id: id, owner: self)
+  }
+
+  fileprivate func removeListener(id: UUID) {
+    lock.lock()
+    listeners.removeValue(forKey: id)
+    lock.unlock()
+  }
+
+  private func dispatch(_ addr: String?) {
+    lock.lock()
+    let snapshot = Array(listeners.values)
+    lock.unlock()
+    for l in snapshot { l(addr) }
+  }
+
+  /// Enumerate BSD interfaces and return the first IPv4 address on an
+  /// `en*` interface (Wi-Fi). Synchronous so callers can probe without
+  /// waiting for the `NWPathMonitor` first-update callback.
+  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
+  }
+}

package/ios/Cast/Core/LocalMediaServer.swift

@@ -0,0 +1,270 @@
+import Foundation
+import Network
+
+/// Process-wide local HTTP server for URL-handoff cast backends
+/// (Chromecast, future DLNA / Sonos). Serves consumer-supplied
+/// `file://` URLs to receivers that can only pull `http://` — the
+/// classic Chromecast offline-content path.
+///
+/// **Not related to the lookahead cache.** The lookahead cache is
+/// fully native + streaming-focused. This server exposes only files
+/// the consumer app has explicitly put in `setQueue` with a `file://`
+/// URL (offline-downloaded content from the host app's own storage).
+///
+/// Binds a `Network.framework` `NWListener` to all interfaces on an
+/// OS-assigned port and serves `GET` / `HEAD /media/{token}` via
+/// `MediaHTTPConnection`, resolving tokens through `MediaTokenRegistry`.
+/// 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.
+final class LocalMediaServer: @unchecked Sendable {
+  /// Process-wide singleton — only the Chromecast / DLNA / Sonos
+  /// backends acquire handles; AirPlay-only apps never touch this and
+  /// the listener never starts.
+  static let shared = LocalMediaServer()
+
+  private let lock = NSLock()
+  private var listener: NWListener?
+  /// OS-assigned port, read back once the listener reaches `.ready`.
+  /// `0` while not bound.
+  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] = [:]
+  private let serverQueue = DispatchQueue(label: "queueplayer.cast.mediaserver.listener")
+
+  // Continuations awaiting the listener's first bind, guarded by `lock`. Resumed
+  // from the listener state handler (.ready / .failed / .cancelled) so the
+  // 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.
+  var currentLanAddress: String? {
+    if let cached = addressMonitor?.currentAddress { return cached }
+    return LocalAddressMonitor.firstWifiIPv4()
+  }
+
+  func attachAddressMonitor(_ monitor: LocalAddressMonitor) {
+    addressMonitor = monitor
+  }
+
+  func addAddressChangeListener(
+    _ listener: @escaping (String?) -> Void
+  ) -> LocalAddressMonitor.Subscription? {
+    addressMonitor?.addListener(listener)
+  }
+
+  func acquire(sessionId: String) async -> MediaServerHandle {
+    if takeRefCountWasFirst() {
+      await startAndWait()
+      fireLifecycle(true)
+    }
+    return MediaServerHandle(server: self, sessionId: sessionId)
+  }
+
+  /// Increment the refcount; returns true when this was the first holder (so the
+  /// caller starts the listener). Kept synchronous so the lock is never held
+  /// across a suspension in the async [acquire].
+  private func takeRefCountWasFirst() -> Bool {
+    lock.lock()
+    defer { lock.unlock() }
+    let first = refCount == 0
+    refCount += 1
+    return first
+  }
+
+  func release(sessionId: String) {
+    registry.revokeAll(sessionId: sessionId)
+    lock.lock()
+    refCount -= 1
+    let last = refCount == 0
+    lock.unlock()
+    if last {
+      stop()
+      fireLifecycle(false)
+    }
+  }
+
+  func register(sessionId: String, fileURL: URL, contentType: String?) -> String {
+    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
+  /// reports a bound port. `acquire` reads `serverPortOrNil` synchronously
+  /// straight after, so the port must be live by the time this returns. Binding
+  /// a TCP listener is a local operation that settles in milliseconds; the wait
+  /// is a guard, not a normal cost. Resumes from the listener state handler
+  /// (event-driven, so no cooperative thread is blocked) with a timeout backstop
+  /// for the pathological never-binds case (the caller then surfaces a nil port).
+  private func startAndWait(timeoutMs: Int = 2000) async {
+    startListenerIfNeeded()
+    if serverPortOrNil != nil { return }
+    await withCheckedContinuation { (cont: CheckedContinuation<Void, Never>) in
+      lock.lock()
+      if boundPort != 0 || listener == nil {
+        lock.unlock()
+        cont.resume()
+        return
+      }
+      readinessWaiters.append(cont)
+      lock.unlock()
+      serverQueue.asyncAfter(deadline: .now() + .milliseconds(timeoutMs)) { [weak self] in
+        guard let self = self, self.serverPortOrNil == nil else { return }
+        NSLog("[LocalMediaServer] listener did not bind within \(timeoutMs)ms")
+        self.resumeReadinessWaiters()
+      }
+    }
+  }
+
+  /// Resume + clear all readiness waiters. The list is the single resume claim:
+  /// whichever trigger (bind, failure, or the timeout backstop) drains it first
+  /// resumes each continuation, so each resumes exactly once.
+  private func resumeReadinessWaiters() {
+    lock.lock()
+    let waiters = readinessWaiters
+    readinessWaiters.removeAll()
+    lock.unlock()
+    waiters.forEach { $0.resume() }
+  }
+
+  private func startListenerIfNeeded() {
+    lock.lock()
+    if let existing = listener, existing.state == .ready || existing.state == .setup {
+      lock.unlock()
+      return
+    }
+    lock.unlock()
+
+    let params = NWParameters.tcp
+    // 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`;
+    // 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.
+    params.allowLocalEndpointReuse = true
+    // Keep accepted connections alive through the receiver's buffer-ahead idle
+    // gaps — a long track can sit idle on the wire while the buffered audio
+    // plays, and without keepalive a router/connection-tracking idle timeout can
+    // drop the transfer mid-track.
+    if let tcp = params.defaultProtocolStack.transportProtocol as? NWProtocolTCP.Options {
+      tcp.enableKeepalive = true
+      tcp.keepaliveIdle = 30
+      tcp.keepaliveInterval = 15
+      tcp.keepaliveCount = 4
+    }
+    guard let newListener = try? NWListener(using: params) else {
+      // Init threw — unblock any acquire waiting on a bind that won't come.
+      resumeReadinessWaiters()
+      return
+    }
+    newListener.stateUpdateHandler = { [weak self] state in
+      guard let self = self else { return }
+      switch state {
+      case .ready:
+        if let port = newListener.port?.rawValue {
+          self.lock.lock()
+          if self.listener === newListener { self.boundPort = port }
+          self.lock.unlock()
+        }
+        self.resumeReadinessWaiters()
+      case .failed, .cancelled:
+        self.lock.lock()
+        if self.listener === newListener {
+          self.listener = nil
+          self.boundPort = 0
+        }
+        self.lock.unlock()
+        self.resumeReadinessWaiters()
+      default:
+        break
+      }
+    }
+    newListener.newConnectionHandler = { [weak self] conn in
+      self?.accept(conn)
+    }
+    lock.lock()
+    listener = newListener
+    lock.unlock()
+    newListener.start(queue: serverQueue)
+  }
+
+  private func accept(_ conn: NWConnection) {
+    let responder = MediaHTTPConnection(connection: conn, registry: registry) { [weak self] in
+      self?.untrack(conn)
+    }
+    // Track BEFORE start(): the responder's finish callback (-> untrack)
+    // can fire as soon as start() runs, so the insert must precede it or
+    // untrack would no-op and the responder would leak until stop().
+    lock.lock()
+    connections[ObjectIdentifier(conn)] = responder
+    lock.unlock()
+    responder.start()
+  }
+
+  private func untrack(_ conn: NWConnection) {
+    lock.lock()
+    connections.removeValue(forKey: ObjectIdentifier(conn))
+    lock.unlock()
+  }
+
+  private func stop() {
+    lock.lock()
+    let l = listener
+    listener = nil
+    boundPort = 0
+    let live = Array(connections.values)
+    connections.removeAll()
+    lock.unlock()
+    live.forEach { $0.cancel() }
+    l?.cancel()
+  }
+}