react-native-tvos 0.75.3-0 → 0.76.0-0

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

@@ -32,10 +32,12 @@ import com.facebook.react.uimanager.events.EventDispatcher;
 import com.facebook.react.uimanager.events.EventDispatcherListener;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
+import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.ListIterator;
 import java.util.Queue;
+import java.util.Set;
 
 /**
  * This is the main class that coordinates how native animated JS implementation drives UI changes.
@@ -147,7 +149,7 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
     } else {
       throw new JSApplicationIllegalArgumentException("Unsupported node type: " + type);
     }
-    node.mTag = tag;
+    node.tag = tag;
     mAnimatedNodes.put(tag, node);
     mUpdatedNodes.put(tag, node);
   }
@@ -207,7 +209,7 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
               + "] does not exist, or is not a 'value' node");
     }
     stopAnimationsForNode(node);
-    ((ValueAnimatedNode) node).mValue = value;
+    ((ValueAnimatedNode) node).nodeValue = value;
     mUpdatedNodes.put(tag, node);
   }
 
@@ -220,7 +222,7 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
               + tag
               + "] does not exist, or is not a 'value' node");
     }
-    ((ValueAnimatedNode) node).mOffset = offset;
+    ((ValueAnimatedNode) node).offset = offset;
     mUpdatedNodes.put(tag, node);
   }
 
@@ -284,9 +286,9 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
       throw new JSApplicationIllegalArgumentException(
           "startAnimatingNode: Unsupported animation type [" + animatedNodeTag + "]: " + type);
     }
-    animation.mId = animationId;
-    animation.mEndCallback = endCallback;
-    animation.mAnimatedValue = (ValueAnimatedNode) node;
+    animation.id = animationId;
+    animation.endCallback = endCallback;
+    animation.animatedValue = (ValueAnimatedNode) node;
     mActiveAnimations.put(animationId, animation);
   }
 
@@ -299,21 +301,21 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
     WritableArray events = null;
     for (int i = 0; i < mActiveAnimations.size(); i++) {
       AnimationDriver animation = mActiveAnimations.valueAt(i);
-      if (animatedNode.equals(animation.mAnimatedValue)) {
-        if (animation.mEndCallback != null) {
+      if (animatedNode.equals(animation.animatedValue)) {
+        if (animation.endCallback != null) {
           // Invoke animation end callback with {finished: false}
           WritableMap endCallbackResponse = Arguments.createMap();
           endCallbackResponse.putBoolean("finished", false);
-          endCallbackResponse.putDouble("value", animation.mAnimatedValue.mValue);
-          animation.mEndCallback.invoke(endCallbackResponse);
+          endCallbackResponse.putDouble("value", animation.animatedValue.nodeValue);
+          animation.endCallback.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.putInt("animationId", animation.id);
           params.putBoolean("finished", false);
-          params.putDouble("value", animation.mAnimatedValue.mValue);
+          params.putDouble("value", animation.animatedValue.nodeValue);
           if (events == null) {
             events = Arguments.createArray();
           }
@@ -337,21 +339,21 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
     WritableArray events = null;
     for (int i = 0; i < mActiveAnimations.size(); i++) {
       AnimationDriver animation = mActiveAnimations.valueAt(i);
-      if (animation.mId == animationId) {
-        if (animation.mEndCallback != null) {
+      if (animation.id == animationId) {
+        if (animation.endCallback != null) {
           // Invoke animation end callback with {finished: false}
           WritableMap endCallbackResponse = Arguments.createMap();
           endCallbackResponse.putBoolean("finished", false);
-          endCallbackResponse.putDouble("value", animation.mAnimatedValue.mValue);
-          animation.mEndCallback.invoke(endCallbackResponse);
+          endCallbackResponse.putDouble("value", animation.animatedValue.nodeValue);
+          animation.endCallback.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.putInt("animationId", animation.id);
           params.putBoolean("finished", false);
-          params.putDouble("value", animation.mAnimatedValue.mValue);
+          params.putDouble("value", animation.animatedValue.nodeValue);
           if (events == null) {
             events = Arguments.createArray();
           }
@@ -545,6 +547,11 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
     EventAnimationDriver eventDriver =
         new EventAnimationDriver(eventName, viewTag, pathList, (ValueAnimatedNode) node);
     mEventDrivers.add(eventDriver);
+
+    if (eventName.equals("topScroll")) {
+      // Handle the custom topScrollEnded event sent by the ScrollViews when the user stops dragging
+      addAnimatedEventToView(viewTag, "topScrollEnded", eventMapping);
+    }
   }
 
   @UiThread
@@ -556,9 +563,9 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
     ListIterator<EventAnimationDriver> it = mEventDrivers.listIterator();
     while (it.hasNext()) {
       EventAnimationDriver driver = it.next();
-      if (eventName.equals(driver.mEventName)
-          && viewTag == driver.mViewTag
-          && animatedValueTag == driver.mValueNode.mTag) {
+      if (eventName.equals(driver.eventName)
+          && viewTag == driver.viewTag
+          && animatedValueTag == driver.valueNode.tag) {
         it.remove();
         break;
       }
@@ -602,11 +609,11 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
       boolean foundAtLeastOneDriver = false;
       Event.EventAnimationDriverMatchSpec matchSpec = event.getEventAnimationDriverMatchSpec();
       for (EventAnimationDriver driver : mEventDrivers) {
-        if (matchSpec.match(driver.mViewTag, driver.mEventName)) {
+        if (matchSpec.match(driver.viewTag, driver.eventName)) {
           foundAtLeastOneDriver = true;
-          stopAnimationsForNode(driver.mValueNode);
+          stopAnimationsForNode(driver.valueNode);
           event.dispatchModern(driver);
-          mRunUpdateNodeList.add(driver.mValueNode);
+          mRunUpdateNodeList.add(driver.valueNode);
         }
       }
 
@@ -625,7 +632,7 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
    * <p>First BFS starts with nodes that are in {@code mUpdatedNodes} (that is, their value have
    * been modified from JS in the last batch of JS operations) or directly attached to an active
    * animation (hence linked to objects from {@code mActiveAnimations}). In that step we calculate
-   * an attribute {@code mActiveIncomingNodes}. The second BFS runs in topological order over the
+   * an attribute {@code activeIncomingNodes}. The second BFS runs in topological order over the
    * sub-graph of *active* nodes. This is done by adding node to the BFS queue only if all its
    * "predecessors" have already been visited.
    */
