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

package/android/src/rnv7/java/com/npaw/forge/reactnative/video/NPAWForgeVideoModule.java

@@ -0,0 +1,388 @@
+/**
+ * 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: react-native-video 7 glue TurboModule for Android. Owns a ForgeRNVideoPlugin (upstream ReactNativeVideoPlugin subclass), tracks rn-video's HybridVideoPlayer objects by identity, reads the source URI and X-NPAW-Forge header token straight from the public source config (no MediaItem tag smuggling), copes with the ExoPlayer instance swap that upstream performs on deferred initialisation, and delegates policy to the shared RNVideoAttachCoordinator to bind Forge's Media3PlayerAdapter.
+ */
+
+package com.npaw.forge.reactnative.video;
+
+import android.os.Handler;
+import android.os.Looper;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.OptIn;
+import androidx.media3.common.util.UnstableApi;
+import androidx.media3.exoplayer.ExoPlayer;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.bridge.WritableMap;
+import com.margelo.nitro.video.HybridVideoPlayer;
+import com.margelo.nitro.video.HybridVideoPlayerSourceSpec;
+import com.margelo.nitro.video.NativeVideoConfig;
+import com.npaw.forge.android.NPAWForge;
+import com.npaw.forge.android.adapters.media3.Media3PlayerAdapter;
+import com.npaw.forge.android.video.VideoAdapter;
+import com.npaw.forge.reactnative.ForgeInstanceRegistry;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+@OptIn(markerClass = UnstableApi.class)
+public class NPAWForgeVideoModule extends NativeNPAWForgeVideoSpec
+    implements ForgeRNVideoPlugin.Listener {
+
+  public static final String NAME = "NPAWForgeVideoRN";
+  /** Header customers set on the source config for multi-player matching. */
+  public static final String TOKEN_HEADER = RNVideoHeaderToken.HEADER;
+  private static final String E_UNKNOWN_INSTANCE = "E_FORGE_UNKNOWN_INSTANCE";
+  private static final String PLAYER_ID_PREFIX = "rnv7-";
+  /** Poll cadence while a player created with initializeOnCreation=false waits for its real ExoPlayer. */
+  private static final long DEFERRED_INIT_POLL_MS = 500L;
+
+  /**
+   * One rn-video player as this module sees it. rn-video 7 hands out no id, so the
+   * module mints one and keeps only a weak reference to the hybrid object (upstream
+   * owns its lifetime; the JS-side VideoPlayer releases it).
+   */
+  private static final class PlayerRecord {
+    final String id;
+    final WeakReference<HybridVideoPlayer> hybrid;
+    @Nullable volatile String token;
+    @Nullable volatile String uri;
+    // Main-thread state of the current binding, if any.
+    @Nullable String boundInstanceId;
+    @Nullable String boundIdentifier;
+    @Nullable ExoPlayer boundPlayer;
+    @Nullable Media3PlayerAdapter adapter;
+
+    PlayerRecord(String id, HybridVideoPlayer hybrid) {
+      this.id = id;
+      this.hybrid = new WeakReference<>(hybrid);
+    }
+
+    boolean isBoundTo(String instanceId, String identifier) {
+      return instanceId.equals(boundInstanceId) && identifier.equals(boundIdentifier);
+    }
+  }
+
+  private final ConcurrentHashMap<String, PlayerRecord> records = new ConcurrentHashMap<>();
+  private final AtomicInteger sequence = new AtomicInteger();
+  private final Handler mainHandler = new Handler(Looper.getMainLooper());
+  @Nullable private volatile ForgeRNVideoPlugin plugin;
+
+  private final RNVideoAttachCoordinator<HybridVideoPlayer> coordinator =
+      new RNVideoAttachCoordinator<>(
+          new RNVideoAttachCoordinator.PlayerIntrospection() {
+            @Nullable
+            @Override
+            public String currentToken(String playerId) {
+              PlayerRecord record = records.get(playerId);
+              return record == null ? null : record.token;
+            }
+
+            @Nullable
+            @Override
+            public String currentUri(String playerId) {
+              PlayerRecord record = records.get(playerId);
+              return record == null ? null : record.uri;
+            }
+          },
+          new RNVideoAttachCoordinator.Binder<HybridVideoPlayer>() {
+            @Override
+            public void bind(
+                String instanceId, String identifier, String playerId, HybridVideoPlayer player) {
+              bindOnMain(instanceId, identifier, playerId);
+            }
+
+            @Override
+            public void unbind(
+                String instanceId, String identifier, String playerId, boolean fireStop) {
+              unbindOnMain(instanceId, identifier, playerId, fireStop);
+            }
+          });
+
+  public NPAWForgeVideoModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+    // Register where upstream iterates its registry (VideoManager notifies plugins
+    // under runOnMainThreadSync). PluginsRegistry replaces a same-id plugin, so a
+    // dev-menu reload that re-creates this module cannot leave a stale plugin behind.
+    UiThreadUtil.runOnUiThread(
+        () -> {
+          if (plugin == null) {
+            plugin = new ForgeRNVideoPlugin(this);
+          }
+        });
+  }
+
+  @Override
+  public String getName() {
+    return NAME;
+  }
+
+  // ---- spec surface ----
+
+  @Override
+  public void attach(
+      String instanceId, String identifier, @Nullable ReadableMap options, Promise promise) {
+    NPAWForge forge = ForgeInstanceRegistry.resolve(instanceId);
+    if (forge == null) {
+      promise.reject(E_UNKNOWN_INSTANCE, "No NPAWForge instance '" + instanceId + "'");
+      return;
+    }
+    ensureVideo(forge, identifier);
+
+    Map<String, Object> map = options == null ? new HashMap<>() : options.toHashMap();
+    String headerToken = stringOrNull(map.get("headerToken"));
+    String sourceUri = stringOrNull(map.get("sourceUri"));
+    String policy = stringOrNull(map.get("policy"));
+    if (policy == null) {
+      policy = (headerToken != null || sourceUri != null) ? "match" : "auto";
+    }
+    boolean stopOnPlayerRemoved =
+        !(map.get("stopOnPlayerRemoved") instanceof Boolean)
+            || (Boolean) map.get("stopOnPlayerRemoved");
+
+    RNVideoAttachCoordinator.AttachOutcome outcome =
+        coordinator.attach(
+            new RNVideoAttachCoordinator.AttachRequest(
+                instanceId, identifier, policy, headerToken, sourceUri, stopOnPlayerRemoved));
+    scheduleFactRefreshes();
+    promise.resolve(attachResult(outcome));
+  }
+
+  @Override
+  public void detach(String instanceId, String identifier, Promise promise) {
+    boolean removed = coordinator.detach(instanceId, identifier, true);
+    WritableMap result = Arguments.createMap();
+    result.putString("code", removed ? "accepted" : "ignored_invalid_state");
+    result.putBoolean("isAccepted", removed);
+    result.putString("attachment", "pending");
+    promise.resolve(result);
+  }
+
+  @Override
+  public void invalidate() {
+    ForgeRNVideoPlugin current = plugin;
+    plugin = null;
+    if (current != null) {
+      UiThreadUtil.runOnUiThread(current::unregister);
+    }
+    coordinator.clear();
+    records.clear();
+    super.invalidate();
+  }
+
+  // ---- ForgeRNVideoPlugin.Listener (main thread) ----
+
+  @Override
+  public void onRnvPlayerCreated(@NonNull HybridVideoPlayer hybrid) {
+    if (findRecord(hybrid) != null) {
+      return; // defensive: upstream registers each hybrid once
+    }
+    String id = PLAYER_ID_PREFIX + sequence.incrementAndGet();
+    PlayerRecord record = new PlayerRecord(id, hybrid);
+    records.put(id, record);
+    refreshFacts(record, hybrid);
+    coordinator.playerCreated(id, hybrid);
+    scheduleFactRefreshes();
+  }
+
+  @Override
+  public void onRnvPlayerDestroyed(@Nullable HybridVideoPlayer hybrid) {
+    if (hybrid != null) {
+      PlayerRecord record = findRecord(hybrid);
+      if (record != null) {
+        removeRecord(record);
+      }
+    }
+    // Upstream's WeakReference can already be cleared; anything we track whose
+    // hybrid is gone is gone too.
+    for (PlayerRecord record : new ArrayList<>(records.values())) {
+      if (record.hybrid.get() == null) {
+        removeRecord(record);
+      }
+    }
+  }
+
+  // ---- internals ----
+
+  @Nullable
+  private PlayerRecord findRecord(HybridVideoPlayer hybrid) {
+    for (PlayerRecord record : records.values()) {
+      if (record.hybrid.get() == hybrid) {
+        return record;
+      }
+    }
+    return null;
+  }
+
+  private void removeRecord(PlayerRecord record) {
+    records.remove(record.id);
+    coordinator.playerRemoved(record.id);
+  }
+
+  private void ensureVideo(NPAWForge forge, String identifier) {
+    if (forge.getVideoAdapter(identifier) == null) {
+      forge.videoBuilder().setIdentifier(identifier).build();
+    }
+  }
+
+  /**
+   * Facts come straight from the public source config. Sources can be replaced after
+   * creation (replaceSourceAsync) and the real ExoPlayer can appear after a deferred
+   * initialize(); a few delayed main-thread refreshes converge both and re-run the
+   * pending-match evaluation, mirroring the v6 module's cadence.
+   */
+  private void scheduleFactRefreshes() {
+    for (long delayMs : new long[] {0L, 500L, 1500L, 3000L}) {
+      mainHandler.postDelayed(
+          () -> {
+            for (PlayerRecord record : records.values()) {
+              HybridVideoPlayer hybrid = record.hybrid.get();
+              if (hybrid == null) {
+                continue;
+              }
+              refreshFacts(record, hybrid);
+              rebindIfPlayerSwapped(record, hybrid);
+            }
+            coordinator.playerSourceSettled();
+          },
+          delayMs);
+    }
+  }
+
+  /** Reads uri + token; safe on any thread (the config is an immutable data class). */
+  private static void refreshFacts(PlayerRecord record, HybridVideoPlayer hybrid) {
+    try {
+      HybridVideoPlayerSourceSpec source = hybrid.getSource();
+      record.uri = source.getUri();
+      NativeVideoConfig config = source.getConfig();
+      record.token = RNVideoHeaderToken.fromHeaders(config.getHeaders());
+    } catch (RuntimeException ignored) {
+      // `source` is a Kotlin lateinit upstream; it is always assigned before the
+      // player is registered, but a racing release must not take the module down.
+    }
+  }
+
+  private void bindOnMain(String instanceId, String identifier, String playerId) {
+    UiThreadUtil.runOnUiThread(
+        () -> {
+          PlayerRecord record = records.get(playerId);
+          if (record == null) {
+            return;
+          }
+          record.boundInstanceId = instanceId;
+          record.boundIdentifier = identifier;
+          record.boundPlayer = null;
+          record.adapter = null;
+          attachAdapterWhenReady(record, instanceId, identifier);
+        });
+  }
+
+  /** Main thread. Binds Media3PlayerAdapter to the hybrid's REAL ExoPlayer. */
+  private void attachAdapterWhenReady(PlayerRecord record, String instanceId, String identifier) {
+    if (!record.isBoundTo(instanceId, identifier)) {
+      return; // detached or rebound meanwhile
+    }
+    HybridVideoPlayer hybrid = record.hybrid.get();
+    if (hybrid == null) {
+      return;
+    }
+    if (!hybrid.getLoadedWithSource()) {
+      // initializeOnCreation=false: upstream still holds its temporary ExoPlayer and
+      // will replace it inside initialize()/preload(). Binding the placeholder would
+      // observe nothing, so wait for the real one.
+      mainHandler.postDelayed(
+          () -> attachAdapterWhenReady(record, instanceId, identifier), DEFERRED_INIT_POLL_MS);
+      return;
+    }
+    attachAdapter(record, hybrid, instanceId, identifier);
+  }
+
+  /** Main thread. */
+  private void attachAdapter(
+      PlayerRecord record, HybridVideoPlayer hybrid, String instanceId, String identifier) {
+    NPAWForge forge = ForgeInstanceRegistry.resolve(instanceId);
+    if (forge == null) {
+      return;
+    }
+    ensureVideo(forge, identifier);
+    VideoAdapter video = forge.getVideoAdapter(identifier);
+    if (video == null) {
+      return;
+    }
+    ExoPlayer player = hybrid.getPlayer();
+    Media3PlayerAdapter adapter = new Media3PlayerAdapter(player);
+    video.setPlayerAdapter(adapter);
+    record.boundPlayer = player;
+    record.adapter = adapter;
+  }
+
+  /** Main thread. A late initialize() swaps the ExoPlayer under a live binding: follow it. */
+  private void rebindIfPlayerSwapped(PlayerRecord record, HybridVideoPlayer hybrid) {
+    if (record.boundPlayer == null || record.boundInstanceId == null || record.boundIdentifier == null) {
+      return;
+    }
+    if (!hybrid.getLoadedWithSource() || hybrid.getPlayer() == record.boundPlayer) {
+      return;
+    }
+    // The previous instance was upstream's placeholder (or a stale player): it never
+    // reported anything, so replace the adapter silently rather than firing Stop.
+    attachAdapter(record, hybrid, record.boundInstanceId, record.boundIdentifier);
+  }
+
+  private void unbindOnMain(String instanceId, String identifier, String playerId, boolean fireStop) {
+    UiThreadUtil.runOnUiThread(
+        () -> {
+          PlayerRecord record = records.get(playerId);
+          if (record != null && record.isBoundTo(instanceId, identifier)) {
+            record.boundInstanceId = null;
+            record.boundIdentifier = null;
+            record.boundPlayer = null;
+            record.adapter = null;
+          }
+          VideoAdapter video = ForgeInstanceRegistry.resolveVideoAdapter(instanceId, identifier);
+          if (video == null) {
+            return;
+          }
+          if (fireStop) {
+            video.fireStop();
+          }
+          video.setPlayerAdapter(null);
+        });
+  }
+
+  @Nullable
+  private static String stringOrNull(@Nullable Object value) {
+    if (value instanceof String && !((String) value).isEmpty()) {
+      return (String) value;
+    }
+    return null;
+  }
+
+  private static WritableMap attachResult(RNVideoAttachCoordinator.AttachOutcome outcome) {
+    WritableMap result = Arguments.createMap();
+    result.putString("code", outcome.code);
+    result.putBoolean("isAccepted", outcome.accepted);
+    result.putString("attachment", outcome.attachment);
+    if (outcome.reason != null) {
+      result.putString("reason", outcome.reason);
+    }
+    return result;
+  }
+}

