react-native-tvos 0.74.5-0 → 0.75.2-0

package/ReactAndroid/src/main/java/com/facebook/react/animated/NativeAnimatedModule.java

@@ -25,6 +25,7 @@ import com.facebook.react.bridge.UIManager;
 import com.facebook.react.bridge.UIManagerListener;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.common.annotations.VisibleForTesting;
+import com.facebook.react.internal.featureflags.ReactNativeFeatureFlags;
 import com.facebook.react.module.annotations.ReactModule;
 import com.facebook.react.modules.core.ReactChoreographer;
 import com.facebook.react.uimanager.GuardedFrameCallback;
@@ -225,6 +226,7 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
 
   private boolean mInitializedForFabric = false;
   private boolean mInitializedForNonFabric = false;
+  private boolean mEnqueuedAnimationOnFrame = false;
   private @UIManagerType int mUIManagerType = UIManagerType.DEFAULT;
   private int mNumFabricAnimations = 0;
   private int mNumNonFabricAnimations = 0;
@@ -238,23 +240,20 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
           @Override
           protected void doFrameGuarded(final long frameTimeNanos) {
             try {
+              mEnqueuedAnimationOnFrame = false;
               NativeAnimatedNodesManager nodesManager = getNodesManager();
               if (nodesManager != null && nodesManager.hasActiveAnimations()) {
                 nodesManager.runUpdates(frameTimeNanos);
               }
               // This is very unlikely to ever be hit.
-              if (nodesManager == null && mReactChoreographer == null) {
+              if (nodesManager == null || mReactChoreographer == null) {
                 return;
               }
 
-              // TODO: Would be great to avoid adding this callback in case there are no active
-              // animations and no outstanding tasks on the operations queue. Apparently frame
-              // callbacks can only be posted from the UI thread and therefore we cannot schedule
-              // them directly from other threads.
-              Assertions.assertNotNull(mReactChoreographer)
-                  .postFrameCallback(
-                      ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE,
-                      mAnimatedFrameCallback);
+              if (!ReactNativeFeatureFlags.lazyAnimationCallbacks()
+                  || nodesManager.hasActiveAnimations()) {
+                enqueueFrameCallback();
+              }
             } catch (Exception ex) {
               throw new RuntimeException(ex);
             }
@@ -406,12 +405,16 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
     Assertions.assertNotNull(mReactChoreographer)
         .removeFrameCallback(
             ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE, mAnimatedFrameCallback);
+    mEnqueuedAnimationOnFrame = false;
   }
 
   private void enqueueFrameCallback() {
-    Assertions.assertNotNull(mReactChoreographer)
-        .postFrameCallback(
-            ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE, mAnimatedFrameCallback);
+    if (!mEnqueuedAnimationOnFrame) {
+      Assertions.assertNotNull(mReactChoreographer)
+          .postFrameCallback(
+              ReactChoreographer.CallbackType.NATIVE_ANIMATED_MODULE, mAnimatedFrameCallback);
+      mEnqueuedAnimationOnFrame = true;
+    }
   }
 
   @VisibleForTesting
@@ -441,7 +444,8 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
       ReactSoftExceptionLogger.logSoftException(
           NAME,
           new RuntimeException(
-              "initializeLifecycleEventListenersForViewTag could not get NativeAnimatedNodesManager"));
+              "initializeLifecycleEventListenersForViewTag could not get"
+                  + " NativeAnimatedNodesManager"));
     }
 
     // Subscribe to UIManager (Fabric or non-Fabric) lifecycle events if we haven't yet
@@ -1116,6 +1120,9 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
                       opsAndArgs.getInt(i++), opsAndArgs.getInt(i++));
                   break;
                 case OP_CODE_START_ANIMATING_NODE:
+                  if (ReactNativeFeatureFlags.lazyAnimationCallbacks()) {
+                    enqueueFrameCallback();
+                  }
                   animatedNodesManager.startAnimatingNode(
                       opsAndArgs.getInt(i++), opsAndArgs.getInt(i++), opsAndArgs.getMap(i++), null);
                   break;

