Rename directories

Reviewed By: gkassabli

Differential Revision: D4284681

Summary: Rename csslayout directories to yoga

fbshipit-source-id: f0c6855c2c6e4389b7867f48f72cbb697830fc5a

java/com/facebook/yoga/YogaAlign.java

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.yoga;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+
+@DoNotStrip
+public enum YogaAlign {
+  AUTO(0),
+  FLEX_START(1),
+  CENTER(2),
+  FLEX_END(3),
+  STRETCH(4);
+
+  private int mIntValue;
+
+  YogaAlign(int intValue) {
+    mIntValue = intValue;
+  }
+
+  public int intValue() {
+    return mIntValue;
+  }
+
+  public static YogaAlign fromInt(int value) {
+    switch (value) {
+      case 0: return AUTO;
+      case 1: return FLEX_START;
+      case 2: return CENTER;
+      case 3: return FLEX_END;
+      case 4: return STRETCH;
+      default: throw new IllegalArgumentException("Unkown enum value: " + value);
+    }
+  }
+}

java/com/facebook/yoga/YogaConstants.java

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.yoga;
+
+public class YogaConstants {
+
+  public static final float UNDEFINED = Float.NaN;
+
+  public static boolean isUndefined(float value) {
+    return Float.compare(value, UNDEFINED) == 0;
+  }
+}

java/com/facebook/yoga/YogaDimension.java

@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.yoga;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+
+@DoNotStrip
+public enum YogaDimension {
+  WIDTH(0),
+  HEIGHT(1);
+
+  private int mIntValue;
+
+  YogaDimension(int intValue) {
+    mIntValue = intValue;
+  }
+
+  public int intValue() {
+    return mIntValue;
+  }
+
+  public static YogaDimension fromInt(int value) {
+    switch (value) {
+      case 0: return WIDTH;
+      case 1: return HEIGHT;
+      default: throw new IllegalArgumentException("Unkown enum value: " + value);
+    }
+  }
+}

java/com/facebook/yoga/YogaDirection.java

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.yoga;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+
+@DoNotStrip
+public enum YogaDirection {
+  INHERIT(0),
+  LTR(1),
+  RTL(2);
+
+  private int mIntValue;
+
+  YogaDirection(int intValue) {
+    mIntValue = intValue;
+  }
+
+  public int intValue() {
+    return mIntValue;
+  }
+
+  public static YogaDirection fromInt(int value) {
+    switch (value) {
+      case 0: return INHERIT;
+      case 1: return LTR;
+      case 2: return RTL;
+      default: throw new IllegalArgumentException("Unkown enum value: " + value);
+    }
+  }
+}

java/com/facebook/yoga/YogaEdge.java

@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.yoga;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+
+@DoNotStrip
+public enum YogaEdge {
+  LEFT(0),
+  TOP(1),
+  RIGHT(2),
+  BOTTOM(3),
+  START(4),
+  END(5),
+  HORIZONTAL(6),
+  VERTICAL(7),
+  ALL(8);
+
+  private int mIntValue;
+
+  YogaEdge(int intValue) {
+    mIntValue = intValue;
+  }
+
+  public int intValue() {
+    return mIntValue;
+  }
+
+  public static YogaEdge fromInt(int value) {
+    switch (value) {
+      case 0: return LEFT;
+      case 1: return TOP;
+      case 2: return RIGHT;
+      case 3: return BOTTOM;
+      case 4: return START;
+      case 5: return END;
+      case 6: return HORIZONTAL;
+      case 7: return VERTICAL;
+      case 8: return ALL;
+      default: throw new IllegalArgumentException("Unkown enum value: " + value);
+    }
+  }
+}

java/com/facebook/yoga/YogaExperimentalFeature.java

@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.yoga;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+
+@DoNotStrip
+public enum YogaExperimentalFeature {
+  ROUNDING(0),
+  WEB_FLEX_BASIS(1);
+
+  private int mIntValue;
+
+  YogaExperimentalFeature(int intValue) {
+    mIntValue = intValue;
+  }
+
+  public int intValue() {
+    return mIntValue;
+  }
+
+  public static YogaExperimentalFeature fromInt(int value) {
+    switch (value) {
+      case 0: return ROUNDING;
+      case 1: return WEB_FLEX_BASIS;
+      default: throw new IllegalArgumentException("Unkown enum value: " + value);
+    }
+  }
+}

