react-native 0.0.0-e6fc20ee6 → 0.0.0-e9440508e-20211011-2008

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

@@ -9,23 +9,22 @@ package com.facebook.react.animated;
 
 import android.util.SparseArray;
 import androidx.annotation.Nullable;
+import androidx.annotation.UiThread;
 import com.facebook.common.logging.FLog;
-import com.facebook.infer.annotation.Assertions;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.JSApplicationCausedNativeException;
 import com.facebook.react.bridge.JSApplicationIllegalArgumentException;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactNoCrashSoftException;
-import com.facebook.react.bridge.ReactSoftException;
+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.UiThreadUtil;
 import com.facebook.react.bridge.WritableMap;
-import com.facebook.react.uimanager.IllegalViewOperationException;
 import com.facebook.react.uimanager.UIManagerHelper;
-import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.common.UIManagerType;
 import com.facebook.react.uimanager.events.Event;
 import com.facebook.react.uimanager.events.EventDispatcher;
 import com.facebook.react.uimanager.events.EventDispatcherListener;
@@ -54,7 +53,6 @@ import java.util.Queue;
 /*package*/ class NativeAnimatedNodesManager implements EventDispatcherListener {
 
   private static final String TAG = "NativeAnimatedNodesManager";
-  private static final int MAX_INCONSISTENT_FRAMES = 64;
 
   private final SparseArray<AnimatedNode> mAnimatedNodes = new SparseArray<>();
   private final SparseArray<AnimationDriver> mActiveAnimations = new SparseArray<>();
@@ -62,23 +60,52 @@ import java.util.Queue;
   // Mapping of a view tag and an event name to a list of event animation drivers. 99% of the time
   // there will be only one driver per mapping so all code code should be optimized around that.
   private final Map<String, List<EventAnimationDriver>> mEventDrivers = new HashMap<>();
-  private final UIManagerModule.CustomEventNamesResolver mCustomEventNamesResolver;
   private final ReactApplicationContext mReactApplicationContext;
   private int mAnimatedGraphBFSColor = 0;
-  private int mNumInconsistentFrames = 0;
   // Used to avoid allocating a new array on every frame in `runUpdates` and `onEventDispatch`.
   private final List<AnimatedNode> mRunUpdateNodeList = new LinkedList<>();
 
+  private boolean mEventListenerInitializedForFabric = false;
+  private boolean mEventListenerInitializedForNonFabric = false;
+
+  private boolean mWarnedAboutGraphTraversal = false;
+
   public NativeAnimatedNodesManager(ReactApplicationContext reactApplicationContext) {
     mReactApplicationContext = reactApplicationContext;
+  }
 
-    UIManagerModule uiManager =
-        Assertions.assertNotNull(reactApplicationContext.getNativeModule(UIManagerModule.class));
+  /**
+   * 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.
+   *
+   * @param uiManagerType
+   */
+  @UiThread
+  public void initializeEventListenerForUIManagerType(@UIManagerType final int uiManagerType) {
+    if ((uiManagerType == UIManagerType.FABRIC && mEventListenerInitializedForFabric)
+        || (uiManagerType == UIManagerType.DEFAULT && mEventListenerInitializedForNonFabric)) {
+      return;
+    }
 
-    uiManager.<EventDispatcher>getEventDispatcher().addListener(this);
-    // TODO T64216139 Remove dependency of UIManagerModule when the Constants are not in Native
-    // anymore
-    mCustomEventNamesResolver = uiManager.getDirectEventNamesResolver();
+    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;
+              }
+            }
+          }
+        });
   }
 
   /*package*/ @Nullable
@@ -90,10 +117,11 @@ import java.util.Queue;
     return mActiveAnimations.size() > 0 || mUpdatedNodes.size() > 0;
   }
 
+  @UiThread
   public void createAnimatedNode(int tag, ReadableMap config) {
     if (mAnimatedNodes.get(tag) != null) {
       throw new JSApplicationIllegalArgumentException(
-          "Animated node with tag " + tag + " already exists");
+          "createAnimatedNode: Animated node [" + tag + "] already exists");
     }
     String type = config.getString("type");
     final AnimatedNode node;
@@ -129,78 +157,101 @@ import java.util.Queue;
     mUpdatedNodes.put(tag, node);
   }
 
+  @UiThread
   public void dropAnimatedNode(int tag) {
     mAnimatedNodes.remove(tag);
     mUpdatedNodes.remove(tag);
   }
 