package/android/src/{main → rnv7}/java/com/npaw/forge/reactnative/video/NPAWForgeVideoPackage.java

@@ -9,11 +9,12 @@
  *
  *
  * @author: Victor Soto <victor.soto@nicepeopleatwork.com>
- * @description: React package registering the NPAWForgeVideo TurboModule for autolinking.
+ * @description: React package registering the NPAWForgeVideo TurboModule for autolinking (react-native-video 7 generation; same class name and module id as the v6 generation so JS and autolinking are generation-agnostic).
  */
 
 package com.npaw.forge.reactnative.video;
 
+import androidx.annotation.Nullable;
 import com.facebook.react.TurboReactPackage;
 import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
@@ -21,7 +22,6 @@ import com.facebook.react.module.model.ReactModuleInfo;
 import com.facebook.react.module.model.ReactModuleInfoProvider;
 import java.util.HashMap;
 import java.util.Map;
-import androidx.annotation.Nullable;
 
 public class NPAWForgeVideoPackage extends TurboReactPackage {
 

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

@@ -0,0 +1,68 @@
+/**
+ * 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 header-token extraction shared by the react-native-video 7 module (case-insensitive header key, empty and missing values, first non-empty casing wins).
+ */
+
+package com.npaw.forge.reactnative.video;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import org.junit.Test;
+
+public class RNVideoHeaderTokenTest {
+
+  @Test
+  public void nullMapYieldsNull() {
+    assertNull(RNVideoHeaderToken.fromHeaders(null));
+  }
+
+  @Test
+  public void missingHeaderYieldsNull() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put("Authorization", "Bearer x");
+    assertNull(RNVideoHeaderToken.fromHeaders(headers));
+  }
+
+  @Test
+  public void matchesTheHeaderCaseInsensitively() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put("X-NPAW-Forge", "main");
+    assertEquals("main", RNVideoHeaderToken.fromHeaders(headers));
+
+    headers.clear();
+    headers.put("x-npaw-forge", "pip");
+    assertEquals("pip", RNVideoHeaderToken.fromHeaders(headers));
+
+    headers.clear();
+    headers.put("X-Npaw-FORGE", "mixed");
+    assertEquals("mixed", RNVideoHeaderToken.fromHeaders(headers));
+  }
+
+  @Test
+  public void emptyValueCountsAsAbsent() {
+    Map<String, String> headers = new HashMap<>();
+    headers.put("X-NPAW-Forge", "");
+    assertNull(RNVideoHeaderToken.fromHeaders(headers));
+  }
+
+  @Test
+  public void firstNonEmptyCasingWins() {
+    Map<String, String> headers = new LinkedHashMap<>();
+    headers.put("x-npaw-forge", "");
+    headers.put("X-NPAW-Forge", "second");
+    assertEquals("second", RNVideoHeaderToken.fromHeaders(headers));
+  }
+}