java/com/facebook/yoga/YogaFlexDirection.java

@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.yoga;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+
+@DoNotStrip
+public enum YogaFlexDirection {
+  COLUMN(0),
+  COLUMN_REVERSE(1),
+  ROW(2),
+  ROW_REVERSE(3);
+
+  private int mIntValue;
+
+  YogaFlexDirection(int intValue) {
+    mIntValue = intValue;
+  }
+
+  public int intValue() {
+    return mIntValue;
+  }
+
+  public static YogaFlexDirection fromInt(int value) {
+    switch (value) {
+      case 0: return COLUMN;
+      case 1: return COLUMN_REVERSE;
+      case 2: return ROW;
+      case 3: return ROW_REVERSE;
+      default: throw new IllegalArgumentException("Unkown enum value: " + value);
+    }
+  }
+}

java/com/facebook/yoga/YogaJustify.java

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.yoga;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+
+@DoNotStrip
+public enum YogaJustify {
+  FLEX_START(0),
+  CENTER(1),
+  FLEX_END(2),
+  SPACE_BETWEEN(3),
+  SPACE_AROUND(4);
+
+  private int mIntValue;
+
+  YogaJustify(int intValue) {
+    mIntValue = intValue;
+  }
+
+  public int intValue() {
+    return mIntValue;
+  }
+
+  public static YogaJustify fromInt(int value) {
+    switch (value) {
+      case 0: return FLEX_START;
+      case 1: return CENTER;
+      case 2: return FLEX_END;
+      case 3: return SPACE_BETWEEN;
+      case 4: return SPACE_AROUND;
+      default: throw new IllegalArgumentException("Unkown enum value: " + value);
+    }
+  }
+}

java/com/facebook/yoga/YogaLogLevel.java

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.yoga;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+
+@DoNotStrip
+public enum YogaLogLevel {
+  ERROR(0),
+  WARN(1),
+  INFO(2),
+  DEBUG(3),
+  VERBOSE(4);
+
+  private int mIntValue;
+
+  YogaLogLevel(int intValue) {
+    mIntValue = intValue;
+  }
+
+  public int intValue() {
+    return mIntValue;
+  }
+
+  public static YogaLogLevel fromInt(int value) {
+    switch (value) {
+      case 0: return ERROR;
+      case 1: return WARN;
+      case 2: return INFO;
+      case 3: return DEBUG;
+      case 4: return VERBOSE;
+      default: throw new IllegalArgumentException("Unkown enum value: " + value);
+    }
+  }
+}

java/com/facebook/yoga/YogaLogger.java

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.yoga;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+
+/**
+ * Inteface for recieving logs from native layer. Use by setting YogaNode.setLogger(myLogger);
+ * See YogaLogLevel for the different log levels.
+ */
+@DoNotStrip
+public interface YogaLogger {
+  @DoNotStrip
+  void log(YogaLogLevel level, String message);
+}

java/com/facebook/yoga/YogaMeasureFunction.java

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.yoga;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+
+@DoNotStrip
+public interface YogaMeasureFunction {
+  /**
+   * Return a value created by YogaMeasureOutput.make(width, height);
+   */
+  @DoNotStrip
+  long measure(
+      YogaNodeAPI node,
+      float width,
+      YogaMeasureMode widthMode,
+      float height,
+      YogaMeasureMode heightMode);
+}

java/com/facebook/yoga/YogaMeasureMode.java

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.yoga;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+
+@DoNotStrip
+public enum YogaMeasureMode {
+  UNDEFINED(0),
+  EXACTLY(1),
+  AT_MOST(2);
+
+  private int mIntValue;
+
+  YogaMeasureMode(int intValue) {
+    mIntValue = intValue;
+  }
+
+  public int intValue() {
+    return mIntValue;
+  }
+
+  public static YogaMeasureMode fromInt(int value) {
+    switch (value) {
+      case 0: return UNDEFINED;
+      case 1: return EXACTLY;
+      case 2: return AT_MOST;
+      default: throw new IllegalArgumentException("Unkown enum value: " + value);
+    }
+  }
+}

java/com/facebook/yoga/YogaMeasureOutput.java

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.yoga;
+
+/**
+ * Helpers for building measure output value.
+ */
+public class YogaMeasureOutput {
+
+  public static long make(float width, float height) {
+    return make((int) width, (int) height);
+  }
+
+  public static long make(int width, int height) {
+    return ((long) width) << 32 | ((long) height);
+  }
+
+  public static int getWidth(long measureOutput) {
+    return (int) (0xFFFFFFFF & (measureOutput >> 32));
+  }
+
+  public static int getHeight(long measureOutput) {
+    return (int) (0xFFFFFFFF & measureOutput);
+  }
+}

