react-native-tvos 0.68.2-7 → 0.69.5-0

package/ReactAndroid/src/main/java/com/facebook/react/ReactActivityDelegate.java

@@ -15,6 +15,7 @@ import android.content.res.Configuration;
 import android.os.Build;
 import android.os.Bundle;
 import android.view.KeyEvent;
+import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.react.bridge.Callback;
@@ -33,6 +34,7 @@ public class ReactActivityDelegate {
   private @Nullable PermissionListener mPermissionListener;
   private @Nullable Callback mPermissionsCallback;
   private ReactDelegate mReactDelegate;
+  private boolean mConcurrentRootEnabled;
 
   @Deprecated
   public ReactActivityDelegate(Activity activity, @Nullable String mainComponentName) {
@@ -45,10 +47,27 @@ public class ReactActivityDelegate {
     mMainComponentName = mainComponentName;
   }
 
+  /**
+   * Public API to populate the launch options that will be passed to React. Here you can customize
+   * the values that will be passed as `initialProperties` to the Renderer.
+   *
+   * @return Either null or a key-value map as a Bundle
+   */
   protected @Nullable Bundle getLaunchOptions() {
     return null;
   }
 
+  private @NonNull Bundle composeLaunchOptions() {
+    Bundle composedLaunchOptions = getLaunchOptions();
+    if (isConcurrentRootEnabled()) {
+      if (composedLaunchOptions == null) {
+        composedLaunchOptions = new Bundle();
+      }
+      composedLaunchOptions.putBoolean("concurrentRoot", true);
+    }
+    return composedLaunchOptions;
+  }
+
   protected ReactRootView createRootView() {
     return new ReactRootView(getContext());
   }
@@ -74,9 +93,10 @@ public class ReactActivityDelegate {
 
   protected void onCreate(Bundle savedInstanceState) {
     String mainComponentName = getMainComponentName();
+    Bundle launchOptions = composeLaunchOptions();
     mReactDelegate =
         new ReactDelegate(
-            getPlainActivity(), getReactNativeHost(), mainComponentName, getLaunchOptions()) {
+            getPlainActivity(), getReactNativeHost(), mainComponentName, launchOptions) {
           @Override
           protected ReactRootView createRootView() {
             return ReactActivityDelegate.this.createRootView();
@@ -190,4 +210,16 @@ public class ReactActivityDelegate {
   protected Activity getPlainActivity() {
     return ((Activity) getContext());
   }
+
+  /**
+   * Override this method to enable Concurrent Root on the surface for this Activity. See:
+   * https://reactjs.org/blog/2022/03/29/react-v18.html
+   *
+   * <p>This requires to be rendering on Fabric (i.e. on the New Architecture).
+   *
+   * @return Wether you want to enable Concurrent Root for this surface or not.
+   */
+  protected boolean isConcurrentRootEnabled() {
+    return false;
+  }
 }

package/ReactAndroid/src/main/java/com/facebook/react/ReactInstanceManager.java

@@ -81,10 +81,10 @@ import com.facebook.react.common.annotations.VisibleForTesting;
 import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.react.devsupport.DevSupportManagerFactory;
 import com.facebook.react.devsupport.ReactInstanceDevHelper;
-import com.facebook.react.devsupport.RedBoxHandler;
 import com.facebook.react.devsupport.interfaces.DevBundleDownloadListener;
 import com.facebook.react.devsupport.interfaces.DevSupportManager;
 import com.facebook.react.devsupport.interfaces.PackagerStatusCallback;
+import com.facebook.react.devsupport.interfaces.RedBoxHandler;
 import com.facebook.react.modules.appearance.AppearanceModule;
 import com.facebook.react.modules.appregistry.AppRegistry;
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
@@ -97,8 +97,6 @@ import com.facebook.react.surface.ReactStage;
 import com.facebook.react.turbomodule.core.TurboModuleManager;
 import com.facebook.react.turbomodule.core.TurboModuleManagerDelegate;
 import com.facebook.react.turbomodule.core.interfaces.TurboModuleRegistry;
-import com.facebook.react.uimanager.ComponentNameResolver;
-import com.facebook.react.uimanager.ComponentNameResolverManager;
 import com.facebook.react.uimanager.DisplayMetricsHolder;
 import com.facebook.react.uimanager.ReactRoot;
 import com.facebook.react.uimanager.UIImplementationProvider;
@@ -168,7 +166,6 @@ public class ReactInstanceManager {
   private final DevSupportManager mDevSupportManager;
   private final boolean mUseDeveloperSupport;
   private final boolean mRequireActivity;
-  private @Nullable ComponentNameResolverManager mComponentNameResolverManager;
   private final @Nullable NotThreadSafeBridgeIdleDebugListener mBridgeIdleDebugListener;
   private final Object mReactContextLock = new Object();
   private @Nullable volatile ReactContext mCurrentReactContext;
@@ -770,7 +767,6 @@ public class ReactInstanceManager {
     synchronized (mPackages) {
       mViewManagerNames = null;
     }
-    mComponentNameResolverManager = null;
     FLog.d(ReactConstants.TAG, "ReactInstanceManager has been destroyed");
   }
 
@@ -1016,6 +1012,7 @@ public class ReactInstanceManager {
     mReactInstanceEventListeners.remove(listener);
   }
 
+  /** @return current ReactApplicationContext */
   @VisibleForTesting
   public @Nullable ReactContext getCurrentReactContext() {
     synchronized (mReactContextLock) {
@@ -1178,7 +1175,6 @@ public class ReactInstanceManager {
 
       mDevSupportManager.onNewReactContextCreated(reactContext);
       mMemoryPressureRouter.addMemoryPressureListener(catalystInstance);
-      moveReactContextToCurrentLifecycleState();
 
       ReactMarker.logMarker(ATTACH_MEASURED_ROOT_VIEWS_START);
       for (ReactRoot reactRoot : mAttachedReactRoots) {
@@ -1200,6 +1196,8 @@ public class ReactInstanceManager {
         new Runnable() {
           @Override
           public void run() {
+            moveReactContextToCurrentLifecycleState();
+
             for (com.facebook.react.ReactInstanceEventListener listener : finalListeners) {
               // Sometimes this listener is null - probably due to race
               // condition between allocating listeners with a certain
@@ -1211,10 +1209,6 @@ public class ReactInstanceManager {
             }
           }
         });
-    Systrace.endSection(TRACE_TAG_REACT_JAVA_BRIDGE);
-    ReactMarker.logMarker(SETUP_REACT_CONTEXT_END);
-    // Mark end of bridge loading
-    ReactMarker.logMarker(ReactMarkerConstants.REACT_BRIDGE_LOADING_END);
     reactContext.runOnJSQueueThread(
         new Runnable() {
           @Override
@@ -1230,6 +1224,11 @@ public class ReactInstanceManager {
             Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
           }
         });
+
+    Systrace.endSection(TRACE_TAG_REACT_JAVA_BRIDGE);
+    ReactMarker.logMarker(SETUP_REACT_CONTEXT_END);
+    // Mark end of bridge loading
+    ReactMarker.logMarker(ReactMarkerConstants.REACT_BRIDGE_LOADING_END);
   }
 
   private void attachRootViewToInstance(final ReactRoot reactRoot) {
@@ -1399,23 +1398,6 @@ public class ReactInstanceManager {
     if (Systrace.isTracing(TRACE_TAG_REACT_APPS | TRACE_TAG_REACT_JS_VM_CALLS)) {
       catalystInstance.setGlobalVariable("__RCTProfileIsProfiling", "true");
     }
-    if (ReactFeatureFlags.enableExperimentalStaticViewConfigs) {
-      mComponentNameResolverManager =
-          new ComponentNameResolverManager(
-              catalystInstance.getRuntimeExecutor(),
-              new ComponentNameResolver() {
-                @Override
-                public String[] getComponentNames() {
-                  List<String> viewManagerNames = getViewManagerNames();
-                  if (viewManagerNames == null) {
-                    FLog.e(TAG, "No ViewManager names found");
-                    return new String[0];
-                  }
-                  return viewManagerNames.toArray(new String[0]);
-                }
-              });
-      catalystInstance.setGlobalVariable("__fbStaticViewConfig", "true");
-    }
 
     ReactMarker.logMarker(ReactMarkerConstants.PRE_RUN_JS_BUNDLE_START);
     Systrace.beginSection(TRACE_TAG_REACT_JAVA_BRIDGE, "runJSBundle");

package/ReactAndroid/src/main/java/com/facebook/react/ReactInstanceManagerBuilder.java

@@ -26,9 +26,9 @@ import com.facebook.react.common.LifecycleState;
 import com.facebook.react.common.SurfaceDelegateFactory;
 import com.facebook.react.devsupport.DefaultDevSupportManagerFactory;
 import com.facebook.react.devsupport.DevSupportManagerFactory;
-import com.facebook.react.devsupport.RedBoxHandler;
 import com.facebook.react.devsupport.interfaces.DevBundleDownloadListener;
 import com.facebook.react.devsupport.interfaces.DevSupportManager;
+import com.facebook.react.devsupport.interfaces.RedBoxHandler;
 import com.facebook.react.jscexecutor.JSCExecutor;
 import com.facebook.react.jscexecutor.JSCExecutorFactory;
 import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
@@ -66,6 +66,7 @@ public class ReactInstanceManagerBuilder {
   private @Nullable Map<String, RequestHandler> mCustomPackagerCommandHandlers;
   private @Nullable ReactPackageTurboModuleManagerDelegate.Builder mTMMDelegateBuilder;
   private @Nullable SurfaceDelegateFactory mSurfaceDelegateFactory;
+  private JSInterpreter jsInterpreter = JSInterpreter.OLD_LOGIC;
 
   /* package protected */ ReactInstanceManagerBuilder() {}
 
@@ -125,6 +126,31 @@ public class ReactInstanceManagerBuilder {
     return this;
   }
 
+  /**
+   * Sets the jsEngine as JSC or HERMES as per the setJsEngineAsHermes call Uses the enum {@link
+   * JSInterpreter}
+   *
+   * @param jsInterpreter
+   */
+  private void setJSEngine(JSInterpreter jsInterpreter) {
+    this.jsInterpreter = jsInterpreter;
+  }
+
+  /**
+   * Utility setter to set the required JSEngine as HERMES or JSC Defaults to OLD_LOGIC if not
+   * called by the host app
+   *
+   * @param hermesEnabled hermesEnabled = true sets the JS Engine as HERMES and JSC otherwise
+   */
+  public ReactInstanceManagerBuilder setJsEngineAsHermes(boolean hermesEnabled) {
+    if (hermesEnabled) {
+      setJSEngine(JSInterpreter.HERMES);
+    } else {
+      setJSEngine(JSInterpreter.JSC);
+    }
+    return this;
+  }
+
   /**
    * Path to your app's main module on Metro. This is used when reloading JS during development. All
    * paths are relative to the root folder the packager is serving files from. Examples: {@code
@@ -345,41 +371,35 @@ public class ReactInstanceManagerBuilder {
 
   private JavaScriptExecutorFactory getDefaultJSExecutorFactory(
       String appName, String deviceName, Context applicationContext) {
-    try {
-      // If JSC is included, use it as normal
-      initializeSoLoaderIfNecessary(applicationContext);
-      JSCExecutor.loadLibrary();
-      return new JSCExecutorFactory(appName, deviceName);
-    } catch (UnsatisfiedLinkError jscE) {
-      // https://github.com/facebook/hermes/issues/78 shows that
-      // people who aren't trying to use Hermes are having issues.
-      // https://github.com/facebook/react-native/issues/25923#issuecomment-554295179
-      // includes the actual JSC error in at least one case.
-      //
-      // So, if "__cxa_bad_typeid" shows up in the jscE exception
-      // message, then we will assume that's the failure and just
-      // throw now.
-
-      if (jscE.getMessage().contains("__cxa_bad_typeid")) {
-        throw jscE;
-      }
 
-      // Otherwise use Hermes
+    // Relying solely on try catch block and loading jsc even when
+    // project is using hermes can lead to launch-time crashes especially in
+    // monorepo architectures and hybrid apps using both native android
+    // and react native.
+    // So we can use the value of enableHermes received by the constructor
+    // to decide which library to load at launch
+
+    // if nothing is specified, use old loading method
+    // else load the required engine
+    if (jsInterpreter == JSInterpreter.OLD_LOGIC) {
       try {
+        // If JSC is included, use it as normal
+        initializeSoLoaderIfNecessary(applicationContext);
+        JSCExecutor.loadLibrary();
+        return new JSCExecutorFactory(appName, deviceName);
+      } catch (UnsatisfiedLinkError jscE) {
+        if (jscE.getMessage().contains("__cxa_bad_typeid")) {
+          throw jscE;
+        }
         HermesExecutor.loadLibrary();
         return new HermesExecutorFactory();
-      } catch (UnsatisfiedLinkError hermesE) {
-        // If we get here, either this is a JSC build, and of course
-        // Hermes failed (since it's not in the APK), or it's a Hermes
-        // build, and Hermes had a problem.
-
-        // We suspect this is a JSC issue (it's the default), so we
-        // will throw that exception, but we will print hermesE first,
-        // since it could be a Hermes issue and we don't want to
-        // swallow that.
-        hermesE.printStackTrace();
-        throw jscE;
       }
+    } else if (jsInterpreter == JSInterpreter.HERMES) {
+      HermesExecutor.loadLibrary();
+      return new HermesExecutorFactory();
+    } else {
+      JSCExecutor.loadLibrary();
+      return new JSCExecutorFactory(appName, deviceName);
     }
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/ReactNativeHost.java

@@ -18,7 +18,7 @@ import com.facebook.react.common.LifecycleState;
 import com.facebook.react.common.SurfaceDelegate;
 import com.facebook.react.common.SurfaceDelegateFactory;
 import com.facebook.react.devsupport.DevSupportManagerFactory;
-import com.facebook.react.devsupport.RedBoxHandler;
+import com.facebook.react.devsupport.interfaces.RedBoxHandler;
 import com.facebook.react.uimanager.UIImplementationProvider;
 import java.util.List;
 

package/ReactAndroid/src/main/java/com/facebook/react/ReactRootView.java

@@ -52,6 +52,7 @@ import com.facebook.react.modules.deviceinfo.DeviceInfoModule;
 import com.facebook.react.surface.ReactStage;
 import com.facebook.react.uimanager.DisplayMetricsHolder;
 import com.facebook.react.uimanager.IllegalViewOperationException;
+import com.facebook.react.uimanager.JSPointerDispatcher;
 import com.facebook.react.uimanager.JSTouchDispatcher;
 import com.facebook.react.uimanager.PixelUtil;
 import com.facebook.react.uimanager.ReactClippingProhibitedView;
@@ -97,6 +98,7 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
   private boolean mIsAttachedToInstance;
   private boolean mShouldLogContentAppeared;
   private @Nullable JSTouchDispatcher mJSTouchDispatcher;
+  private @Nullable JSPointerDispatcher mJSPointerDispatcher;
   private final ReactAndroidHWInputDeviceHelper mAndroidHWInputDeviceHelper =
       new ReactAndroidHWInputDeviceHelper();
   private boolean mWasMeasured = false;
@@ -188,6 +190,11 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
 
   @Override
   public void onChildStartedNativeGesture(MotionEvent ev) {
+    onChildStartedNativeGesture(null, ev);
+  }
+
+  @Override
+  public void onChildStartedNativeGesture(View childView, MotionEvent ev) {
     if (!isDispatcherReady()) {
       return;
     }
@@ -197,14 +204,12 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
     if (uiManager != null) {
       EventDispatcher eventDispatcher = uiManager.getEventDispatcher();
       mJSTouchDispatcher.onChildStartedNativeGesture(ev, eventDispatcher);
+      if (childView != null && mJSPointerDispatcher != null) {
+        mJSPointerDispatcher.onChildStartedNativeGesture(childView, ev, eventDispatcher);
+      }
     }
   }
 
-  @Override
-  public void onChildStartedNativeGesture(View childView, MotionEvent ev) {
-    onChildStartedNativeGesture(ev);
-  }
-
   @Override
   public void onChildEndedNativeGesture(View childView, MotionEvent ev) {
     if (!isDispatcherReady()) {
@@ -216,6 +221,9 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
     if (uiManager != null) {
       EventDispatcher eventDispatcher = uiManager.getEventDispatcher();
       mJSTouchDispatcher.onChildEndedNativeGesture(ev, eventDispatcher);
+      if (mJSPointerDispatcher != null) {
+        mJSPointerDispatcher.onChildEndedNativeGesture();
+      }
     }
   }
 
@@ -230,25 +238,53 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
       FLog.w(TAG, "Unable to dispatch touch to JS before the dispatcher is available");
       return false;
     }
+    if (ReactFeatureFlags.dispatchPointerEvents && mJSPointerDispatcher == null) {
+      FLog.w(TAG, "Unable to dispatch pointer events to JS before the dispatcher is available");
+      return false;
+    }
 
     return true;
   }
 
+  // By default the JS touch events are dispatched at the root view. This can be overridden in
+  // subclasses as needed.
+  public boolean shouldDispatchJSTouchEvent(MotionEvent ev) {
+    return true;
+  }
+
   @Override
   public boolean onInterceptTouchEvent(MotionEvent ev) {
-    dispatchJSTouchEvent(ev);
+    if (shouldDispatchJSTouchEvent(ev)) {
+      dispatchJSTouchEvent(ev);
+    }
+    dispatchJSPointerEvent(ev);
     return super.onInterceptTouchEvent(ev);
   }
 
+  @Override
+  public boolean onInterceptHoverEvent(MotionEvent ev) {
+    dispatchJSPointerEvent(ev);
+    return super.onInterceptHoverEvent(ev);
+  }
+
   @Override
   public boolean onTouchEvent(MotionEvent ev) {
-    dispatchJSTouchEvent(ev);
+    if (shouldDispatchJSTouchEvent(ev)) {
+      dispatchJSTouchEvent(ev);
+    }
+    dispatchJSPointerEvent(ev);
     super.onTouchEvent(ev);
     // In case when there is no children interested in handling touch event, we return true from
     // the root view in order to receive subsequent events related to that gesture
     return true;
   }
 
+  @Override
+  public boolean onHoverEvent(MotionEvent ev) {
+    dispatchJSPointerEvent(ev);
+    return super.onHoverEvent(ev);
+  }
+
   @Override
   protected void dispatchDraw(Canvas canvas) {
     try {
@@ -302,6 +338,29 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
     super.requestChildFocus(child, focused);
   }
 
+  private void dispatchJSPointerEvent(MotionEvent event) {
+    if (mReactInstanceManager == null
+        || !mIsAttachedToInstance
+        || mReactInstanceManager.getCurrentReactContext() == null) {
+      FLog.w(TAG, "Unable to dispatch touch to JS as the catalyst instance has not been attached");
+      return;
+    }
+    if (mJSPointerDispatcher == null) {
+      if (!ReactFeatureFlags.dispatchPointerEvents) {
+        return;
+      }
+      FLog.w(TAG, "Unable to dispatch pointer events to JS before the dispatcher is available");
+      return;
+    }
+    ReactContext reactContext = mReactInstanceManager.getCurrentReactContext();
+    UIManager uiManager = UIManagerHelper.getUIManager(reactContext, getUIManagerType());
+
+    if (uiManager != null) {
+      EventDispatcher eventDispatcher = uiManager.getEventDispatcher();
+      mJSPointerDispatcher.handleMotionEvent(event, eventDispatcher);
+    }
+  }
+
   private void dispatchJSTouchEvent(MotionEvent event) {
     if (mReactInstanceManager == null
         || !mIsAttachedToInstance
@@ -619,6 +678,11 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
     // them. Otherwise, these events might break the states expected by JS.
     // Note that this callback was invoked from within the UI thread.
     mJSTouchDispatcher = new JSTouchDispatcher(this);
+
+    if (ReactFeatureFlags.dispatchPointerEvents) {
+      mJSPointerDispatcher = new JSPointerDispatcher(this);
+    }
+
     if (mRootViewEventListener != null) {
       mRootViewEventListener.onAttachedToReactInstance(this);
     }
@@ -699,6 +763,9 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
   /* package */ void simulateAttachForTesting() {
     mIsAttachedToInstance = true;
     mJSTouchDispatcher = new JSTouchDispatcher(this);
+    if (ReactFeatureFlags.dispatchPointerEvents) {
+      mJSPointerDispatcher = new JSPointerDispatcher(this);
+    }
   }
 
   @VisibleForTesting
@@ -719,12 +786,22 @@ public class ReactRootView extends FrameLayout implements RootView, ReactRoot {
 
     // React Native requires that the RootView id be managed entirely by React Native, and will
     // crash in addRootView/startSurface if the native View id isn't set to NO_ID.
+
+    // This behavior can not be guaranteed in hybrid apps that have a native android layer over
+    // which reactRootViews are added and the native views need to have ids on them in order to
+    // work.
+    // Hence this can cause unnecessary crashes at runtime for hybrid apps.
+    // So converting this to a soft exception such that pure react-native devs can still see the
+    // warning while hybrid apps continue to run without crashes
+
     if (getId() != View.NO_ID) {
-      throw new IllegalViewOperationException(
-          "Trying to attach a ReactRootView with an explicit id already set to ["
-              + getId()
-              + "]. React Native uses the id field to track react tags and will overwrite this"
-              + " field. If that is fine, explicitly overwrite the id field to View.NO_ID.");
+      ReactSoftExceptionLogger.logSoftException(
+          TAG,
+          new IllegalViewOperationException(
+              "Trying to attach a ReactRootView with an explicit id already set to ["
+                  + getId()
+                  + "]. React Native uses the id field to track react tags and will overwrite this"
+                  + " field. If that is fine, explicitly overwrite the id field to View.NO_ID."));
     }
 
     try {

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

@@ -0,0 +1,15 @@
+/*
+ * 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.animated;
+
+import com.facebook.react.bridge.ReadableMap;
+
+/** Indicates that AnimatedNode is able to receive native config updates. */
+public interface AnimatedNodeWithUpdateableConfig {
+  void onUpdateConfig(ReadableMap config);
+}

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

@@ -7,7 +7,10 @@ rn_android_library(
     ]),
     autoglob = False,
     is_androidx = True,
-    labels = ["supermodule:xplat/default/public.react_native.infra"],
+    labels = [
+        "pfh:ReactNative_CommonInfrastructurePlaceholder",
+        "supermodule:xplat/default/public.react_native.infra",
+    ],
     provided_deps = [
         react_native_dep("third-party/android/androidx:annotation"),
         react_native_dep("third-party/android/androidx:core"),
@@ -26,8 +29,10 @@ rn_android_library(
         react_native_target("java/com/facebook/react/common:common"),
         react_native_target("java/com/facebook/react/module/annotations:annotations"),
         react_native_target("java/com/facebook/react/modules/core:core"),
+        react_native_target("java/com/facebook/react/config:config"),
         react_native_target("java/com/facebook/react/uimanager:uimanager"),
         react_native_target("java/com/facebook/react/uimanager/annotations:annotations"),
+        react_native_target("java/com/facebook/react/views/view:view"),
     ],
     exported_deps = [react_native_root_target(":FBReactNativeSpec")],
 )

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

@@ -0,0 +1,131 @@
+/*
+ * 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.animated;
+
+import android.content.Context;
+import android.graphics.Color;
+import android.view.View;
+import com.facebook.react.bridge.ColorPropConverter;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.views.view.ColorUtil;
+
+/** Animated node that represents a color. */
+/*package*/ class ColorAnimatedNode extends AnimatedNode
+    implements AnimatedNodeWithUpdateableConfig {
+
+  private final NativeAnimatedNodesManager mNativeAnimatedNodesManager;
+  private final ReactApplicationContext mReactApplicationContext;
+  private int mRNodeId;
+  private int mGNodeId;
+  private int mBNodeId;
+  private int mANodeId;
+  private ReadableMap mNativeColor;
+  private boolean mNativeColorApplied;
+
+  public ColorAnimatedNode(
+      ReadableMap config,
+      NativeAnimatedNodesManager nativeAnimatedNodesManager,
+      ReactApplicationContext reactApplicationContext) {
+    mNativeAnimatedNodesManager = nativeAnimatedNodesManager;
+    mReactApplicationContext = reactApplicationContext;
+    onUpdateConfig(config);
+  }
+
+  public int getColor() {
+    tryApplyNativeColor();
+
+    ValueAnimatedNode rNode = (ValueAnimatedNode) mNativeAnimatedNodesManager.getNodeById(mRNodeId);
+    ValueAnimatedNode gNode = (ValueAnimatedNode) mNativeAnimatedNodesManager.getNodeById(mGNodeId);
+    ValueAnimatedNode bNode = (ValueAnimatedNode) mNativeAnimatedNodesManager.getNodeById(mBNodeId);
+    ValueAnimatedNode aNode = (ValueAnimatedNode) mNativeAnimatedNodesManager.getNodeById(mANodeId);
+
+    double r = rNode.getValue();
+    double g = gNode.getValue();
+    double b = bNode.getValue();
+    double a = aNode.getValue();
+
+    return ColorUtil.normalize(r, g, b, a);
+  }
+
+  public void onUpdateConfig(ReadableMap config) {
+    mRNodeId = config.getInt("r");
+    mGNodeId = config.getInt("g");
+    mBNodeId = config.getInt("b");
+    mANodeId = config.getInt("a");
+    mNativeColor = config.getMap("nativeColor");
+    mNativeColorApplied = false;
+    tryApplyNativeColor();
+  }
+
+  @Override
+  public String prettyPrint() {
+    return "ColorAnimatedNode["
+        + mTag
+        + "]: r: "
+        + mRNodeId
+        + " g: "
+        + mGNodeId
+        + " b: "
+        + mBNodeId
+        + " a: "
+        + mANodeId;
+  }
+
+  private void tryApplyNativeColor() {
+    if (mNativeColor == null || mNativeColorApplied) {
+      return;
+    }
+
+    Context context = getContext();
+    if (context == null) {
+      return;
+    }
+
+    int color = ColorPropConverter.getColor(mNativeColor, context);
+
+    ValueAnimatedNode rNode = (ValueAnimatedNode) mNativeAnimatedNodesManager.getNodeById(mRNodeId);
+    ValueAnimatedNode gNode = (ValueAnimatedNode) mNativeAnimatedNodesManager.getNodeById(mGNodeId);
+    ValueAnimatedNode bNode = (ValueAnimatedNode) mNativeAnimatedNodesManager.getNodeById(mBNodeId);
+    ValueAnimatedNode aNode = (ValueAnimatedNode) mNativeAnimatedNodesManager.getNodeById(mANodeId);
+
+    rNode.mValue = Color.red(color);
+    gNode.mValue = Color.green(color);
+    bNode.mValue = Color.blue(color);
+    aNode.mValue = Color.alpha(color) / 255.0;
+
+    mNativeColorApplied = true;
+  }
+
+  private Context getContext() {
+    Context context = mReactApplicationContext.getCurrentActivity();
+    if (context != null) {
+      return context;
+    }
+
+    // There are cases where the activity may not exist (such as for VRShell panel apps). In this
+    // case we will search for a view associated with a PropsAnimatedNode to get the context.
+    return getContextHelper(this);
+  }
+
+  private static Context getContextHelper(AnimatedNode node) {
+    // Search children depth-first until we get to a PropsAnimatedNode, from which we can
+    // get the view and its context
+    if (node.mChildren != null) {
+      for (AnimatedNode child : node.mChildren) {
+        if (child instanceof PropsAnimatedNode) {
+          View view = ((PropsAnimatedNode) child).getConnectedView();
+          return view != null ? view.getContext() : null;
+        } else {
+          return getContextHelper(child);
+        }
+      }
+    }
+    return null;
+  }
+}