package/generations.json

@@ -0,0 +1,31 @@
+{
+  "$comment": "Single source of truth for the react-native-video generations shipped by @npaw/forge-react-native-video. Read by android/build.gradle, the podspec, the jest guard, and scripts/react-native/stage-react-native-npm.sh. Same npm package name, one major per generation.",
+  "package": "@npaw/forge-react-native-video",
+  "generations": {
+    "rnv6": {
+      "reactNativeVideo": ">=6.11.0 <7",
+      "reactNativeVideoMajor": 6,
+      "verifiedUpstream": "6.19.2",
+      "packageMajor": "forge",
+      "distTag": "latest",
+      "androidSourceSet": "src/rnv6/java",
+      "iosDir": "ios/rnv6",
+      "podDependency": "react-native-video",
+      "platforms": ["ios", "tvos"]
+    },
+    "rnv7": {
+      "reactNativeVideo": ">=7.0.0-beta.11 <8",
+      "reactNativeVideoMajor": 7,
+      "verifiedUpstream": "7.0.0-beta.11",
+      "upstreamStatus": "beta",
+      "packageMajor": 10,
+      "distTag": "rn-video-7",
+      "androidSourceSet": "src/rnv7/java",
+      "iosDir": "ios/rnv7",
+      "podDependency": "ReactNativeVideo",
+      "extraPodDependencies": ["NitroModules"],
+      "nitroModules": ">=0.35.0",
+      "platforms": ["ios"]
+    }
+  }
+}