java/com/facebook/yoga/YogaNode.java

@@ -0,0 +1,549 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.yoga;
+
+import javax.annotation.Nullable;
+
+import java.util.List;
+import java.util.ArrayList;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.soloader.SoLoader;
+
+@DoNotStrip
+public class YogaNode implements YogaNodeAPI<YogaNode> {
+
+  static {
+    SoLoader.loadLibrary("yoga");
+  }
+
+  /**
+   * Get native instance count. Useful for testing only.
+   */
+  static native int jni_YGNodeGetInstanceCount();
+  static native void jni_YGLog(int level, String message);
+
+  private static native void jni_YGSetLogger(Object logger);
+  public static void setLogger(YogaLogger logger) {
+    jni_YGSetLogger(logger);
+  }
+
+  private static native void jni_YGSetExperimentalFeatureEnabled(
+      int feature,
+      boolean enabled);
+  public static void setExperimentalFeatureEnabled(
+      YogaExperimentalFeature feature,
+      boolean enabled) {
+    jni_YGSetExperimentalFeatureEnabled(feature.intValue(), enabled);
+  }
+
+  private static native boolean jni_YGIsExperimentalFeatureEnabled(int feature);
+  public static boolean isExperimentalFeatureEnabled(YogaExperimentalFeature feature) {
+    return jni_YGIsExperimentalFeatureEnabled(feature.intValue());
+  }
+
+  private YogaNode mParent;
+  private List<YogaNode> mChildren;
+  private YogaMeasureFunction mMeasureFunction;
+  private long mNativePointer;
+  private Object mData;
+
+  private boolean mHasSetPadding = false;
+  private boolean mHasSetMargin = false;
+  private boolean mHasSetBorder = false;
+  private boolean mHasSetPosition = false;
+
+  @DoNotStrip
+  private float mWidth = YogaConstants.UNDEFINED;
+  @DoNotStrip
+  private float mHeight = YogaConstants.UNDEFINED;
+  @DoNotStrip
+  private float mTop = YogaConstants.UNDEFINED;
+  @DoNotStrip
+  private float mLeft = YogaConstants.UNDEFINED;
+  @DoNotStrip
+  private int mLayoutDirection = 0;
+
+  private native long jni_YGNodeNew();
+  public YogaNode() {
+    mNativePointer = jni_YGNodeNew();
+    if (mNativePointer == 0) {
+      throw new IllegalStateException("Failed to allocate native memory");
+    }
+  }
+
+  private native void jni_YGNodeFree(long nativePointer);
+  @Override
+  protected void finalize() throws Throwable {
+    try {
+      jni_YGNodeFree(mNativePointer);
+    } finally {
+      super.finalize();
+    }
+  }
+
+  private native void jni_YGNodeReset(long nativePointer);
+  @Override
+  public void reset() {
+    mHasSetPadding = false;
+    mHasSetMargin = false;
+    mHasSetBorder = false;
+    mHasSetPosition = false;
+
+    mWidth = YogaConstants.UNDEFINED;
+    mHeight = YogaConstants.UNDEFINED;
+    mTop = YogaConstants.UNDEFINED;
+    mLeft = YogaConstants.UNDEFINED;
+    mLayoutDirection = 0;
+
+    mMeasureFunction = null;
+    mData = null;
+
+    jni_YGNodeReset(mNativePointer);
+  }
+
+  @Override
+  public int getChildCount() {
+    return mChildren == null ? 0 : mChildren.size();
+  }
+
+  @Override
+  public YogaNode getChildAt(int i) {
+    return mChildren.get(i);
+  }
+
+  private native void jni_YGNodeInsertChild(long nativePointer, long childPointer, int index);
+  @Override
+  public void addChildAt(YogaNode child, int i) {
+    if (child.mParent != null) {
+      throw new IllegalStateException("Child already has a parent, it must be removed first.");
+    }
+
+    if (mChildren == null) {
+      mChildren = new ArrayList<>(4);
+    }
+    mChildren.add(i, child);
+    child.mParent = this;
+    jni_YGNodeInsertChild(mNativePointer, child.mNativePointer, i);
+  }
+
+  private native void jni_YGNodeRemoveChild(long nativePointer, long childPointer);
+  @Override
+  public YogaNode removeChildAt(int i) {
+
+    final YogaNode child = mChildren.remove(i);
+    child.mParent = null;
+    jni_YGNodeRemoveChild(mNativePointer, child.mNativePointer);
+    return child;
+  }
+
+  @Override
+  public @Nullable
+  YogaNode getParent() {
+    return mParent;
+  }
+
+  @Override
+  public int indexOf(YogaNode child) {
+    return mChildren == null ? -1 : mChildren.indexOf(child);
+  }
+
+  private native void jni_YGNodeCalculateLayout(long nativePointer);
+  @Override
+  public void calculateLayout() {
+    jni_YGNodeCalculateLayout(mNativePointer);
+  }
+
+  private native boolean jni_YGNodeHasNewLayout(long nativePointer);
+  @Override
+  public boolean hasNewLayout() {
+    return jni_YGNodeHasNewLayout(mNativePointer);
+  }
+
+  private native void jni_YGNodeMarkDirty(long nativePointer);
+  @Override
+  public void dirty() {
+    jni_YGNodeMarkDirty(mNativePointer);
+  }
+
+  private native boolean jni_YGNodeIsDirty(long nativePointer);
+  @Override
+  public boolean isDirty() {
+    return jni_YGNodeIsDirty(mNativePointer);
+  }
+
+  private native void jni_YGNodeMarkLayoutSeen(long nativePointer);
+  @Override
+  public void markLayoutSeen() {
+    jni_YGNodeMarkLayoutSeen(mNativePointer);
+  }
+
+  private native void jni_YGNodeCopyStyle(long dstNativePointer, long srcNativePointer);
+  @Override
+  public void copyStyle(YogaNode srcNode) {
+    jni_YGNodeCopyStyle(mNativePointer, srcNode.mNativePointer);
+  }
+
+  private native int jni_YGNodeStyleGetDirection(long nativePointer);
+  @Override
+  public YogaDirection getStyleDirection() {
+    return YogaDirection.values()[jni_YGNodeStyleGetDirection(mNativePointer)];
+  }
+
+  private native void jni_YGNodeStyleSetDirection(long nativePointer, int direction);
+  @Override
+  public void setDirection(YogaDirection direction) {
+    jni_YGNodeStyleSetDirection(mNativePointer, direction.intValue());
+  }
+
+  private native int jni_YGNodeStyleGetFlexDirection(long nativePointer);
+  @Override
+  public YogaFlexDirection getFlexDirection() {
+    return YogaFlexDirection.values()[jni_YGNodeStyleGetFlexDirection(mNativePointer)];
+  }
+
+  private native void jni_YGNodeStyleSetFlexDirection(long nativePointer, int flexDirection);
+  @Override
+  public void setFlexDirection(YogaFlexDirection flexDirection) {
+    jni_YGNodeStyleSetFlexDirection(mNativePointer, flexDirection.intValue());
+  }
+
+  private native int jni_YGNodeStyleGetJustifyContent(long nativePointer);
+  @Override
+  public YogaJustify getJustifyContent() {
+    return YogaJustify.values()[jni_YGNodeStyleGetJustifyContent(mNativePointer)];
+  }
+
+  private native void jni_YGNodeStyleSetJustifyContent(long nativePointer, int justifyContent);
+  @Override
+  public void setJustifyContent(YogaJustify justifyContent) {
+    jni_YGNodeStyleSetJustifyContent(mNativePointer, justifyContent.intValue());
+  }
+
+  private native int jni_YGNodeStyleGetAlignItems(long nativePointer);
+  @Override
+  public YogaAlign getAlignItems() {
+    return YogaAlign.values()[jni_YGNodeStyleGetAlignItems(mNativePointer)];
+  }
+
+  private native void jni_YGNodeStyleSetAlignItems(long nativePointer, int alignItems);
+  @Override
+  public void setAlignItems(YogaAlign alignItems) {
+    jni_YGNodeStyleSetAlignItems(mNativePointer, alignItems.intValue());
+  }
+
+  private native int jni_YGNodeStyleGetAlignSelf(long nativePointer);
+  @Override
+  public YogaAlign getAlignSelf() {
+    return YogaAlign.values()[jni_YGNodeStyleGetAlignSelf(mNativePointer)];
+  }
+
+  private native void jni_YGNodeStyleSetAlignSelf(long nativePointer, int alignSelf);
+  @Override
+  public void setAlignSelf(YogaAlign alignSelf) {
+    jni_YGNodeStyleSetAlignSelf(mNativePointer, alignSelf.intValue());
+  }
+
+  private native int jni_YGNodeStyleGetAlignContent(long nativePointer);
+  @Override
+  public YogaAlign getAlignContent() {
+    return YogaAlign.values()[jni_YGNodeStyleGetAlignContent(mNativePointer)];
+  }
+
+  private native void jni_YGNodeStyleSetAlignContent(long nativePointer, int alignContent);
+  @Override
+  public void setAlignContent(YogaAlign alignContent) {
+    jni_YGNodeStyleSetAlignContent(mNativePointer, alignContent.intValue());
+  }
+
+  private native int jni_YGNodeStyleGetPositionType(long nativePointer);
+  @Override
+  public YogaPositionType getPositionType() {
+    return YogaPositionType.values()[jni_YGNodeStyleGetPositionType(mNativePointer)];
+  }
+
+  private native void jni_YGNodeStyleSetPositionType(long nativePointer, int positionType);
+  @Override
+  public void setPositionType(YogaPositionType positionType) {
+    jni_YGNodeStyleSetPositionType(mNativePointer, positionType.intValue());
+  }
+
+  private native void jni_YGNodeStyleSetFlexWrap(long nativePointer, int wrapType);
+  @Override
+  public void setWrap(YogaWrap flexWrap) {
+    jni_YGNodeStyleSetFlexWrap(mNativePointer, flexWrap.intValue());
+  }
+
+  private native int jni_YGNodeStyleGetOverflow(long nativePointer);
+  @Override
+  public YogaOverflow getOverflow() {
+    return YogaOverflow.values()[jni_YGNodeStyleGetOverflow(mNativePointer)];
+  }
+
+  private native void jni_YGNodeStyleSetOverflow(long nativePointer, int overflow);
+  @Override
+  public void setOverflow(YogaOverflow overflow) {
+    jni_YGNodeStyleSetOverflow(mNativePointer, overflow.intValue());
+  }
+
+  private native void jni_YGNodeStyleSetFlex(long nativePointer, float flex);
+  @Override
+  public void setFlex(float flex) {
+    jni_YGNodeStyleSetFlex(mNativePointer, flex);
+  }
+
+  private native float jni_YGNodeStyleGetFlexGrow(long nativePointer);
+  @Override
+  public float getFlexGrow() {
+    return jni_YGNodeStyleGetFlexGrow(mNativePointer);
+  }
+
+  private native void jni_YGNodeStyleSetFlexGrow(long nativePointer, float flexGrow);
+  @Override
+  public void setFlexGrow(float flexGrow) {
+    jni_YGNodeStyleSetFlexGrow(mNativePointer, flexGrow);
+  }
+
+  private native float jni_YGNodeStyleGetFlexShrink(long nativePointer);
+  @Override
+  public float getFlexShrink() {
+    return jni_YGNodeStyleGetFlexShrink(mNativePointer);
+  }
+
+  private native void jni_YGNodeStyleSetFlexShrink(long nativePointer, float flexShrink);
+  @Override
+  public void setFlexShrink(float flexShrink) {
+    jni_YGNodeStyleSetFlexShrink(mNativePointer, flexShrink);
+  }
+
+  private native float jni_YGNodeStyleGetFlexBasis(long nativePointer);
+  @Override
+  public float getFlexBasis() {
+    return jni_YGNodeStyleGetFlexBasis(mNativePointer);
+  }
+
+  private native void jni_YGNodeStyleSetFlexBasis(long nativePointer, float flexBasis);
+  @Override
+  public void setFlexBasis(float flexBasis) {
+    jni_YGNodeStyleSetFlexBasis(mNativePointer, flexBasis);
+  }
+
+  private native float jni_YGNodeStyleGetMargin(long nativePointer, int edge);
+  @Override
+  public float getMargin(YogaEdge edge) {
+    if (!mHasSetMargin) {
+      return edge.intValue() < YogaEdge.START.intValue() ? 0 : YogaConstants.UNDEFINED;
+    }
+    return jni_YGNodeStyleGetMargin(mNativePointer, edge.intValue());
+  }
+
+  private native void jni_YGNodeStyleSetMargin(long nativePointer, int edge, float margin);
+  @Override
+  public void setMargin(YogaEdge edge, float margin) {
+    mHasSetMargin = true;
+    jni_YGNodeStyleSetMargin(mNativePointer, edge.intValue(), margin);
+  }
+
+  private native float jni_YGNodeStyleGetPadding(long nativePointer, int edge);
+  @Override
+  public float getPadding(YogaEdge edge) {
+    if (!mHasSetPadding) {
+      return edge.intValue() < YogaEdge.START.intValue() ? 0 : YogaConstants.UNDEFINED;
+    }
+    return jni_YGNodeStyleGetPadding(mNativePointer, edge.intValue());
+  }
+
+  private native void jni_YGNodeStyleSetPadding(long nativePointer, int edge, float padding);
+  @Override
+  public void setPadding(YogaEdge edge, float padding) {
+    mHasSetPadding = true;
+    jni_YGNodeStyleSetPadding(mNativePointer, edge.intValue(), padding);
+  }
+
+  private native float jni_YGNodeStyleGetBorder(long nativePointer, int edge);
+  @Override
+  public float getBorder(YogaEdge edge) {
+    if (!mHasSetBorder) {
+      return edge.intValue() < YogaEdge.START.intValue() ? 0 : YogaConstants.UNDEFINED;
+    }
+    return jni_YGNodeStyleGetBorder(mNativePointer, edge.intValue());
+  }
+
+  private native void jni_YGNodeStyleSetBorder(long nativePointer, int edge, float border);
+  @Override
+  public void setBorder(YogaEdge edge, float border) {
+    mHasSetBorder = true;
+    jni_YGNodeStyleSetBorder(mNativePointer, edge.intValue(), border);
+  }
+
+  private native float jni_YGNodeStyleGetPosition(long nativePointer, int edge);
+  @Override
+  public float getPosition(YogaEdge edge) {
+    if (!mHasSetPosition) {
+      return YogaConstants.UNDEFINED;
+    }
+    return jni_YGNodeStyleGetPosition(mNativePointer, edge.intValue());
+  }
+
+  private native void jni_YGNodeStyleSetPosition(long nativePointer, int edge, float position);
+  @Override
+  public void setPosition(YogaEdge edge, float position) {
+    mHasSetPosition = true;
+    jni_YGNodeStyleSetPosition(mNativePointer, edge.intValue(), position);
+  }
+
+  private native float jni_YGNodeStyleGetWidth(long nativePointer);
+  @Override
+  public float getWidth() {
+    return jni_YGNodeStyleGetWidth(mNativePointer);
+  }
+
+  private native void jni_YGNodeStyleSetWidth(long nativePointer, float width);
+  @Override
+  public void setWidth(float width) {
+    jni_YGNodeStyleSetWidth(mNativePointer, width);
+  }
+
+  private native float jni_YGNodeStyleGetHeight(long nativePointer);
+  @Override
+  public float getHeight() {
+    return jni_YGNodeStyleGetHeight(mNativePointer);
+  }
+
+  private native void jni_YGNodeStyleSetHeight(long nativePointer, float height);
+  @Override
+  public void setHeight(float height) {
+    jni_YGNodeStyleSetHeight(mNativePointer, height);
+  }
+
+  private native float jni_YGNodeStyleGetMinWidth(long nativePointer);
+  @Override
+  public float getMinWidth() {
+    return jni_YGNodeStyleGetMinWidth(mNativePointer);
+  }
+
+  private native void jni_YGNodeStyleSetMinWidth(long nativePointer, float minWidth);
+  @Override
+  public void setMinWidth(float minWidth) {
+    jni_YGNodeStyleSetMinWidth(mNativePointer, minWidth);
+  }
+
+  private native float jni_YGNodeStyleGetMinHeight(long nativePointer);
+  @Override
+  public float getMinHeight() {
+    return jni_YGNodeStyleGetMinHeight(mNativePointer);
+  }
+
+  private native void jni_YGNodeStyleSetMinHeight(long nativePointer, float minHeight);
+  @Override
+  public void setMinHeight(float minHeight) {
+    jni_YGNodeStyleSetMinHeight(mNativePointer, minHeight);
+  }
+
+  private native float jni_YGNodeStyleGetMaxWidth(long nativePointer);
+  @Override
+  public float getMaxWidth() {
+    return jni_YGNodeStyleGetMaxWidth(mNativePointer);
+  }
+
+  private native void jni_YGNodeStyleSetMaxWidth(long nativePointer, float maxWidth);
+  @Override
+  public void setMaxWidth(float maxWidth) {
+    jni_YGNodeStyleSetMaxWidth(mNativePointer, maxWidth);
+  }
+
+  private native float jni_YGNodeStyleGetMaxHeight(long nativePointer);
+  @Override
+  public float getMaxHeight() {
+    return jni_YGNodeStyleGetMaxHeight(mNativePointer);
+  }
+
+  private native void jni_YGNodeStyleSetMaxHeight(long nativePointer, float maxheight);
+  @Override
+  public void setMaxHeight(float maxheight) {
+    jni_YGNodeStyleSetMaxHeight(mNativePointer, maxheight);
+  }
+
+  private native float jni_YGNodeStyleGetAspectRatio(long nativePointer);
+  public float getAspectRatio() {
+    return jni_YGNodeStyleGetAspectRatio(mNativePointer);
+  }
+
+  private native void jni_YGNodeStyleSetAspectRatio(long nativePointer, float aspectRatio);
+  public void setAspectRatio(float aspectRatio) {
+    jni_YGNodeStyleSetAspectRatio(mNativePointer, aspectRatio);
+  }
+
+  @Override
+  public float getLayoutX() {
+    return mLeft;
+  }
+
+  @Override
+  public float getLayoutY() {
+    return mTop;
+  }
+
+  @Override
+  public float getLayoutWidth() {
+    return mWidth;
+  }
+
+  @Override
+  public float getLayoutHeight() {
+    return mHeight;
+  }
+
+  @Override
+  public YogaDirection getLayoutDirection() {
+    return YogaDirection.values()[mLayoutDirection];
+  }
+
+  private native void jni_YGNodeSetHasMeasureFunc(long nativePointer, boolean hasMeasureFunc);
+  @Override
+  public void setMeasureFunction(YogaMeasureFunction measureFunction) {
+    mMeasureFunction = measureFunction;
+    jni_YGNodeSetHasMeasureFunc(mNativePointer, measureFunction != null);
+  }
+
+  // Implementation Note: Why this method needs to stay final
+  //
+  // We cache the jmethodid for this method in Yoga code. This means that even if a subclass
+  // were to override measure, we'd still call this implementation from layout code since the
+  // overriding method will have a different jmethodid. This is final to prevent that mistake.
+  @DoNotStrip
+  public final long measure(float width, int widthMode, float height, int heightMode) {
+    if (!isMeasureDefined()) {
+      throw new RuntimeException("Measure function isn't defined!");
+    }
+
+    return mMeasureFunction.measure(
+          this,
+          width,
+          YogaMeasureMode.values()[widthMode],
+          height,
+          YogaMeasureMode.values()[heightMode]);
+  }
+
+  @Override
+  public boolean isMeasureDefined() {
+    return mMeasureFunction != null;
+  }
+
+  @Override
+  public void setData(Object data) {
+    mData = data;
+  }
+
+  @Override
+  public Object getData() {
+    return mData;
+  }
+}