+  @UiThread
   public void startListeningToAnimatedNodeValue(int tag, AnimatedNodeValueListener listener) {
     AnimatedNode node = mAnimatedNodes.get(tag);
     if (node == null || !(node instanceof ValueAnimatedNode)) {
       throw new JSApplicationIllegalArgumentException(
-          "Animated node with tag " + tag + " does not exist, or is not a 'value' node");
+          "startListeningToAnimatedNodeValue: Animated node ["
+              + tag
+              + "] does not exist, or is not a 'value' node");
     }
     ((ValueAnimatedNode) node).setValueListener(listener);
   }
 
+  @UiThread
   public void stopListeningToAnimatedNodeValue(int tag) {
     AnimatedNode node = mAnimatedNodes.get(tag);
     if (node == null || !(node instanceof ValueAnimatedNode)) {
       throw new JSApplicationIllegalArgumentException(
-          "Animated node with tag " + tag + " does not exist, or is not a 'value' node");
+          "startListeningToAnimatedNodeValue: Animated node ["
+              + tag
+              + "] does not exist, or is not a 'value' node");
     }
     ((ValueAnimatedNode) node).setValueListener(null);
   }
 
+  @UiThread
   public void setAnimatedNodeValue(int tag, double value) {
     AnimatedNode node = mAnimatedNodes.get(tag);
     if (node == null || !(node instanceof ValueAnimatedNode)) {
       throw new JSApplicationIllegalArgumentException(
-          "Animated node with tag " + tag + " does not exist, or is not a 'value' node");
+          "setAnimatedNodeValue: Animated node ["
+              + tag
+              + "] does not exist, or is not a 'value' node");
     }
     stopAnimationsForNode(node);
     ((ValueAnimatedNode) node).mValue = value;
     mUpdatedNodes.put(tag, node);
   }
 
+  @UiThread
   public void setAnimatedNodeOffset(int tag, double offset) {
     AnimatedNode node = mAnimatedNodes.get(tag);
     if (node == null || !(node instanceof ValueAnimatedNode)) {
       throw new JSApplicationIllegalArgumentException(
-          "Animated node with tag " + tag + " does not exist, or is not a 'value' node");
+          "setAnimatedNodeOffset: Animated node ["
+              + tag
+              + "] does not exist, or is not a 'value' node");
     }
     ((ValueAnimatedNode) node).mOffset = offset;
     mUpdatedNodes.put(tag, node);
   }
 
+  @UiThread
   public void flattenAnimatedNodeOffset(int tag) {
     AnimatedNode node = mAnimatedNodes.get(tag);
     if (node == null || !(node instanceof ValueAnimatedNode)) {
       throw new JSApplicationIllegalArgumentException(
-          "Animated node with tag " + tag + " does not exist, or is not a 'value' node");
+          "flattenAnimatedNodeOffset: Animated node ["
+              + tag
+              + "] does not exist, or is not a 'value' node");
     }
     ((ValueAnimatedNode) node).flattenOffset();
   }
 
+  @UiThread
   public void extractAnimatedNodeOffset(int tag) {
     AnimatedNode node = mAnimatedNodes.get(tag);
     if (node == null || !(node instanceof ValueAnimatedNode)) {
       throw new JSApplicationIllegalArgumentException(
-          "Animated node with tag " + tag + " does not exist, or is not a 'value' node");
+          "extractAnimatedNodeOffset: Animated node ["
+              + tag
+              + "] does not exist, or is not a 'value' node");
     }
     ((ValueAnimatedNode) node).extractOffset();
   }
 
+  @UiThread
   public void startAnimatingNode(
       int animationId, int animatedNodeTag, ReadableMap animationConfig, Callback endCallback) {
     AnimatedNode node = mAnimatedNodes.get(animatedNodeTag);
     if (node == null) {
       throw new JSApplicationIllegalArgumentException(
-          "Animated node with tag " + animatedNodeTag + " does not exist");
+          "startAnimatingNode: Animated node [" + animatedNodeTag + "] does not exist");
     }
     if (!(node instanceof ValueAnimatedNode)) {
       throw new JSApplicationIllegalArgumentException(
-          "Animated node should be of type " + ValueAnimatedNode.class.getName());
+          "startAnimatingNode: Animated node ["
+              + animatedNodeTag
+              + "] should be of type "
+              + ValueAnimatedNode.class.getName());
     }
 
     final AnimationDriver existingDriver = mActiveAnimations.get(animationId);
