YogaNode.setNodeType selects a measured node's pixel rounding (#2046)

Summary:
Pull Request resolved: #2046

X-link: meta/litho#1093

**In one sentence.** A Java `YogaNode` with a measure function can now select Yoga's default pixel rounding, through a new `setNodeType` and its JNI binding to Yoga's existing `YGNodeSetNodeType`.

## Why this is needed

Installing a measure function makes a Yoga node a text node, which is rounded to the pixel grid as text: its fractional size is rounded up, and its position down, so its content is not truncated. A container measured through a callback should round as a container does, each edge to the nearest pixel. The C API can select that (`YGNodeSetNodeType`); the Java binding could not.
- Measured: of three nodes flexed to a third of a 100 wide row each, the first, given a measure function, ends at 33.33 and comes out 34 wide; without one, 33.

## What this diff does

**`YogaNode.setNodeType(nodeType)`,** a new public open method that does nothing by default, so a `YogaNode` subclass built against an earlier class does not fail with `AbstractMethodError`. `YogaNodeJNIBase` overrides it through a new native method, `YogaNative.jni_YGNodeSetNodeTypeJNI`, which `YGJNIVanilla.cpp` registers and implements with `YGNodeSetNodeType`. `setMeasureFunction` still sets the type (text for a function, default for null), so a caller selects the type after it.

## What a Yoga user sees

**A new public Yoga API.**

**The Java and native halves must ship together.** `registerNatives` is strict: a Java class declaring `jni_YGNodeSetNodeTypeJNI` with a native library that lacks it, or the reverse, fails when the class registers.

Changelog:
[Android][Added] - Add `YogaNode.setNodeType` to select pixel rounding for measured nodes

Reviewed By: christophpurrer

Differential Revision: D125292521

Author: pentiumao

java/com/facebook/yoga/YogaNative.kt

@@ -311,6 +311,8 @@ public object YogaNative {
   @JvmStatic
   public external fun jni_YGNodeSetHasMeasureFuncJNI(nativePointer: Long, hasMeasureFunc: Boolean)
 
+  @JvmStatic public external fun jni_YGNodeSetNodeTypeJNI(nativePointer: Long, nodeType: Int)
+
   @JvmStatic
   public external fun jni_YGNodeSetHasMinContentMeasureFuncJNI(
       nativePointer: Long,

java/com/facebook/yoga/YogaNode.kt

@@ -228,6 +228,17 @@ public abstract class YogaNode : YogaProps {
 
   abstract override fun setMeasureFunction(measureFunction: YogaMeasureFunction?)
 
+  /**
+   * Sets the node type, which selects how layout is rounded to the pixel grid: a
+   * [YogaNodeType.TEXT] node's fractional size is rounded up and its position down, so its content
+   * is not truncated. [setMeasureFunction] sets it ([YogaNodeType.TEXT] for a function,
+   * [YogaNodeType.DEFAULT] for null), so call this after it.
+   *
+   * Does nothing by default, so a subclass built against an earlier [YogaNode] keeps working, with
+   * the rounding [setMeasureFunction] selected.
+   */
+  public open fun setNodeType(nodeType: YogaNodeType) {}
+
   abstract override fun setMinContentMeasureFunction(measureFunction: YogaMeasureFunction?)
 
   abstract override fun setMinContentWidth(minContentWidth: Float)

java/com/facebook/yoga/YogaNodeJNIBase.kt

@@ -526,6 +526,10 @@ public abstract class YogaNodeJNIBase : YogaNode, Cloneable {
     YogaNative.jni_YGNodeSetHasMeasureFuncJNI(nativePointer, measureFunction != null)
   }
 
+  override fun setNodeType(nodeType: YogaNodeType) {
+    YogaNative.jni_YGNodeSetNodeTypeJNI(nativePointer, nodeType.intValue())
+  }
+
   override fun setMinContentMeasureFunction(measureFunction: YogaMeasureFunction?) {
     this.minContentMeasureFunction = measureFunction
     YogaNative.jni_YGNodeSetHasMinContentMeasureFuncJNI(nativePointer, measureFunction != null)

java/jni/YGJNIVanilla.cpp

@@ -685,6 +685,15 @@ static void jni_YGNodeSetHasMeasureFuncJNI(
       static_cast<bool>(hasMeasureFunc) ? YGJNIMeasureFunc : nullptr);
 }
 
+static void jni_YGNodeSetNodeTypeJNI(
+    JNIEnv* /*env*/,
+    jobject /*obj*/,
+    jlong nativePointer,
+    jint nodeType) {
+  YGNodeSetNodeType(
+      _jlong2YGNodeRef(nativePointer), static_cast<YGNodeType>(nodeType));
+}
+
 static YGSize YGJNIMinContentMeasureFunc(
     YGNodeConstRef node,
     float width,
@@ -1139,6 +1148,7 @@ static JNINativeMethod methods[] = {
      "(JZ)V",
      (void*)jni_YGNodeSetHasMeasureFuncJNI},
     // NOLINTBEGIN(cppcoreguidelines-pro-type-cstyle-cast)
+    {"jni_YGNodeSetNodeTypeJNI", "(JI)V", (void*)jni_YGNodeSetNodeTypeJNI},
     {"jni_YGNodeSetHasMinContentMeasureFuncJNI",
      "(JZ)V",
      (void*)jni_YGNodeSetHasMinContentMeasureFuncJNI},

java/tests/com/facebook/yoga/YogaNodeTest.kt

@@ -313,6 +313,58 @@ class YogaNodeTest {
     assertNull(node.data)
   }
 
+  @Test
+  fun testMeasuredNodeRoundsAsText() {
+    assertEquals(34, firstThirdWidth { it.setMeasureFunction(fillsWidth) })
+  }
+
+  @Test
+  fun testSetNodeTypeDefaultRoundsMeasuredNodeToNearest() {
+    assertEquals(
+        33,
+        firstThirdWidth {
+          it.setMeasureFunction(fillsWidth)
+          it.setNodeType(YogaNodeType.DEFAULT)
+        },
+    )
+  }
+
+  @Test
+  fun testSetMeasureFunctionResetsNodeTypeToText() {
+    assertEquals(
+        34,
+        firstThirdWidth {
+          it.setMeasureFunction(fillsWidth)
+          it.setNodeType(YogaNodeType.DEFAULT)
+          it.setMeasureFunction(fillsWidth)
+        },
+    )
+  }
+
+  /** No width of its own, so flexing gives it its third. */
+  private val fillsWidth = YogaMeasureFunction { _, _, _, _, _ -> YogaMeasureOutput.make(0f, 10f) }
+
+  /**
+   * The rounded width of the first of three nodes flexed to a third of a 100 wide row each, set up
+   * by [configure]: its right edge is at 33.33, which text rounding takes up to 34.
+   */
+  private fun firstThirdWidth(configure: (YogaNode) -> Unit): Int {
+    val root = createNode()
+    root.flexDirection = YogaFlexDirection.ROW
+    root.setWidth(100f)
+    root.setHeight(10f)
+    for (i in 0 until 3) {
+      val child = createNode()
+      child.flexGrow = 1f
+      if (i == 0) {
+        configure(child)
+      }
+      root.addChildAt(child, i)
+    }
+    root.calculateLayout(YogaConstants.UNDEFINED, YogaConstants.UNDEFINED)
+    return root.getChildAt(0).layoutWidth.toInt()
+  }
+
   private fun createNode(): YogaNode = mNodeFactory.create()
 
   private fun createNode(config: YogaConfig): YogaNode = mNodeFactory.create(config)