react-native-reanimated 3.0.0-rc.4 → 3.0.0-rc.6

package/android/src/main/cpp/NativeProxy.cpp

@@ -203,7 +203,7 @@ void NativeProxy::installJSIBindings(
 
   auto jsQueue = std::make_shared<JMessageQueueThread>(messageQueueThread);
   std::shared_ptr<jsi::Runtime> animatedRuntime =
-      ReanimatedRuntime::make(jsQueue);
+      ReanimatedRuntime::make(runtime_, jsQueue);
 
   auto workletRuntimeValue =
       runtime_->global()
@@ -230,19 +230,68 @@ void NativeProxy::installJSIBindings(
 
   // Layout Animations Start
 
-  auto notifyAboutProgress = [=](int tag, jsi::Value progress) {
-    this->layoutAnimations->cthis()->notifyAboutProgress(progress, tag);
+  auto progressLayoutAnimation = [this](int tag, jsi::Value progress) {
+    this->layoutAnimations->cthis()->progressLayoutAnimation(tag, progress);
   };
 
-  auto notifyAboutEnd = [=](int tag, bool isCancelled) {
-    this->layoutAnimations->cthis()->notifyAboutEnd(tag, (isCancelled) ? 1 : 0);
+  auto endLayoutAnimation = [this](int tag, bool isCancelled, bool removeView) {
+    this->layoutAnimations->cthis()->endLayoutAnimation(
+        tag, isCancelled, removeView);
   };
 
   std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy =
       std::make_shared<LayoutAnimationsProxy>(
-          notifyAboutProgress, notifyAboutEnd);
+          progressLayoutAnimation, endLayoutAnimation, errorHandler);
   std::weak_ptr<jsi::Runtime> wrt = animatedRuntime;
+  std::weak_ptr<LayoutAnimationsProxy> weakLayoutAnimationsProxy =
+      layoutAnimationsProxy;
   layoutAnimations->cthis()->setWeakUIRuntime(wrt);
+  std::weak_ptr<ErrorHandler> weakErrorHandler = errorHandler;
+
+  layoutAnimations->cthis()->setAnimationStartingBlock(
+      [wrt, weakLayoutAnimationsProxy, weakErrorHandler](
+          int tag,
+          alias_ref<JString> type,
+          alias_ref<JMap<jstring, jstring>> values) {
+        auto runtime = wrt.lock();
+        auto layoutAnimationsProxy = weakLayoutAnimationsProxy.lock();
+        if (!runtime || !layoutAnimationsProxy) {
+          return;
+        }
+        auto &rt = *runtime;
+        jsi::Object yogaValues(rt);
+        for (const auto &entry : *values) {
+          try {
+            auto key =
+                jsi::String::createFromAscii(rt, entry.first->toStdString());
+            auto value = stod(entry.second->toStdString());
+            yogaValues.setProperty(rt, key, value);
+          } catch (std::invalid_argument e) {
+            if (auto errorHandler = weakErrorHandler.lock()) {
+              errorHandler->setError("Failed to convert value to number");
+              errorHandler->raise();
+            }
+          }
+        }
+
+        layoutAnimationsProxy->startLayoutAnimation(
+            *runtime, tag, type->toStdString(), yogaValues);
+      });
+
+  layoutAnimations->cthis()->setHasAnimationBlock(
+      [weakLayoutAnimationsProxy](int tag, std::string type) {
+        auto layoutAnimationsProxy = weakLayoutAnimationsProxy.lock();
+        return layoutAnimationsProxy &&
+            layoutAnimationsProxy->hasLayoutAnimation(tag, type);
+      });
+
+  layoutAnimations->cthis()->setClearAnimationConfigBlock(
+      [weakLayoutAnimationsProxy](int tag) {
+        auto layoutAnimationsProxy = weakLayoutAnimationsProxy.lock();
+        if (layoutAnimationsProxy) {
+          layoutAnimationsProxy->clearLayoutAnimationConfig(tag);
+        }
+      });
 
   // Layout Animations End
 

package/android/src/main/java/com/swmansion/reanimated/NodesManager.java

@@ -153,7 +153,7 @@ public class NodesManager implements EventDispatcherListener {
     // registration, creating race condition
     mUIManager.getEventDispatcher().addListener(this);
 
-    mAnimationManager = new AnimationsManager(mContext, mUIImplementation, mUIManager);
+    mAnimationManager = new AnimationsManager(mContext, mUIManager);
   }
 
   public void onHostPause() {

package/android/src/main/java/com/swmansion/reanimated/layoutReanimation/AnimationsManager.java

@@ -16,9 +16,7 @@ import com.facebook.react.uimanager.IllegalViewOperationException;
 import com.facebook.react.uimanager.PixelUtil;
 import com.facebook.react.uimanager.ReactStylesDiffMap;
 import com.facebook.react.uimanager.RootView;
-import com.facebook.react.uimanager.UIImplementation;
 import com.facebook.react.uimanager.UIManagerModule;
-import com.facebook.react.uimanager.ViewGroupManager;
 import com.facebook.react.uimanager.ViewManager;
 import com.swmansion.reanimated.Scheduler;
 import java.lang.ref.WeakReference;
@@ -28,25 +26,17 @@ import java.util.HashSet;
 import java.util.Map;
 
 public class AnimationsManager implements ViewHierarchyObserver {
-  private static final String[] LAYOUT_KEYS = {
-    Snapshot.ORIGIN_X, Snapshot.ORIGIN_Y, Snapshot.WIDTH, Snapshot.HEIGHT
-  };
   private WeakReference<Scheduler> mScheduler;
   private ReactContext mContext;
-  private UIImplementation mUIImplementation;
   private UIManagerModule mUIManager;
   private NativeMethodsHolder mNativeMethodsHolder;
 
-  private HashMap<Integer, ViewState> mStates;
-  private HashMap<Integer, View> mViewForTag;
-  private HashSet<Integer> mToRemove;
-  private HashMap<Integer, ViewManager> mViewManager;
-  private HashMap<Integer, ViewManager> mParentViewManager;
-  private HashMap<Integer, View> mParent;
-  private HashMap<Integer, Runnable> mCallbacks;
-  private boolean mCleaningScheduled = false;
+  private HashMap<Integer, View> mExitingViews = new HashMap<>();
+  private HashMap<Integer, Integer> mExitingSubviewCountMap = new HashMap<>();
+  private HashSet<Integer> mAncestorsToRemove = new HashSet<>();
+  private HashMap<Integer, Runnable> mCallbacks = new HashMap<>();
   private ReanimatedNativeHierarchyManager mReanimatedNativeHierarchyManager;
-  private boolean isCatalystInstanceDestroyed = false;
+  private boolean isCatalystInstanceDestroyed;
 
   public void setReanimatedNativeHierarchyManager(
       ReanimatedNativeHierarchyManager reanimatedNativeHierarchyManager) {
@@ -61,26 +51,9 @@ public class AnimationsManager implements ViewHierarchyObserver {
     mScheduler = new WeakReference<>(scheduler);
   }
 
-  public enum ViewState {
-    Inactive,
-    Appearing,
-    Disappearing,
-    Layout,
-    ToRemove;
-  }
-
-  public AnimationsManager(
-      ReactContext context, UIImplementation uiImplementation, UIManagerModule uiManagerModule) {
+  public AnimationsManager(ReactContext context, UIManagerModule uiManagerModule) {
     mContext = context;
-    mUIImplementation = uiImplementation;
     mUIManager = uiManagerModule;
-    mStates = new HashMap<>();
-    mViewForTag = new HashMap<>();
-    mToRemove = new HashSet<>();
-    mViewManager = new HashMap<>();
-    mParentViewManager = new HashMap<>();
-    mParent = new HashMap();
-    mCallbacks = new HashMap<>();
     isCatalystInstanceDestroyed = false;
   }
 
@@ -88,41 +61,24 @@ public class AnimationsManager implements ViewHierarchyObserver {
     isCatalystInstanceDestroyed = true;
     mNativeMethodsHolder = null;
     mContext = null;
-    mUIImplementation = null;
     mUIManager = null;
-    mStates = null;
-    mToRemove = null;
-    mViewForTag = null;
-    mViewManager = null;
-    mParent = null;
-    mParentViewManager = null;
+    mExitingViews = null;
+    mExitingSubviewCountMap = null;
+    mAncestorsToRemove = null;
     mCallbacks = null;
   }
 
   @Override
-  public void onViewRemoval(View view, ViewGroup parent, Snapshot before, Runnable callback) {
+  public void onViewRemoval(View view, ViewGroup parent, Runnable callback) {
     if (isCatalystInstanceDestroyed) {
       return;
     }
     Integer tag = view.getId();
-    HashMap<String, Object> currentValues = before.toCurrentMap();
-    ViewState state = mStates.get(view.getId());
-
-    if (state == ViewState.Disappearing || state == ViewState.ToRemove) {
-      return;
-    }
     mCallbacks.put(tag, callback);
-    if (state == ViewState.Inactive || state == null) {
-      if (currentValues != null) {
-        mStates.put(view.getId(), ViewState.ToRemove);
-        mToRemove.add(view.getId());
-        scheduleCleaning();
-      }
-      return;
+
+    if (!removeOrAnimateExitRecursive(view, parent, true)) {
+      removeView(view, parent);
     }
-    mStates.put(tag, ViewState.Disappearing);
-    HashMap<String, Float> preparedValues = prepareDataForAnimationWorklet(currentValues, false);
-    mNativeMethodsHolder.startAnimationForTag(tag, "exiting", preparedValues);
   }
 
   @Override
@@ -130,27 +86,21 @@ public class AnimationsManager implements ViewHierarchyObserver {
     if (isCatalystInstanceDestroyed) {
       return;
     }
+
+    if (!hasAnimationForTag(view.getId(), "entering")) {
+      return;
+    }
+
     Scheduler strongScheduler = mScheduler.get();
     if (strongScheduler != null) {
       strongScheduler.triggerUI();
     }
-    if (!mStates.containsKey(view.getId())) {
-      mStates.put(view.getId(), ViewState.Inactive);
-      mViewForTag.put(view.getId(), view);
-      mViewManager.put(view.getId(), after.viewManager);
-      mParentViewManager.put(view.getId(), after.parentViewManager);
-      mParent.put(view.getId(), after.parent);
-    }
-    Integer tag = view.getId();
+    int tag = view.getId();
     HashMap<String, Object> targetValues = after.toTargetMap();
-    ViewState state = mStates.get(view.getId());
 
-    if (state == ViewState.Inactive) { // it can be a fresh view
-      if (targetValues != null) {
-        HashMap<String, Float> preparedValues = prepareDataForAnimationWorklet(targetValues, true);
-        mNativeMethodsHolder.startAnimationForTag(tag, "entering", preparedValues);
-      }
-      return;
+    if (targetValues != null) {
+      HashMap<String, Float> preparedValues = prepareDataForAnimationWorklet(targetValues, true);
+      mNativeMethodsHolder.startAnimation(tag, "entering", preparedValues);
     }
   }
 
@@ -159,36 +109,32 @@ public class AnimationsManager implements ViewHierarchyObserver {
     if (isCatalystInstanceDestroyed) {
       return;
     }
-    Integer tag = view.getId();
-    HashMap<String, Object> targetValues = after.toTargetMap();
-    HashMap<String, Object> startValues = before.toCurrentMap();
-    ViewState state = mStates.get(view.getId());
-    if (state == null
-        || state == ViewState.Disappearing
-        || state == ViewState.ToRemove
-        || state == ViewState.Inactive) {
+    int tag = view.getId();
+
+    if (!hasAnimationForTag(tag, "layout")) {
       return;
     }
+
+    HashMap<String, Object> targetValues = after.toTargetMap();
+    HashMap<String, Object> startValues = before.toCurrentMap();
+
     // If startValues are equal to targetValues it means that there was no UI Operation changing
     // layout of the View. So dirtiness of that View is false positive
-    if (state == ViewState.Appearing) {
-      boolean doNotStartLayout = true;
-      for (int i = 0; i < Snapshot.targetKeysToTransform.size(); ++i) {
-        double startV =
-            ((Number) startValues.get(Snapshot.currentKeysToTransform.get(i))).doubleValue();
-        double targetV =
-            ((Number) targetValues.get(Snapshot.targetKeysToTransform.get(i))).doubleValue();
-        if (startV != targetV) {
-          doNotStartLayout = false;
-        }
-      }
-      if (doNotStartLayout) {
-        return;
+    boolean doNotStartLayout = true;
+    for (int i = 0; i < Snapshot.targetKeysToTransform.size(); ++i) {
+      double startV =
+          ((Number) startValues.get(Snapshot.currentKeysToTransform.get(i))).doubleValue();
+      double targetV =
+          ((Number) targetValues.get(Snapshot.targetKeysToTransform.get(i))).doubleValue();
+      if (startV != targetV) {
+        doNotStartLayout = false;
       }
     }
+    if (doNotStartLayout) {
+      return;
+    }
 
     // View must be in Layout state
-    mStates.put(view.getId(), ViewState.Layout);
     HashMap<String, Float> preparedStartValues = prepareDataForAnimationWorklet(startValues, false);
     HashMap<String, Float> preparedTargetValues =
         prepareDataForAnimationWorklet(targetValues, true);
@@ -196,60 +142,41 @@ public class AnimationsManager implements ViewHierarchyObserver {
     for (String key : preparedStartValues.keySet()) {
       preparedValues.put(key, preparedStartValues.get(key));
     }
-    mNativeMethodsHolder.startAnimationForTag(tag, "layout", preparedValues);
+    mNativeMethodsHolder.startAnimation(tag, "layout", preparedValues);
   }
 
-  public void notifyAboutProgress(Map<String, Object> newStyle, Integer tag) {
-    ViewState state = mStates.get(tag);
-    if (state == ViewState.Inactive) {
-      mStates.put(tag, ViewState.Appearing);
-    }
+  public void progressLayoutAnimation(int tag, Map<String, Object> newStyle) {
+    View view = resolveView(tag);
 
-    setNewProps(
-        newStyle,
-        mViewForTag.get(tag),
-        mViewManager.get(tag),
-        mParentViewManager.get(tag),
-        mParent.get(tag).getId());
-  }
+    if (view == null) {
+      return;
+    }
 
-  public void notifyAboutEnd(int tag, boolean cancelled) {
-    if (!cancelled) {
-      ViewState state = mStates.get(tag);
-      if (state == ViewState.Appearing) {
-        mStates.put(tag, ViewState.Layout);
-      }
+    ViewGroup parent = (ViewGroup) view.getParent();
 
-      if (state == ViewState.Disappearing) {
-        mStates.put(tag, ViewState.ToRemove);
-        mToRemove.add(tag);
-        scheduleCleaning();
-      }
+    if (parent == null) {
+      return;
     }
+
+    ViewManager viewManager = resolveViewManager(tag);
+    ViewManager parentViewManager = resolveViewManager(parent.getId());
+
+    setNewProps(newStyle, view, viewManager, parentViewManager, parent.getId());
   }
 
-  private void removeLeftovers() {
-    // mToRemove may be null if onCatalystInstanceDestroy was called first
-    if (mToRemove != null) {
-      HashSet<Integer> roots = new HashSet<>();
-      // go through ready to remove from bottom to top
-      for (int tag : mToRemove) {
-        View view = mViewForTag.get(tag);
-        if (view == null) {
-          try {
-            view = mUIManager.resolveView(tag);
-            mViewForTag.put(tag, view);
-          } catch (IllegalViewOperationException ignored) {
-            continue;
-          }
-        }
-        findRoot(view, roots);
+  public void endLayoutAnimation(int tag, boolean cancelled, boolean removeView) {
+    View exitingView = mExitingViews.get(tag);
+    if (exitingView != null && removeView) {
+      if (exitingView instanceof ViewGroup && mAncestorsToRemove.contains(tag)) {
+        cancelAnimationsInSubviews((ViewGroup) exitingView);
       }
-      for (int tag : roots) {
-        View view = mViewForTag.get(tag);
-        if (view != null) {
-          dfs(view, view, mToRemove);
-        }
+
+      mExitingViews.remove(tag);
+      maybeDropAncestors(exitingView);
+
+      ViewGroup parent = (ViewGroup) exitingView.getParent();
+      if (parent != null) {
+        removeView(exitingView, parent);
       }
     }
   }
@@ -267,8 +194,6 @@ public class AnimationsManager implements ViewHierarchyObserver {
     }
     out.append(" TAG:");
     out.append(view.getId());
-    out.append(" STATE:");
-    out.append(this.mStates.get(view.getId()));
     out.append(" CLASS:");
     out.append(view.getClass().getSimpleName());
     Log.v("rea", out.toString());
@@ -280,85 +205,6 @@ public class AnimationsManager implements ViewHierarchyObserver {
     }
   }
 
-  private void scheduleCleaning() {
-    if (mCleaningScheduled) return;
-    mCleaningScheduled = true;
-    WeakReference<AnimationsManager> animationsManagerWeakReference = new WeakReference<>(this);
-    mContext.runOnUiQueueThread(
-        () -> {
-          mCleaningScheduled = false;
-          AnimationsManager thiz = animationsManagerWeakReference.get();
-          if (thiz == null) {
-            return;
-          }
-          removeLeftovers();
-        });
-  }
-
-  private void findRoot(View view, HashSet<Integer> roots) {
-    View currentView = view;
-    int lastToRemoveTag = -1;
-    while (currentView != null) {
-      ViewState state = mStates.get(currentView.getId());
-      if (state == ViewState.Disappearing) {
-        return;
-      }
-      if (state == ViewState.ToRemove) {
-        lastToRemoveTag = currentView.getId();
-      }
-      if (currentView.getParent() instanceof View) {
-        currentView = (View) currentView.getParent();
-      } else {
-        break;
-      }
-    }
-    if (lastToRemoveTag != -1) {
-      roots.add(lastToRemoveTag);
-    }
-  }
-
-  private boolean dfs(View root, View view, HashSet<Integer> cands) {
-    if ((!cands.contains(view.getId())) && (mStates.containsKey(view.getId()))) {
-      return true;
-    }
-    boolean cannotStripe = false;
-    if (view instanceof ViewGroup && mViewManager.get(view.getId()) instanceof ViewGroupManager) {
-      ViewGroup vg = (ViewGroup) view;
-      ViewGroupManager vgm = (ViewGroupManager) mViewManager.get(vg.getId());
-      ArrayList<View> children = new ArrayList<>();
-      for (int i = 0; i < vgm.getChildCount(vg); ++i) {
-        children.add(vgm.getChildAt(vg, i));
-      }
-      for (View child : children) {
-        cannotStripe = cannotStripe || dfs(root, child, cands);
-      }
-    }
-
-    if (!cannotStripe) {
-      View parentView = (View) view.getParent();
-      if (mCallbacks.containsKey(view.getId())) {
-        Runnable runnable = mCallbacks.get(view.getId());
-        mCallbacks.remove(view.getId());
-        runnable.run();
-      }
-      if (mParent.containsKey(view.getId())) {
-        ViewGroup parent = (ViewGroup) mParent.get(view.getId());
-        if (parent != null) {
-          parent.removeView(view);
-        }
-      }
-      View curView = view;
-      mStates.remove(curView.getId());
-      mViewForTag.remove(curView.getId());
-      mViewManager.remove(curView.getId());
-      mParentViewManager.remove(curView.getId());
-      mParent.remove(curView.getId());
-      mNativeMethodsHolder.removeConfigForTag(curView.getId());
-      mToRemove.remove(view.getId());
-    }
-    return cannotStripe;
-  }
-
   public HashMap<String, Float> prepareDataForAnimationWorklet(
       HashMap<String, Object> values, boolean isTargetValues) {
     HashMap<String, Float> preparedValues = new HashMap<>();
@@ -449,7 +295,7 @@ public class AnimationsManager implements ViewHierarchyObserver {
     } else if (value instanceof ReadableMap) {
       propMap.putMap(key, (ReadableMap) value);
     } else {
-      throw new IllegalStateException("Unknown type of animated value [Layout Aniamtions]");
+      throw new IllegalStateException("Unknown type of animated value [Layout Animations]");
     }
   }
 
@@ -512,8 +358,7 @@ public class AnimationsManager implements ViewHierarchyObserver {
                 + parentTag
                 + " as a parent, but its Manager doesn't implement IViewManagerWithChildren");
       }
-      if (parentViewManagerWithChildren != null
-          && !parentViewManagerWithChildren.needsCustomLayoutForChildren()) {
+      if (!parentViewManagerWithChildren.needsCustomLayoutForChildren()) {
         viewToUpdate.layout(x, y, x + width, y + height);
       }
     } else {
@@ -521,7 +366,147 @@ public class AnimationsManager implements ViewHierarchyObserver {
     }
   }
 
+  public boolean hasAnimationForTag(int tag, String type) {
+    return mNativeMethodsHolder.hasAnimation(tag, type);
+  }
+
   public boolean isLayoutAnimationEnabled() {
     return mNativeMethodsHolder != null && mNativeMethodsHolder.isLayoutAnimationEnabled();
   }
+
+  private boolean removeOrAnimateExitRecursive(View view, ViewGroup parent, boolean shouldRemove) {
+    int tag = view.getId();
+    boolean hasExitAnimation = hasAnimationForTag(tag, "exiting") || mExitingViews.containsKey(tag);
+    boolean hasAnimatedChildren = false;
+    shouldRemove = shouldRemove && !hasExitAnimation;
+
+    ArrayList<View> toBeRemoved = new ArrayList<>();
+
+    // we might want to keep this view around
+    // because one of the (children's) children
+    // has an exiting animation
+    if (view instanceof ViewGroup) {
+      ViewGroup viewGroup = (ViewGroup) view;
+      for (int i = viewGroup.getChildCount() - 1; i >= 0; i--) {
+        View child = viewGroup.getChildAt(i);
+        if (removeOrAnimateExitRecursive(child, viewGroup, shouldRemove)) {
+          hasAnimatedChildren = true;
+        } else if (shouldRemove) {
+          toBeRemoved.add(child);
+        }
+      }
+    }
+
+    boolean wantAnimateExit = hasExitAnimation || hasAnimatedChildren;
+
+    if (hasExitAnimation) {
+      Snapshot before = new Snapshot(view, mReanimatedNativeHierarchyManager);
+      HashMap<String, Object> currentValues = before.toCurrentMap();
+      HashMap<String, Float> preparedValues = prepareDataForAnimationWorklet(currentValues, false);
+      if (!mExitingViews.containsKey(tag)) {
+        mExitingViews.put(tag, view);
+        registerExitingAncestors(view);
+        mNativeMethodsHolder.startAnimation(tag, "exiting", preparedValues);
+      }
+    }
+
+    mNativeMethodsHolder.clearAnimationConfig(tag);
+
+    if (!wantAnimateExit) {
+      return false;
+    }
+
+    if (hasAnimatedChildren) {
+      mAncestorsToRemove.add(tag);
+    }
+
+    for (View child : toBeRemoved) {
+      removeView(child, (ViewGroup) view);
+    }
+
+    return true;
+  }
+
+  private void registerExitingAncestors(View view) {
+    View parent = (View) view.getParent();
+    while (parent != null && !(parent instanceof RootView)) {
+      int tag = parent.getId();
+      Integer previousValue = mExitingSubviewCountMap.get(tag);
+      int newValue = previousValue != null ? previousValue + 1 : 1;
+      mExitingSubviewCountMap.put(tag, newValue);
+
+      parent = (View) parent.getParent();
+    }
+  }
+
+  private void maybeDropAncestors(View exitingView) {
+    View parent = (View) exitingView.getParent();
+    while (parent != null && !(parent instanceof RootView)) {
+      View view = parent;
+      parent = (View) view.getParent();
+      int tag = view.getId();
+      Integer ancestorOfCount = mExitingSubviewCountMap.get(tag);
+      ancestorOfCount = ancestorOfCount != null ? ancestorOfCount - 1 : 0;
+      if (ancestorOfCount <= 0) {
+        if (mAncestorsToRemove.contains(tag)) {
+          mAncestorsToRemove.remove(tag);
+          if (!mExitingViews.containsKey(tag)) {
+            removeView(view, (ViewGroup) parent);
+          }
+        }
+        mExitingSubviewCountMap.remove(tag);
+      } else {
+        mExitingSubviewCountMap.put(tag, ancestorOfCount);
+      }
+    }
+  }
+
+  private void removeView(View view, ViewGroup parent) {
+    int tag = view.getId();
+    if (mCallbacks.containsKey(tag)) {
+      Runnable callback = mCallbacks.get(tag);
+      mCallbacks.remove(tag);
+      if (callback != null) {
+        callback.run();
+      }
+    } else {
+      mReanimatedNativeHierarchyManager.publicDropView(view);
+    }
+
+    parent.removeView(view);
+  }
+
+  private void cancelAnimationsInSubviews(ViewGroup view) {
+    for (int i = view.getChildCount() - 1; i >= 0; i--) {
+      View child = view.getChildAt(i);
+
+      if (mExitingViews.containsKey(child.getId())) {
+        endLayoutAnimation(child.getId(), true, true);
+      } else if (child instanceof ViewGroup && mAncestorsToRemove.contains(child.getId())) {
+        cancelAnimationsInSubviews((ViewGroup) child);
+      }
+    }
+  }
+
+  private View resolveView(int tag) {
+    if (mExitingViews.containsKey(tag)) {
+      return mExitingViews.get(tag);
+    }
+    try {
+      return mUIManager.resolveView(tag);
+    } catch (IllegalViewOperationException e) {
+      // view has been removed already
+      e.printStackTrace();
+      return null;
+    }
+  }
+
+  private ViewManager resolveViewManager(int tag) {
+    try {
+      return mReanimatedNativeHierarchyManager.resolveViewManager(tag);
+    } catch (Exception e) {
+      e.printStackTrace();
+      return null;
+    }
+  }
 }

package/android/src/main/java/com/swmansion/reanimated/layoutReanimation/LayoutAnimations.java

@@ -29,29 +29,31 @@ public class LayoutAnimations {
   // LayoutReanimation
   public native void startAnimationForTag(int tag, String type, Map<String, String> values);
 
-  public native void removeConfigForTag(int tag);
+  public native boolean hasAnimationForTag(int tag, String type);
+
+  public native void clearAnimationConfigForTag(int tag);
 
   public native boolean isLayoutAnimationEnabled();
 
-  private void notifyAboutEnd(int tag, int cancelledInt) {
+  private void endLayoutAnimation(int tag, boolean cancelled, boolean removeView) {
     ReactApplicationContext context = mContext.get();
     if (context != null) {
       context
           .getNativeModule(ReanimatedModule.class)
           .getNodesManager()
           .getAnimationsManager()
-          .notifyAboutEnd(tag, (cancelledInt == 0) ? false : true);
+          .endLayoutAnimation(tag, cancelled, removeView);
     }
   }
 
-  private void notifyAboutProgress(Map<String, Object> newStyle, int tag) {
+  private void progressLayoutAnimation(int tag, Map<String, Object> newStyle) {
     ReactApplicationContext context = mContext.get();
     if (context != null) {
       context
           .getNativeModule(ReanimatedModule.class)
           .getNodesManager()
           .getAnimationsManager()
-          .notifyAboutProgress(newStyle, tag);
+          .progressLayoutAnimation(tag, newStyle);
     }
   }
 }