@npaw/forge-react-native-video 9.6.1

package/android/src/test/java/com/npaw/forge/reactnative/video/RNVideoAttachCoordinatorTest.java

@@ -0,0 +1,218 @@
+/**
+ * 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: JVM unit tests for the attach correlation policy engine (fake players; no ExoPlayer or Android runtime).
+ */
+
+package com.npaw.forge.reactnative.video;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import androidx.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.Before;
+import org.junit.Test;
+
+public class RNVideoAttachCoordinatorTest {
+
+  private static final class FakeBinder implements RNVideoAttachCoordinator.Binder<Object> {
+    final List<String> binds = new ArrayList<>();
+    final List<String> unbinds = new ArrayList<>();
+
+    @Override
+    public void bind(String instanceId, String identifier, String playerId, Object player) {
+      binds.add(identifier + "->" + playerId);
+    }
+
+    @Override
+    public void unbind(String instanceId, String identifier, String playerId, boolean fireStop) {
+      unbinds.add(identifier + "->" + playerId + (fireStop ? " stop" : " silent"));
+    }
+  }
+
+  private final Map<String, String> tokens = new HashMap<>();
+  private final Map<String, String> uris = new HashMap<>();
+  private FakeBinder binder;
+  private RNVideoAttachCoordinator<Object> coordinator;
+
+  @Before
+  public void setUp() {
+    tokens.clear();
+    uris.clear();
+    binder = new FakeBinder();
+    coordinator =
+        new RNVideoAttachCoordinator<>(
+            new RNVideoAttachCoordinator.PlayerIntrospection() {
+              @Nullable
+              @Override
+              public String currentToken(String playerId) {
+                return tokens.get(playerId);
+              }
+
+              @Nullable
+              @Override
+              public String currentUri(String playerId) {
+                return uris.get(playerId);
+              }
+            },
+            binder);
+  }
+
+  private static RNVideoAttachCoordinator.AttachRequest auto(String identifier) {
+    return new RNVideoAttachCoordinator.AttachRequest(
+        "forge-1", identifier, "auto", null, null, true);
+  }
+
+  private static RNVideoAttachCoordinator.AttachRequest token(String identifier, String token) {
+    return new RNVideoAttachCoordinator.AttachRequest(
+        "forge-1", identifier, "match", token, null, true);
+  }
+
+  private static RNVideoAttachCoordinator.AttachRequest uri(String identifier, String uri) {
+    return new RNVideoAttachCoordinator.AttachRequest(
+        "forge-1", identifier, "match", null, uri, true);
+  }
+
+  @Test
+  public void attachBeforeCreateBindsWhenPlayerArrives() {
+    RNVideoAttachCoordinator.AttachOutcome outcome = coordinator.attach(auto("default"));
+    assertEquals("pending", outcome.attachment);
+    assertTrue(outcome.accepted);
+
+    coordinator.playerCreated("p1", new Object());
+    assertEquals(List.of("default->p1"), binder.binds);
+  }
+
+  @Test
+  public void createBeforeAttachBindsImmediately() {
+    coordinator.playerCreated("p1", new Object());
+    RNVideoAttachCoordinator.AttachOutcome outcome = coordinator.attach(auto("default"));
+    assertEquals("bound", outcome.attachment);
+    assertEquals(List.of("default->p1"), binder.binds);
+  }
+
+  @Test
+  public void autoRefusesAmbiguity() {
+    coordinator.playerCreated("p1", new Object());
+    coordinator.playerCreated("p2", new Object());
+    RNVideoAttachCoordinator.AttachOutcome outcome = coordinator.attach(auto("default"));
+    assertEquals("unsupported_capability", outcome.code);
+    assertEquals("ambiguous_auto_attach", outcome.reason);
+    assertTrue(binder.binds.isEmpty());
+  }
+
+  @Test
+  public void autoPendingDoesNotBindWhileAmbiguous() {
+    coordinator.attach(auto("default"));
+    coordinator.playerCreated("p1", new Object());
+    coordinator.playerCreated("p2", new Object());
+    // p1 bound the pending attach when it was the single player; p2 arriving
+    // afterwards must not steal or duplicate.
+    assertEquals(List.of("default->p1"), binder.binds);
+  }
+
+  @Test
+  public void headerTokenMatchesTheRightPlayer() {
+    coordinator.playerCreated("p1", new Object());
+    coordinator.playerCreated("p2", new Object());
+    tokens.put("p2", "main");
+
+    RNVideoAttachCoordinator.AttachOutcome outcome = coordinator.attach(token("default", "main"));
+    assertEquals("bound", outcome.attachment);
+    assertEquals(List.of("default->p2"), binder.binds);
+  }
+
+  @Test
+  public void tokenSettlingLateBindsOnSourceSettled() {
+    coordinator.playerCreated("p1", new Object());
+    coordinator.playerCreated("p2", new Object());
+    RNVideoAttachCoordinator.AttachOutcome outcome = coordinator.attach(token("default", "main"));
+    assertEquals("pending", outcome.attachment);
+
+    tokens.put("p1", "main");
+    coordinator.playerSourceSettled();
+    assertEquals(List.of("default->p1"), binder.binds);
+  }
+
+  @Test
+  public void sourceUriFallbackMatches() {
+    coordinator.playerCreated("p1", new Object());
+    coordinator.playerCreated("p2", new Object());
+    uris.put("p2", "https://cdn/x.m3u8");
+
+    coordinator.attach(uri("default", "https://cdn/x.m3u8"));
+    assertEquals(List.of("default->p2"), binder.binds);
+  }
+
+  @Test
+  public void twoIdentifiersTwoTokensBindDistinctPlayers() {
+    coordinator.playerCreated("p1", new Object());
+    coordinator.playerCreated("p2", new Object());
+    tokens.put("p1", "a");
+    tokens.put("p2", "b");
+
+    coordinator.attach(token("main", "a"));
+    coordinator.attach(token("pip", "b"));
+    assertEquals(List.of("main->p1", "pip->b".replace("b", "p2")), binder.binds);
+  }
+
+  @Test
+  public void duplicateAttachIsIgnored() {
+    coordinator.playerCreated("p1", new Object());
+    coordinator.attach(auto("default"));
+    RNVideoAttachCoordinator.AttachOutcome outcome = coordinator.attach(auto("default"));
+    assertEquals("ignored_duplicate", outcome.code);
+    assertEquals(1, binder.binds.size());
+  }
+
+  @Test
+  public void detachUnbindsWithStopAndAllowsRebind() {
+    coordinator.playerCreated("p1", new Object());
+    coordinator.attach(auto("default"));
+
+    assertTrue(coordinator.detach("forge-1", "default", true));
+    assertEquals(List.of("default->p1 stop"), binder.unbinds);
+
+    coordinator.attach(auto("default"));
+    assertEquals(2, binder.binds.size());
+  }
+
+  @Test
+  public void detachWithoutBindingReportsFalse() {
+    assertFalse(coordinator.detach("forge-1", "default", true));
+  }
+
+  @Test
+  public void playerRemovedHonorsStopOnPlayerRemoved() {
+    coordinator.playerCreated("p1", new Object());
+    coordinator.attach(
+        new RNVideoAttachCoordinator.AttachRequest("forge-1", "default", "auto", null, null, false));
+    coordinator.playerRemoved("p1");
+    assertEquals(List.of("default->p1 silent"), binder.unbinds);
+  }
+
+  @Test
+  public void reattachAfterRemovalGoesPendingThenBindsNextPlayer() {
+    coordinator.playerCreated("p1", new Object());
+    coordinator.attach(auto("default"));
+    coordinator.playerRemoved("p1");
+
+    RNVideoAttachCoordinator.AttachOutcome outcome = coordinator.attach(auto("default"));
+    assertEquals("pending", outcome.attachment);
+    coordinator.playerCreated("p2", new Object());
+    assertEquals(List.of("default->p1", "default->p2"), binder.binds);
+  }
+}