@@ -645,9 +652,9 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
     for (int i = 0; i < mActiveAnimations.size(); i++) {
       AnimationDriver animation = mActiveAnimations.valueAt(i);
       animation.runAnimationStep(frameTimeNanos);
-      AnimatedNode valueNode = animation.mAnimatedValue;
+      AnimatedNode valueNode = animation.animatedValue;
       mRunUpdateNodeList.add(valueNode);
-      if (animation.mHasFinished) {
+      if (animation.hasFinished) {
         hasFinishedAnimations = true;
       }
     }
@@ -661,20 +668,20 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
       WritableArray events = null;
       for (int i = mActiveAnimations.size() - 1; i >= 0; i--) {
         AnimationDriver animation = mActiveAnimations.valueAt(i);
-        if (animation.mHasFinished) {
-          if (animation.mEndCallback != null) {
+        if (animation.hasFinished) {
+          if (animation.endCallback != null) {
             WritableMap endCallbackResponse = Arguments.createMap();
             endCallbackResponse.putBoolean("finished", true);
-            endCallbackResponse.putDouble("value", animation.mAnimatedValue.mValue);
-            animation.mEndCallback.invoke(endCallbackResponse);
+            endCallbackResponse.putDouble("value", animation.animatedValue.nodeValue);
+            animation.endCallback.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.putInt("animationId", animation.id);
             params.putBoolean("finished", true);
-            params.putDouble("value", animation.mAnimatedValue.mValue);
+            params.putDouble("value", animation.animatedValue.nodeValue);
             if (events == null) {
               events = Arguments.createArray();
             }
@@ -689,6 +696,28 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
     }
   }
 
+  Set<Integer> getTagsOfConnectedNodes(int tag, String eventName) {
+    Set<Integer> tags = new HashSet<>();
+
+    // Filter only relevant animation drivers
+    ListIterator<EventAnimationDriver> it = mEventDrivers.listIterator();
+    while (it.hasNext()) {
+      EventAnimationDriver driver = it.next();
+      if (driver != null) {
+        if (eventName.equals(driver.eventName) && tag == driver.viewTag) {
+          tags.add(driver.viewTag);
+          if (driver.valueNode != null && driver.valueNode.children != null) {
+            for (AnimatedNode node : driver.valueNode.children) {
+              tags.add(node.tag);
+            }
+          }
+        }
+      }
+    }
+
+    return tags;
+  }
+
   @UiThread
   private void updateNodes(List<AnimatedNode> nodes) {
     int activeNodesCount = 0;
@@ -708,8 +737,8 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
 
     Queue<AnimatedNode> nodesQueue = new ArrayDeque<>();
     for (AnimatedNode node : nodes) {
-      if (node.mBFSColor != mAnimatedGraphBFSColor) {
-        node.mBFSColor = mAnimatedGraphBFSColor;
+      if (node.BFSColor != mAnimatedGraphBFSColor) {
+        node.BFSColor = mAnimatedGraphBFSColor;
         activeNodesCount++;
         nodesQueue.add(node);
       }
@@ -717,12 +746,12 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
 
     while (!nodesQueue.isEmpty()) {
       AnimatedNode nextNode = nodesQueue.poll();
-      if (nextNode.mChildren != null) {
-        for (int i = 0; i < nextNode.mChildren.size(); i++) {
-          AnimatedNode child = nextNode.mChildren.get(i);
-          child.mActiveIncomingNodes++;
-          if (child.mBFSColor != mAnimatedGraphBFSColor) {
-            child.mBFSColor = mAnimatedGraphBFSColor;
+      if (nextNode.children != null) {
+        for (int i = 0; i < nextNode.children.size(); i++) {
+          AnimatedNode child = nextNode.children.get(i);
+          child.activeIncomingNodes++;
+          if (child.BFSColor != mAnimatedGraphBFSColor) {
+            child.BFSColor = mAnimatedGraphBFSColor;
             activeNodesCount++;
             nodesQueue.add(child);
           }
@@ -735,7 +764,7 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
     // "predecessors" in the graph have already been visited. It is important to visit nodes in that
     // order as they may often use values of their predecessors in order to calculate "next state"
     // of their own. We start by determining the starting set of nodes by looking for nodes with
-    // `mActiveIncomingNodes = 0` (those can only be the ones that we start BFS in the previous
+    // `activeIncomingNodes = 0` (those can only be the ones that we start BFS in the previous
     // step). We store number of visited nodes in this step in `updatedNodesCount`
 
     mAnimatedGraphBFSColor++;
@@ -747,8 +776,8 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
     // find nodes with zero "incoming nodes", those can be either nodes from `mUpdatedNodes` or
     // ones connected to active animations
     for (AnimatedNode node : nodes) {
-      if (node.mActiveIncomingNodes == 0 && node.mBFSColor != mAnimatedGraphBFSColor) {
-        node.mBFSColor = mAnimatedGraphBFSColor;
+      if (node.activeIncomingNodes == 0 && node.BFSColor != mAnimatedGraphBFSColor) {
+        node.BFSColor = mAnimatedGraphBFSColor;
         updatedNodesCount++;
         nodesQueue.add(node);
       }
@@ -778,15 +807,15 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
         // Potentially send events to JS when the node's value is updated
         ((ValueAnimatedNode) nextNode).onValueUpdate();
       }
-      if (nextNode.mChildren != null) {
-        for (int i = 0; i < nextNode.mChildren.size(); i++) {
-          AnimatedNode child = nextNode.mChildren.get(i);
-          child.mActiveIncomingNodes--;
-          if (child.mBFSColor != mAnimatedGraphBFSColor && child.mActiveIncomingNodes == 0) {
-            child.mBFSColor = mAnimatedGraphBFSColor;
+      if (nextNode.children != null) {
+        for (int i = 0; i < nextNode.children.size(); i++) {
+          AnimatedNode child = nextNode.children.get(i);
+          child.activeIncomingNodes--;
+          if (child.BFSColor != mAnimatedGraphBFSColor && child.activeIncomingNodes == 0) {
+            child.BFSColor = mAnimatedGraphBFSColor;
             updatedNodesCount++;
             nodesQueue.add(child);
-          } else if (child.mBFSColor == mAnimatedGraphBFSColor) {
+          } else if (child.BFSColor == mAnimatedGraphBFSColor) {
             cyclesDetected++;
           }
         }
@@ -796,7 +825,7 @@ public class NativeAnimatedNodesManager implements EventDispatcherListener {
     // Verify that we've visited *all* active nodes. Throw otherwise as this could mean there is a
     // cycle in animated node graph, or that the graph is only partially set up. We also take
     // advantage of the fact that all active nodes are visited in the step above so that all the
-    // nodes properties `mActiveIncomingNodes` are set to zero.
+    // nodes properties `activeIncomingNodes` are set to zero.
     // In Fabric there can be race conditions between the JS thread setting up or tearing down
     // animated nodes, and Fabric executing them on the UI thread, leading to temporary inconsistent
     // states.

package/ReactAndroid/src/main/java/com/facebook/react/animated/ObjectAnimatedNode.kt

@@ -0,0 +1,120 @@
+/*
+ * 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.JavaOnlyArray
+import com.facebook.react.bridge.JavaOnlyMap
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+
+/**
+ * Native counterpart of object animated node (see AnimatedObject class in
+ * AnimatedImplementation.js)
+ */
+internal class ObjectAnimatedNode(
+    config: ReadableMap,
+    private val nativeAnimatedNodesManager: NativeAnimatedNodesManager
+) : AnimatedNode() {
+  private val configClone: JavaOnlyMap = JavaOnlyMap.deepClone(config)
+
+  fun collectViewUpdates(propKey: String, propsMap: JavaOnlyMap) {
+    val valueType = configClone.getType(VALUE_KEY)
+    if (valueType == ReadableType.Map) {
+      propsMap.putMap(propKey, collectViewUpdatesHelper(configClone.getMap(VALUE_KEY)))
+    } else if (valueType == ReadableType.Array) {
+      propsMap.putArray(propKey, collectViewUpdatesHelper(configClone.getArray(VALUE_KEY)))
+    } else {
+      throw IllegalArgumentException("Invalid value type for ObjectAnimatedNode")
+    }
+  }
+
+  private fun collectViewUpdatesHelper(source: ReadableArray?): JavaOnlyArray? {
+    source ?: return null
+    val result = JavaOnlyArray()
+    for (i in 0 until source.size()) {
+      when (source.getType(i)) {
+        ReadableType.Null -> result.pushNull()
+        ReadableType.Boolean -> result.pushBoolean(source.getBoolean(i))
+        ReadableType.Number -> result.pushDouble(source.getDouble(i))
+        ReadableType.String -> result.pushString(source.getString(i))
+        ReadableType.Map -> {
+          val map = source.getMap(i)
+          if (map.hasKey(NODE_TAG_KEY) && map.getType(NODE_TAG_KEY) == ReadableType.Number) {
+            val node = nativeAnimatedNodesManager.getNodeById(map.getInt(NODE_TAG_KEY))
+            requireNotNull(node) { "Mapped value node does not exist" }
+            if (node is ValueAnimatedNode) {
+              val animatedObject = node.getAnimatedObject()
+              if (animatedObject is Int) {
+                result.pushInt(animatedObject)
+              } else if (animatedObject is String) {
+                result.pushString(animatedObject)
+              } else {
+                result.pushDouble(node.getValue())
+              }
+            } else if (node is ColorAnimatedNode) {
+              result.pushInt(node.color)
+            }
+          } else {
+            result.pushMap(collectViewUpdatesHelper(source.getMap(i)))
+          }
+        }
+        ReadableType.Array -> result.pushArray(collectViewUpdatesHelper(source.getArray(i)))
+      }
+    }
+    return result
+  }
+
+  private fun collectViewUpdatesHelper(source: ReadableMap?): JavaOnlyMap? {
+    source ?: return null
+    val result = JavaOnlyMap()
+    val iter = source.keySetIterator()
+    while (iter.hasNextKey()) {
+      val propKey = iter.nextKey()
+      when (source.getType(propKey)) {
+        ReadableType.Null -> result.putNull(propKey)
+        ReadableType.Boolean -> result.putBoolean(propKey, source.getBoolean(propKey))
+        ReadableType.Number -> result.putDouble(propKey, source.getDouble(propKey))
+        ReadableType.String -> result.putString(propKey, source.getString(propKey))
+        ReadableType.Map -> {
+          val map = source.getMap(propKey)
+          if (map != null &&
+              map.hasKey(NODE_TAG_KEY) &&
+              map.getType(NODE_TAG_KEY) == ReadableType.Number) {
+            val node = nativeAnimatedNodesManager.getNodeById(map.getInt(NODE_TAG_KEY))
+            requireNotNull(node) { "Mapped value node does not exist" }
+            if (node is ValueAnimatedNode) {
+              val animatedObject = node.getAnimatedObject()
+              if (animatedObject is Int) {
+                result.putInt(propKey, animatedObject)
+              } else if (animatedObject is String) {
+                result.putString(propKey, animatedObject)
+              } else {
+                result.putDouble(propKey, node.getValue())
+              }
+            } else if (node is ColorAnimatedNode) {
+              result.putInt(propKey, node.color)
+            }
+          } else {
+            result.putMap(propKey, collectViewUpdatesHelper(map))
+          }
+        }
+        ReadableType.Array ->
+            result.putArray(propKey, collectViewUpdatesHelper(source.getArray(propKey)))
+      }
+    }
+    return result
+  }
+
+  override fun prettyPrint(): String = "ObjectAnimatedNode[$tag]: mConfig: $configClone"
+
+  companion object {
+    private const val VALUE_KEY = "value"
+    private const val NODE_TAG_KEY = "nodeTag"
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/animated/PropsAnimatedNode.kt

@@ -0,0 +1,120 @@
+/*
+ * 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.view.View
+import com.facebook.react.bridge.JSApplicationIllegalArgumentException
+import com.facebook.react.bridge.JavaOnlyMap
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.UIManager
+import com.facebook.react.uimanager.common.UIManagerType
+import com.facebook.react.uimanager.common.ViewUtil.getUIManagerType
+
+/**
+ * Animated node that represents view properties. There is a special handling logic implemented for
+ * the nodes of this type in [NativeAnimatedNodesManager] that is responsible for extracting a map
+ * of updated properties, which can be then passed down to the view.
+ */
+internal class PropsAnimatedNode(
+    config: ReadableMap,
+    private val nativeAnimatedNodesManager: NativeAnimatedNodesManager
+) : AnimatedNode() {
+  private var connectedViewTag = -1
+  private val propNodeMapping: MutableMap<String, Int>
+  private val propMap = JavaOnlyMap()
+  private var connectedViewUIManager: UIManager? = null
+
+  init {
+    val props = config.getMap("props")
+    val iter = props?.keySetIterator()
+    propNodeMapping = mutableMapOf()
+    while (iter != null && iter.hasNextKey()) {
+      val propKey = iter.nextKey()
+      val nodeIndex = props.getInt(propKey)
+      propNodeMapping[propKey] = nodeIndex
+    }
+  }
+
+  public fun connectToView(viewTag: Int, uiManager: UIManager?) {
+    if (connectedViewTag != -1) {
+      throw JSApplicationIllegalArgumentException(
+          "Animated node $tag is already attached to a view: $connectedViewTag")
+    }
+    connectedViewTag = viewTag
+    connectedViewUIManager = uiManager
+  }
+
+  public fun disconnectFromView(viewTag: Int) {
+    if (connectedViewTag != viewTag && connectedViewTag != -1) {
+      throw JSApplicationIllegalArgumentException(
+          "Attempting to disconnect view that has " +
+              "not been connected with the given animated node: $viewTag " +
+              "but is connected to view $connectedViewTag")
+    }
+    connectedViewTag = -1
+  }
+
+  public fun restoreDefaultValues() {
+    // Cannot restore default values if this view has already been disconnected.
+    if (connectedViewTag == -1) {
+      return
+    }
+    // Don't restore default values in Fabric.
+    // In Non-Fabric this had the effect of "restore the value to whatever the value was on the
+    // ShadowNode instead of in the View hierarchy". However, "synchronouslyUpdateViewOnUIThread"
+    // will not have that impact on Fabric, because the FabricUIManager doesn't have access to the
+    // ShadowNode layer.
+    if (getUIManagerType(connectedViewTag) == UIManagerType.FABRIC) {
+      return
+    }
+    val it = propMap.keySetIterator()
+    while (it.hasNextKey()) {
+      propMap.putNull(it.nextKey())
+    }
+    connectedViewUIManager?.synchronouslyUpdateViewOnUIThread(connectedViewTag, propMap)
+  }
+
+  public fun updateView() {
+    if (connectedViewTag == -1) {
+      return
+    }
+    for ((key, value) in propNodeMapping) {
+      val node = nativeAnimatedNodesManager.getNodeById(value)
+      requireNotNull(node) { "Mapped property node does not exist" }
+      if (node is StyleAnimatedNode) {
+        node.collectViewUpdates(propMap)
+      } else if (node is ValueAnimatedNode) {
+        val animatedObject = node.getAnimatedObject()
+        if (animatedObject is Int) {
+          propMap.putInt(key, animatedObject)
+        } else if (animatedObject is String) {
+          propMap.putString(key, animatedObject)
+        } else {
+          propMap.putDouble(key, node.getValue())
+        }
+      } else if (node is ColorAnimatedNode) {
+        propMap.putInt(key, node.color)
+      } else if (node is ObjectAnimatedNode) {
+        node.collectViewUpdates(key, propMap)
+      } else {
+        throw IllegalArgumentException(
+            "Unsupported type of node used in property node ${node.javaClass}")
+      }
+    }
+    connectedViewUIManager?.synchronouslyUpdateViewOnUIThread(connectedViewTag, propMap)
+  }
+
+  public val connectedView: View?
+    // resolveView throws an {@link IllegalViewOperationException} when the view doesn't exist
+    // (this can happen if the surface is being deallocated).
+    get() = runCatching { connectedViewUIManager?.resolveView(connectedViewTag) }.getOrNull()
+
+  override fun prettyPrint(): String =
+      "PropsAnimatedNode[$tag] connectedViewTag: $connectedViewTag " +
+          "propNodeMapping: $propNodeMapping propMap: $propMap"
+}