java/com/facebook/yoga/YogaNodeAPI.java

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.yoga;
+
+// This only exists for legacy reasons. It will be removed sometime in the near future.
+public interface YogaNodeAPI<YogaNodeType extends YogaNodeAPI> {
+  int getChildCount();
+  YogaNodeType getChildAt(int i);
+  void addChildAt(YogaNodeType child, int i);
+  YogaNodeType removeChildAt(int i);
+  YogaNodeType getParent();
+  int indexOf(YogaNodeType child);
+  void setMeasureFunction(YogaMeasureFunction measureFunction);
+  boolean isMeasureDefined();
+  void calculateLayout();
+  boolean isDirty();
+  boolean hasNewLayout();
+  void dirty();
+  void markLayoutSeen();
+  void copyStyle(YogaNodeType srcNode);
+  YogaDirection getStyleDirection();
+  void setDirection(YogaDirection direction);
+  YogaFlexDirection getFlexDirection();
+  void setFlexDirection(YogaFlexDirection flexDirection);
+  YogaJustify getJustifyContent();
+  void setJustifyContent(YogaJustify justifyContent);
+  YogaAlign getAlignItems();
+  void setAlignItems(YogaAlign alignItems);
+  YogaAlign getAlignSelf();
+  void setAlignSelf(YogaAlign alignSelf);
+  YogaAlign getAlignContent();
+  void setAlignContent(YogaAlign alignContent);
+  YogaPositionType getPositionType();
+  void setPositionType(YogaPositionType positionType);
+  void setWrap(YogaWrap flexWrap);
+  void setFlex(float flex);
+  float getFlexGrow();
+  void setFlexGrow(float flexGrow);
+  float getFlexShrink();
+  void setFlexShrink(float flexShrink);
+  float getFlexBasis();
+  void setFlexBasis(float flexBasis);
+  float getMargin(YogaEdge edge);
+  void setMargin(YogaEdge edge, float margin);
+  float getPadding(YogaEdge edge);
+  void setPadding(YogaEdge edge, float padding);
+  float getBorder(YogaEdge edge);
+  void setBorder(YogaEdge edge, float border);
+  float getPosition(YogaEdge edge);
+  void setPosition(YogaEdge edge, float position);
+  float getWidth();
+  void setWidth(float width);
+  float getHeight();
+  void setHeight(float height);
+  float getMaxWidth();
+  void setMaxWidth(float maxWidth);
+  float getMinWidth();
+  void setMinWidth(float minWidth);
+  float getMaxHeight();
+  void setMaxHeight(float maxHeight);
+  float getMinHeight();
+  void setMinHeight(float minHeight);
+  float getLayoutX();
+  float getLayoutY();
+  float getLayoutWidth();
+  float getLayoutHeight();
+  YogaDirection getLayoutDirection();
+  YogaOverflow getOverflow();
+  void setOverflow(YogaOverflow overflow);
+  void setData(Object data);
+  Object getData();
+  void reset();
+}

