react-native 0.0.0-201c10733 → 0.0.0-268efb102

package/ReactAndroid/src/main/java/com/facebook/react/views/textinput/ReactTextInputSubmitEditingEvent.java

@@ -7,11 +7,10 @@
 
 package com.facebook.react.views.textinput;
 
+import androidx.annotation.Nullable;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.uimanager.events.Event;
-import com.facebook.react.uimanager.events.RCTEventEmitter;
-import com.facebook.react.uimanager.events.RCTModernEventEmitter;
 
 /** Event emitted by EditText native view when the user submits the text. */
 /* package */ class ReactTextInputSubmitEditingEvent
@@ -36,26 +35,17 @@ import com.facebook.react.uimanager.events.RCTModernEventEmitter;
     return EVENT_NAME;
   }
 
+  @Nullable
   @Override
-  public boolean canCoalesce() {
-    return false;
-  }
-
-  @Override
-  public void dispatch(RCTEventEmitter rctEventEmitter) {
-    rctEventEmitter.receiveEvent(getViewTag(), getEventName(), serializeEventData());
-  }
-
-  @Override
-  public void dispatchModern(RCTModernEventEmitter rctEventEmitter) {
-    rctEventEmitter.receiveEvent(
-        getSurfaceId(), getViewTag(), getEventName(), serializeEventData());
-  }
-
-  private WritableMap serializeEventData() {
+  protected WritableMap getEventData() {
     WritableMap eventData = Arguments.createMap();
     eventData.putInt("target", getViewTag());
     eventData.putString("text", mText);
     return eventData;
   }
+
+  @Override
+  public boolean canCoalesce() {
+    return false;
+  }
 }