package/ReactAndroid/src/main/java/com/facebook/react/animated/NativeAnimatedNodesManager.java

@@ -427,7 +427,8 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
     }
     if (mReactApplicationContext == null) {
       throw new IllegalStateException(
-          "connectAnimatedNodeToView: Animated node could not be connected, no ReactApplicationContext: "
+          "connectAnimatedNodeToView: Animated node could not be connected, no"
+              + " ReactApplicationContext: "
               + viewTag);
     }
 
@@ -438,7 +439,8 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
       ReactSoftExceptionLogger.logSoftException(
           TAG,
           new ReactNoCrashSoftException(
-              "connectAnimatedNodeToView: Animated node could not be connected to UIManager - uiManager disappeared for tag: "
+              "connectAnimatedNodeToView: Animated node could not be connected to UIManager -"
+                  + " uiManager disappeared for tag: "
                   + viewTag));
       return;
     }

package/ReactAndroid/src/main/java/com/facebook/react/bridge/BaseActivityEventListener.java

@@ -14,7 +14,9 @@ import androidx.annotation.Nullable;
 /** An empty implementation of {@link ActivityEventListener} */
 public class BaseActivityEventListener implements ActivityEventListener {
 
-  /** @deprecated use {@link #onActivityResult(Activity, int, int, Intent)} instead. */
+  /**
+   * @deprecated use {@link #onActivityResult(Activity, int, int, Intent)} instead.
+   */
   @Deprecated
   public void onActivityResult(int requestCode, int resultCode, Intent data) {}
 

package/ReactAndroid/src/main/java/com/facebook/react/bridge/BaseJavaModule.java

@@ -64,7 +64,9 @@ public abstract class BaseJavaModule implements NativeModule {
     mReactApplicationContext = reactContext;
   }
 
-  /** @return a map of constants this module exports to JS. Supports JSON types. */
+  /**
+   * @return a map of constants this module exports to JS. Supports JSON types.
+   */
   @DeprecatedInNewArchitecture()
   public @Nullable Map<String, Object> getConstants() {
     return null;
@@ -94,7 +96,8 @@ public abstract class BaseJavaModule implements NativeModule {
   protected final ReactApplicationContext getReactApplicationContext() {
     return Assertions.assertNotNull(
         mReactApplicationContext,
-        "Tried to get ReactApplicationContext even though NativeModule wasn't instantiated with one");
+        "Tried to get ReactApplicationContext even though NativeModule wasn't instantiated with"
+            + " one");
   }
 
   /**

package/ReactAndroid/src/main/java/com/facebook/react/bridge/BridgeReactContext.java

@@ -0,0 +1,292 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.bridge;
+
+import static com.facebook.infer.annotation.ThreadConfined.UI;
+
+import android.content.Context;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.facebook.common.logging.FLog;
+import com.facebook.infer.annotation.Assertions;
+import com.facebook.infer.annotation.ThreadConfined;
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.queue.ReactQueueConfiguration;
+import com.facebook.react.common.ReactConstants;
+import com.facebook.react.common.annotations.DeprecatedInNewArchitecture;
+import com.facebook.react.common.annotations.FrameworkAPI;
+import com.facebook.react.common.annotations.UnstableReactNativeAPI;
+import com.facebook.react.turbomodule.core.interfaces.CallInvokerHolder;
+import java.util.Collection;
+
+/**
+ * This is the bridge-specific concrete subclass of ReactContext. ReactContext has many methods that
+ * delegate to the react instance. This subclass implements those methods, by delegating to the
+ * CatalystInstance. If you need to create a ReactContext within an "bridge context", please create
+ * BridgeReactContext.
+ */
+@DeprecatedInNewArchitecture
+public class BridgeReactContext extends ReactApplicationContext {
+  @DoNotStrip
+  public interface RCTDeviceEventEmitter extends JavaScriptModule {
+    void emit(@NonNull String eventName, @Nullable Object data);
+  }
+
+  private static final String TAG = "BridgeReactContext";
+
+  private static final String EARLY_JS_ACCESS_EXCEPTION_MESSAGE =
+      "Tried to access a JS module before the React instance was fully set up. Calls to "
+          + "ReactContext#getJSModule should only happen once initialize() has been called on your "
+          + "native module.";
+  private static final String LATE_JS_ACCESS_EXCEPTION_MESSAGE =
+      "Tried to access a JS module after the React instance was destroyed.";
+  private static final String EARLY_NATIVE_MODULE_EXCEPTION_MESSAGE =
+      "Trying to call native module before CatalystInstance has been set!";
+  private static final String LATE_NATIVE_MODULE_EXCEPTION_MESSAGE =
+      "Trying to call native module after CatalystInstance has been destroyed!";
+
+  private volatile boolean mDestroyed = false;
+  private @Nullable CatalystInstance mCatalystInstance;
+
+  public BridgeReactContext(Context context) {
+    super(context);
+  }
+
+  /** Set and initialize CatalystInstance for this Context. This should be called exactly once. */
+  public void initializeWithInstance(CatalystInstance catalystInstance) {
+    if (catalystInstance == null) {
+      throw new IllegalArgumentException("CatalystInstance cannot be null.");
+    }
+    if (mCatalystInstance != null) {
+      throw new IllegalStateException("ReactContext has been already initialized");
+    }
+    if (mDestroyed) {
+      ReactSoftExceptionLogger.logSoftException(
+          TAG,
+          new IllegalStateException("Cannot initialize ReactContext after it has been destroyed."));
+    }
+
+    mCatalystInstance = catalystInstance;
+
+    ReactQueueConfiguration queueConfig = catalystInstance.getReactQueueConfiguration();
+    initializeMessageQueueThreads(queueConfig);
+    initializeInteropModules();
+  }
+
+  private void raiseCatalystInstanceMissingException() {
+    throw new IllegalStateException(
+        mDestroyed ? LATE_NATIVE_MODULE_EXCEPTION_MESSAGE : EARLY_NATIVE_MODULE_EXCEPTION_MESSAGE);
+  }
+
+  /**
+   * @return handle to the specified JS module for the CatalystInstance associated with this Context
+   */
+  @Override
+  public <T extends JavaScriptModule> T getJSModule(Class<T> jsInterface) {
+    if (mCatalystInstance == null) {
+      if (mDestroyed) {
+        throw new IllegalStateException(LATE_JS_ACCESS_EXCEPTION_MESSAGE);
+      }
+      throw new IllegalStateException(EARLY_JS_ACCESS_EXCEPTION_MESSAGE);
+    }
+    if (mInteropModuleRegistry != null
+        && mInteropModuleRegistry.shouldReturnInteropModule(jsInterface)) {
+      return mInteropModuleRegistry.getInteropModule(jsInterface);
+    }
+    return mCatalystInstance.getJSModule(jsInterface);
+  }
+
+  @Override
+  public <T extends NativeModule> boolean hasNativeModule(Class<T> nativeModuleInterface) {
+    if (mCatalystInstance == null) {
+      raiseCatalystInstanceMissingException();
+    }
+    return mCatalystInstance.hasNativeModule(nativeModuleInterface);
+  }
+
+  @Override
+  public Collection<NativeModule> getNativeModules() {
+    if (mCatalystInstance == null) {
+      raiseCatalystInstanceMissingException();
+    }
+    return mCatalystInstance.getNativeModules();
+  }
+
+  /**
+   * @return the instance of the specified module interface associated with this ReactContext.
+   */
+  @Override
+  @Nullable
+  public <T extends NativeModule> T getNativeModule(Class<T> nativeModuleInterface) {
+    if (mCatalystInstance == null) {
+      raiseCatalystInstanceMissingException();
+    }
+    return mCatalystInstance.getNativeModule(nativeModuleInterface);
+  }
+
+  @Override
+  public @Nullable NativeModule getNativeModule(String moduleName) {
+    if (mCatalystInstance == null) {
+      raiseCatalystInstanceMissingException();
+    }
+    return mCatalystInstance.getNativeModule(moduleName);
+  }
+
+  @Override
+  public CatalystInstance getCatalystInstance() {
+    return Assertions.assertNotNull(mCatalystInstance);
+  }
+
+  /**
+   * This API has been deprecated due to naming consideration, please use hasActiveReactInstance()
+   * instead
+   *
+   * @return
+   */
+  @Deprecated
+  @Override
+  public boolean hasActiveCatalystInstance() {
+    return hasActiveReactInstance();
+  }
+
+  /**
+   * @return true if there is an non-null, alive react native instance
+   */
+  @Override
+  public boolean hasActiveReactInstance() {
+    return mCatalystInstance != null && !mCatalystInstance.isDestroyed();
+  }
+
+  /**
+   * This API has been deprecated due to naming consideration, please use hasReactInstance() instead
+   *
+   * @return
+   */
+  @Deprecated
+  @Override
+  public boolean hasCatalystInstance() {
+    return mCatalystInstance != null;
+  }
+
+  @Override
+  public boolean hasReactInstance() {
+    return mCatalystInstance != null;
+  }
+
+  /** Destroy this instance, making it unusable. */
+  @Override
+  @ThreadConfined(UI)
+  public void destroy() {
+    UiThreadUtil.assertOnUiThread();
+
+    mDestroyed = true;
+    if (mCatalystInstance != null) {
+      mCatalystInstance.destroy();
+    }
+  }
+
+  /**
+   * Passes the given exception to the current {@link JSExceptionHandler} if one exists, rethrowing
+   * otherwise.
+   */
+  @Override
+  public void handleException(Exception e) {
+    boolean catalystInstanceVariableExists = mCatalystInstance != null;
+    boolean isCatalystInstanceAlive =
+        catalystInstanceVariableExists && !mCatalystInstance.isDestroyed();
+    boolean hasExceptionHandler = getJSExceptionHandler() != null;
+
+    if (isCatalystInstanceAlive && hasExceptionHandler) {
+      getJSExceptionHandler().handleException(e);
+    } else {
+      FLog.e(
+          ReactConstants.TAG,
+          "Unable to handle Exception - catalystInstanceVariableExists: "
+              + catalystInstanceVariableExists
+              + " - isCatalystInstanceAlive: "
+              + isCatalystInstanceAlive
+              + " - hasExceptionHandler: "
+              + hasExceptionHandler,
+          e);
+      throw new IllegalStateException(e);
+    }
+  }
+
+  /**
+   * @deprecated DO NOT USE, this method will be removed in the near future.
+   */
+  @Deprecated
+  @Override
+  public boolean isBridgeless() {
+    return false;
+  }
+
+  /**
+   * Get the C pointer (as a long) to the JavaScriptCore context associated with this instance. Use
+   * the following pattern to ensure that the JS context is not cleared while you are using it:
+   * JavaScriptContextHolder jsContext = reactContext.getJavaScriptContextHolder()
+   * synchronized(jsContext) { nativeThingNeedingJsContext(jsContext.get()); }
+   */
+  @Override
+  @FrameworkAPI
+  @UnstableReactNativeAPI
+  public @Nullable JavaScriptContextHolder getJavaScriptContextHolder() {
+    if (mCatalystInstance != null) {
+      return mCatalystInstance.getJavaScriptContextHolder();
+    }
+    return null;
+  }
+
+  /**
+   * Returns a hybrid object that contains a pointer to a JS CallInvoker, which is used to schedule
+   * work on the JS Thread.
+   */
+  @Nullable
+  @Override
+  public CallInvokerHolder getJSCallInvokerHolder() {
+    if (mCatalystInstance != null) {
+      return mCatalystInstance.getJSCallInvokerHolder();
+    }
+    return null;
+  }
+
+  @DeprecatedInNewArchitecture(
+      message =
+          "This method will be deprecated later as part of Stable APIs with bridge removal and not"
+              + " encouraged usage.")
+  /**
+   * Get the UIManager for Fabric from the CatalystInstance.
+   *
+   * @return The UIManager when CatalystInstance is active.
+   */
+  @Override
+  public @Nullable UIManager getFabricUIManager() {
+    return mCatalystInstance.getFabricUIManager();
+  }
+
+  /**
+   * Get the sourceURL for the JS bundle from the CatalystInstance. This method is needed for
+   * compatibility with bridgeless mode, which has no CatalystInstance.
+   *
+   * @return The JS bundle URL set when the bundle was loaded
+   */
+  @Override
+  public @Nullable String getSourceURL() {
+    return mCatalystInstance == null ? null : mCatalystInstance.getSourceURL();
+  }
+
+  /**
+   * Register a JS segment after loading it from cache or server, make sure mCatalystInstance is
+   * properly initialised and not null before calling.
+   */
+  @Override
+  public void registerSegment(int segmentId, String path, Callback callback) {
+    Assertions.assertNotNull(mCatalystInstance).registerSegment(segmentId, path);
+    Assertions.assertNotNull(callback).invoke();
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/bridge/Callback.kt

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.bridge
+/**
+ * Interface that represent javascript callback function which can be passed to the native module as
+ * a method parameter.
+ */
+public fun interface Callback {
+  /**
+   * Schedule javascript function execution represented by this [Callback] instance
+   *
+   * @param args arguments passed to javascript callback method via bridge
+   */
+  public operator fun invoke(vararg args: Any?)
+}

package/ReactAndroid/src/main/java/com/facebook/react/bridge/CatalystInstance.kt

@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.bridge
+
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.bridge.queue.ReactQueueConfiguration
+import com.facebook.react.common.annotations.DeprecatedInNewArchitecture
+import com.facebook.react.common.annotations.VisibleForTesting
+import com.facebook.react.internal.turbomodule.core.interfaces.TurboModuleRegistry
+import com.facebook.react.turbomodule.core.interfaces.CallInvokerHolder
+import com.facebook.react.turbomodule.core.interfaces.NativeMethodCallInvokerHolder
+
+/**
+ * A higher level API on top of the asynchronous JSC bridge. This provides an environment allowing
+ * the invocation of JavaScript methods and lets a set of Java APIs be invocable from JavaScript as
+ * well.
+ */
+@DoNotStrip
+public interface CatalystInstance : MemoryPressureListener, JSInstance, JSBundleLoaderDelegate {
+  public fun runJSBundle()
+
+  // Returns the status of running the JS bundle; waits for an answer if runJSBundle is running
+  public fun hasRunJSBundle(): Boolean
+
+  /**
+   * Return the source URL of the JS Bundle that was run, or `null` if no JS bundle has been run
+   * yet.
+   */
+  public val sourceURL: String?
+
+  // This is called from java code, so it won't be stripped anyway, but proguard will rename it,
+  // which this prevents.
+  @DoNotStrip public override fun invokeCallback(callbackID: Int, arguments: NativeArrayInterface)
+
+  @DoNotStrip public fun callFunction(module: String, method: String, arguments: NativeArray?)
+
+  /**
+   * Destroys this catalyst instance, waiting for any other threads in ReactQueueConfiguration
+   * (besides the UI thread) to finish running. Must be called from the UI thread so that we can
+   * fully shut down other threads.
+   */
+  public fun destroy()
+
+  public val isDestroyed: Boolean
+
+  /** Initialize all the native modules */
+  @VisibleForTesting public fun initialize()
+
+  public val reactQueueConfiguration: ReactQueueConfiguration
+
+  public fun <T : JavaScriptModule> getJSModule(jsInterface: Class<T>): T?
+
+  public fun <T : NativeModule> hasNativeModule(nativeModuleInterface: Class<T>): Boolean
+
+  public fun <T : NativeModule> getNativeModule(nativeModuleInterface: Class<T>): T?
+
+  public fun getNativeModule(moduleName: String): NativeModule?
+
+  public val nativeModules: Collection<NativeModule>
+
+  /**
+   * This method permits a CatalystInstance to extend the known Native modules. This provided
+   * registry contains only the new modules to load.
+   */
+  public fun extendNativeModules(modules: NativeModuleRegistry)
+
+  /**
+   * Adds a idle listener for this Catalyst instance. The listener will receive notifications
+   * whenever the bridge transitions from idle to busy and vice-versa, where the busy state is
+   * defined as there being some non-zero number of calls to JS that haven't resolved via a
+   * onBatchCompleted call. The listener should be purely passive and not affect application logic.
+   */
+  public fun addBridgeIdleDebugListener(listener: NotThreadSafeBridgeIdleDebugListener)
+
+  /**
+   * Removes a NotThreadSafeBridgeIdleDebugListener previously added with
+   * [ ][.addBridgeIdleDebugListener]
+   */
+  public fun removeBridgeIdleDebugListener(listener: NotThreadSafeBridgeIdleDebugListener)
+
+  /** This method registers the file path of an additional JS segment by its ID. */
+  public fun registerSegment(segmentId: Int, path: String)
+
+  @VisibleForTesting public fun setGlobalVariable(propName: String, jsonValue: String)
+
+  /**
+   * Do not use this anymore. Use {@link #getRuntimeExecutor()} instead. Get the C pointer (as a
+   * long) to the JavaScriptCore context associated with this instance.
+   *
+   * <p>Use the following pattern to ensure that the JS context is not cleared while you are using
+   * it: JavaScriptContextHolder jsContext = reactContext.getJavaScriptContextHolder()
+   * synchronized(jsContext) { nativeThingNeedingJsContext(jsContext.get()); }
+   */
+  @get:Deprecated("Use getRuntimeExecutor() instead.")
+  public val javaScriptContextHolder: JavaScriptContextHolder
+
+  public val runtimeExecutor: RuntimeExecutor?
+  public val runtimeScheduler: RuntimeScheduler?
+
+  /**
+   * Returns a hybrid object that contains a pointer to a JS CallInvoker, which is used to schedule
+   * work on the JS Thread. Required for TurboModuleManager initialization.
+   */
+  @get:Deprecated("Use ReactContext.getJSCallInvokerHolder instead")
+  @Suppress("INAPPLICABLE_JVM_NAME")
+  @get:JvmName("getJSCallInvokerHolder") // This is needed to keep backward compatibility
+  public val jsCallInvokerHolder: CallInvokerHolder
+
+  /**
+   * Returns a hybrid object that contains a pointer to a NativeMethodCallInvoker, which is used to
+   * schedule work on the NativeModules thread. Required for TurboModuleManager initialization.
+   */
+  public val nativeMethodCallInvokerHolder: NativeMethodCallInvokerHolder
+
+  @DeprecatedInNewArchitecture(
+      message =
+          "This method will be deprecated later as part of Stable APIs with bridge removal and not" +
+              " encouraged usage.")
+  public fun setTurboModuleRegistry(turboModuleRegistry: TurboModuleRegistry)
+
+  @DeprecatedInNewArchitecture(
+      message =
+          "This method will be deprecated later as part of Stable APIs with bridge removal and not" +
+              " encouraged usage.")
+  public fun setFabricUIManager(fabricUIManager: UIManager)
+
+  @DeprecatedInNewArchitecture(
+      message =
+          "This method will be deprecated later as part of Stable APIs with bridge removal and not" +
+              " encouraged usage.")
+  public fun getFabricUIManager(): UIManager?
+}