java/com/facebook/yoga/YogaOverflow.java

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.yoga;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+
+@DoNotStrip
+public enum YogaOverflow {
+  VISIBLE(0),
+  HIDDEN(1),
+  SCROLL(2);
+
+  private int mIntValue;
+
+  YogaOverflow(int intValue) {
+    mIntValue = intValue;
+  }
+
+  public int intValue() {
+    return mIntValue;
+  }
+
+  public static YogaOverflow fromInt(int value) {
+    switch (value) {
+      case 0: return VISIBLE;
+      case 1: return HIDDEN;
+      case 2: return SCROLL;
+      default: throw new IllegalArgumentException("Unkown enum value: " + value);
+    }
+  }
+}

java/com/facebook/yoga/YogaPositionType.java

@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.yoga;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+
+@DoNotStrip
+public enum YogaPositionType {
+  RELATIVE(0),
+  ABSOLUTE(1);
+
+  private int mIntValue;
+
+  YogaPositionType(int intValue) {
+    mIntValue = intValue;
+  }
+
+  public int intValue() {
+    return mIntValue;
+  }
+
+  public static YogaPositionType fromInt(int value) {
+    switch (value) {
+      case 0: return RELATIVE;
+      case 1: return ABSOLUTE;
+      default: throw new IllegalArgumentException("Unkown enum value: " + value);
+    }
+  }
+}