package/ios/ForgeRNVPlayerPlugin.swift

@@ -0,0 +1,80 @@
+/**
+ * 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: Mandatory RNVAVPlayerPlugin subclass (split object from the TurboModule); forwards react-native-video player lifecycle and source/asset sightings to the Forge attach coordinator.
+ */
+
+import AVFoundation
+import Foundation
+#if canImport(react_native_video)
+import react_native_video
+#endif
+
+/// react-native-video stores plugins in an unordered Set and RCTVideo has two
+/// onInstanceCreated call sites, so this object registers exactly once and the
+/// coordinator dedupes repeated deliveries of the same player.
+final class ForgeRNVPlayerPlugin: RNVAVPlayerPlugin {
+
+    static let shared = ForgeRNVPlayerPlugin()
+    private static var registered = false
+    private static let registrationLock = NSLock()
+
+    static func registerOnce() {
+        registrationLock.lock()
+        defer { registrationLock.unlock() }
+        guard !registered else { return }
+        registered = true
+        ReactNativeVideoManager.shared.registerPlugin(plugin: shared)
+    }
+
+    override func onInstanceCreated(id: String, player: AVPlayer) {
+        NSLog("[NPAWForgeRNV] player created id=%@", id)
+        ForgeVideoModuleImpl.shared.playerCreated(id: id, player: player)
+    }
+
+    override func onInstanceRemoved(id: String, player: AVPlayer) {
+        ForgeVideoModuleImpl.shared.playerRemoved(id: id, player: player)
+    }
+
+    /// Called for every AVPlayerItem creation; we never override the asset,
+    /// but we record (asset identity -> token/uri) so the coordinator can
+    /// correlate players with sources deterministically.
+    ///
+    /// VideoSource's fields are `internal` to react-native-video, so the
+    /// token/uri are read via Mirror reflection (read-only), with the
+    /// AVURLAsset URL as the fallback. Follow-up filed to propose public
+    /// accessors upstream.
+    override func overridePlayerAsset(source: VideoSource, asset: AVAsset) async -> OverridePlayerAssetResult? {
+        var token: String?
+        var uri: String?
+        let mirror = Mirror(reflecting: source)
+        for child in mirror.children {
+            switch child.label {
+            case "uri":
+                uri = child.value as? String ?? (child.value as? String?) ?? nil
+            case "requestHeaders":
+                let headers = (child.value as? [String: Any]) ?? (child.value as? [String: Any]?) ?? nil
+                if let headers {
+                    for (key, value) in headers where key.lowercased() == ForgeVideoModuleImpl.tokenHeader {
+                        token = value as? String
+                    }
+                }
+            default:
+                break
+            }
+        }
+        if uri == nil, let urlAsset = asset as? AVURLAsset {
+            uri = urlAsset.url.absoluteString
+        }
+        ForgeVideoModuleImpl.shared.sourceSeen(asset: asset, token: token, uri: uri)
+        return nil
+    }
+}

package/ios/ForgeVideoModuleImpl.swift

@@ -0,0 +1,347 @@
+/**
+ * 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()
+            }
+        }
+    }
+
+    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 }
+            if fireStop {
+                _ = video.fireStop()
+            }
+            _ = video.setPlayerAdapter(nil)
+        }
+    }
+
+    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
+    }
+}