react-native-reanimated 2.3.3 → 2.5.0

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

@@ -0,0 +1,517 @@
+package com.swmansion.reanimated.layoutReanimation;
+
+import android.util.DisplayMetrics;
+import android.util.Log;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewParent;
+import com.facebook.react.bridge.JavaOnlyMap;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.IViewManagerWithChildren;
+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;
+import java.util.ArrayList;
+import java.util.HashMap;
+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 ReanimatedNativeHierarchyManager mReanimatedNativeHierarchyManager;
+  private boolean isCatalystInstanceDestroyed = false;
+
+  public void setReanimatedNativeHierarchyManager(
+      ReanimatedNativeHierarchyManager reanimatedNativeHierarchyManager) {
+    this.mReanimatedNativeHierarchyManager = reanimatedNativeHierarchyManager;
+  }
+
+  public ReanimatedNativeHierarchyManager getReanimatedNativeHierarchyManager() {
+    return mReanimatedNativeHierarchyManager;
+  }
+
+  public void setScheduler(Scheduler scheduler) {
+    mScheduler = new WeakReference<>(scheduler);
+  }
+
+  public enum ViewState {
+    Inactive,
+    Appearing,
+    Disappearing,
+    Layout,
+    ToRemove;
+  }
+
+  public AnimationsManager(
+      ReactContext context, UIImplementation uiImplementation, 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;
+  }
+
+  public void onCatalystInstanceDestroy() {
+    isCatalystInstanceDestroyed = true;
+    mNativeMethodsHolder = null;
+    mContext = null;
+    mUIImplementation = null;
+    mUIManager = null;
+    mStates = null;
+    mToRemove = null;
+    mViewForTag = null;
+    mViewManager = null;
+    mParent = null;
+    mParentViewManager = null;
+    mCallbacks = null;
+  }
+
+  @Override
+  public void onViewRemoval(View view, ViewGroup parent, Snapshot before, 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;
+    }
+    mStates.put(tag, ViewState.Disappearing);
+    HashMap<String, Float> preparedValues = prepareDataForAnimationWorklet(currentValues, false);
+    mNativeMethodsHolder.startAnimationForTag(tag, "exiting", preparedValues);
+  }
+
+  @Override
+  public void onViewCreate(View view, ViewGroup parent, Snapshot after) {
+    if (isCatalystInstanceDestroyed) {
+      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();
+    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;
+    }
+  }
+
+  @Override
+  public void onViewUpdate(View view, Snapshot before, Snapshot after) {
+    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) {
+      return;
+    }
+    // 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;
+      }
+    }
+
+    // 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);
+    HashMap<String, Float> preparedValues = new HashMap<>(preparedTargetValues);
+    for (String key : preparedStartValues.keySet()) {
+      preparedValues.put(key, preparedStartValues.get(key));
+    }
+    mNativeMethodsHolder.startAnimationForTag(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);
+    }
+
+    setNewProps(
+        newStyle,
+        mViewForTag.get(tag),
+        mViewManager.get(tag),
+        mParentViewManager.get(tag),
+        mParent.get(tag).getId());
+  }
+
+  public void notifyAboutEnd(int tag, boolean cancelled) {
+    if (!cancelled) {
+      ViewState state = mStates.get(tag);
+      if (state == ViewState.Appearing) {
+        mStates.put(tag, ViewState.Layout);
+      }
+
+      if (state == ViewState.Disappearing) {
+        mStates.put(tag, ViewState.ToRemove);
+        mToRemove.add(tag);
+        scheduleCleaning();
+      }
+    }
+  }
+
+  private void removeLeftovers() {
+    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);
+    }
+    for (int tag : roots) {
+      View view = mViewForTag.get(tag);
+      if (view != null) {
+        dfs(view, view, mToRemove);
+      }
+    }
+  }
+
+  public void printSubTree(View view, int level) {
+    if (level == 0) {
+      Log.v("rea", "----------------------");
+    }
+    if (view == null) {
+      return;
+    }
+    StringBuilder out = new StringBuilder();
+    for (int i = 0; i < level; ++i) {
+      out.append("+");
+    }
+    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());
+
+    if (view instanceof ViewGroup) {
+      for (int i = 0; i < ((ViewGroup) view).getChildCount(); ++i) {
+        printSubTree(((ViewGroup) view).getChildAt(i), level + 1);
+      }
+    }
+  }
+
+  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<>();
+    ArrayList<String> keys;
+    if (isTargetValues) {
+      keys = Snapshot.targetKeysToTransform;
+    } else {
+      keys = Snapshot.currentKeysToTransform;
+    }
+    for (String key : keys) {
+      preparedValues.put(key, PixelUtil.toDIPFromPixel((int) values.get(key)));
+    }
+
+    DisplayMetrics displaymetrics = new DisplayMetrics();
+    mContext.getCurrentActivity().getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
+    int height = displaymetrics.heightPixels;
+    int width = displaymetrics.widthPixels;
+    preparedValues.put("windowWidth", PixelUtil.toDIPFromPixel(width));
+    preparedValues.put("windowHeight", PixelUtil.toDIPFromPixel(height));
+    return preparedValues;
+  }
+
+  public void setNativeMethods(NativeMethodsHolder nativeMethods) {
+    mNativeMethodsHolder = nativeMethods;
+  }
+
+  public void setNewProps(
+      Map<String, Object> props,
+      View view,
+      ViewManager viewManager,
+      ViewManager parentViewManager,
+      Integer parentTag) {
+    float x =
+        (props.get(Snapshot.ORIGIN_X) != null)
+            ? ((Double) props.get(Snapshot.ORIGIN_X)).floatValue()
+            : PixelUtil.toDIPFromPixel(view.getLeft());
+    float y =
+        (props.get(Snapshot.ORIGIN_Y) != null)
+            ? ((Double) props.get(Snapshot.ORIGIN_Y)).floatValue()
+            : PixelUtil.toDIPFromPixel(view.getTop());
+    float width =
+        (props.get(Snapshot.WIDTH) != null)
+            ? ((Double) props.get(Snapshot.WIDTH)).floatValue()
+            : PixelUtil.toDIPFromPixel(view.getWidth());
+    float height =
+        (props.get(Snapshot.HEIGHT) != null)
+            ? ((Double) props.get(Snapshot.HEIGHT)).floatValue()
+            : PixelUtil.toDIPFromPixel(view.getHeight());
+    updateLayout(view, parentViewManager, parentTag, view.getId(), x, y, width, height);
+    props.remove(Snapshot.ORIGIN_X);
+    props.remove(Snapshot.ORIGIN_Y);
+    props.remove(Snapshot.WIDTH);
+    props.remove(Snapshot.HEIGHT);
+
+    if (props.size() == 0) {
+      return;
+    }
+
+    JavaOnlyMap javaOnlyMap = new JavaOnlyMap();
+    for (String key : props.keySet()) {
+      addProp(javaOnlyMap, key, props.get(key));
+    }
+
+    viewManager.updateProperties(view, new ReactStylesDiffMap(javaOnlyMap));
+  }
+
+  private static void addProp(WritableMap propMap, String key, Object value) {
+    if (value == null) {
+      propMap.putNull(key);
+    } else if (value instanceof Double) {
+      propMap.putDouble(key, (Double) value);
+    } else if (value instanceof Integer) {
+      propMap.putInt(key, (Integer) value);
+    } else if (value instanceof Number) {
+      propMap.putDouble(key, ((Number) value).doubleValue());
+    } else if (value instanceof Boolean) {
+      propMap.putBoolean(key, (Boolean) value);
+    } else if (value instanceof String) {
+      propMap.putString(key, (String) value);
+    } else if (value instanceof ReadableArray) {
+      propMap.putArray(key, (ReadableArray) value);
+    } else if (value instanceof ReadableMap) {
+      propMap.putMap(key, (ReadableMap) value);
+    } else {
+      throw new IllegalStateException("Unknown type of animated value [Layout Aniamtions]");
+    }
+  }
+
+  public void updateLayout(
+      View viewToUpdate,
+      ViewManager parentViewManager,
+      int parentTag,
+      int tag,
+      float xf,
+      float yf,
+      float widthf,
+      float heightf) {
+
+    int x = Math.round(PixelUtil.toPixelFromDIP(xf));
+    int y = Math.round(PixelUtil.toPixelFromDIP(yf));
+    int width = Math.round(PixelUtil.toPixelFromDIP(widthf));
+    int height = Math.round(PixelUtil.toPixelFromDIP(heightf));
+    // Even though we have exact dimensions, we still call measure because some platform views
+    // (e.g.
+    // Switch) assume that method will always be called before onLayout and onDraw. They use it to
+    // calculate and cache information used in the draw pass. For most views, onMeasure can be
+    // stubbed out to only call setMeasuredDimensions. For ViewGroups, onLayout should be stubbed
+    // out to not recursively call layout on its children: React Native already handles doing
+    // that.
+    //
+    // Also, note measure and layout need to be called *after* all View properties have been
+    // updated
+    // because of caching and calculation that may occur in onMeasure and onLayout. Layout
+    // operations should also follow the native view hierarchy and go top to bottom for
+    // consistency
+    // with standard layout passes (some views may depend on this).
+
+    viewToUpdate.measure(
+        View.MeasureSpec.makeMeasureSpec(width, View.MeasureSpec.EXACTLY),
+        View.MeasureSpec.makeMeasureSpec(height, View.MeasureSpec.EXACTLY));
+
+    // We update the layout of the ReactRootView when there is a change in the layout of its
+    // child.
+    // This is required to re-measure the size of the native View container (usually a
+    // FrameLayout) that is configured with layout_height = WRAP_CONTENT or layout_width =
+    // WRAP_CONTENT
+    //
+    // This code is going to be executed ONLY when there is a change in the size of the Root
+    // View defined in the js side. Changes in the layout of inner views will not trigger an
+    // update
+    // on the layout of the Root View.
+    ViewParent parent = viewToUpdate.getParent();
+    if (parent instanceof RootView) {
+      parent.requestLayout();
+    }
+
+    // Check if the parent of the view has to layout the view, or the child has to lay itself out.
+    if (parentTag % 10 == 1) { // ParentIsARoot
+      IViewManagerWithChildren parentViewManagerWithChildren;
+      if (parentViewManager instanceof IViewManagerWithChildren) {
+        parentViewManagerWithChildren = (IViewManagerWithChildren) parentViewManager;
+      } else {
+        throw new IllegalViewOperationException(
+            "Trying to use view with tag "
+                + parentTag
+                + " as a parent, but its Manager doesn't implement IViewManagerWithChildren");
+      }
+      if (parentViewManagerWithChildren != null
+          && !parentViewManagerWithChildren.needsCustomLayoutForChildren()) {
+        viewToUpdate.layout(x, y, x + width, y + height);
+      }
+    } else {
+      viewToUpdate.layout(x, y, x + width, y + height);
+    }
+  }
+
+  public boolean isLayoutAnimationEnabled() {
+    return mNativeMethodsHolder != null && mNativeMethodsHolder.isLayoutAnimationEnabled();
+  }
+}

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

