react-native-reanimated 3.0.0-rc.8 → 3.0.0

package/android/src/reactNativeVersionPatch/ReanimatedUIManager/latest/com/swmansion/reanimated/layoutReanimation/ReanimatedUIManager.java

@@ -0,0 +1,271 @@
+package com.facebook.react.uimanager;
+
+import androidx.annotation.Nullable;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.Dynamic;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.module.annotations.ReactModule;
+import java.util.List;
+
+@ReactModule(name = UIManagerModule.NAME)
+public class ReanimatedUIManager extends UIManagerModule {
+
+  public ReanimatedUIManager(
+      ReactApplicationContext reactContext,
+      List<ViewManager> viewManagersList,
+      int minTimeLeftInFrameForNonBatchedOperationMs) {
+    super(reactContext, viewManagersList, minTimeLeftInFrameForNonBatchedOperationMs);
+  }
+
+  public void onBatchComplete() {
+    super.onBatchComplete();
+  }
+
+  @Override
+  public boolean canOverrideExistingModule() {
+    return true;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public @Nullable WritableMap getConstantsForViewManager(@Nullable String viewManagerName) {
+    return super.getConstantsForViewManager(viewManagerName);
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public WritableMap getDefaultEventTypes() {
+    return super.getDefaultEventTypes();
+  }
+
+  /** Unregisters a new root view. */
+  @ReactMethod
+  public void removeRootView(int rootViewTag) {
+    super.removeRootView(rootViewTag);
+  }
+
+  @ReactMethod
+  public void createView(int tag, String className, int rootViewTag, ReadableMap props) {
+    super.createView(tag, className, rootViewTag, props);
+  }
+
+  @ReactMethod
+  public void updateView(final int tag, final String className, final ReadableMap props) {
+    super.updateView(tag, className, props);
+  }
+
+  /**
+   * Interface for adding/removing/moving views within a parent view from JS.
+   *
+   * @param viewTag the view tag of the parent view
+   * @param moveFrom a list of indices in the parent view to move views from
+   * @param moveTo parallel to moveFrom, a list of indices in the parent view to move views to
+   * @param addChildTags a list of tags of views to add to the parent
+   * @param addAtIndices parallel to addChildTags, a list of indices to insert those children at
+   * @param removeFrom a list of indices of views to permanently remove. The memory for the
+   *     corresponding views and data structures should be reclaimed.
+   */
+  @ReactMethod
+  public void manageChildren(
+      int viewTag,
+      @Nullable ReadableArray moveFrom,
+      @Nullable ReadableArray moveTo,
+      @Nullable ReadableArray addChildTags,
+      @Nullable ReadableArray addAtIndices,
+      @Nullable ReadableArray removeFrom) {
+    super.manageChildren(viewTag, moveFrom, moveTo, addChildTags, addAtIndices, removeFrom);
+  }
+
+  /**
+   * Interface for fast tracking the initial adding of views. Children view tags are assumed to be
+   * in order
+   *
+   * @param viewTag the view tag of the parent view
+   * @param childrenTags An array of tags to add to the parent in order
+   */
+  @ReactMethod
+  public void setChildren(int viewTag, ReadableArray childrenTags) {
+    super.setChildren(viewTag, childrenTags);
+  }
+
+  /**
+   * Replaces the View specified by oldTag with the View specified by newTag within oldTag's parent.
+   * This resolves to a simple {@link #manageChildren} call, but React doesn't have enough info in
+   * JS to formulate it itself.
+   *
+   * @deprecated This method will not be available in Fabric UIManager class.
+   */
+  @ReactMethod
+  @Deprecated
+  public void replaceExistingNonRootView(int oldTag, int newTag) {
+    super.replaceExistingNonRootView(oldTag, newTag);
+  }
+
+  /**
+   * Method which takes a container tag and then releases all subviews for that container upon
+   * receipt.
+   *
+   * @param containerTag the tag of the container for which the subviews must be removed
+   * @deprecated This method will not be available in Fabric UIManager class.
+   */
+  @ReactMethod
+  @Deprecated
+  public void removeSubviewsFromContainerWithID(int containerTag) {
+    super.removeSubviewsFromContainerWithID(containerTag);
+  }
+
+  /**
+   * Determines the location on screen, width, and height of the given view and returns the values
+   * via an async callback.
+   */
+  @ReactMethod
+  public void measure(int reactTag, Callback callback) {
+    super.measure(reactTag, callback);
+  }
+
+  /**
+   * Determines the location on screen, width, and height of the given view relative to the device
+   * screen and returns the values via an async callback. This is the absolute position including
+   * things like the status bar
+   */
+  @ReactMethod
+  public void measureInWindow(int reactTag, Callback callback) {
+    super.measureInWindow(reactTag, callback);
+  }
+
+  /**
+   * Measures the view specified by tag relative to the given ancestorTag. This means that the
+   * returned x, y are relative to the origin x, y of the ancestor view. Results are stored in the
+   * given outputBuffer. We allow ancestor view and measured view to be the same, in which case the
+   * position always will be (0, 0) and method will only measure the view dimensions.
+   *
+   * <p>NB: Unlike {@link #measure}, this will measure relative to the view layout, not the visible
+   * window which can cause unexpected results when measuring relative to things like ScrollViews
+   * that can have offset content on the screen.
+   */
+  @ReactMethod
+  public void measureLayout(
+      int tag, int ancestorTag, Callback errorCallback, Callback successCallback) {
+    super.measureLayout(tag, ancestorTag, errorCallback, successCallback);
+  }
+
+  /**
+   * Like {@link #measure} and {@link #measureLayout} but measures relative to the immediate parent.
+   *
+   * <p>NB: Unlike {@link #measure}, this will measure relative to the view layout, not the visible
+   * window which can cause unexpected results when measuring relative to things like ScrollViews
+   * that can have offset content on the screen.
+   *
+   * @deprecated this method will not be available in FabricUIManager class.
+   */
+  @ReactMethod
+  @Deprecated
+  public void measureLayoutRelativeToParent(
+      int tag, Callback errorCallback, Callback successCallback) {
+    super.measureLayoutRelativeToParent(tag, errorCallback, successCallback);
+  }
+
+  /**
+   * Find the touch target child native view in the supplied root view hierarchy, given a react
+   * target location.
+   *
+   * <p>This method is currently used only by Element Inspector DevTool.
+   *
+   * @param reactTag the tag of the root view to traverse
+   * @param point an array containing both X and Y target location
+   * @param callback will be called if with the identified child view react ID, and measurement
+   *     info. If no view was found, callback will be invoked with no data.
+   */
+  @ReactMethod
+  public void findSubviewIn(
+      final int reactTag, final ReadableArray point, final Callback callback) {
+    super.findSubviewIn(reactTag, point, callback);
+  }
+
+  /**
+   * Check if the first shadow node is the descendant of the second shadow node
+   *
+   * @deprecated this method will not be available in FabricUIManager class.
+   */
+  @ReactMethod
+  @Deprecated
+  public void viewIsDescendantOf(
+      final int reactTag, final int ancestorReactTag, final Callback callback) {
+    super.viewIsDescendantOf(reactTag, ancestorReactTag, callback);
+  }
+
+  @ReactMethod
+  public void setJSResponder(int reactTag, boolean blockNativeResponder) {
+    super.setJSResponder(reactTag, blockNativeResponder);
+  }
+
+  @ReactMethod
+  public void clearJSResponder() {
+    super.clearJSResponder();
+  }
+
+  @ReactMethod
+  public void dispatchViewManagerCommand(
+      int reactTag, Dynamic commandId, @Nullable ReadableArray commandArgs) {
+    super.dispatchViewManagerCommand(reactTag, commandId, commandArgs);
+  }
+
+  /**
+   * Show a PopupMenu.
+   *
+   * @param reactTag the tag of the anchor view (the PopupMenu is displayed next to this view); this
+   *     needs to be the tag of a native view (shadow views can not be anchors)
+   * @param items the menu items as an array of strings
+   * @param error will be called if there is an error displaying the menu
+   * @param success will be called with the position of the selected item as the first argument, or
+   *     no arguments if the menu is dismissed
+   */
+  @ReactMethod
+  public void showPopupMenu(int reactTag, ReadableArray items, Callback error, Callback success) {
+    super.showPopupMenu(reactTag, items, error, success);
+  }
+
+  @ReactMethod
+  public void dismissPopupMenu() {
+    super.dismissPopupMenu();
+  }
+
+  /**
+   * LayoutAnimation API on Android is currently experimental. Therefore, it needs to be enabled
+   * explicitly in order to avoid regression in existing application written for iOS using this API.
+   *
+   * <p>Warning : This method will be removed in future version of React Native, and layout
+   * animation will be enabled by default, so always check for its existence before invoking it.
+   *
+   * <p>TODO(9139831) : remove this method once layout animation is fully stable.
+   *
+   * @param enabled whether layout animation is enabled or not
+   */
+  @ReactMethod
+  public void setLayoutAnimationEnabledExperimental(boolean enabled) {
+    super.setLayoutAnimationEnabledExperimental(enabled);
+  }
+
+  /**
+   * Configure an animation to be used for the native layout changes, and native views creation. The
+   * animation will only apply during the current batch operations.
+   *
+   * <p>TODO(7728153) : animating view deletion is currently not supported.
+   *
+   * @param config the configuration of the animation for view addition/removal/update.
+   * @param success will be called when the animation completes, or when the animation get
+   *     interrupted. In this case, callback parameter will be false.
+   * @param error will be called if there was an error processing the animation
+   */
+  @ReactMethod
+  public void configureNextLayoutAnimation(ReadableMap config, Callback success, Callback error) {
+    super.configureNextLayoutAnimation(config, success, error);
+  }
+
+  @ReactMethod
+  public void sendAccessibilityEvent(int tag, int eventType) {
+    super.sendAccessibilityEvent(tag, eventType);
+  }
+}

package/android/src/reactNativeVersionPatch/nativeHierarchyManager/latest/com/swmansion/reanimated/layoutReanimation/ReanimatedNativeHierarchyManager.java

@@ -4,7 +4,9 @@ import android.os.Build;
 import android.util.Log;
 import android.view.View;
 import android.view.ViewGroup;
+
 import androidx.annotation.Nullable;
+
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.uimanager.IllegalViewOperationException;
@@ -16,6 +18,7 @@ import com.facebook.react.uimanager.ViewManagerRegistry;
 import com.facebook.react.uimanager.layoutanimation.LayoutAnimationController;
 import com.facebook.react.uimanager.layoutanimation.LayoutAnimationListener;
 import com.swmansion.reanimated.ReanimatedModule;
+
 import java.lang.ref.WeakReference;
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
@@ -29,6 +32,7 @@ class ReaLayoutAnimator extends LayoutAnimationController {
   private volatile boolean mInitialized = false;
   private final ReactApplicationContext mContext;
   private final WeakReference<NativeViewHierarchyManager> mWeakNativeViewHierarchyManager;
+  private final ArrayList<View> viewsToSnapshot = new ArrayList<>();
 
   ReaLayoutAnimator(
       ReactApplicationContext context, NativeViewHierarchyManager nativeViewHierarchyManager) {
@@ -60,6 +64,22 @@ class ReaLayoutAnimator extends LayoutAnimationController {
     return (viewToAnimate.getParent() != null);
   }
 
+  @Override
+  public void reset() {
+    super.reset();
+    // we have to make snapshots of the views after all of them have updated layouts
+    // to have correct global coordinates in the snapshots
+    // we do it here because React calls reset() method after all views have updated layouts
+    // and there is no semantically valid place to do it
+    for(View view : viewsToSnapshot) {
+              mAnimationsManager.onViewCreate(
+            view,
+            (ViewGroup) view.getParent(),
+            new Snapshot(view, mWeakNativeViewHierarchyManager.get()));
+    }
+    viewsToSnapshot.clear();
+  }
+
   /**
    * Update layout of given view, via immediate update or animation depending on the current batch
    * layout animation configuration supplied during initialization. Handles create and update
@@ -82,19 +102,22 @@ class ReaLayoutAnimator extends LayoutAnimationController {
     // otherwise use update animation. This approach is easier than maintaining a list of tags
     // for recently created views.
     if (view.getWidth() == 0 || view.getHeight() == 0) {
+      if (!mAnimationsManager.hasAnimationForTag(view.getId(), LayoutAnimations.Types.ENTERING)) {
+        super.applyLayoutUpdate(view, x, y, width, height);
+        mAnimationsManager.maybeRegisterSharedView(view);
+        return;
+      }
       view.layout(x, y, x + width, y + height);
       if (view.getId() != -1) {
-        mAnimationsManager.onViewCreate(
-            view,
-            (ViewGroup) view.getParent(),
-            new Snapshot(view, mWeakNativeViewHierarchyManager.get()));
+        viewsToSnapshot.add(view);
       }
-    } else {
-      Snapshot before = new Snapshot(view, mWeakNativeViewHierarchyManager.get());
-      view.layout(x, y, x + width, y + height);
-      Snapshot after = new Snapshot(view, mWeakNativeViewHierarchyManager.get());
-      mAnimationsManager.onViewUpdate(view, before, after);
+      return;
     }
+
+    Snapshot before = new Snapshot(view, mWeakNativeViewHierarchyManager.get());
+    view.layout(x, y, x + width, y + height);
+    Snapshot after = new Snapshot(view, mWeakNativeViewHierarchyManager.get());
+    mAnimationsManager.onViewUpdate(view, before, after);
   }
 
   /**
@@ -118,6 +141,7 @@ class ReaLayoutAnimator extends LayoutAnimationController {
     } catch (IllegalViewOperationException e) {
       // (IllegalViewOperationException) == (vm == null)
       e.printStackTrace();
+      mAnimationsManager.cancelAnimationsInSubviews(view);
       super.deleteView(view, listener);
       return;
     }
@@ -135,11 +159,13 @@ class ReaLayoutAnimator extends LayoutAnimationController {
       } catch (IllegalViewOperationException e) {
         // (IllegalViewOperationException) == (vm == null)
         e.printStackTrace();
+        mAnimationsManager.cancelAnimationsInSubviews(view);
         super.deleteView(view, listener);
         return;
       }
       String parentName = screenParentViewManager.getName();
       if (parentName.equals("RNSScreenStack")) {
+        mAnimationsManager.cancelAnimationsInSubviews(view);
         super.deleteView(view, listener);
         return;
       }
@@ -153,12 +179,16 @@ class ReaLayoutAnimator extends LayoutAnimationController {
     maybeInit();
     return mAnimationsManager.isLayoutAnimationEnabled();
   }
+
+  public AnimationsManager getAnimationsManager() {
+    return mAnimationsManager;
+  }
 }
 
 public class ReanimatedNativeHierarchyManager extends NativeViewHierarchyManager {
   private final HashMap<Integer, ArrayList<View>> toBeRemoved = new HashMap<>();
   private final HashMap<Integer, Runnable> cleanerCallback = new HashMap<>();
-  private final LayoutAnimationController mReaLayoutAnimator;
+  private final ReaLayoutAnimator mReaLayoutAnimator;
   private final HashMap<Integer, Set<Integer>> mPendingDeletionsForTag = new HashMap<>();
   private boolean initOk = true;
 
@@ -232,19 +262,20 @@ public class ReanimatedNativeHierarchyManager extends NativeViewHierarchyManager
       return;
     }
     try {
-      View viewToUpdate = this.resolveView(tag);
-      ViewManager viewManager = this.resolveViewManager(tag);
+      ViewManager viewManager = resolveViewManager(tag);
       String viewManagerName = viewManager.getName();
       View container = resolveView(parentTag);
       if (container != null
           && viewManagerName.equals("RNSScreen")
-          && this.mReaLayoutAnimator != null) {
-        this.mReaLayoutAnimator.applyLayoutUpdate(
-            viewToUpdate,
-            (int) container.getX(),
-            (int) container.getY(),
-            container.getWidth(),
-            container.getHeight());
+          && mReaLayoutAnimator != null) {
+        boolean hasHeader = checkIfTopScreenHasHeader((ViewGroup) container);
+        if (!hasHeader || !container.isLayoutRequested()) {
+          mReaLayoutAnimator.getAnimationsManager().screenDidLayout();
+        }
+      }
+      View view = resolveView(tag);
+      if (view != null && mReaLayoutAnimator != null) {
+        mReaLayoutAnimator.getAnimationsManager().viewDidLayout(view);
       }
     } catch (IllegalViewOperationException e) {
       // (IllegalViewOperationException) == (vm == null)
@@ -252,6 +283,19 @@ public class ReanimatedNativeHierarchyManager extends NativeViewHierarchyManager
     }
   }
 
+  private boolean checkIfTopScreenHasHeader(ViewGroup screenStack) {
+    try {
+      ViewGroup fragment = (ViewGroup)screenStack.getChildAt(0);
+      ViewGroup screen = (ViewGroup)fragment.getChildAt(0);
+      View headerConfig = screen.getChildAt(0);
+      Field field = headerConfig.getClass().getDeclaredField("mIsHidden");
+      field.setAccessible(true);
+      return !field.getBoolean(headerConfig);
+    } catch (NullPointerException | NoSuchFieldException | IllegalAccessException e) {
+      return false;
+    }
+  }
+
   @Override
   public synchronized void manageChildren(
       int tag,
@@ -275,7 +319,19 @@ public class ReanimatedNativeHierarchyManager extends NativeViewHierarchyManager
     }
 
     // we don't want layout animations in native-stack since it is currently buggy there
+    AnimationsManager animationsManager = mReaLayoutAnimator.getAnimationsManager();
     if (viewGroupManager.getName().equals("RNSScreenStack")) {
+      if (tagsToDelete == null) {
+        animationsManager.makeSnapshotOfTopScreenViews(viewGroup);
+      } else {
+        animationsManager.notifyAboutViewsRemoval(tagsToDelete);
+      }
+      if (indicesToRemove != null && mReaLayoutAnimator instanceof ReaLayoutAnimator) {
+        for (int index : indicesToRemove) {
+          View child = viewGroupManager.getChildAt(viewGroup, index);
+          mReaLayoutAnimator.getAnimationsManager().cancelAnimationsInSubviews(child);
+        }
+      }
       super.manageChildren(tag, indicesToRemove, viewsToAdd, tagsToDelete);
       return;
     }
@@ -328,7 +384,7 @@ public class ReanimatedNativeHierarchyManager extends NativeViewHierarchyManager
         pendingTags.clear();
       }
     }
-
+    animationsManager.notifyAboutViewsRemoval(tagsToDelete);
     super.manageChildren(tag, indicesToRemove, viewsToAdd, null);
     if (toBeRemoved.containsKey(tag)) {
       ArrayList<View> childrenToBeRemoved = toBeRemoved.get(tag);

package/ios/LayoutReanimation/REAAnimationsManager.h

@@ -1,4 +1,6 @@
 #import <Foundation/Foundation.h>
+#import <RNReanimated/LayoutAnimationType.h>
+#import <RNReanimated/REANodesManager.h>
 #import <RNReanimated/REASnapshot.h>
 #import <React/RCTUIManager.h>
 
@@ -12,13 +14,19 @@ typedef NS_ENUM(NSInteger, ViewState) {
   ToRemove,
 };
 
-typedef BOOL (^REAHasAnimationBlock)(NSNumber *_Nonnull tag, NSString *_Nonnull type);
+typedef BOOL (^REAHasAnimationBlock)(NSNumber *_Nonnull tag, LayoutAnimationType type);
 typedef void (^REAAnimationStartingBlock)(
     NSNumber *_Nonnull tag,
-    NSString *_Nonnull type,
+    LayoutAnimationType type,
     NSDictionary *_Nonnull yogaValues,
     NSNumber *_Nonnull depth);
 typedef void (^REAAnimationRemovingBlock)(NSNumber *_Nonnull tag);
+typedef void (
+    ^REACancelAnimationBlock)(NSNumber *_Nonnull tag, LayoutAnimationType type, BOOL cancelled, BOOL removeView);
+typedef NSNumber *_Nullable (^REAFindPrecedingViewTagForTransitionBlock)(NSNumber *_Nonnull tag);
+typedef int (^REATreeVisitor)(id<RCTComponent>);
+
+BOOL REANodeFind(id<RCTComponent> view, int (^block)(id<RCTComponent>));
 
 @interface REAAnimationsManager : NSObject
 
@@ -26,16 +34,34 @@ typedef void (^REAAnimationRemovingBlock)(NSNumber *_Nonnull tag);
 - (void)setAnimationStartingBlock:(REAAnimationStartingBlock)startAnimation;
 - (void)setHasAnimationBlock:(REAHasAnimationBlock)hasAnimation;
 - (void)setAnimationRemovingBlock:(REAAnimationRemovingBlock)clearAnimation;
-- (void)progressLayoutAnimationWithStyle:(NSDictionary *_Nonnull)newStyle forTag:(NSNumber *_Nonnull)tag;
+- (void)progressLayoutAnimationWithStyle:(NSDictionary *_Nonnull)newStyle
+                                  forTag:(NSNumber *_Nonnull)tag
+                      isSharedTransition:(BOOL)isSharedTransition;
+- (void)setFindPrecedingViewTagForTransitionBlock:
+    (REAFindPrecedingViewTagForTransitionBlock)findPrecedingViewTagForTransition;
+- (void)setCancelAnimationBlock:(REACancelAnimationBlock)animationCancellingBlock;
 - (void)endLayoutAnimationForTag:(NSNumber *_Nonnull)tag cancelled:(BOOL)cancelled removeView:(BOOL)removeView;
+- (void)endAnimationsRecursive:(UIView *)view;
 - (void)invalidate;
-- (void)viewDidMount:(UIView *)view withBeforeSnapshot:(REASnapshot *)snapshot;
+- (void)viewDidMount:(UIView *)view withBeforeSnapshot:(REASnapshot *)snapshot withNewFrame:(CGRect)frame;
 - (REASnapshot *)prepareSnapshotBeforeMountForView:(UIView *)view;
 - (BOOL)wantsHandleRemovalOfView:(UIView *)view;
 - (void)removeAnimationsFromSubtree:(UIView *)view;
-- (void)removeChildren:(NSArray<UIView *> *)children fromContainer:(UIView *)container;
+- (void)reattachAnimatedChildren:(NSArray<id<RCTComponent>> *)children
+                     toContainer:(id<RCTComponent>)container
+                       atIndices:(NSArray<NSNumber *> *)indices;
 - (void)onViewCreate:(UIView *)view after:(REASnapshot *)after;
 - (void)onViewUpdate:(UIView *)view before:(REASnapshot *)before after:(REASnapshot *)after;
+- (void)viewsDidLayout;
+- (NSDictionary *)prepareDataForLayoutAnimatingWorklet:(NSMutableDictionary *)currentValues
+                                          targetValues:(NSMutableDictionary *)targetValues;
+- (UIView *)viewForTag:(NSNumber *)tag;
+- (BOOL)hasAnimationForTag:(NSNumber *)tag type:(LayoutAnimationType)type;
+- (void)clearAnimationConfigForTag:(NSNumber *)tag;
+- (void)startAnimationForTag:(NSNumber *)tag
+                        type:(LayoutAnimationType)type
+                  yogaValues:(NSDictionary *)yogaValues
+                       depth:(NSNumber *)depth;
 
 @end