package/ios/rnv7/ForgeRNVideoPlugin.swift

@@ -0,0 +1,64 @@
+/**
+ * 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: react-native-video 7 plugin object for iOS. Subclasses the upstream ReactNativeVideoPlugin (whose initializer registers it in PluginsRegistry.shared, keyed by id) and forwards player create/destroy notifications, delivered on the main thread, to the Forge video module implementation.
+ */
+
+import AVFoundation
+import Foundation
+#if canImport(NitroModules)
+import NitroModules
+#endif
+#if canImport(ReactNativeVideo)
+import ReactNativeVideo
+#endif
+
+/// One plugin object per process. rn-video 7 keys plugins by `id`
+/// ("RNV_Plugin_NPAWForge") and replaces a same-id registration, so even a
+/// double registration could not duplicate callbacks; this class still creates
+/// the object exactly once and unregisters it on module invalidation.
+final class ForgeRNVideoPlugin: ReactNativeVideoPlugin {
+
+    static let pluginName = "NPAWForge"
+    private static var current: ForgeRNVideoPlugin?
+    private static let registrationLock = NSLock()
+
+    static func registerOnce() {
+        registrationLock.lock()
+        defer { registrationLock.unlock() }
+        guard current == nil else { return }
+        current = ForgeRNVideoPlugin()
+    }
+
+    static func unregister() {
+        registrationLock.lock()
+        defer { registrationLock.unlock() }
+        guard let plugin = current else { return }
+        PluginsRegistry.shared.unregister(plugin: plugin)
+        current = nil
+    }
+
+    private init() {
+        // The upstream initializer performs the registration.
+        super.init(name: ForgeRNVideoPlugin.pluginName)
+    }
+
+    override func onPlayerCreated(player: Weak<NativeVideoPlayer>) {
+        guard let hybrid = player.value else { return }
+        ForgeVideoModuleImpl.shared.playerCreated(hybrid)
+    }
+
+    override func onPlayerDestroyed(player: Weak<NativeVideoPlayer>) {
+        // `value` is nil when upstream notifies from the hybrid's deinit; the module
+        // then sweeps whichever tracked player has gone away.
+        ForgeVideoModuleImpl.shared.playerDestroyed(player.value)
+    }
+}