@@ -220,7 +271,8 @@ import java.util.Queue;
     } else if ("decay".equals(type)) {
       animation = new DecayAnimation(animationConfig);
     } else {
-      throw new JSApplicationIllegalArgumentException("Unsupported animation type: " + type);
+      throw new JSApplicationIllegalArgumentException(
+          "startAnimatingNode: Unsupported animation type [" + animatedNodeTag + "]: " + type);
     }
     animation.mId = animationId;
     animation.mEndCallback = endCallback;
@@ -228,6 +280,7 @@ import java.util.Queue;
     mActiveAnimations.put(animationId, animation);
   }
 
+  @UiThread
   private void stopAnimationsForNode(AnimatedNode animatedNode) {
     // in most of the cases there should never be more than a few active animations running at the
     // same time. Therefore it does not make much sense to create an animationId -> animation
@@ -248,6 +301,7 @@ import java.util.Queue;
     }
   }
 
+  @UiThread
   public void stopAnimation(int animationId) {
     // in most of the cases there should never be more than a few active animations running at the
     // same time. Therefore it does not make much sense to create an animationId -> animation
@@ -272,16 +326,21 @@ import java.util.Queue;
     // when the animation is already over.
   }
 
+  @UiThread
   public void connectAnimatedNodes(int parentNodeTag, int childNodeTag) {
     AnimatedNode parentNode = mAnimatedNodes.get(parentNodeTag);
     if (parentNode == null) {
       throw new JSApplicationIllegalArgumentException(
-          "Animated node with tag " + parentNodeTag + " does not exists");
+          "connectAnimatedNodes: Animated node with tag (parent) ["
+              + parentNodeTag
+              + "] does not exist");
     }
     AnimatedNode childNode = mAnimatedNodes.get(childNodeTag);
     if (childNode == null) {
       throw new JSApplicationIllegalArgumentException(
-          "Animated node with tag " + childNodeTag + " does not exists");
+          "connectAnimatedNodes: Animated node with tag (child) ["
+              + childNodeTag
+              + "] does not exist");
     }
     parentNode.addChild(childNode);
     mUpdatedNodes.put(childNodeTag, childNode);
@@ -291,42 +350,51 @@ import java.util.Queue;
     AnimatedNode parentNode = mAnimatedNodes.get(parentNodeTag);
     if (parentNode == null) {
       throw new JSApplicationIllegalArgumentException(
-          "Animated node with tag " + parentNodeTag + " does not exists");
+          "disconnectAnimatedNodes: Animated node with tag (parent) ["
+              + parentNodeTag
+              + "] does not exist");
     }
     AnimatedNode childNode = mAnimatedNodes.get(childNodeTag);
     if (childNode == null) {
       throw new JSApplicationIllegalArgumentException(
-          "Animated node with tag " + childNodeTag + " does not exists");
+          "disconnectAnimatedNodes: Animated node with tag (child) ["
+              + childNodeTag
+              + "] does not exist");
     }
     parentNode.removeChild(childNode);
     mUpdatedNodes.put(childNodeTag, childNode);
   }
 
