react-native-tvos 0.77.1-0 → 0.78.0-0

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

@@ -161,6 +161,7 @@ public class ReactViewGroup extends ViewGroup
   // {@link ViewGroup#getChildCount} so those methods may return views that are not attached.
   // This is risky but allows us to perform a correct cleanup in {@link NativeViewHierarchyManager}.
   private boolean mRemoveClippedSubviews;
+  private volatile boolean mInSubviewClippingLoop;
   private @Nullable View[] mAllChildren;
   private int mAllChildrenCount;
   private @Nullable Rect mClippingRect;
@@ -172,7 +173,7 @@ public class ReactViewGroup extends ViewGroup
   private boolean mNeedsOffscreenAlphaCompositing;
   private @Nullable ViewGroupDrawingOrderHelper mDrawingOrderHelper;
   private float mBackfaceOpacity;
-  private String mBackfaceVisibility;
+  private boolean mBackfaceVisible;
   private @Nullable Set<Integer> mChildrenRemovedWhileTransitioning;
 
   /**
@@ -195,6 +196,7 @@ public class ReactViewGroup extends ViewGroup
     setClipChildren(false);
 
     mRemoveClippedSubviews = false;
+    mInSubviewClippingLoop = false;
     mAllChildren = null;
     mAllChildrenCount = 0;
     mClippingRect = null;
@@ -206,7 +208,7 @@ public class ReactViewGroup extends ViewGroup
     mNeedsOffscreenAlphaCompositing = false;
     mDrawingOrderHelper = null;
     mBackfaceOpacity = 1.f;
-    mBackfaceVisibility = "visible";
+    mBackfaceVisible = true;
     mChildrenRemovedWhileTransitioning = null;
   }
 
@@ -404,6 +406,7 @@ public class ReactViewGroup extends ViewGroup
         View child = getChildAt(i);
         mAllChildren[i] = child;
         child.addOnLayoutChangeListener(mChildrenLayoutChangeListener);
+        setViewClipped(child, false);
       }
       updateClippingRect();
     } else {
@@ -468,11 +471,19 @@ public class ReactViewGroup extends ViewGroup
 
   private void updateClippingToRect(Rect clippingRect) {
     Assertions.assertNotNull(mAllChildren);
+    mInSubviewClippingLoop = true;
     int clippedSoFar = 0;
     for (int i = 0; i < mAllChildrenCount; i++) {
       try {
         updateSubviewClipStatus(clippingRect, i, clippedSoFar);
       } catch (IndexOutOfBoundsException e) {
+        int realClippedSoFar = 0;
+        Set<View> uniqueViews = new HashSet<>();
+        for (int j = 0; j < i; j++) {
+          realClippedSoFar += isViewClipped(mAllChildren[j], null) ? 1 : 0;
+          uniqueViews.add(mAllChildren[j]);
+        }
+
         throw new IllegalStateException(
             "Invalid clipping state. i="
                 + i
@@ -483,13 +494,18 @@ public class ReactViewGroup extends ViewGroup
                 + " allChildrenCount="
                 + mAllChildrenCount
                 + " recycleCount="
-                + mRecycleCount,
+                + mRecycleCount
+                + " realClippedSoFar="
+                + realClippedSoFar
+                + " uniqueViewsCount="
+                + uniqueViews.size(),
             e);
       }
-      if (isViewClipped(mAllChildren[i])) {
+      if (isViewClipped(mAllChildren[i], i)) {
         clippedSoFar++;
       }
     }
+    mInSubviewClippingLoop = false;
   }
 
   private void updateSubviewClipStatus(Rect clippingRect, int idx, int clippedSoFar) {
@@ -508,14 +524,18 @@ public class ReactViewGroup extends ViewGroup
     // it won't be size and located properly.
     Animation animation = child.getAnimation();
     boolean isAnimating = animation != null && !animation.hasEnded();
-    if (!intersects && !isViewClipped(child) && !isAnimating) {
+    if (!intersects && !isViewClipped(child, idx) && !isAnimating) {
+      setViewClipped(child, true);
       recoverFocus(child);
       // We can try saving on invalidate call here as the view that we remove is out of visible area
       // therefore invalidation is not necessary.
       removeViewInLayout(child);
       needUpdateClippingRecursive = true;
-    } else if (intersects && isViewClipped(child)) {
-      addViewInLayout(child, idx - clippedSoFar, sDefaultLayoutParam, true);
+    } else if (intersects && isViewClipped(child, idx)) {
+      int adjustedIdx = idx - clippedSoFar;
+      Assertions.assertCondition(adjustedIdx >= 0);
+      setViewClipped(child, false);
+      addViewInLayout(child, adjustedIdx, sDefaultLayoutParam, true);
       invalidate();
       needUpdateClippingRecursive = true;
     } else if (intersects) {
@@ -546,19 +566,21 @@ public class ReactViewGroup extends ViewGroup
             subview.getLeft(), subview.getTop(), subview.getRight(), subview.getBottom());
 
     // If it was intersecting before, should be attached to the parent
-    boolean oldIntersects = !isViewClipped(subview);
+    boolean oldIntersects = !isViewClipped(subview, null);
 
     if (intersects != oldIntersects) {
+      mInSubviewClippingLoop = true;
       int clippedSoFar = 0;
       for (int i = 0; i < mAllChildrenCount; i++) {
         if (mAllChildren[i] == subview) {
           updateSubviewClipStatus(mClippingRect, i, clippedSoFar);
           break;
         }
-        if (isViewClipped(mAllChildren[i])) {
+        if (isViewClipped(mAllChildren[i], i)) {
           clippedSoFar++;
         }
       }
+      mInSubviewClippingLoop = false;
     }
   }
 
@@ -673,7 +695,7 @@ public class ReactViewGroup extends ViewGroup
   @Override
   public void onViewAdded(View child) {
     UiThreadUtil.assertOnUiThread();
-
+    checkViewClippingTag(child, Boolean.FALSE);
     if (!customDrawOrderDisabled()) {
       getDrawingOrderHelper().handleAddView(child);
       setChildrenDrawingOrderEnabled(getDrawingOrderHelper().shouldEnableCustomDrawingOrder());
@@ -686,7 +708,7 @@ public class ReactViewGroup extends ViewGroup
   @Override
   public void onViewRemoved(View child) {
     UiThreadUtil.assertOnUiThread();
-
+    checkViewClippingTag(child, Boolean.TRUE);
     if (!customDrawOrderDisabled()) {
       if (indexOfChild(child) == -1) {
         return;
@@ -705,6 +727,21 @@ public class ReactViewGroup extends ViewGroup
     super.onViewRemoved(child);
   }
 
+  private void checkViewClippingTag(View child, Boolean expectedTag) {
+    if (mInSubviewClippingLoop) {
+      Object tag = child.getTag(R.id.view_clipped);
+      if (!expectedTag.equals(tag)) {
+        ReactSoftExceptionLogger.logSoftException(
+            ReactSoftExceptionLogger.Categories.RVG_ON_VIEW_REMOVED,
+            new ReactNoCrashSoftException(
+                "View clipping tag mismatch: tag=" + tag + " expected=" + expectedTag));
+      }
+    }
+    if (mRemoveClippedSubviews) {
+      child.setTag(R.id.view_clipped, expectedTag);
+    }
+  }
+
   @Override
   protected int getChildDrawingOrder(int childCount, int index) {
     UiThreadUtil.assertOnUiThread();
@@ -776,19 +813,22 @@ public class ReactViewGroup extends ViewGroup
   /*package*/ void addViewWithSubviewClippingEnabled(
       final View child, int index, ViewGroup.LayoutParams params) {
     Assertions.assertCondition(mRemoveClippedSubviews);
+    setViewClipped(child, true); // the view has not been added, so it is "clipped"
     addInArray(child, index);
 
     // we add view as "clipped" and then run {@link #updateSubviewClipStatus} to conditionally
     // attach it
     Rect clippingRect = Assertions.assertNotNull(mClippingRect);
     View[] childArray = Assertions.assertNotNull(mAllChildren);
+    mInSubviewClippingLoop = true;
     int clippedSoFar = 0;
     for (int i = 0; i < index; i++) {
-      if (isViewClipped(childArray[i])) {
+      if (isViewClipped(childArray[i], i)) {
         clippedSoFar++;
       }
     }
     updateSubviewClipStatus(clippingRect, index, clippedSoFar);
+    mInSubviewClippingLoop = false;
     child.addOnLayoutChangeListener(mChildrenLayoutChangeListener);
 
     if (child instanceof ReactClippingProhibitedView) {
@@ -823,10 +863,10 @@ public class ReactViewGroup extends ViewGroup
     View[] childArray = Assertions.assertNotNull(mAllChildren);
     view.removeOnLayoutChangeListener(mChildrenLayoutChangeListener);
     int index = indexOfChildInAllChildren(view);
-    if (!isViewClipped(childArray[index])) {
+    if (!isViewClipped(childArray[index], index)) {
       int clippedSoFar = 0;
       for (int i = 0; i < index; i++) {
-        if (isViewClipped(childArray[i])) {
+        if (isViewClipped(childArray[i], i)) {
           clippedSoFar++;
         }
       }
@@ -848,9 +888,40 @@ public class ReactViewGroup extends ViewGroup
 
   /**
    * @return {@code true} if the view has been removed from the ViewGroup.
+   * @param index For logging - index of the view in {@code mAllChildren}, or {@code null} to skip
+   *     logging.
    */
-  private boolean isViewClipped(View view) {
-    return view.getParent() == null;
+  private boolean isViewClipped(View view, @Nullable Integer index) {
+    Object tag = view.getTag(R.id.view_clipped);
+    if (tag != null) {
+      return (boolean) tag;
+    }
+    ViewParent parent = view.getParent();
+    boolean transitioning = isChildRemovedWhileTransitioning(view);
+    if (index != null) {
+      ReactSoftExceptionLogger.logSoftException(
+          ReactSoftExceptionLogger.Categories.RVG_IS_VIEW_CLIPPED,
+          new ReactNoCrashSoftException(
+              "View missing clipping tag: index="
+                  + index
+                  + " parentNull="
+                  + (parent == null)
+                  + " parentThis="
+                  + (parent == this)
+                  + " transitioning="
+                  + transitioning));
+    }
+    // fallback - should be transitioning or have no parent if the view was removed
+    if (parent == null || transitioning) {
+      return true;
+    } else {
+      Assertions.assertCondition(parent == this);
+      return false;
+    }
+  }
+
+  private static void setViewClipped(View view, boolean clipped) {
+    view.setTag(R.id.view_clipped, clipped);
   }
 
   private int indexOfChildInAllChildren(View child) {
@@ -1007,6 +1078,7 @@ public class ReactViewGroup extends ViewGroup
 
     BlendMode mixBlendMode = null;
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q
+        && ViewUtil.getUIManagerType(this) == UIManagerType.FABRIC
         && BlendModeHelper.needsIsolatedLayer(this)) {
       mixBlendMode = (BlendMode) child.getTag(R.id.mix_blend_mode);
       if (mixBlendMode != null) {
@@ -1040,14 +1112,12 @@ public class ReactViewGroup extends ViewGroup
   }
 
   public void setBackfaceVisibility(String backfaceVisibility) {
-    mBackfaceVisibility = backfaceVisibility;
+    mBackfaceVisible = "visible".equals(backfaceVisibility);
     setBackfaceVisibilityDependantOpacity();
   }
 
   public void setBackfaceVisibilityDependantOpacity() {
-    boolean isBackfaceVisible = mBackfaceVisibility.equals("visible");
-
-    if (isBackfaceVisible) {
+    if (mBackfaceVisible) {
       setAlpha(mBackfaceOpacity);
       return;
     }

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

@@ -271,7 +271,7 @@ public open class ReactViewManager : ReactClippingViewManager<ReactViewGroup>()
 
   @ReactProp(name = ViewProps.POINTER_EVENTS)
   public open fun setPointerEvents(view: ReactViewGroup, pointerEventsStr: String?) {
-    view.pointerEvents = PointerEvents.parsePointerEvents(pointerEventsStr)
+    view.setPointerEvents(PointerEvents.parsePointerEvents(pointerEventsStr))
   }
 
   @ReactProp(name = "nativeBackgroundAndroid")
@@ -367,7 +367,7 @@ public open class ReactViewManager : ReactClippingViewManager<ReactViewGroup>()
 
   @ReactProp(name = ViewProps.OVERFLOW)
   public open fun setOverflow(view: ReactViewGroup, overflow: String?) {
-    view.overflow = overflow
+    view.setOverflow(overflow)
   }
 
   @ReactProp(name = "backfaceVisibility")

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

@@ -74,6 +74,9 @@ public class YogaNative {
   static native void jni_YGNodeStyleSetFlexBasisJNI(long nativePointer, float flexBasis);
   static native void jni_YGNodeStyleSetFlexBasisPercentJNI(long nativePointer, float percent);
   static native void jni_YGNodeStyleSetFlexBasisAutoJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetFlexBasisMaxContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetFlexBasisFitContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetFlexBasisStretchJNI(long nativePointer);
   static native long jni_YGNodeStyleGetMarginJNI(long nativePointer, int edge);
   static native void jni_YGNodeStyleSetMarginJNI(long nativePointer, int edge, float margin);
   static native void jni_YGNodeStyleSetMarginPercentJNI(long nativePointer, int edge, float percent);
@@ -91,25 +94,43 @@ public class YogaNative {
   static native void jni_YGNodeStyleSetWidthJNI(long nativePointer, float width);
   static native void jni_YGNodeStyleSetWidthPercentJNI(long nativePointer, float percent);
   static native void jni_YGNodeStyleSetWidthAutoJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetWidthMaxContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetWidthFitContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetWidthStretchJNI(long nativePointer);
   static native long jni_YGNodeStyleGetHeightJNI(long nativePointer);
   static native void jni_YGNodeStyleSetHeightJNI(long nativePointer, float height);
   static native void jni_YGNodeStyleSetHeightPercentJNI(long nativePointer, float percent);
   static native void jni_YGNodeStyleSetHeightAutoJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetHeightMaxContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetHeightFitContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetHeightStretchJNI(long nativePointer);
   static native long jni_YGNodeStyleGetMinWidthJNI(long nativePointer);
   static native void jni_YGNodeStyleSetMinWidthJNI(long nativePointer, float minWidth);
   static native void jni_YGNodeStyleSetMinWidthPercentJNI(long nativePointer, float percent);
+  static native void jni_YGNodeStyleSetMinWidthMaxContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetMinWidthFitContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetMinWidthStretchJNI(long nativePointer);
   static native long jni_YGNodeStyleGetMinHeightJNI(long nativePointer);
   static native void jni_YGNodeStyleSetMinHeightJNI(long nativePointer, float minHeight);
   static native void jni_YGNodeStyleSetMinHeightPercentJNI(long nativePointer, float percent);
+  static native void jni_YGNodeStyleSetMinHeightMaxContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetMinHeightFitContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetMinHeightStretchJNI(long nativePointer);
   static native long jni_YGNodeStyleGetMaxWidthJNI(long nativePointer);
   static native void jni_YGNodeStyleSetMaxWidthJNI(long nativePointer, float maxWidth);
   static native void jni_YGNodeStyleSetMaxWidthPercentJNI(long nativePointer, float percent);
+  static native void jni_YGNodeStyleSetMaxWidthMaxContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetMaxWidthFitContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetMaxWidthStretchJNI(long nativePointer);
   static native long jni_YGNodeStyleGetMaxHeightJNI(long nativePointer);
   static native void jni_YGNodeStyleSetMaxHeightJNI(long nativePointer, float maxheight);
   static native void jni_YGNodeStyleSetMaxHeightPercentJNI(long nativePointer, float percent);
+  static native void jni_YGNodeStyleSetMaxHeightMaxContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetMaxHeightFitContentJNI(long nativePointer);
+  static native void jni_YGNodeStyleSetMaxHeightStretchJNI(long nativePointer);
   static native float jni_YGNodeStyleGetAspectRatioJNI(long nativePointer);
   static native void jni_YGNodeStyleSetAspectRatioJNI(long nativePointer, float aspectRatio);
-  static native float jni_YGNodeStyleGetGapJNI(long nativePointer, int gutter);
+  static native long jni_YGNodeStyleGetGapJNI(long nativePointer, int gutter);
   static native void jni_YGNodeStyleSetGapJNI(long nativePointer, int gutter, float gapLength);
   static native void jni_YGNodeStyleSetGapPercentJNI(long nativePointer, int gutter, float gapLength);
   static native void jni_YGNodeSetHasMeasureFuncJNI(long nativePointer, boolean hasMeasureFunc);

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

@@ -124,6 +124,12 @@ public abstract class YogaNode implements YogaProps {
 
   public abstract void setFlexBasisAuto();
 
+  public abstract void setFlexBasisMaxContent();
+
+  public abstract void setFlexBasisFitContent();
+
+  public abstract void setFlexBasisStretch();
+
   public abstract YogaValue getMargin(YogaEdge edge);
 
   public abstract void setMargin(YogaEdge edge, float margin);
@@ -158,6 +164,12 @@ public abstract class YogaNode implements YogaProps {
 
   public abstract void setWidthAuto();
 
+  public abstract void setWidthMaxContent();
+
+  public abstract void setWidthFitContent();
+
+  public abstract void setWidthStretch();
+
   public abstract YogaValue getHeight();
 
   public abstract void setHeight(float height);
@@ -166,35 +178,65 @@ public abstract class YogaNode implements YogaProps {
 
   public abstract void setHeightAuto();
 
+  public abstract void setHeightMaxContent();
+
+  public abstract void setHeightFitContent();
+
+  public abstract void setHeightStretch();
+
   public abstract YogaValue getMinWidth();
 
   public abstract void setMinWidth(float minWidth);
 
   public abstract void setMinWidthPercent(float percent);
 
+  public abstract void setMinWidthMaxContent();
+
+  public abstract void setMinWidthFitContent();
+
+  public abstract void setMinWidthStretch();
+
   public abstract YogaValue getMinHeight();
 
   public abstract void setMinHeight(float minHeight);
 
   public abstract void setMinHeightPercent(float percent);
 
+  public abstract void setMinHeightMaxContent();
+
+  public abstract void setMinHeightFitContent();
+
+  public abstract void setMinHeightStretch();
+
   public abstract YogaValue getMaxWidth();
 
   public abstract void setMaxWidth(float maxWidth);
 
   public abstract void setMaxWidthPercent(float percent);
 
+  public abstract void setMaxWidthMaxContent();
+
+  public abstract void setMaxWidthFitContent();
+
+  public abstract void setMaxWidthStretch();
+
   public abstract YogaValue getMaxHeight();
 
   public abstract void setMaxHeight(float maxheight);
 
   public abstract void setMaxHeightPercent(float percent);
 
+  public abstract void setMaxHeightMaxContent();
+
+  public abstract void setMaxHeightFitContent();
+
+  public abstract void setMaxHeightStretch();
+
   public abstract float getAspectRatio();
 
   public abstract void setAspectRatio(float aspectRatio);
 
-  public abstract float getGap(YogaGutter gutter);
+  public abstract YogaValue getGap(YogaGutter gutter);
 
   public abstract void setGap(YogaGutter gutter, float gapLength);
 

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

@@ -373,6 +373,18 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
     YogaNative.jni_YGNodeStyleSetFlexBasisAutoJNI(mNativePointer);
   }
 
+  public void setFlexBasisMaxContent() {
+    YogaNative.jni_YGNodeStyleSetFlexBasisMaxContentJNI(mNativePointer);
+  }
+
+  public void setFlexBasisFitContent() {
+    YogaNative.jni_YGNodeStyleSetFlexBasisFitContentJNI(mNativePointer);
+  }
+
+  public void setFlexBasisStretch() {
+    YogaNative.jni_YGNodeStyleSetFlexBasisStretchJNI(mNativePointer);
+  }
+
   public YogaValue getMargin(YogaEdge edge) {
     return valueFromLong(YogaNative.jni_YGNodeStyleGetMarginJNI(mNativePointer, edge.intValue()));
   }
@@ -441,6 +453,18 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
     YogaNative.jni_YGNodeStyleSetWidthAutoJNI(mNativePointer);
   }
 
+  public void setWidthMaxContent() {
+    YogaNative.jni_YGNodeStyleSetWidthMaxContentJNI(mNativePointer);
+  }
+
+  public void setWidthFitContent() {
+    YogaNative.jni_YGNodeStyleSetWidthFitContentJNI(mNativePointer);
+  }
+
+  public void setWidthStretch() {
+    YogaNative.jni_YGNodeStyleSetWidthStretchJNI(mNativePointer);
+  }
+
   public YogaValue getHeight() {
     return valueFromLong(YogaNative.jni_YGNodeStyleGetHeightJNI(mNativePointer));
   }
@@ -457,6 +481,18 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
     YogaNative.jni_YGNodeStyleSetHeightAutoJNI(mNativePointer);
   }
 
+  public void setHeightMaxContent() {
+    YogaNative.jni_YGNodeStyleSetHeightMaxContentJNI(mNativePointer);
+  }
+
+  public void setHeightFitContent() {
+    YogaNative.jni_YGNodeStyleSetHeightFitContentJNI(mNativePointer);
+  }
+
+  public void setHeightStretch() {
+    YogaNative.jni_YGNodeStyleSetHeightStretchJNI(mNativePointer);
+  }
+
   public YogaValue getMinWidth() {
     return valueFromLong(YogaNative.jni_YGNodeStyleGetMinWidthJNI(mNativePointer));
   }
@@ -469,6 +505,18 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
     YogaNative.jni_YGNodeStyleSetMinWidthPercentJNI(mNativePointer, percent);
   }
 
+  public void setMinWidthMaxContent() {
+    YogaNative.jni_YGNodeStyleSetMinWidthMaxContentJNI(mNativePointer);
+  }
+
+  public void setMinWidthFitContent() {
+    YogaNative.jni_YGNodeStyleSetMinWidthFitContentJNI(mNativePointer);
+  }
+
+  public void setMinWidthStretch() {
+    YogaNative.jni_YGNodeStyleSetMinWidthStretchJNI(mNativePointer);
+  }
+
   public YogaValue getMinHeight() {
     return valueFromLong(YogaNative.jni_YGNodeStyleGetMinHeightJNI(mNativePointer));
   }
@@ -481,6 +529,18 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
     YogaNative.jni_YGNodeStyleSetMinHeightPercentJNI(mNativePointer, percent);
   }
 
+  public void setMinHeightMaxContent() {
+    YogaNative.jni_YGNodeStyleSetMinHeightMaxContentJNI(mNativePointer);
+  }
+
+  public void setMinHeightFitContent() {
+    YogaNative.jni_YGNodeStyleSetMinHeightFitContentJNI(mNativePointer);
+  }
+
+  public void setMinHeightStretch() {
+    YogaNative.jni_YGNodeStyleSetMinHeightStretchJNI(mNativePointer);
+  }
+
   public YogaValue getMaxWidth() {
     return valueFromLong(YogaNative.jni_YGNodeStyleGetMaxWidthJNI(mNativePointer));
   }
@@ -493,6 +553,18 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
     YogaNative.jni_YGNodeStyleSetMaxWidthPercentJNI(mNativePointer, percent);
   }
 
+  public void setMaxWidthMaxContent() {
+    YogaNative.jni_YGNodeStyleSetMaxWidthMaxContentJNI(mNativePointer);
+  }
+
+  public void setMaxWidthFitContent() {
+    YogaNative.jni_YGNodeStyleSetMaxWidthFitContentJNI(mNativePointer);
+  }
+
+  public void setMaxWidthStretch() {
+    YogaNative.jni_YGNodeStyleSetMaxWidthStretchJNI(mNativePointer);
+  }
+
   public YogaValue getMaxHeight() {
     return valueFromLong(YogaNative.jni_YGNodeStyleGetMaxHeightJNI(mNativePointer));
   }
@@ -505,6 +577,18 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
     YogaNative.jni_YGNodeStyleSetMaxHeightPercentJNI(mNativePointer, percent);
   }
 
+  public void setMaxHeightMaxContent() {
+    YogaNative.jni_YGNodeStyleSetMaxHeightMaxContentJNI(mNativePointer);
+  }
+
+  public void setMaxHeightFitContent() {
+    YogaNative.jni_YGNodeStyleSetMaxHeightFitContentJNI(mNativePointer);
+  }
+
+  public void setMaxHeightStretch() {
+    YogaNative.jni_YGNodeStyleSetMaxHeightStretchJNI(mNativePointer);
+  }
+
   public float getAspectRatio() {
     return YogaNative.jni_YGNodeStyleGetAspectRatioJNI(mNativePointer);
   }
@@ -727,8 +811,8 @@ public abstract class YogaNodeJNIBase extends YogaNode implements Cloneable {
   }
 
   @Override
-  public float getGap(YogaGutter gutter) {
-    return YogaNative.jni_YGNodeStyleGetGapJNI(mNativePointer, gutter.intValue());
+  public YogaValue getGap(YogaGutter gutter) {
+    return valueFromLong(YogaNative.jni_YGNodeStyleGetGapJNI(mNativePointer, gutter.intValue()));
   }
 
   @Override

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

@@ -15,15 +15,33 @@ public interface YogaProps {
 
   void setWidthPercent(float percent);
 
+  void setWidthAuto();
+
+  void setWidthMaxContent();
+
+  void setWidthFitContent();
+
+  void setWidthStretch();
+
   void setMinWidth(float minWidth);
 
   void setMinWidthPercent(float percent);
 
+  void setMinWidthMaxContent();
+
+  void setMinWidthFitContent();
+
+  void setMinWidthStretch();
+
   void setMaxWidth(float maxWidth);
 
   void setMaxWidthPercent(float percent);
 
-  void setWidthAuto();
+  void setMaxWidthMaxContent();
+
+  void setMaxWidthFitContent();
+
+  void setMaxWidthStretch();
 
   /* Height properties */
 
@@ -31,15 +49,33 @@ public interface YogaProps {
 
   void setHeightPercent(float percent);
 
+  void setHeightAuto();
+
+  void setHeightMaxContent();
+
+  void setHeightFitContent();
+
+  void setHeightStretch();
+
   void setMinHeight(float minHeight);
 
   void setMinHeightPercent(float percent);
 
+  void setMinHeightMaxContent();
+
+  void setMinHeightFitContent();
+
+  void setMinHeightStretch();
+
   void setMaxHeight(float maxHeight);
 
   void setMaxHeightPercent(float percent);
 
-  void setHeightAuto();
+  void setMaxHeightMaxContent();
+
+  void setMaxHeightFitContent();
+
+  void setMaxHeightStretch();
 
   /* Margin properties */
 
@@ -81,6 +117,12 @@ public interface YogaProps {
 
   void setFlexBasis(float flexBasis);
 
+  void setFlexBasisMaxContent();
+
+  void setFlexBasisFitContent();
+
+  void setFlexBasisStretch();
+
   void setFlexDirection(YogaFlexDirection direction);
 
   void setFlexGrow(float flexGrow);

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

@@ -13,7 +13,10 @@ public enum YogaUnit {
   UNDEFINED(0),
   POINT(1),
   PERCENT(2),
-  AUTO(3);
+  AUTO(3),
+  MAX_CONTENT(4),
+  FIT_CONTENT(5),
+  STRETCH(6);
 
   private final int mIntValue;
 
@@ -31,6 +34,9 @@ public enum YogaUnit {
       case 1: return POINT;
       case 2: return PERCENT;
       case 3: return AUTO;
+      case 4: return MAX_CONTENT;
+      case 5: return FIT_CONTENT;
+      case 6: return STRETCH;
       default: throw new IllegalArgumentException("Unknown enum value: " + value);
     }
   }