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

package/ios/rnv7/ForgeVideoModuleImpl.swift

@@ -0,0 +1,474 @@
+/**
+ * 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 7 on iOS. Same ObjC surface and outcome contract as the v6 generation (auto single-player policy, X-NPAW-Forge token matching, source-URI fallback, per-binding stopOnPlayerRemoved), but the facts come straight from the public HybridVideoPlayer source (uri + config.headers) and one AVPlayer per hybrid means one bind per player - no asset-identity map, no Mirror reflection.
+ */
+
+import AVFoundation
+import Foundation
+#if canImport(NitroModules)
+import NitroModules
+#endif
+#if canImport(ReactNativeVideo)
+import ReactNativeVideo
+#endif
+#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
+    }
+
+    /// One rn-video player as this module sees it. Upstream hands out no id, so
+    /// the module mints one; the hybrid is held weakly (upstream owns its
+    /// lifetime), the AVPlayer strongly (the adapter observes it).
+    private final class LivePlayer {
+        let id: String
+        let identity: ObjectIdentifier
+        weak var hybrid: (any NativeVideoPlayer)?
+        let player: AVPlayer
+        // Facts snapshot, refreshed from the hybrid while it is alive.
+        var token: String?
+        var uri: String?
+
+        /// Whether this AVPlayer showed play intent (`timeControlStatus` other
+        /// than `.paused`) for its current item. That is exactly the condition
+        /// under which `AVPlayerAdapter` opens a started view - and therefore
+        /// fires the terminal stop itself when the item is later replaced with
+        /// nil. See `unbindOnMain`.
+        private var playIntent = false
+        private let playIntentLock = NSLock()
+        private var observations: [NSKeyValueObservation] = []
+
+        init(id: String, hybrid: any NativeVideoPlayer) {
+            self.id = id
+            self.identity = ObjectIdentifier(hybrid as AnyObject)
+            self.hybrid = hybrid
+            self.player = hybrid.player
+            observations.append(
+                player.observe(\.timeControlStatus, options: [.initial, .new]) { [weak self] player, _ in
+                    guard let self, player.timeControlStatus != .paused else { return }
+                    self.playIntentLock.lock()
+                    self.playIntent = true
+                    self.playIntentLock.unlock()
+                }
+            )
+            observations.append(
+                player.observe(\.currentItem, options: [.new]) { [weak self] player, _ in
+                    // A NEW item resets the adapter's started flag (it stops the old
+                    // view first); a transition to nil must keep the flag, because
+                    // that is the teardown we consult it for.
+                    guard let self, player.currentItem != nil else { return }
+                    self.playIntentLock.lock()
+                    self.playIntent = false
+                    self.playIntentLock.unlock()
+                }
+            )
+        }
+
+        deinit {
+            observations.forEach { $0.invalidate() }
+        }
+
+        var sawPlayIntent: Bool {
+            playIntentLock.lock()
+            defer { playIntentLock.unlock() }
+            return playIntent
+        }
+    }
+
+    private struct Binding {
+        let request: AttachRequest
+        let playerId: String
+        let adapter: AVPlayerAdapter
+    }
+
+    private let lock = NSLock()
+    private var livePlayers: [LivePlayer] = []
+    private var sequence = 0
+    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
+    ) {
+        ForgeRNVideoPlugin.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 }
+        refreshFactsLocked()
+
+        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, to: candidate)
+                lock.unlock()
+                resolve(attachResult(code: "accepted", accepted: true, attachment: "bound"))
+                return
+            }
+        } else if let candidate = findMatchLocked(request) {
+            bindLocked(request, to: candidate)
+            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, live: livePlayer(id: removed.playerId))
+        resolve(attachResult(code: "accepted", accepted: true, attachment: "pending"))
+    }
+
+    @objc public func invalidate() {
+        lock.lock()
+        livePlayers.removeAll()
+        pending.removeAll()
+        let current = Array(bindings.values)
+        bindings.removeAll()
+        lock.unlock()
+
+        for binding in current {
+            unbindOnMain(binding, fireStop: false, live: nil)
+        }
+        ForgeRNVideoPlugin.unregister()
+    }
+
+    // MARK: - Plugin callbacks (main thread)
+
+    func playerCreated(_ hybrid: any NativeVideoPlayer) {
+        let identity = ObjectIdentifier(hybrid as AnyObject)
+        lock.lock()
+        if livePlayers.contains(where: { $0.identity == identity }) {
+            // v7 has a single create call site; the guard stays because it is free
+            // and a duplicate would otherwise double-bind.
+            lock.unlock()
+            NSLog("[NPAWForgeRNV] duplicate onPlayerCreated suppressed")
+            return
+        }
+        sequence += 1
+        let live = LivePlayer(id: "rnv7-\(sequence)", hybrid: hybrid)
+        refreshFacts(live)
+        livePlayers.append(live)
+        NSLog("[NPAWForgeRNV] player created id=%@ uri=%@", live.id, live.uri ?? "-")
+        lock.unlock()
+
+        reevaluate()
+        scheduleReevaluations()
+    }
+
+    func playerDestroyed(_ hybrid: (any NativeVideoPlayer)?) {
+        var affected: [(Binding, LivePlayer)] = []
+        var removed: [LivePlayer] = []
+
+        lock.lock()
+        let identity = hybrid.map { ObjectIdentifier($0 as AnyObject) }
+        livePlayers.removeAll { live in
+            // The notified hybrid, plus anything whose weak reference already
+            // cleared (upstream can notify from the hybrid's deinit).
+            let gone = live.identity == identity || live.hybrid == nil
+            if gone { removed.append(live) }
+            return gone
+        }
+        for (key, binding) in bindings {
+            if let live = removed.first(where: { $0.id == binding.playerId }) {
+                bindings.removeValue(forKey: key)
+                affected.append((binding, live))
+            }
+        }
+        lock.unlock()
+
+        // Upstream notifies on the main thread AFTER it replaced the item with
+        // nil, and the AVPlayer keeps delivering transitional KVO (rate /
+        // timeControlStatus) for a moment. Detach synchronously here, on this
+        // very runloop turn, so those late deliveries meet a detached adapter
+        // instead of re-opening a view the adapter has just stopped.
+        for (binding, live) in affected {
+            unbindOnMain(binding, fireStop: binding.request.stopOnPlayerRemoved, live: live)
+        }
+    }
+
+    // MARK: - Coordinator internals
+
+    private func bindingKey(_ instanceId: String, _ identifier: String) -> String {
+        "\(instanceId) \(identifier)"
+    }
+
+    private func livePlayer(id: String) -> LivePlayer? {
+        lock.lock()
+        defer { lock.unlock() }
+        return livePlayers.first { $0.id == id }
+    }
+
+    private func ensureVideo(_ forge: NPAWForge, identifier: String) {
+        if forge.getVideoAdapter(identifier: identifier) == nil {
+            _ = forge.videoBuilder().setIdentifier(identifier).build()
+        }
+    }
+
+    private func unboundPlayersLocked() -> [LivePlayer] {
+        let boundIds = Set(bindings.values.map { $0.playerId })
+        return livePlayers.filter { !boundIds.contains($0.id) }
+    }
+
+    /// Facts live on the hybrid's public source (`uri`, `config.headers`); the
+    /// source can be replaced after creation, so they are re-read on every
+    /// evaluation while the hybrid is alive and the last snapshot is kept after.
+    private func refreshFacts(_ live: LivePlayer) {
+        guard let hybrid = live.hybrid else { return }
+        let source = hybrid.source
+        live.uri = source.uri
+        var token: String?
+        if let headers = source.config.headers {
+            for (key, value) in headers where key.lowercased() == ForgeVideoModuleImpl.tokenHeader {
+                token = value.isEmpty ? nil : value
+                if token != nil { break }
+            }
+        }
+        live.token = token
+    }
+
+    private func refreshFactsLocked() {
+        for live in livePlayers {
+            refreshFacts(live)
+        }
+    }
+
+    private func findMatchLocked(_ request: AttachRequest) -> LivePlayer? {
+        let candidates = unboundPlayersLocked()
+        if let token = request.headerToken {
+            for candidate in candidates where candidate.token == token {
+                return candidate
+            }
+        }
+        if let uri = request.sourceUri {
+            for candidate in candidates where candidate.uri == uri {
+                return candidate
+            }
+        }
+        return nil
+    }
+
+    private func bindLocked(_ request: AttachRequest, to live: LivePlayer) {
+        let adapter = AVPlayerAdapter(player: live.player)
+        bindings[bindingKey(request.instanceId, request.identifier)] = Binding(
+            request: request,
+            playerId: live.id,
+            adapter: adapter
+        )
+        let instanceId = request.instanceId
+        let identifier = request.identifier
+        let playerId = live.id
+        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()
+        refreshFactsLocked()
+        var resolved: [AttachRequest] = []
+        for request in pending {
+            if request.policy == "auto" {
+                let unbound = unboundPlayersLocked()
+                if unbound.count == 1, let candidate = unbound.first {
+                    bindLocked(request, to: candidate)
+                    resolved.append(request)
+                }
+            } else if let candidate = findMatchLocked(request) {
+                bindLocked(request, to: candidate)
+                resolved.append(request)
+            }
+        }
+        pending.removeAll { request in
+            resolved.contains {
+                $0.instanceId == request.instanceId && $0.identifier == request.identifier
+            }
+        }
+        lock.unlock()
+    }
+
+    /// Sources can be replaced after creation (replaceSourceAsync); retry matching
+    /// a few times so 'match' attaches converge without observing upstream state.
+    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 unless the adapter already did. Detach first on purpose: by the time
+    /// this block runs upstream may already have released its player, so the
+    /// view is closed to the adapter before the stop makes it terminal (same
+    /// rationale as the v6 generation). The stop keeps the final position
+    /// through the kernel's playhead backfill.
+    ///
+    /// rn-video 7 tears a player down by `replaceCurrentItem(with: nil)` BEFORE
+    /// it notifies plugins (`HybridVideoPlayer.releaseOnMainThread`), while
+    /// rn-video 6 notified first. So on the removal path the still-attached
+    /// `AVPlayerAdapter` has already seen the item transition and, if the view
+    /// had started, has already fired its terminal stop. A second stop would
+    /// make the kernel open a replacement view (`init -> stop`, the very phantom
+    /// `native/2026-08-13_rn-video-teardown-reinits-view` fixed for v6), so the
+    /// explicit stop is skipped exactly when the item is already gone AND the
+    /// player had shown play intent (= the adapter's own start condition). A
+    /// player torn down before it ever played keeps the explicit stop, which
+    /// closes its init-only view as a genuine exit-before-start.
+    private func unbindOnMain(_ binding: Binding, fireStop: Bool, live: LivePlayer?) {
+        let instanceId = binding.request.instanceId
+        let identifier = binding.request.identifier
+        let playerId = binding.playerId
+        let work: () -> Void = { [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)
+            guard fireStop else { return }
+            if let live, live.player.currentItem == nil, live.sawPlayIntent {
+                NSLog(
+                    "[NPAWForgeRNV] terminal stop already reported by the adapter for playerId=%@ identifier=%@ (item removed upstream before the plugin was notified)",
+                    playerId, identifier)
+                return
+            }
+            _ = video.fireStop()
+        }
+        // Run inline when already on the main thread (the plugin's removal
+        // callback): deferring by a runloop turn is exactly the window in which
+        // a dying AVPlayer's late KVO could still reach the adapter.
+        if Thread.isMainThread {
+            work()
+        } else {
+            DispatchQueue.main.async(execute: work)
+        }
+    }
+
+    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
+        }
+        // One line per attach/detach outcome in the device log, next to the
+        // player-created/binding lines, so a smoke run is legible without the
+        // JS console (RN >= 0.79 no longer echoes console.log to Metro).
+        NSLog("[NPAWForgeRNV] outcome code=%@ attachment=%@ reason=%@", code, attachment, reason ?? "-")
+        return result
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@npaw/forge-react-native-video",
-  "version": "9.7.4",
+  "version": "10.7.4",
   "description": "react-native-video adapter glue for NPAW Forge: attaches the native Media3/AVPlayer Forge adapters to react-native-video's internal players via its native plugin API (react-native-video 6 and 7 generations, one major each).",
   "license": "SEE LICENSE IN LICENSE",
   "author": "Victor Soto <victor.soto@nicepeopleatwork.com>",
@@ -23,7 +23,8 @@
     "@npaw/forge-react-native": "^9.7.4",
     "react": "*",
     "react-native": "*",
-    "react-native-video": ">=6.11.0 <7"
+    "react-native-video": ">=7.0.0-beta.11 <8",
+    "react-native-nitro-modules": ">=0.35.0"
   },
   "codegenConfig": {
     "name": "NPAWForgeVideoSpec",