@@ -0,0 +1,56 @@
+package com.swmansion.reanimated.layoutReanimation;
+
+import com.facebook.jni.HybridData;
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.swmansion.reanimated.ReanimatedModule;
+import java.lang.ref.WeakReference;
+import java.util.Map;
+
+public class LayoutAnimations {
+  static {
+    System.loadLibrary("reanimated");
+  }
+
+  @DoNotStrip
+  @SuppressWarnings("unused")
+  private final HybridData mHybridData;
+
+  private WeakReference<ReactApplicationContext> mContext;
+
+  public LayoutAnimations(ReactApplicationContext context) {
+    mContext = new WeakReference<>(context);
+    mHybridData = initHybrid();
+  }
+
+  private native HybridData initHybrid();
+
+  // LayoutReanimation
+  public native void startAnimationForTag(int tag, String type, Map<String, String> values);
+
+  public native void removeConfigForTag(int tag);
+
+  public native boolean isLayoutAnimationEnabled();
+
+  private void notifyAboutEnd(int tag, int cancelledInt) {
+    ReactApplicationContext context = mContext.get();
+    if (context != null) {
+      context
+          .getNativeModule(ReanimatedModule.class)
+          .getNodesManager()
+          .getAnimationsManager()
+          .notifyAboutEnd(tag, (cancelledInt == 0) ? false : true);
+    }
+  }
+
+  private void notifyAboutProgress(Map<String, Object> newStyle, int tag) {
+    ReactApplicationContext context = mContext.get();
+    if (context != null) {
+      context
+          .getNativeModule(ReanimatedModule.class)
+          .getNodesManager()
+          .getAnimationsManager()
+          .notifyAboutProgress(newStyle, tag);
+    }
+  }
+}

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

@@ -0,0 +1,11 @@
+package com.swmansion.reanimated.layoutReanimation;
+
+import java.util.HashMap;
+
+public interface NativeMethodsHolder {
+  public void startAnimationForTag(int tag, String type, HashMap<String, Float> values);
+
+  public void removeConfigForTag(int tag);
+
+  public boolean isLayoutAnimationEnabled();
+}