package/ReactAndroid/src/main/java/com/facebook/react/views/view/CanvasUtil.java

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.react.views.view;
+
+import android.annotation.SuppressLint;
+import android.graphics.Canvas;
+import android.os.Build;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import javax.annotation.Nullable;
+
+/**
+ * Copied from <a
+ * href="https://cs.android.com/androidx/platform/frameworks/support/+/androidx-main:compose/ui/ui-graphics/src/androidMain/kotlin/androidx/compose/ui/graphics/CanvasUtils.android.kt;drc=3b2dde134afab8d58b9c39ad4820eaf9a6e014a9">
+ * Compose canvas utils </a>
+ */
+public class CanvasUtil {
+  private CanvasUtil() {}
+
+  private @Nullable static Method mReorderBarrierMethod = null;
+  private @Nullable static Method mInorderBarrierMethod = null;
+  private static boolean mOrderMethodsFetched = false;
+
+  /**
+   * Enables Z support for the Canvas. The method is publicly available starting from API 29 and was
+   * hidden before, so we have to resort to reflection tricks to ensure we can use this API.
+   */
+  @SuppressLint({"SoonBlockedPrivateApi", "PrivateApi"})
+  public static void enableZ(Canvas canvas, boolean enable) {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+      return;
+    }
+
+    if (Build.VERSION.SDK_INT >= 29) {
+      if (enable) {
+        canvas.enableZ();
+      } else {
+        canvas.disableZ();
+      }
+    } else {
+      fetchOrderMethods();
+      try {
+        if (enable && mReorderBarrierMethod != null) {
+          mReorderBarrierMethod.invoke(canvas);
+        }
+        if (!enable && mInorderBarrierMethod != null) {
+          mInorderBarrierMethod.invoke(canvas);
+        }
+      } catch (IllegalAccessException | InvocationTargetException ignore) {
+        // Do nothing
+      }
+    }
+  }
+
+  private static void fetchOrderMethods() {
+    if (!mOrderMethodsFetched) {
+      try {
+        if (Build.VERSION.SDK_INT == Build.VERSION_CODES.P) {
+          // use double reflection to avoid grey list on P
+          Method getDeclaredMethod =
+              Class.class.getDeclaredMethod("getDeclaredMethod", String.class, Class[].class);
+          mReorderBarrierMethod =
+              (Method) getDeclaredMethod.invoke(Canvas.class, "insertReorderBarrier", new Class[0]);
+          mInorderBarrierMethod =
+              (Method) getDeclaredMethod.invoke(Canvas.class, "insertInorderBarrier", new Class[0]);
+        } else {
+          mReorderBarrierMethod = Canvas.class.getDeclaredMethod("insertReorderBarrier");
+          mInorderBarrierMethod = Canvas.class.getDeclaredMethod("insertInorderBarrier");
+        }
+
+        if (mReorderBarrierMethod == null || mInorderBarrierMethod == null) {
+          return;
+        }
+
+        mReorderBarrierMethod.setAccessible(true);
+        mInorderBarrierMethod.setAccessible(true);
+      } catch (IllegalAccessException ignore) {
+        // Do nothing
+      } catch (InvocationTargetException ignore) {
+        // Do nothing
+      } catch (NoSuchMethodException ignore) {
+        // Do nothing
+      }
+      mOrderMethodsFetched = true;
+    }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/views/view/ReactViewBackgroundDrawable.java

@@ -89,6 +89,7 @@ public class ReactViewBackgroundDrawable extends Drawable {
   private @Nullable Path mOuterClipPathForBorderRadius;
   private @Nullable Path mPathForBorderRadiusOutline;
   private @Nullable Path mPathForBorder;
+  private Path mPathForSingleBorder = new Path();
   private @Nullable Path mCenterDrawPath;
   private @Nullable RectF mInnerClipTempRectForBorderRadius;
   private @Nullable RectF mOuterClipTempRectForBorderRadius;
@@ -968,6 +969,14 @@ public class ReactViewBackgroundDrawable extends Drawable {
     mPaint.setPathEffect(mPathEffectForBorderStyle);
   }
 
+  private void updatePathEffect(int borderWidth) {
+    PathEffect pathEffectForBorderStyle = null;
+    if (mBorderStyle != null) {
+      pathEffectForBorderStyle = BorderStyle.getPathEffect(mBorderStyle, borderWidth);
+    }
+    mPaint.setPathEffect(pathEffectForBorderStyle);
+  }
+
   /** For rounded borders we use default "borderWidth" property. */
   public float getFullBorderWidth() {
     return (mBorderWidth != null && !YogaConstants.isUndefined(mBorderWidth.getRaw(Spacing.ALL)))
@@ -1083,6 +1092,7 @@ public class ReactViewBackgroundDrawable extends Drawable {
               colorTop,
               colorRight,
               colorBottom);
+
       if (fastBorderColor != 0) {
         if (Color.alpha(fastBorderColor) != 0) {
           // Border color is not transparent.
@@ -1090,21 +1100,42 @@ public class ReactViewBackgroundDrawable extends Drawable {
           int bottom = bounds.bottom;
 
           mPaint.setColor(fastBorderColor);
+          mPaint.setStyle(Paint.Style.STROKE);
           if (borderLeft > 0) {
-            int leftInset = left + borderLeft;
-            canvas.drawRect(left, top, leftInset, bottom - borderBottom, mPaint);
+            mPathForSingleBorder.reset();
+            int width = Math.round(borderWidth.left);
+            updatePathEffect(width);
+            mPaint.setStrokeWidth(width);
+            mPathForSingleBorder.moveTo(left, top - borderWidth.top / 2);
+            mPathForSingleBorder.lineTo(left, bottom + borderWidth.bottom / 2);
+            canvas.drawPath(mPathForSingleBorder, mPaint);
           }
           if (borderTop > 0) {
-            int topInset = top + borderTop;
-            canvas.drawRect(left + borderLeft, top, right, topInset, mPaint);
+            mPathForSingleBorder.reset();
+            int width = Math.round(borderWidth.top);
+            updatePathEffect(width);
+            mPaint.setStrokeWidth(width);
+            mPathForSingleBorder.moveTo(left, top);
+            mPathForSingleBorder.lineTo(right, top);
+            canvas.drawPath(mPathForSingleBorder, mPaint);
           }
           if (borderRight > 0) {
-            int rightInset = right - borderRight;
-            canvas.drawRect(rightInset, top + borderTop, right, bottom, mPaint);
+            mPathForSingleBorder.reset();
+            int width = Math.round(borderWidth.right);
+            updatePathEffect(width);
+            mPaint.setStrokeWidth(width);
+            mPathForSingleBorder.moveTo(right, top - borderWidth.top / 2);
+            mPathForSingleBorder.lineTo(right, bottom + borderWidth.bottom / 2);
+            canvas.drawPath(mPathForSingleBorder, mPaint);
           }
           if (borderBottom > 0) {
-            int bottomInset = bottom - borderBottom;
-            canvas.drawRect(left, bottomInset, right - borderRight, bottom, mPaint);
+            mPathForSingleBorder.reset();
+            int width = Math.round(borderWidth.bottom);
+            updatePathEffect(width);
+            mPaint.setStrokeWidth(width);
+            mPathForSingleBorder.moveTo(left, bottom);
+            mPathForSingleBorder.lineTo(right, bottom);
+            canvas.drawPath(mPathForSingleBorder, mPaint);
           }
         }
       } else {

package/ReactAndroid/src/main/java/com/facebook/react/views/view/ReactViewGroup.java

@@ -29,8 +29,11 @@ import androidx.annotation.Nullable;
 import com.facebook.common.logging.FLog;
 import com.facebook.infer.annotation.Assertions;
 import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.ReactNoCrashSoftException;
+import com.facebook.react.bridge.ReactSoftExceptionLogger;
 import com.facebook.react.bridge.UiThreadUtil;
 import com.facebook.react.common.annotations.VisibleForTesting;
+import com.facebook.react.config.ReactFeatureFlags;
 import com.facebook.react.modules.i18nmanager.I18nUtil;
 import com.facebook.react.touch.OnInterceptTouchEventListener;
 import com.facebook.react.touch.ReactHitSlopView;
@@ -38,8 +41,10 @@ import com.facebook.react.touch.ReactInterceptingViewGroup;
 import com.facebook.react.uimanager.IllegalViewOperationException;
 import com.facebook.react.uimanager.MeasureSpecAssertions;
 import com.facebook.react.uimanager.PointerEvents;
+import com.facebook.react.uimanager.ReactClippingProhibitedView;
 import com.facebook.react.uimanager.ReactClippingViewGroup;
 import com.facebook.react.uimanager.ReactClippingViewGroupHelper;
+import com.facebook.react.uimanager.ReactOverflowView;
 import com.facebook.react.uimanager.ReactPointerEventsView;
 import com.facebook.react.uimanager.ReactZIndexedViewGroup;
 import com.facebook.react.uimanager.RootView;
@@ -60,7 +65,8 @@ public class ReactViewGroup extends ViewGroup
         ReactClippingViewGroup,
         ReactPointerEventsView,
         ReactHitSlopView,
-        ReactZIndexedViewGroup {
+        ReactZIndexedViewGroup,
+        ReactOverflowView {
 
   private static final int ARRAY_CAPACITY_INCREMENT = 12;
   private static final int DEFAULT_BACKGROUND_COLOR = Color.TRANSPARENT;
@@ -549,7 +555,7 @@ public class ReactViewGroup extends ViewGroup
   }
 
   /*package*/ void addViewWithSubviewClippingEnabled(
-      View child, int index, ViewGroup.LayoutParams params) {
+      final View child, int index, ViewGroup.LayoutParams params) {
     Assertions.assertCondition(mRemoveClippedSubviews);
     Assertions.assertNotNull(mClippingRect);
     Assertions.assertNotNull(mAllChildren);
@@ -564,6 +570,29 @@ public class ReactViewGroup extends ViewGroup
     }
     updateSubviewClipStatus(mClippingRect, index, clippedSoFar);
     child.addOnLayoutChangeListener(mChildrenLayoutChangeListener);
+
+    if (child instanceof ReactClippingProhibitedView) {
+      UiThreadUtil.runOnUiThread(
+          new Runnable() {
+            @Override
+            public void run() {
+              if (!child.isShown()) {
+                ReactSoftExceptionLogger.logSoftException(
+                    TAG,
+                    new ReactNoCrashSoftException(
+                        "Child view has been added to Parent view in which it is clipped and not visible."
+                            + " This is not legal for this particular child view. Child: ["
+                            + child.getId()
+                            + "] "
+                            + child.toString()
+                            + " Parent: ["
+                            + getId()
+                            + "] "
+                            + toString()));
+              }
+            }
+          });
+    }
   }
 
   /*package*/ void removeViewWithSubviewClippingEnabled(View view) {
@@ -692,6 +721,7 @@ public class ReactViewGroup extends ViewGroup
     invalidate();
   }
 
+  @Override
   public @Nullable String getOverflow() {
     return mOverflow;
   }
@@ -730,6 +760,23 @@ public class ReactViewGroup extends ViewGroup
     }
   }
 
+  @Override
+  protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
+    boolean drawWithZ =
+        child.getElevation() > 0 && ReactFeatureFlags.insertZReorderBarriersOnViewGroupChildren;
+
+    if (drawWithZ) {
+      CanvasUtil.enableZ(canvas, false);
+    }
+
+    boolean result = super.drawChild(canvas, child, drawingTime);
+
+    if (drawWithZ) {
+      CanvasUtil.enableZ(canvas, true);
+    }
+    return result;
+  }
+
   private void dispatchOverflowDraw(Canvas canvas) {
     if (mOverflow != null) {
       switch (mOverflow) {

package/ReactAndroid/src/main/java/com/facebook/react/views/view/ReactViewManager.java

@@ -239,7 +239,9 @@ public class ReactViewManager extends ReactClippingViewManager<ReactViewGroup> {
               if (mEventDispatcher == null) {
                 return;
               }
-              mEventDispatcher.dispatchEvent(new ViewGroupClickEvent(view.getId()));
+              mEventDispatcher.dispatchEvent(
+                  new ViewGroupClickEvent(
+                      UIManagerHelper.getSurfaceId(view.getContext()), view.getId()));
             }
           });
 

package/ReactAndroid/src/main/java/com/facebook/react/views/view/ViewGroupClickEvent.java

@@ -7,16 +7,22 @@
 
 package com.facebook.react.views.view;
 
+import androidx.annotation.Nullable;
 import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.uimanager.events.Event;
-import com.facebook.react.uimanager.events.RCTEventEmitter;
 
 /** Represents a Click on the ReactViewGroup */
 public class ViewGroupClickEvent extends Event<ViewGroupClickEvent> {
   private static final String EVENT_NAME = "topClick";
 
+  @Deprecated
   public ViewGroupClickEvent(int viewId) {
-    super(viewId);
+    this(-1, viewId);
+  }
+
+  public ViewGroupClickEvent(int surfaceId, int viewId) {
+    super(surfaceId, viewId);
   }
 
   @Override
@@ -29,8 +35,9 @@ public class ViewGroupClickEvent extends Event<ViewGroupClickEvent> {
     return false;
   }
 
+  @Nullable
   @Override
-  public void dispatch(RCTEventEmitter rctEventEmitter) {
-    rctEventEmitter.receiveEvent(getViewTag(), getEventName(), Arguments.createMap());
+  protected WritableMap getEventData() {
+    return Arguments.createMap();
   }
 }

package/ReactAndroid/src/main/java/com/facebook/yoga/YogaNode.java

@@ -9,7 +9,15 @@ package com.facebook.yoga;
 
 import javax.annotation.Nullable;
 
-public abstract class YogaNode {
+public abstract class YogaNode implements YogaProps {
+
+  /** The interface the {@link #getData()} object can optionally implement. */
+  public interface Inputs {
+
+    /** Requests the data object to disable mutations of its inputs. */
+    void freeze(final YogaNode node, final @Nullable YogaNode parent);
+  }
+
   public abstract void reset();
 
   public abstract int getChildCount();
@@ -25,12 +33,10 @@ public abstract class YogaNode {
   public abstract YogaNode removeChildAt(int i);
 
   /**
-   * @returns the {@link YogaNode} that owns this {@link YogaNode}.
-   * The owner is used to identify the YogaTree that a {@link YogaNode} belongs
-   * to.
-   * This method will return the parent of the {@link YogaNode} when the
-   * {@link YogaNode} only belongs to one YogaTree or null when the
-   * {@link YogaNode} is shared between two or more YogaTrees.
+   * @returns the {@link YogaNode} that owns this {@link YogaNode}. The owner is used to identify
+   *     the YogaTree that a {@link YogaNode} belongs to. This method will return the parent of the
+   *     {@link YogaNode} when the {@link YogaNode} only belongs to one YogaTree or null when the
+   *     {@link YogaNode} is shared between two or more YogaTrees.
    */
   @Nullable
   public abstract YogaNode getOwner();

package/ReactAndroid/src/main/java/com/facebook/yoga/YogaNodeJNIBase.java

@@ -83,6 +83,9 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
   }
 
   public void addChildAt(YogaNode c, int i) {
+    if (!(c instanceof YogaNodeJNIBase)) {
+      return;
+    }
     YogaNodeJNIBase child = (YogaNodeJNIBase) c;
     if (child.mOwner != null) {
       throw new IllegalStateException("Child already has a parent, it must be removed first.");
@@ -105,6 +108,9 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
   }
 
   public void swapChildAt(YogaNode newChild, int position) {
+    if (!(newChild instanceof YogaNodeJNIBase)) {
+      return;
+    }
     YogaNodeJNIBase child = (YogaNodeJNIBase) newChild;
     mChildren.remove(position);
     mChildren.add(position, child);
@@ -191,12 +197,18 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
     long[] nativePointers = null;
     YogaNodeJNIBase[] nodes = null;
 
+    freeze(null);
+
     ArrayList<YogaNodeJNIBase> n = new ArrayList<>();
     n.add(this);
     for (int i = 0; i < n.size(); ++i) {
-      List<YogaNodeJNIBase> children = n.get(i).mChildren;
+      final YogaNodeJNIBase parent = n.get(i);
+      List<YogaNodeJNIBase> children = parent.mChildren;
       if (children != null) {
-        n.addAll(children);
+        for (YogaNodeJNIBase child : children) {
+          child.freeze(parent);
+          n.add(child);
+        }
       }
     }
 
@@ -209,6 +221,13 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
     YogaNative.jni_YGNodeCalculateLayoutJNI(mNativePointer, width, height, nativePointers, nodes);
   }
 
+  private void freeze(YogaNode parent) {
+    Object data = getData();
+    if (data instanceof Inputs) {
+      ((Inputs) data).freeze(this, parent);
+    }
+  }
+
   public void dirty() {
     YogaNative.jni_YGNodeMarkDirtyJNI(mNativePointer);
   }
@@ -223,6 +242,9 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
 
   @Override
   public void copyStyle(YogaNode srcNode) {
+    if (!(srcNode instanceof YogaNodeJNIBase)) {
+      return;
+    }
     YogaNative.jni_YGNodeCopyStyleJNI(mNativePointer, ((YogaNodeJNIBase) srcNode).mNativePointer);
   }
 

package/ReactAndroid/src/main/java/com/facebook/yoga/YogaProps.java

@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+package com.facebook.yoga;
+
+public interface YogaProps {
+
+  /* Width properties */
+
+  void setWidth(float width);
+
+  void setWidthPercent(float percent);
+
+  void setMinWidth(float minWidth);
+
+  void setMinWidthPercent(float percent);
+
+  void setMaxWidth(float maxWidth);
+
+  void setMaxWidthPercent(float percent);
+
+  void setWidthAuto();
+
+  /* Height properties */
+
+  void setHeight(float height);
+
+  void setHeightPercent(float percent);
+
+  void setMinHeight(float minHeight);
+
+  void setMinHeightPercent(float percent);
+
+  void setMaxHeight(float maxHeight);
+
+  void setMaxHeightPercent(float percent);
+
+  void setHeightAuto();
+
+  /* Margin properties */
+
+  void setMargin(YogaEdge edge, float margin);
+
+  void setMarginPercent(YogaEdge edge, float percent);
+
+  void setMarginAuto(YogaEdge edge);
+
+  /* Padding properties */
+
+  void setPadding(YogaEdge edge, float padding);
+
+  void setPaddingPercent(YogaEdge edge, float percent);
+
+  /* Position properties */
+
+  void setPositionType(YogaPositionType positionType);
+
+  void setPosition(YogaEdge edge, float position);
+
+  void setPositionPercent(YogaEdge edge, float percent);
+
+  /* Alignment properties */
+
+  void setAlignContent(YogaAlign alignContent);
+
+  void setAlignItems(YogaAlign alignItems);
+
+  void setAlignSelf(YogaAlign alignSelf);
+
+  /* Flex properties */
+
+  void setFlex(float flex);
+
+  void setFlexBasisAuto();
+
+  void setFlexBasisPercent(float percent);
+
+  void setFlexBasis(float flexBasis);
+
+  void setFlexDirection(YogaFlexDirection direction);
+
+  void setFlexGrow(float flexGrow);
+
+  void setFlexShrink(float flexShrink);
+
+  /* Other properties */
+
+  void setJustifyContent(YogaJustify justifyContent);
+
+  void setDirection(YogaDirection direction);
+
+  void setBorder(YogaEdge edge, float value);
+
+  void setWrap(YogaWrap wrap);
+
+  void setAspectRatio(float aspectRatio);
+
+  void setIsReferenceBaseline(boolean isReferenceBaseline);
+
+  void setMeasureFunction(YogaMeasureFunction measureFunction);
+
+  void setBaselineFunction(YogaBaselineFunction yogaBaselineFunction);
+
+  /* Getters */
+
+  YogaValue getWidth();
+
+  YogaValue getMinWidth();
+
+  YogaValue getMaxWidth();
+
+  YogaValue getHeight();
+
+  YogaValue getMinHeight();
+
+  YogaValue getMaxHeight();
+
+  YogaDirection getStyleDirection();
+
+  YogaFlexDirection getFlexDirection();
+
+  YogaJustify getJustifyContent();
+
+  YogaAlign getAlignItems();
+
+  YogaAlign getAlignSelf();
+
+  YogaAlign getAlignContent();
+
+  YogaPositionType getPositionType();
+
+  float getFlexGrow();
+
+  float getFlexShrink();
+
+  YogaValue getFlexBasis();
+
+  float getAspectRatio();
+
+  YogaValue getMargin(YogaEdge edge);
+
+  YogaValue getPadding(YogaEdge edge);
+
+  YogaValue getPosition(YogaEdge edge);
+
+  float getBorder(YogaEdge edge);
+}

package/ReactAndroid/src/main/jni/first-party/fb/BUCK

@@ -23,6 +23,10 @@ oss_cxx_library(
         "-DDISABLE_CPUCAP",
         "-DDISABLE_XPLAT",
     ],
+    linker_flags = [
+        "-llog",
+    ],
+    preferred_linkage = "static",
     soname = "libfb.$(ext)",
     visibility = ["PUBLIC"],
     deps = [

package/ReactAndroid/src/main/jni/first-party/yogajni/jni/YGJNIVanilla.cpp

@@ -367,11 +367,7 @@ static void jni_YGNodeCalculateLayoutJNI(
     void* layoutContext = nullptr;
     auto map = PtrJNodeMapVanilla{};
     if (nativePointers) {
-      size_t nativePointersSize = env->GetArrayLength(nativePointers);
-      jlong result[nativePointersSize];
-      env->GetLongArrayRegion(nativePointers, 0, nativePointersSize, result);
-
-      map = PtrJNodeMapVanilla{result, nativePointersSize, javaNodes};
+      map = PtrJNodeMapVanilla{nativePointers, javaNodes};
       layoutContext = ↦
     }
 
@@ -726,8 +722,7 @@ static void jni_YGNodePrintJNI(JNIEnv* env, jobject obj, jlong nativePointer) {
   const YGNodeRef node = _jlong2YGNodeRef(nativePointer);
   YGNodePrint(
       node,
-      (YGPrintOptions)(
-          YGPrintOptionsStyle | YGPrintOptionsLayout | YGPrintOptionsChildren));
+      (YGPrintOptions) (YGPrintOptionsStyle | YGPrintOptionsLayout | YGPrintOptionsChildren));
 #endif
 }
 

package/ReactAndroid/src/main/jni/first-party/yogajni/jni/YGJTypesVanilla.h

@@ -20,11 +20,15 @@ class PtrJNodeMapVanilla {
 
 public:
   PtrJNodeMapVanilla() : ptrsToIdxs_{}, javaNodes_{} {}
-  PtrJNodeMapVanilla(
-      jlong* nativePointers,
-      size_t nativePointersSize,
-      jobjectArray javaNodes)
+  PtrJNodeMapVanilla(jlongArray javaNativePointers, jobjectArray javaNodes)
       : javaNodes_{javaNodes} {
+
+    JNIEnv* env = getCurrentEnv();
+    size_t nativePointersSize = env->GetArrayLength(javaNativePointers);
+    std::vector<jlong> nativePointers(nativePointersSize);
+    env->GetLongArrayRegion(
+        javaNativePointers, 0, nativePointersSize, nativePointers.data());
+
     for (size_t i = 0; i < nativePointersSize; ++i) {
       ptrsToIdxs_[(YGNodeRef) nativePointers[i]] = i;
     }