+  @UiThread
   public void connectAnimatedNodeToView(int animatedNodeTag, int viewTag) {
     AnimatedNode node = mAnimatedNodes.get(animatedNodeTag);
     if (node == null) {
       throw new JSApplicationIllegalArgumentException(
-          "Animated node with tag " + animatedNodeTag + " does not exists");
+          "connectAnimatedNodeToView: Animated node with tag ["
+              + animatedNodeTag
+              + "] does not exist");
     }
     if (!(node instanceof PropsAnimatedNode)) {
       throw new JSApplicationIllegalArgumentException(
-          "Animated node connected to view should be"
-              + "of type "
+          "connectAnimatedNodeToView: Animated node connected to view ["
+              + viewTag
+              + "] should be of type "
               + PropsAnimatedNode.class.getName());
     }
     if (mReactApplicationContext == null) {
       throw new IllegalStateException(
-          "Animated node could not be connected, no ReactApplicationContext: " + viewTag);
+          "connectAnimatedNodeToView: Animated node could not be connected, no ReactApplicationContext: "
+              + viewTag);
     }
 
     @Nullable
     UIManager uiManager =
         UIManagerHelper.getUIManagerForReactTag(mReactApplicationContext, viewTag);
     if (uiManager == null) {
-      ReactSoftException.logSoftException(
+      ReactSoftExceptionLogger.logSoftException(
           TAG,
           new ReactNoCrashSoftException(
-              "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;
     }
@@ -336,22 +404,37 @@ import java.util.Queue;
     mUpdatedNodes.put(animatedNodeTag, node);
   }
 
+  @UiThread
   public void disconnectAnimatedNodeFromView(int animatedNodeTag, int viewTag) {
     AnimatedNode node = mAnimatedNodes.get(animatedNodeTag);
     if (node == null) {
       throw new JSApplicationIllegalArgumentException(
-          "Animated node with tag " + animatedNodeTag + " does not exists");
+          "disconnectAnimatedNodeFromView: Animated node with tag ["
+              + animatedNodeTag
+              + "] does not exist");
     }
     if (!(node instanceof PropsAnimatedNode)) {
       throw new JSApplicationIllegalArgumentException(
-          "Animated node connected to view should be"
-              + "of type "
+          "disconnectAnimatedNodeFromView: Animated node connected to view ["
+              + viewTag
+              + "] should be of type "
               + PropsAnimatedNode.class.getName());
     }
     PropsAnimatedNode propsAnimatedNode = (PropsAnimatedNode) node;
     propsAnimatedNode.disconnectFromView(viewTag);
   }
 
+  @UiThread
+  public void getValue(int tag, Callback callback) {
+    AnimatedNode node = mAnimatedNodes.get(tag);
+    if (node == null || !(node instanceof ValueAnimatedNode)) {
+      throw new JSApplicationIllegalArgumentException(
+          "getValue: Animated node with tag [" + tag + "] does not exist or is not a 'value' node");
+    }
+    callback.invoke(((ValueAnimatedNode) node).getValue());
+  }
+
+  @UiThread
   public void restoreDefaultValues(int animatedNodeTag) {
     AnimatedNode node = mAnimatedNodes.get(animatedNodeTag);
     // Restoring default values needs to happen before UIManager operations so it is
@@ -363,25 +446,28 @@ import java.util.Queue;
     }
     if (!(node instanceof PropsAnimatedNode)) {
       throw new JSApplicationIllegalArgumentException(
-          "Animated node connected to view should be"
-              + "of type "
+          "Animated node connected to view [?] should be of type "
               + PropsAnimatedNode.class.getName());
     }
     PropsAnimatedNode propsAnimatedNode = (PropsAnimatedNode) node;
     propsAnimatedNode.restoreDefaultValues();
   }
 
+  @UiThread
   public void addAnimatedEventToView(int viewTag, String eventName, ReadableMap eventMapping) {
     int nodeTag = eventMapping.getInt("animatedValueTag");
     AnimatedNode node = mAnimatedNodes.get(nodeTag);
     if (node == null) {
       throw new JSApplicationIllegalArgumentException(
-          "Animated node with tag " + nodeTag + " does not exists");
+          "addAnimatedEventToView: Animated node with tag [" + nodeTag + "] does not exist");
     }
     if (!(node instanceof ValueAnimatedNode)) {
       throw new JSApplicationIllegalArgumentException(
-          "Animated node connected to event should be"
-              + "of type "
+          "addAnimatedEventToView: Animated node on view ["
+              + viewTag
+              + "] connected to event ("
+              + eventName
+              + ") should be of type "
               + ValueAnimatedNode.class.getName());
     }
 
@@ -402,6 +488,7 @@ import java.util.Queue;
     }
   }
 
+  @UiThread
   public void removeAnimatedEventFromView(int viewTag, String eventName, int animatedValueTag) {
     String key = viewTag + eventName;
     if (mEventDrivers.containsKey(key)) {
@@ -420,6 +507,7 @@ 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
@@ -437,10 +525,25 @@ import java.util.Queue;
     }
   }
 