java/com/facebook/yoga/YogaPrintOptions.java

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.yoga;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+
+@DoNotStrip
+public enum YogaPrintOptions {
+  LAYOUT(1),
+  STYLE(2),
+  CHILDREN(4);
+
+  private int mIntValue;
+
+  YogaPrintOptions(int intValue) {
+    mIntValue = intValue;
+  }
+
+  public int intValue() {
+    return mIntValue;
+  }
+
+  public static YogaPrintOptions fromInt(int value) {
+    switch (value) {
+      case 1: return LAYOUT;
+      case 2: return STYLE;
+      case 4: return CHILDREN;
+      default: throw new IllegalArgumentException("Unkown enum value: " + value);
+    }
+  }
+}

java/com/facebook/yoga/YogaWrap.java

@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+package com.facebook.yoga;
+
+import com.facebook.proguard.annotations.DoNotStrip;
+
+@DoNotStrip
+public enum YogaWrap {
+  NO_WRAP(0),
+  WRAP(1);
+
+  private int mIntValue;
+
+  YogaWrap(int intValue) {
+    mIntValue = intValue;
+  }
+
+  public int intValue() {
+    return mIntValue;
+  }
+
+  public static YogaWrap fromInt(int value) {
+    switch (value) {
+      case 0: return NO_WRAP;
+      case 1: return WRAP;
+      default: throw new IllegalArgumentException("Unkown enum value: " + value);
+    }
+  }
+}