@npaw/forge-react-native-video 9.7.3 → 10.7.4

package/ios/ForgeVideoModuleImpl.swift

@@ -1,363 +0,0 @@
-/**
- * Copyright (C) NPAW - All Rights Reserved
- *
- * This source code is protected under international copyright law. All rights
- * reserved and protected by the copyright holders.
- * This file is confidential and only available to authorized individuals with the
- * permission of the copyright holders. If you encounter this file and do not have
- * permission, please contact the copyright holders and delete this file.
- *
- *
- * @author: Victor Soto <victor.soto@nicepeopleatwork.com>
- * @description: Swift attach coordinator + module implementation for react-native-video on iOS. Mirrors the Android RNVideoAttachCoordinator semantics: auto single-player policy, X-NPAW-Forge token matching via asset identity, source-URI fallback, per-binding stopOnPlayerRemoved, double-create guard.
- */
-
-import AVFoundation
-import Foundation
-#if canImport(NPAWForgeCore)
-import NPAWForgeCore
-import NPAWForgeAVPlayerAdapter
-#elseif canImport(NPAWForgeApple)
-import NPAWForgeApple
-#endif
-#if canImport(NPAWForgeReactNative)
-import NPAWForgeReactNative
-#endif
-
-public typealias ForgeVideoResolveBlock = (Any?) -> Void
-public typealias ForgeVideoRejectBlock = (String, String) -> Void
-
-@objc(ForgeVideoModuleImpl)
-public final class ForgeVideoModuleImpl: NSObject {
-
-    @objc public static let shared = ForgeVideoModuleImpl()
-    static let tokenHeader = "x-npaw-forge"
-
-    private struct AttachRequest {
-        let instanceId: String
-        let identifier: String
-        let policy: String
-        let headerToken: String?
-        let sourceUri: String?
-        let stopOnPlayerRemoved: Bool
-    }
-
-    private struct Binding {
-        let request: AttachRequest
-        let playerId: String
-        let playerIdentity: ObjectIdentifier
-        let adapter: AVPlayerAdapter
-    }
-
-    private let lock = NSLock()
-    private var livePlayers: [(id: String, player: AVPlayer)] = []
-    private var seenPlayerIdentities = Set<ObjectIdentifier>()
-    private var assetFacts: [ObjectIdentifier: (token: String?, uri: String?)] = [:]
-    private var pending: [AttachRequest] = []
-    private var bindings: [String: Binding] = [:] // key: instanceId + " " + identifier
-
-    private let resolveForge: (String) -> NPAWForge?
-
-    private override init() {
-        self.resolveForge = { ForgeModuleImpl.shared.resolveInstance($0) }
-        super.init()
-    }
-
-    // MARK: - Spec surface
-
-    @objc public func attach(
-        _ instanceId: String,
-        identifier: String,
-        options: [String: Any]?,
-        resolve: @escaping ForgeVideoResolveBlock,
-        reject: @escaping ForgeVideoRejectBlock
-    ) {
-        ForgeRNVPlayerPlugin.registerOnce()
-
-        guard let forge = resolveForge(instanceId) else {
-            reject("E_FORGE_UNKNOWN_INSTANCE", "No NPAWForge instance '\(instanceId)'")
-            return
-        }
-        ensureVideo(forge, identifier: identifier)
-
-        let headerToken = nonEmpty(options?["headerToken"] as? String)
-        let sourceUri = nonEmpty(options?["sourceUri"] as? String)
-        var policy = nonEmpty(options?["policy"] as? String)
-        if policy == nil {
-            policy = (headerToken != nil || sourceUri != nil) ? "match" : "auto"
-        }
-        let request = AttachRequest(
-            instanceId: instanceId,
-            identifier: identifier,
-            policy: policy ?? "auto",
-            headerToken: headerToken,
-            sourceUri: sourceUri,
-            stopOnPlayerRemoved: options?["stopOnPlayerRemoved"] as? Bool ?? true
-        )
-
-        lock.lock()
-        let key = bindingKey(instanceId, identifier)
-        if bindings[key] != nil {
-            lock.unlock()
-            resolve(attachResult(code: "ignored_duplicate", accepted: false, attachment: "bound"))
-            return
-        }
-        pending.removeAll { $0.instanceId == instanceId && $0.identifier == identifier }
-
-        if request.policy == "auto" {
-            let unbound = unboundPlayersLocked()
-            if unbound.count > 1 {
-                lock.unlock()
-                resolve(
-                    attachResult(
-                        code: "unsupported_capability",
-                        accepted: false,
-                        attachment: "pending",
-                        reason: "ambiguous_auto_attach"
-                    )
-                )
-                return
-            }
-            if let candidate = unbound.first {
-                bindLocked(request, playerId: candidate.id, player: candidate.player)
-                lock.unlock()
-                resolve(attachResult(code: "accepted", accepted: true, attachment: "bound"))
-                return
-            }
-        } else if let candidate = findMatchLocked(request) {
-            bindLocked(request, playerId: candidate.id, player: candidate.player)
-            lock.unlock()
-            resolve(attachResult(code: "accepted", accepted: true, attachment: "bound"))
-            return
-        }
-
-        pending.append(request)
-        lock.unlock()
-        scheduleReevaluations()
-        resolve(attachResult(code: "accepted", accepted: true, attachment: "pending"))
-    }
-
-    @objc public func detach(
-        _ instanceId: String,
-        identifier: String,
-        resolve: @escaping ForgeVideoResolveBlock,
-        reject: @escaping ForgeVideoRejectBlock
-    ) {
-        lock.lock()
-        pending.removeAll { $0.instanceId == instanceId && $0.identifier == identifier }
-        let removed = bindings.removeValue(forKey: bindingKey(instanceId, identifier))
-        lock.unlock()
-
-        guard let removed else {
-            resolve(attachResult(code: "ignored_invalid_state", accepted: false, attachment: "pending"))
-            return
-        }
-        unbindOnMain(removed, fireStop: true)
-        resolve(attachResult(code: "accepted", accepted: true, attachment: "pending"))
-    }
-
-    @objc public func invalidate() {
-        lock.lock()
-        livePlayers.removeAll()
-        seenPlayerIdentities.removeAll()
-        assetFacts.removeAll()
-        pending.removeAll()
-        let current = Array(bindings.values)
-        bindings.removeAll()
-        lock.unlock()
-
-        for binding in current {
-            unbindOnMain(binding, fireStop: false)
-        }
-    }
-
-    // MARK: - Plugin callbacks
-
-    func playerCreated(id: String, player: AVPlayer) {
-        let identity = ObjectIdentifier(player)
-        lock.lock()
-        if seenPlayerIdentities.contains(identity) {
-            lock.unlock()
-            NSLog("[NPAWForgeRNV] duplicate onInstanceCreated suppressed id=%@", id)
-            return
-        }
-        seenPlayerIdentities.insert(identity)
-        livePlayers.append((id: id, player: player))
-        lock.unlock()
-
-        reevaluate()
-        scheduleReevaluations()
-    }
-
-    func playerRemoved(id: String, player: AVPlayer) {
-        let identity = ObjectIdentifier(player)
-        var affected: [Binding] = []
-
-        lock.lock()
-        livePlayers.removeAll { $0.id == id && ObjectIdentifier($0.player) == identity }
-        seenPlayerIdentities.remove(identity)
-        for (key, binding) in bindings where binding.playerId == id {
-            bindings.removeValue(forKey: key)
-            affected.append(binding)
-        }
-        lock.unlock()
-
-        for binding in affected {
-            unbindOnMain(binding, fireStop: binding.request.stopOnPlayerRemoved)
-        }
-    }
-
-    func sourceSeen(asset: AVAsset, token: String?, uri: String?) {
-        lock.lock()
-        assetFacts[ObjectIdentifier(asset)] = (token: token, uri: uri)
-        lock.unlock()
-        reevaluate()
-    }
-
-    // MARK: - Coordinator internals
-
-    private func bindingKey(_ instanceId: String, _ identifier: String) -> String {
-        "\(instanceId) \(identifier)"
-    }
-
-    private func ensureVideo(_ forge: NPAWForge, identifier: String) {
-        if forge.getVideoAdapter(identifier: identifier) == nil {
-            _ = forge.videoBuilder().setIdentifier(identifier).build()
-        }
-    }
-
-    private func unboundPlayersLocked() -> [(id: String, player: AVPlayer)] {
-        let boundIds = Set(bindings.values.map { $0.playerId })
-        return livePlayers.filter { !boundIds.contains($0.id) }
-    }
-
-    private func factsFor(_ player: AVPlayer) -> (token: String?, uri: String?) {
-        if let asset = player.currentItem?.asset {
-            if let stored = assetFacts[ObjectIdentifier(asset)] {
-                return stored
-            }
-            if let urlAsset = asset as? AVURLAsset {
-                return (token: nil, uri: urlAsset.url.absoluteString)
-            }
-        }
-        return (token: nil, uri: nil)
-    }
-
-    private func findMatchLocked(_ request: AttachRequest) -> (id: String, player: AVPlayer)? {
-        let candidates = unboundPlayersLocked()
-        if let token = request.headerToken {
-            for candidate in candidates where factsFor(candidate.player).token == token {
-                return candidate
-            }
-        }
-        if let uri = request.sourceUri {
-            for candidate in candidates where factsFor(candidate.player).uri == uri {
-                return candidate
-            }
-        }
-        return nil
-    }
-
-    private func bindLocked(_ request: AttachRequest, playerId: String, player: AVPlayer) {
-        let adapter = AVPlayerAdapter(player: player)
-        bindings[bindingKey(request.instanceId, request.identifier)] = Binding(
-            request: request,
-            playerId: playerId,
-            playerIdentity: ObjectIdentifier(player),
-            adapter: adapter
-        )
-        let instanceId = request.instanceId
-        let identifier = request.identifier
-        DispatchQueue.main.async { [weak self] in
-            guard let self, let forge = self.resolveForge(instanceId) else { return }
-            self.ensureVideo(forge, identifier: identifier)
-            guard let video = forge.getVideoAdapter(identifier: identifier) else { return }
-            NSLog("[NPAWForgeRNV] binding AVPlayerAdapter playerId=%@ identifier=%@", playerId, identifier)
-            _ = video.setPlayerAdapter(adapter)
-        }
-    }
-
-    private func reevaluate() {
-        lock.lock()
-        var resolved: [AttachRequest] = []
-        for request in pending {
-            if request.policy == "auto" {
-                let unbound = unboundPlayersLocked()
-                if unbound.count == 1, let candidate = unbound.first {
-                    bindLocked(request, playerId: candidate.id, player: candidate.player)
-                    resolved.append(request)
-                }
-            } else if let candidate = findMatchLocked(request) {
-                bindLocked(request, playerId: candidate.id, player: candidate.player)
-                resolved.append(request)
-            }
-        }
-        pending.removeAll { request in
-            resolved.contains {
-                $0.instanceId == request.instanceId && $0.identifier == request.identifier
-            }
-        }
-        lock.unlock()
-    }
-
-    /// currentItem/asset facts can settle after creation; retry matching a few
-    /// times so 'match' attaches converge without a dedicated KVO web.
-    private func scheduleReevaluations() {
-        for delay in [0.5, 1.5, 3.0] {
-            DispatchQueue.main.asyncAfter(deadline: .now() + delay) { [weak self] in
-                self?.reevaluate()
-            }
-        }
-    }
-
-    /// Tears the binding down: detach the player adapter, then fire the
-    /// terminal stop.
-    ///
-    /// The detach comes first deliberately. By the time this block runs,
-    /// react-native-video has already released its player - `playerRemoved`
-    /// arrives on the main thread and this hop defers a full runloop turn - so
-    /// the adapter is observing a player that is being deallocated. Detaching
-    /// first means the view is closed to it before the stop makes the view
-    /// terminal, and nothing the dying player reports afterwards can be
-    /// mistaken for a replay.
-    ///
-    /// The stop still carries the final position: it never read the player
-    /// (`fireStop` builds its metadata from params), and the kernel backfills
-    /// `playhead` from the last observed position when the firing params carry
-    /// none - `backfill_stop_playhead`, added for
-    /// `apple/2026-07-13_ios-stop-playhead-zero-instead-of-final-position`.
-    private func unbindOnMain(_ binding: Binding, fireStop: Bool) {
-        let instanceId = binding.request.instanceId
-        let identifier = binding.request.identifier
-        DispatchQueue.main.async { [weak self] in
-            guard let self, let forge = self.resolveForge(instanceId) else { return }
-            guard let video = forge.getVideoAdapter(identifier: identifier) else { return }
-            _ = video.setPlayerAdapter(nil)
-            if fireStop {
-                _ = video.fireStop()
-            }
-        }
-    }
-
-    private func nonEmpty(_ value: String?) -> String? {
-        guard let value, !value.isEmpty else { return nil }
-        return value
-    }
-
-    private func attachResult(
-        code: String,
-        accepted: Bool,
-        attachment: String,
-        reason: String? = nil
-    ) -> [String: Any] {
-        var result: [String: Any] = [
-            "code": code,
-            "isAccepted": accepted,
-            "attachment": attachment,
-        ]
-        if let reason {
-            result["reason"] = reason
-        }
-        return result
-    }
-}