+  @UiThread
   private void handleEvent(Event event) {
     if (!mEventDrivers.isEmpty()) {
       // If the event has a different name in native convert it to it's JS name.
-      String eventName = mCustomEventNamesResolver.resolveCustomEventName(event.getEventName());
+      // TODO T64216139 Remove dependency of UIManagerModule when the Constants are not in Native
+      // anymore
+      if (mReactApplicationContext == null) {
+        return;
+      }
+      UIManager uiManager =
+          UIManagerHelper.getUIManager(mReactApplicationContext, event.getUIManagerType());
+      if (uiManager == null) {
+        return;
+      }
+      String eventName = uiManager.resolveCustomDirectEventName(event.getEventName());
+      if (eventName == null) {
+        eventName = "";
+      }
+
       List<EventAnimationDriver> driversForKey = mEventDrivers.get(event.getViewTag() + eventName);
       if (driversForKey != null) {
         for (EventAnimationDriver driver : driversForKey) {
@@ -466,6 +569,7 @@ import java.util.Queue;
    * sub-graph of *active* nodes. This is done by adding node to the BFS queue only if all its
    * "predecessors" have already been visited.
    */
+  @UiThread
   public void runUpdates(long frameTimeNanos) {
     UiThreadUtil.assertOnUiThread();
     boolean hasFinishedAnimations = false;
@@ -508,6 +612,7 @@ import java.util.Queue;
     }
   }
 
+  @UiThread
   private void updateNodes(List<AnimatedNode> nodes) {
     int activeNodesCount = 0;
     int updatedNodesCount = 0;
@@ -573,7 +678,7 @@ import java.util.Queue;
     }
 
     // Run main "update" loop
-    boolean errorsCaught = false;
+    int cyclesDetected = 0;
     while (!nodesQueue.isEmpty()) {
       AnimatedNode nextNode = nodesQueue.poll();
       try {
@@ -582,36 +687,15 @@ import java.util.Queue;
           // Send property updates to native view manager
           ((PropsAnimatedNode) nextNode).updateView();
         }
-      } catch (IllegalViewOperationException e) {
+      } catch (JSApplicationCausedNativeException e) {
         // An exception is thrown if the view hasn't been created yet. This can happen because
-        // views are
-        // created in batches. If this particular view didn't make it into a batch yet, the view
-        // won't
-        // exist and an exception will be thrown when attempting to start an animation on it.
+        // views are created in batches. If this particular view didn't make it into a batch yet,
+        // the view won't exist and an exception will be thrown when attempting to start an
+        // animation on it.
         //
         // Eat the exception rather than crashing. The impact is that we may drop one or more
-        // frames of the
-        // animation.
+        // frames of the animation.
         FLog.e(TAG, "Native animation workaround, frame lost as result of race condition", e);
-      } catch (JSApplicationCausedNativeException e) {
-        // 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. We require that the inconsistency last for N frames before throwing these
-        // exceptions.
-        if (!errorsCaught) {
-          errorsCaught = true;
-          mNumInconsistentFrames++;
-        }
-        if (mNumInconsistentFrames > MAX_INCONSISTENT_FRAMES) {
-          throw new IllegalStateException(e);
-        } else {
-          FLog.e(
-              TAG,
-              "Swallowing exception due to potential race between JS and UI threads: inconsistent frame counter: "
-                  + mNumInconsistentFrames,
-              e);
-        }
       }
       if (nextNode instanceof ValueAnimatedNode) {
         // Potentially send events to JS when the node's value is updated
@@ -625,31 +709,60 @@ import java.util.Queue;
             child.mBFSColor = mAnimatedGraphBFSColor;
             updatedNodesCount++;
             nodesQueue.add(child);
+          } else if (child.mBFSColor == mAnimatedGraphBFSColor) {
+            cyclesDetected++;
           }
         }
       }
     }
 
-    // Verify that we've visited *all* active nodes. Throw otherwise as this would mean there is a
-    // cycle in animated node graph. 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.
+    // 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.
     // 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. We require that the inconsistency last for 64 frames before throwing this exception.
