react-native 0.69.3 → 0.70.0-rc.2

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

@@ -19,6 +19,7 @@ import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.LifecycleEventListener;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactSoftExceptionLogger;
+import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.UIManager;
 import com.facebook.react.bridge.UIManagerListener;
@@ -92,6 +93,50 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
   public static final String NAME = "NativeAnimatedModule";
   public static final boolean ANIMATED_MODULE_DEBUG = false;
 
+  // For `queueAndExecuteBatchedOperations`
+  private enum BatchExecutionOpCodes {
+    OP_CODE_CREATE_ANIMATED_NODE(1),
+    OP_CODE_UPDATE_ANIMATED_NODE_CONFIG(2),
+    OP_CODE_GET_VALUE(3),
+    OP_START_LISTENING_TO_ANIMATED_NODE_VALUE(4),
+    OP_STOP_LISTENING_TO_ANIMATED_NODE_VALUE(5),
+    OP_CODE_CONNECT_ANIMATED_NODES(6),
+    OP_CODE_DISCONNECT_ANIMATED_NODES(7),
+    OP_CODE_START_ANIMATING_NODE(8),
+    OP_CODE_STOP_ANIMATION(9),
+    OP_CODE_SET_ANIMATED_NODE_VALUE(10),
+    OP_CODE_SET_ANIMATED_NODE_OFFSET(11),
+    OP_CODE_FLATTEN_ANIMATED_NODE_OFFSET(12),
+    OP_CODE_EXTRACT_ANIMATED_NODE_OFFSET(13),
+    OP_CODE_CONNECT_ANIMATED_NODE_TO_VIEW(14),
+    OP_CODE_DISCONNECT_ANIMATED_NODE_FROM_VIEW(15),
+    OP_CODE_RESTORE_DEFAULT_VALUES(16),
+    OP_CODE_DROP_ANIMATED_NODE(17),
+    OP_CODE_ADD_ANIMATED_EVENT_TO_VIEW(18),
+    OP_CODE_REMOVE_ANIMATED_EVENT_FROM_VIEW(19),
+    OP_CODE_ADD_LISTENER(20), // ios only
+    OP_CODE_REMOVE_LISTENERS(21); // ios only
+
+    private static BatchExecutionOpCodes[] valueMap = null;
+    private final int value;
+
+    private BatchExecutionOpCodes(int value) {
+      this.value = value;
+    }
+
+    public int getValue() {
+      return this.value;
+    }
+
+    public static BatchExecutionOpCodes fromId(int id) {
+      if (BatchExecutionOpCodes.valueMap == null) {
+        BatchExecutionOpCodes.valueMap = BatchExecutionOpCodes.values();
+      }
+      // Enum values are 1-indexed, but the value array is 0-indexed
+      return BatchExecutionOpCodes.valueMap[id - 1];
+    }
+  }
+
   private abstract class UIThreadOperation {
     abstract void execute(NativeAnimatedNodesManager animatedNodesManager);
 
@@ -113,7 +158,7 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
 
     @AnyThread
     boolean isEmpty() {
-      return mQueue.isEmpty();
+      return mQueue.isEmpty() && mPeekedOperation == null;
     }
 
     void setSynchronizedAccess(boolean isSynchronizedAccess) {
@@ -133,9 +178,7 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
 
     @UiThread
     void executeBatch(long maxBatchNumber, NativeAnimatedNodesManager nodesManager) {
-
       List<UIThreadOperation> operations;
-
       if (mSynchronizedAccess) {
         synchronized (this) {
           operations = drainQueueIntoList(maxBatchNumber);
@@ -143,13 +186,19 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
       } else {
         operations = drainQueueIntoList(maxBatchNumber);
       }
-      for (UIThreadOperation operation : operations) {
-        operation.execute(nodesManager);
+      if (operations != null) {
+        for (UIThreadOperation operation : operations) {
+          operation.execute(nodesManager);
+        }
       }
     }
 
     @UiThread
-    private List<UIThreadOperation> drainQueueIntoList(long maxBatchNumber) {
+    private @Nullable List<UIThreadOperation> drainQueueIntoList(long maxBatchNumber) {
+      if (isEmpty()) {
+        return null;
+      }
+
       List<UIThreadOperation> operations = new ArrayList<>();
       while (true) {
         // Due to a race condition, we manually "carry-over" a polled item from previous batch
@@ -362,7 +411,7 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
    * @return {@link NativeAnimatedNodesManager}
    */
   @Nullable
-  private NativeAnimatedNodesManager getNodesManager() {
+  public NativeAnimatedNodesManager getNodesManager() {
     if (mNodesManager.get() == null) {
       ReactApplicationContext reactApplicationContext = getReactApplicationContextIfActiveOrWarn();
 
@@ -393,8 +442,8 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
 
   /**
    * Given a viewTag, detect if we're running in Fabric or non-Fabric and attach an event listener
-   * to the correct UIManager, if necessary. This is expected to only be called from the JS thread,
-   * and not concurrently.
+   * to the correct UIManager, if necessary. This is expected to only be called from the native
+   * module thread, and not concurrently.
    *
    * @param viewTag
    */
@@ -417,8 +466,7 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
     }
 
     // Subscribe to UIManager (Fabric or non-Fabric) lifecycle events if we haven't yet
-    if ((mInitializedForFabric && mUIManagerType == UIManagerType.FABRIC)
-        || (mInitializedForNonFabric && mUIManagerType == UIManagerType.DEFAULT)) {
+    if (mUIManagerType == UIManagerType.FABRIC ? mInitializedForFabric : mInitializedForNonFabric) {
       return;
     }
 
@@ -970,4 +1018,191 @@ public class NativeAnimatedModule extends NativeAnimatedModuleSpec
       context.removeLifecycleEventListener(this);
     }
   }
+
+  /**
+   * This is a currently-experimental method that allows JS to queue and immediately execute many
+   * instructions at once. Since we make 1 JNI/JSI call instead of N, this should significantly
+   * improve performance.
+   *
+   * <p>The arguments operate as a byte buffer. All integer command IDs and any args are packed into
+   * opsAndArgs.
+   *
+   * <p>For the getValue callback: since this is batched, we accumulate a list of all requested
+   * values, in order, and call the callback once at the end (if present) with the list of requested
+   * values.
+   */
+  @Override
+  public void queueAndExecuteBatchedOperations(final ReadableArray opsAndArgs) {
+    final int opBufferSize = opsAndArgs.size();
+
+    if (ANIMATED_MODULE_DEBUG) {
+      FLog.e(NAME, "queueAndExecuteBatchedOperations: opBufferSize: " + opBufferSize);
+    }
+
+    // This block of code is unfortunate and should be refactored - we just want to
+    // extract the ViewTags in the ReadableArray to mark animations on views as being enabled.
+    // We only do this for initializing animations on views - disabling animations on views
+    // happens later, when the disconnect/stop operations are actually executed.
+    for (int i = 0; i < opBufferSize; ) {
+      BatchExecutionOpCodes command = BatchExecutionOpCodes.fromId(opsAndArgs.getInt(i++));
+      switch (command) {
+        case OP_CODE_GET_VALUE:
+        case OP_START_LISTENING_TO_ANIMATED_NODE_VALUE:
+        case OP_STOP_LISTENING_TO_ANIMATED_NODE_VALUE:
+        case OP_CODE_STOP_ANIMATION:
+        case OP_CODE_FLATTEN_ANIMATED_NODE_OFFSET:
+        case OP_CODE_EXTRACT_ANIMATED_NODE_OFFSET:
+        case OP_CODE_RESTORE_DEFAULT_VALUES:
+        case OP_CODE_DROP_ANIMATED_NODE:
+        case OP_CODE_ADD_LISTENER:
+        case OP_CODE_REMOVE_LISTENERS:
+          i++;
+          break;
+        case OP_CODE_CREATE_ANIMATED_NODE:
+        case OP_CODE_UPDATE_ANIMATED_NODE_CONFIG:
+        case OP_CODE_CONNECT_ANIMATED_NODES:
+        case OP_CODE_DISCONNECT_ANIMATED_NODES:
+        case OP_CODE_SET_ANIMATED_NODE_VALUE:
+        case OP_CODE_SET_ANIMATED_NODE_OFFSET:
+        case OP_CODE_DISCONNECT_ANIMATED_NODE_FROM_VIEW:
+          i += 2;
+          break;
+        case OP_CODE_START_ANIMATING_NODE:
+        case OP_CODE_REMOVE_ANIMATED_EVENT_FROM_VIEW:
+          i += 3;
+          break;
+        case OP_CODE_CONNECT_ANIMATED_NODE_TO_VIEW:
+          i++; // tag
+          initializeLifecycleEventListenersForViewTag(opsAndArgs.getInt(i++)); // viewTag
+          break;
+        case OP_CODE_ADD_ANIMATED_EVENT_TO_VIEW:
+          initializeLifecycleEventListenersForViewTag(opsAndArgs.getInt(i++)); // viewTag
+          i++; // eventName
+          i++; // eventMapping
+          break;
+        default:
+          throw new IllegalArgumentException(
+              "Batch animation execution op: fetching viewTag: unknown op code");
+      }
+    }
+
+    // Batching happens inside this operation - so signal to the thread loop that
+    // this operation should be executed as soon as possible, "unbatched" with other
+    // UIThreadOperations
+    startOperationBatch();
+    addUnbatchedOperation(
+        new UIThreadOperation() {
+          @Override
+          public void execute(NativeAnimatedNodesManager animatedNodesManager) {
+            ReactApplicationContext reactApplicationContext =
+                getReactApplicationContextIfActiveOrWarn();
+
+            int viewTag = -1;
+            for (int i = 0; i < opBufferSize; ) {
+              BatchExecutionOpCodes command = BatchExecutionOpCodes.fromId(opsAndArgs.getInt(i++));
+
+              switch (command) {
+                case OP_CODE_CREATE_ANIMATED_NODE:
+                  animatedNodesManager.createAnimatedNode(
+                      opsAndArgs.getInt(i++), opsAndArgs.getMap(i++));
+                  break;
+                case OP_CODE_UPDATE_ANIMATED_NODE_CONFIG:
+                  animatedNodesManager.updateAnimatedNodeConfig(
+                      opsAndArgs.getInt(i++), opsAndArgs.getMap(i++));
+                  break;
+                case OP_CODE_GET_VALUE:
+                  animatedNodesManager.getValue(opsAndArgs.getInt(i++), null);
+                  break;
+                case OP_START_LISTENING_TO_ANIMATED_NODE_VALUE:
+                  final int tag = opsAndArgs.getInt(i++);
+                  final AnimatedNodeValueListener listener =
+                      new AnimatedNodeValueListener() {
+                        public void onValueUpdate(double value) {
+                          WritableMap onAnimatedValueData = Arguments.createMap();
+                          onAnimatedValueData.putInt("tag", tag);
+                          onAnimatedValueData.putDouble("value", value);
+
+                          ReactApplicationContext reactApplicationContext =
+                              getReactApplicationContextIfActiveOrWarn();
+                          if (reactApplicationContext != null) {
+                            reactApplicationContext
+                                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                                .emit("onAnimatedValueUpdate", onAnimatedValueData);
+                          }
+                        }
+                      };
+                  animatedNodesManager.startListeningToAnimatedNodeValue(tag, listener);
+                  break;
+                case OP_STOP_LISTENING_TO_ANIMATED_NODE_VALUE:
+                  animatedNodesManager.stopListeningToAnimatedNodeValue(opsAndArgs.getInt(i++));
+                  break;
+                case OP_CODE_CONNECT_ANIMATED_NODES:
+                  animatedNodesManager.connectAnimatedNodes(
+                      opsAndArgs.getInt(i++), opsAndArgs.getInt(i++));
+                  break;
+                case OP_CODE_DISCONNECT_ANIMATED_NODES:
+                  animatedNodesManager.disconnectAnimatedNodes(
+                      opsAndArgs.getInt(i++), opsAndArgs.getInt(i++));
+                  break;
+                case OP_CODE_START_ANIMATING_NODE:
+                  animatedNodesManager.startAnimatingNode(
+                      opsAndArgs.getInt(i++), opsAndArgs.getInt(i++), opsAndArgs.getMap(i++), null);
+                  break;
+                case OP_CODE_STOP_ANIMATION:
+                  animatedNodesManager.stopAnimation(opsAndArgs.getInt(i++));
+                  break;
+                case OP_CODE_SET_ANIMATED_NODE_VALUE:
+                  animatedNodesManager.setAnimatedNodeValue(
+                      opsAndArgs.getInt(i++), opsAndArgs.getDouble(i++));
+                  break;
+                case OP_CODE_SET_ANIMATED_NODE_OFFSET:
+                  animatedNodesManager.setAnimatedNodeValue(
+                      opsAndArgs.getInt(i++), opsAndArgs.getDouble(i++));
+                  break;
+                case OP_CODE_FLATTEN_ANIMATED_NODE_OFFSET:
+                  animatedNodesManager.flattenAnimatedNodeOffset(opsAndArgs.getInt(i++));
+                  break;
+                case OP_CODE_EXTRACT_ANIMATED_NODE_OFFSET:
+                  animatedNodesManager.extractAnimatedNodeOffset(opsAndArgs.getInt(i++));
+                  break;
+                case OP_CODE_CONNECT_ANIMATED_NODE_TO_VIEW:
+                  animatedNodesManager.connectAnimatedNodeToView(
+                      opsAndArgs.getInt(i++), opsAndArgs.getInt(i++));
+                  break;
+                case OP_CODE_DISCONNECT_ANIMATED_NODE_FROM_VIEW:
+                  int animatedNodeTag = opsAndArgs.getInt(i++);
+                  viewTag = opsAndArgs.getInt(i++);
+                  decrementInFlightAnimationsForViewTag(viewTag);
+                  animatedNodesManager.disconnectAnimatedNodeFromView(animatedNodeTag, viewTag);
+                  break;
+                case OP_CODE_RESTORE_DEFAULT_VALUES:
+                  animatedNodesManager.restoreDefaultValues(opsAndArgs.getInt(i++));
+                  break;
+                case OP_CODE_DROP_ANIMATED_NODE:
+                  animatedNodesManager.dropAnimatedNode(opsAndArgs.getInt(i++));
+                  break;
+                case OP_CODE_ADD_ANIMATED_EVENT_TO_VIEW:
+                  animatedNodesManager.addAnimatedEventToView(
+                      opsAndArgs.getInt(i++), opsAndArgs.getString(i++), opsAndArgs.getMap(i++));
+                  break;
+                case OP_CODE_REMOVE_ANIMATED_EVENT_FROM_VIEW:
+                  viewTag = opsAndArgs.getInt(i++);
+                  decrementInFlightAnimationsForViewTag(viewTag);
+                  animatedNodesManager.removeAnimatedEventFromView(
+                      viewTag, opsAndArgs.getString(i++), opsAndArgs.getInt(i++));
+                  break;
+                case OP_CODE_ADD_LISTENER:
+                case OP_CODE_REMOVE_LISTENERS:
+                  i++;
+                  // ios only, do nothing on android besides incrementing the arg counter
+                  break;
+                default:
+                  throw new IllegalArgumentException(
+                      "Batch animation execution op: unknown op code");
+              }
+            }
+          }
+        });
+    finishOperationBatch();
+  }
 }

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

@@ -23,6 +23,7 @@ import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.UIManager;
 import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
 import com.facebook.react.uimanager.UIManagerHelper;
 import com.facebook.react.uimanager.common.UIManagerType;
 import com.facebook.react.uimanager.events.Event;
@@ -50,7 +51,7 @@ import java.util.Queue;
  *
  * <p>IMPORTANT: This class should be accessed only from the UI Thread
  */
-/*package*/ class NativeAnimatedNodesManager implements EventDispatcherListener {
+public class NativeAnimatedNodesManager implements EventDispatcherListener {
 
   private static final String TAG = "NativeAnimatedNodesManager";
 
@@ -76,40 +77,31 @@ import java.util.Queue;
 
   /**
    * Initialize event listeners for Fabric UIManager or non-Fabric UIManager, exactly once. Once
-   * Fabric is the only UIManager, this logic can be simplified. This is only called on the JS
-   * thread.
+   * Fabric is the only UIManager, this logic can be simplified. This is expected to only be called
+   * from the native module thread.
    *
    * @param uiManagerType
    */
-  @UiThread
   public void initializeEventListenerForUIManagerType(@UIManagerType final int uiManagerType) {
-    if ((uiManagerType == UIManagerType.FABRIC && mEventListenerInitializedForFabric)
-        || (uiManagerType == UIManagerType.DEFAULT && mEventListenerInitializedForNonFabric)) {
+    if (uiManagerType == UIManagerType.FABRIC
+        ? mEventListenerInitializedForFabric
+        : mEventListenerInitializedForNonFabric) {
       return;
     }
 
-    final NativeAnimatedNodesManager self = this;
-    mReactApplicationContext.runOnUiQueueThread(
-        new Runnable() {
-          @Override
-          public void run() {
-            UIManager uiManager =
-                UIManagerHelper.getUIManager(mReactApplicationContext, uiManagerType);
-            if (uiManager != null) {
-              uiManager.<EventDispatcher>getEventDispatcher().addListener(self);
-
-              if (uiManagerType == UIManagerType.FABRIC) {
-                mEventListenerInitializedForFabric = true;
-              } else {
-                mEventListenerInitializedForNonFabric = true;
-              }
-            }
-          }
-        });
+    UIManager uiManager = UIManagerHelper.getUIManager(mReactApplicationContext, uiManagerType);
+    if (uiManager != null) {
+      uiManager.<EventDispatcher>getEventDispatcher().addListener(this);
+      if (uiManagerType == UIManagerType.FABRIC) {
+        mEventListenerInitializedForFabric = true;
+      } else {
+        mEventListenerInitializedForNonFabric = true;
+      }
+    }
   }
 
-  /*package*/ @Nullable
-  AnimatedNode getNodeById(int id) {
+  @Nullable
+  public AnimatedNode getNodeById(int id) {
     return mAnimatedNodes.get(id);
   }
 
@@ -311,6 +303,16 @@ import java.util.Queue;
           WritableMap endCallbackResponse = Arguments.createMap();
           endCallbackResponse.putBoolean("finished", false);
           animation.mEndCallback.invoke(endCallbackResponse);
+        } else if (mReactApplicationContext != null) {
+          // If no callback is passed in, this /may/ be an animation set up by the single-op
+          // instruction from JS, meaning that no jsi::functions are passed into native and
+          // we communicate via RCTDeviceEventEmitter instead of callbacks.
+          WritableMap params = Arguments.createMap();
+          params.putInt("animationId", animation.mId);
+          params.putBoolean("finished", false);
+          mReactApplicationContext
+              .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+              .emit("onNativeAnimatedModuleAnimationFinished", params);
         }
         mActiveAnimations.removeAt(i);
         i--;
@@ -332,6 +334,16 @@ import java.util.Queue;
           WritableMap endCallbackResponse = Arguments.createMap();
           endCallbackResponse.putBoolean("finished", false);
           animation.mEndCallback.invoke(endCallbackResponse);
+        } else if (mReactApplicationContext != null) {
+          // If no callback is passed in, this /may/ be an animation set up by the single-op
+          // instruction from JS, meaning that no jsi::functions are passed into native and
+          // we communicate via RCTDeviceEventEmitter instead of callbacks.
+          WritableMap params = Arguments.createMap();
+          params.putInt("animationId", animation.mId);
+          params.putBoolean("finished", false);
+          mReactApplicationContext
+              .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+              .emit("onNativeAnimatedModuleAnimationFinished", params);
         }
         mActiveAnimations.removeAt(i);
         return;
@@ -448,7 +460,25 @@ import java.util.Queue;
       throw new JSApplicationIllegalArgumentException(
           "getValue: Animated node with tag [" + tag + "] does not exist or is not a 'value' node");
     }
-    callback.invoke(((ValueAnimatedNode) node).getValue());
+    double value = ((ValueAnimatedNode) node).getValue();
+    if (callback != null) {
+      callback.invoke(value);
+      return;
+    }
+
+    // If there's no callback, that means that JS is using the single-operation mode, and not
+    // passing any callbacks into Java.
+    // See NativeAnimatedHelper.js for details.
+    // Instead, we use RCTDeviceEventEmitter to pass data back to JS and emulate callbacks.
+    if (mReactApplicationContext == null) {
+      return;
+    }
+    WritableMap params = Arguments.createMap();
+    params.putInt("tag", tag);
+    params.putDouble("value", value);
+    mReactApplicationContext
+        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+        .emit("onNativeAnimatedModuleGetValue", params);
   }
 
   @UiThread
@@ -524,7 +554,6 @@ import java.util.Queue;
     }
   }
 
-  @UiThread
   @Override
   public void onEventDispatch(final Event event) {
     // Events can be dispatched from any thread so we have to make sure handleEvent is run from the
@@ -622,6 +651,19 @@ import java.util.Queue;
             WritableMap endCallbackResponse = Arguments.createMap();
             endCallbackResponse.putBoolean("finished", true);
             animation.mEndCallback.invoke(endCallbackResponse);
+          } else if (mReactApplicationContext != null) {
+            // If no callback is passed in, this /may/ be an animation set up by the single-op
+            // instruction from JS, meaning that no jsi::functions are passed into native and
+            // we communicate via RCTDeviceEventEmitter instead of callbacks.
+            WritableMap params = Arguments.createMap();
+            params.putInt("animationId", animation.mId);
+            params.putBoolean("finished", true);
+            DeviceEventManagerModule.RCTDeviceEventEmitter eventEmitter =
+                mReactApplicationContext.getJSModule(
+                    DeviceEventManagerModule.RCTDeviceEventEmitter.class);
+            if (eventEmitter != null) {
+              eventEmitter.emit("onNativeAnimatedModuleAnimationFinished", params);
+            }
           }
           mActiveAnimations.removeAt(i);
         }

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

@@ -9,8 +9,8 @@ package com.facebook.react.bridge;
 
 /**
  * Like {@link AssertionError} but extends RuntimeException so that it may be caught by a {@link
- * NativeModuleCallExceptionHandler}. See that class for more details. Used in conjunction with
- * {@link SoftAssertions}.
+ * JSExceptionHandler}. See that class for more details. Used in conjunction with {@link
+ * SoftAssertions}.
  */
 public class AssertionException extends RuntimeException {
 

package/ReactAndroid/src/main/java/com/facebook/react/bridge/BUCK

@@ -26,6 +26,7 @@ rn_android_library(
         "pfh:ReactNative_CommonInfrastructurePlaceholder",
         "supermodule:xplat/default/public.react_native.infra",
     ],
+    language = "JAVA",
     proguard_config = "reactnative.pro",
     provided_deps = [
         react_native_dep("third-party/android/androidx:annotation"),
@@ -75,6 +76,7 @@ rn_android_library(
         "pfh:ReactNative_CommonInfrastructurePlaceholder",
         "supermodule:xplat/default/public.react_native.infra",
     ],
+    language = "JAVA",
     proguard_config = "reactnative.pro",
     provided_deps = [
         react_native_dep("third-party/android/androidx:annotation"),

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

@@ -10,15 +10,32 @@ package com.facebook.react.bridge;
 import com.facebook.proguard.annotations.DoNotStrip;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
 
 @DoNotStrip
 public class BackgroundExecutor {
   private static final String TAG = "FabricBackgroundExecutor";
+
+  private static class NamedThreadFactory implements ThreadFactory {
+    private final String mName;
+
+    public NamedThreadFactory(String name) {
+      mName = name;
+    }
+
+    @Override
+    public Thread newThread(Runnable r) {
+      Thread thread = Executors.defaultThreadFactory().newThread(r);
+      thread.setName(mName);
+      return thread;
+    }
+  }
+
   private final ExecutorService mExecutorService;
 
   @DoNotStrip
-  private BackgroundExecutor() {
-    mExecutorService = Executors.newFixedThreadPool(1);
+  private BackgroundExecutor(String name) {
+    mExecutorService = Executors.newFixedThreadPool(1, new NamedThreadFactory(name));
   }
 
   @DoNotStrip

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

@@ -93,7 +93,7 @@ public class CatalystInstanceImpl implements CatalystInstance {
 
   private final NativeModuleRegistry mNativeModuleRegistry;
   private final JSIModuleRegistry mJSIModuleRegistry = new JSIModuleRegistry();
-  private final NativeModuleCallExceptionHandler mNativeModuleCallExceptionHandler;
+  private final JSExceptionHandler mJSExceptionHandler;
   private final MessageQueueThread mNativeModulesQueueThread;
   private boolean mInitialized = false;
   private volatile boolean mAcceptCalls = false;
@@ -120,7 +120,7 @@ public class CatalystInstanceImpl implements CatalystInstance {
       final JavaScriptExecutor jsExecutor,
       final NativeModuleRegistry nativeModuleRegistry,
       final JSBundleLoader jsBundleLoader,
-      NativeModuleCallExceptionHandler nativeModuleCallExceptionHandler) {
+      JSExceptionHandler jSExceptionHandler) {
     FLog.d(ReactConstants.TAG, "Initializing React Xplat Bridge.");
     Systrace.beginSection(TRACE_TAG_REACT_JAVA_BRIDGE, "createCatalystInstanceImpl");
 
@@ -141,7 +141,7 @@ public class CatalystInstanceImpl implements CatalystInstance {
     mNativeModuleRegistry = nativeModuleRegistry;
     mJSModuleRegistry = new JavaScriptModuleRegistry();
     mJSBundleLoader = jsBundleLoader;
-    mNativeModuleCallExceptionHandler = nativeModuleCallExceptionHandler;
+    mJSExceptionHandler = jSExceptionHandler;
     mNativeModulesQueueThread = mReactQueueConfiguration.getNativeModulesQueueThread();
     mTraceListener = new JSProfilerTraceListener(this);
     Systrace.endSection(TRACE_TAG_REACT_JAVA_BRIDGE);
@@ -626,7 +626,7 @@ public class CatalystInstanceImpl implements CatalystInstance {
   }
 
   private void onNativeException(Exception e) {
-    mNativeModuleCallExceptionHandler.handleException(e);
+    mJSExceptionHandler.handleException(e);
     mReactQueueConfiguration
         .getUIQueueThread()
         .runOnQueue(
@@ -682,7 +682,7 @@ public class CatalystInstanceImpl implements CatalystInstance {
     private @Nullable JSBundleLoader mJSBundleLoader;
     private @Nullable NativeModuleRegistry mRegistry;
     private @Nullable JavaScriptExecutor mJSExecutor;
-    private @Nullable NativeModuleCallExceptionHandler mNativeModuleCallExceptionHandler;
+    private @Nullable JSExceptionHandler mJSExceptionHandler;
 
     public Builder setReactQueueConfigurationSpec(
         ReactQueueConfigurationSpec ReactQueueConfigurationSpec) {
@@ -705,8 +705,8 @@ public class CatalystInstanceImpl implements CatalystInstance {
       return this;
     }
 
-    public Builder setNativeModuleCallExceptionHandler(NativeModuleCallExceptionHandler handler) {
-      mNativeModuleCallExceptionHandler = handler;
+    public Builder setJSExceptionHandler(JSExceptionHandler handler) {
+      mJSExceptionHandler = handler;
       return this;
     }
 
@@ -716,7 +716,7 @@ public class CatalystInstanceImpl implements CatalystInstance {
           Assertions.assertNotNull(mJSExecutor),
           Assertions.assertNotNull(mRegistry),
           Assertions.assertNotNull(mJSBundleLoader),
-          Assertions.assertNotNull(mNativeModuleCallExceptionHandler));
+          Assertions.assertNotNull(mJSExceptionHandler));
     }
   }
 }

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

@@ -10,6 +10,7 @@ package com.facebook.react.bridge;
 import android.content.Context;
 import android.content.res.Resources;
 import android.util.TypedValue;
+import androidx.annotation.Nullable;
 import androidx.core.content.res.ResourcesCompat;
 
 public class ColorPropConverter {
@@ -44,27 +45,9 @@ public class ColorPropConverter {
       }
 
       for (int i = 0; i < resourcePaths.size(); i++) {
-        String resourcePath = resourcePaths.getString(i);
-
-        if (resourcePath == null || resourcePath.isEmpty()) {
-          continue;
-        }
-
-        boolean isResource = resourcePath.startsWith(PREFIX_RESOURCE);
-        boolean isThemeAttribute = resourcePath.startsWith(PREFIX_ATTR);
-
-        resourcePath = resourcePath.substring(1);
-
-        try {
-          if (isResource) {
-            return resolveResource(context, resourcePath);
-          } else if (isThemeAttribute) {
-            return resolveThemeAttribute(context, resourcePath);
-          }
-        } catch (Resources.NotFoundException exception) {
-          // The resource could not be found so do nothing to allow the for loop to continue and
-          // try the next fallback resource in the array.  If none of the fallbacks are
-          // found then the exception immediately after the for loop will be thrown.
+        Integer result = resolveResourcePath(context, resourcePaths.getString(i));
+        if (result != null) {
+          return result;
         }
       }
 
@@ -78,6 +61,30 @@ public class ColorPropConverter {
         "ColorValue: the value must be a number or Object.");
   }
 
+  public static Integer resolveResourcePath(Context context, @Nullable String resourcePath) {
+    if (resourcePath == null || resourcePath.isEmpty()) {
+      return null;
+    }
+
+    boolean isResource = resourcePath.startsWith(PREFIX_RESOURCE);
+    boolean isThemeAttribute = resourcePath.startsWith(PREFIX_ATTR);
+
+    resourcePath = resourcePath.substring(1);
+
+    try {
+      if (isResource) {
+        return resolveResource(context, resourcePath);
+      } else if (isThemeAttribute) {
+        return resolveThemeAttribute(context, resourcePath);
+      }
+    } catch (Resources.NotFoundException exception) {
+      // The resource could not be found so do nothing to allow the for loop to continue and
+      // try the next fallback resource in the array.  If none of the fallbacks are
+      // found then the exception immediately after the for loop will be thrown.
+    }
+    return null;
+  }
+
   private static int resolveResource(Context context, String resourcePath) {
     String[] pathTokens = resourcePath.split(PACKAGE_DELIMITER);