+    // states.
     if (activeNodesCount != updatedNodesCount) {
-      if (!errorsCaught) {
-        mNumInconsistentFrames++;
+      if (mWarnedAboutGraphTraversal) {
+        return;
+      }
+      mWarnedAboutGraphTraversal = true;
+
+      // Before crashing or logging soft exception, log details about current graph setup
+      FLog.e(TAG, "Detected animation cycle or disconnected graph. ");
+      for (AnimatedNode node : nodes) {
+        FLog.e(TAG, node.prettyPrintWithChildren());
       }
-      if (mNumInconsistentFrames > MAX_INCONSISTENT_FRAMES) {
-        throw new IllegalStateException(
-            "Looks like animated nodes graph has cycles, there are "
-                + activeNodesCount
-                + " but toposort visited only "
-                + updatedNodesCount);
+
+      // If we're running only in non-Fabric, we still throw an exception.
+      // In Fabric, it seems that animations enter an inconsistent state fairly often.
+      // We detect if the inconsistency is due to a cycle (a fatal error for which we must crash)
+      // or disconnected regions, indicating a partially-set-up animation graph, which is not
+      // fatal and can stay a warning.
+      String reason =
+          cyclesDetected > 0 ? "cycles (" + cyclesDetected + ")" : "disconnected regions";
+      IllegalStateException ex =
+          new IllegalStateException(
+              "Looks like animated nodes graph has "
+                  + reason
+                  + ", there are "
+                  + activeNodesCount
+                  + " but toposort visited only "
+                  + updatedNodesCount);
+      if (mEventListenerInitializedForFabric && cyclesDetected == 0) {
+        // TODO T71377544: investigate these SoftExceptions and see if we can remove entirely
+        // or fix the root cause
+        ReactSoftExceptionLogger.logSoftException(TAG, new ReactNoCrashSoftException(ex));
+      } else if (mEventListenerInitializedForFabric) {
+        // TODO T71377544: investigate these SoftExceptions and see if we can remove entirely
+        // or fix the root cause
+        ReactSoftExceptionLogger.logSoftException(TAG, new ReactNoCrashSoftException(ex));
+      } else {
+        throw ex;
       }
-    } else if (!errorsCaught) {
-      mNumInconsistentFrames = 0;
+    } else {
+      mWarnedAboutGraphTraversal = false;
     }
   }
 }

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

@@ -13,6 +13,8 @@ import com.facebook.react.bridge.JavaOnlyMap;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableMapKeySetIterator;
 import com.facebook.react.bridge.UIManager;
+import com.facebook.react.uimanager.common.UIManagerType;
+import com.facebook.react.uimanager.common.ViewUtil;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -45,17 +47,20 @@ import java.util.Map;
   public void connectToView(int viewTag, UIManager uiManager) {
     if (mConnectedViewTag != -1) {
       throw new JSApplicationIllegalArgumentException(
-          "Animated node " + mTag + " is " + "already attached to a view");
+          "Animated node " + mTag + " is " + "already attached to a view: " + mConnectedViewTag);
     }
     mConnectedViewTag = viewTag;
     mUIManager = uiManager;
   }
 
   public void disconnectFromView(int viewTag) {
-    if (mConnectedViewTag != viewTag) {
+    if (mConnectedViewTag != viewTag && mConnectedViewTag != -1) {
       throw new JSApplicationIllegalArgumentException(
           "Attempting to disconnect view that has "
-              + "not been connected with the given animated node");
+              + "not been connected with the given animated node: "
+              + viewTag
+              + " but is connected to view "
+              + mConnectedViewTag);
     }
 
     mConnectedViewTag = -1;
@@ -66,6 +71,14 @@ import java.util.Map;
     if (mConnectedViewTag == -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 (ViewUtil.getUIManagerType(mConnectedViewTag) == UIManagerType.FABRIC) {
+      return;
+    }
 
     ReadableMapKeySetIterator it = mPropMap.keySetIterator();
     while (it.hasNextKey()) {
@@ -100,4 +113,15 @@ import java.util.Map;
 
     mUIManager.synchronouslyUpdateViewOnUIThread(mConnectedViewTag, mPropMap);
   }
+
+  public String prettyPrint() {
+    return "PropsAnimatedNode["
+        + mTag
+        + "] connectedViewTag: "
+        + mConnectedViewTag
+        + " mPropNodeMapping: "
+        + (mPropNodeMapping != null ? mPropNodeMapping.toString() : "null")
+        + " mPropMap: "
+        + (mPropMap != null ? mPropMap.toString() : "null");
+  }
 }

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

@@ -49,4 +49,11 @@ import java.util.Map;
       }
     }
   }
+
+  public String prettyPrint() {
+    return "StyleAnimatedNode["
+        + mTag
+        + "] mPropMapping: "
+        + (mPropMapping != null ? mPropMapping.toString() : "null");
+  }
 }

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

@@ -47,4 +47,14 @@ import com.facebook.react.bridge.ReadableMap;
       }
     }
   }
+
+  @Override
+  public String prettyPrint() {
+    return "SubtractionAnimatedNode["
+        + mTag
+        + "]: input nodes: "
+        + (mInputNodes != null ? mInputNodes.toString() : "null")
+        + " - super: "
+        + super.prettyPrint();
+  }
 }