diff --git a/ReactAndroid/BUCK b/ReactAndroid/BUCK deleted file mode 100644 index 079a6a9cf..000000000 --- a/ReactAndroid/BUCK +++ /dev/null @@ -1,7 +0,0 @@ -load("//ReactNative:DEFS.bzl", "rn_android_library") - -rn_android_library( - name = "stubs", - srcs = glob(["stubs/src/**/*.java"]), - visibility = ["PUBLIC"], -) diff --git a/ReactAndroid/build.gradle b/ReactAndroid/build.gradle index cdda93afb..b05e61513 100644 --- a/ReactAndroid/build.gradle +++ b/ReactAndroid/build.gradle @@ -305,7 +305,6 @@ dependencies { compile 'com.squareup.okhttp3:okhttp-urlconnection:3.10.0' compile 'com.squareup.okio:okio:1.14.0' compile 'org.webkit:android-jsc:r174650' - compileOnly project(':ReactAndroid:stubs') testCompile "junit:junit:${JUNIT_VERSION}" testCompile "org.powermock:powermock-api-mockito:${POWERMOCK_VERSION}" diff --git a/ReactAndroid/src/main/java/com/facebook/BUCK b/ReactAndroid/src/main/java/com/facebook/BUCK index fc70f9fb3..bc03b864b 100644 --- a/ReactAndroid/src/main/java/com/facebook/BUCK +++ b/ReactAndroid/src/main/java/com/facebook/BUCK @@ -1,4 +1,4 @@ -load("//ReactNative:DEFS.bzl", "react_native_dep", "rn_android_library", "JAVA_STUBS_TARGET") +load("//ReactNative:DEFS.bzl", "react_native_dep", "rn_android_library") rn_android_library( name = "yoga", @@ -10,7 +10,4 @@ rn_android_library( react_native_dep("third-party/java/infer-annotations:infer-annotations"), react_native_dep("third-party/java/jsr-305:jsr-305"), ], - provided_deps = [ - JAVA_STUBS_TARGET, - ] ) diff --git a/ReactAndroid/src/main/java/com/facebook/yoga/YogaNode.java b/ReactAndroid/src/main/java/com/facebook/yoga/YogaNode.java index 2924f0c39..7c03e7181 100644 --- a/ReactAndroid/src/main/java/com/facebook/yoga/YogaNode.java +++ b/ReactAndroid/src/main/java/com/facebook/yoga/YogaNode.java @@ -21,74 +21,132 @@ public class YogaNode implements Cloneable { SoLoader.loadLibrary("yoga"); } - public static final int BYTE_BUFFER = 1; - public static final int HYBRID = 2; - public static final int UNSAFE = 3; - - /** Get native instance count. Useful for testing only. */ + /** + * Get native instance count. Useful for testing only. + */ static native int jni_YGNodeGetInstanceCount(); - private YogaNodeProperties mDelegate; private YogaNode mOwner; @Nullable private List mChildren; private YogaMeasureFunction mMeasureFunction; private YogaBaselineFunction mBaselineFunction; + private long mNativePointer; private Object mData; + /* Those flags needs be in sync with YGJNI.cpp */ + private static final int MARGIN = 1; + private static final int PADDING = 2; + private static final int BORDER = 4; + + @DoNotStrip + private int mEdgeSetFlag = 0; + + 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 float mMarginLeft = 0; + @DoNotStrip + private float mMarginTop = 0; + @DoNotStrip + private float mMarginRight = 0; + @DoNotStrip + private float mMarginBottom = 0; + @DoNotStrip + private float mPaddingLeft = 0; + @DoNotStrip + private float mPaddingTop = 0; + @DoNotStrip + private float mPaddingRight = 0; + @DoNotStrip + private float mPaddingBottom = 0; + @DoNotStrip + private float mBorderLeft = 0; + @DoNotStrip + private float mBorderTop = 0; + @DoNotStrip + private float mBorderRight = 0; + @DoNotStrip + private float mBorderBottom = 0; + @DoNotStrip + private int mLayoutDirection = 0; + @DoNotStrip + private boolean mHasNewLayout = true; + @DoNotStrip private boolean mDoesLegacyStretchFlagAffectsLayout = false; + + private native long jni_YGNodeNew(); public YogaNode() { - mDelegate = new YogaNodePropertiesJNI(this); + mNativePointer = jni_YGNodeNew(); + if (mNativePointer == 0) { + throw new IllegalStateException("Failed to allocate native memory"); + } } + private native long jni_YGNodeNewWithConfig(long configPointer); public YogaNode(YogaConfig config) { - mDelegate = new YogaNodePropertiesJNI(this, config); - } - - public YogaNode(int storageType) { - switch (storageType) { - case BYTE_BUFFER: - mDelegate = new YogaNodePropertiesByteBuffer(this); - break; - case HYBRID: - mDelegate = new YogaNodePropertiesHybrid(this); - break; - case UNSAFE: - mDelegate = new YogaNodePropertiesUnsafe(this); - break; - default: - mDelegate = new YogaNodePropertiesJNI(this); + mNativePointer = jni_YGNodeNewWithConfig(config.mNativePointer); + if (mNativePointer == 0) { + throw new IllegalStateException("Failed to allocate native memory"); } } - public YogaNode(int storageType, YogaConfig config) { - switch (storageType) { - case BYTE_BUFFER: - mDelegate = new YogaNodePropertiesByteBuffer(this, config); - break; - case HYBRID: - mDelegate = new YogaNodePropertiesHybrid(this, config); - break; - case UNSAFE: - mDelegate = new YogaNodePropertiesUnsafe(this, config); - break; - default: - mDelegate = new YogaNodePropertiesJNI(this, config); + @Override + protected void finalize() throws Throwable { + try { + freeNatives(); + } finally { + super.finalize(); } } - public long getNativePointer() { - return mDelegate.getNativePointer(); - } + private static native void jni_YGNodeFree(long nativePointer); /* frees the native underlying YGNode. Useful for testing. */ public void freeNatives() { - mDelegate.freeNatives(); + if (mNativePointer > 0) { + long nativePointer = mNativePointer; + mNativePointer = 0; + jni_YGNodeFree(nativePointer); + } } + private native void jni_YGNodeReset(long nativePointer); public void reset() { + mEdgeSetFlag = 0; + mHasSetPosition = false; + mHasNewLayout = true; + + mWidth = YogaConstants.UNDEFINED; + mHeight = YogaConstants.UNDEFINED; + mTop = YogaConstants.UNDEFINED; + mLeft = YogaConstants.UNDEFINED; + mMarginLeft = 0; + mMarginTop = 0; + mMarginRight = 0; + mMarginBottom = 0; + mPaddingLeft = 0; + mPaddingTop = 0; + mPaddingRight = 0; + mPaddingBottom = 0; + mBorderLeft = 0; + mBorderTop = 0; + mBorderRight = 0; + mBorderBottom = 0; + mLayoutDirection = 0; + mMeasureFunction = null; mBaselineFunction = null; mData = null; - mDelegate.reset(); + mDoesLegacyStretchFlagAffectsLayout = false; + + jni_YGNodeReset(mNativePointer); } public int getChildCount() { @@ -113,7 +171,7 @@ public class YogaNode implements Cloneable { } mChildren.add(i, child); child.mOwner = this; - jni_YGNodeInsertChild(getNativePointer(), child.getNativePointer(), i); + jni_YGNodeInsertChild(mNativePointer, child.mNativePointer, i); } private native void jni_YGNodeInsertSharedChild(long nativePointer, long childPointer, int index); @@ -124,24 +182,27 @@ public class YogaNode implements Cloneable { } mChildren.add(i, child); child.mOwner = null; - jni_YGNodeInsertSharedChild(getNativePointer(), child.getNativePointer(), i); + jni_YGNodeInsertSharedChild(mNativePointer, child.mNativePointer, i); } private native void jni_YGNodeSetOwner(long nativePointer, long newOwnerNativePointer); + private native long jni_YGNodeClone(long nativePointer, Object newNode); + @Override public YogaNode clone() { try { YogaNode clonedYogaNode = (YogaNode) super.clone(); + long clonedNativePointer = jni_YGNodeClone(mNativePointer, clonedYogaNode); if (mChildren != null) { for (YogaNode child : mChildren) { - child.jni_YGNodeSetOwner(child.getNativePointer(), 0); + child.jni_YGNodeSetOwner(child.mNativePointer, 0); child.mOwner = null; } } - clonedYogaNode.mDelegate = mDelegate.clone(clonedYogaNode); + clonedYogaNode.mNativePointer = clonedNativePointer; clonedYogaNode.mOwner = null; clonedYogaNode.mChildren = mChildren != null ? (List) ((ArrayList) mChildren).clone() : null; @@ -160,8 +221,9 @@ public class YogaNode implements Cloneable { public YogaNode cloneWithNewChildren() { try { YogaNode clonedYogaNode = (YogaNode) super.clone(); - clonedYogaNode.mDelegate = mDelegate.clone(clonedYogaNode); + long clonedNativePointer = jni_YGNodeClone(mNativePointer, clonedYogaNode); clonedYogaNode.mOwner = null; + clonedYogaNode.mNativePointer = clonedNativePointer; clonedYogaNode.clearChildren(); return clonedYogaNode; } catch (CloneNotSupportedException ex) { @@ -174,7 +236,7 @@ public class YogaNode implements Cloneable { private void clearChildren() { mChildren = null; - jni_YGNodeClearChildren(getNativePointer()); + jni_YGNodeClearChildren(mNativePointer); } private native void jni_YGNodeRemoveChild(long nativePointer, long childPointer); @@ -185,7 +247,7 @@ public class YogaNode implements Cloneable { } final YogaNode child = mChildren.remove(i); child.mOwner = null; - jni_YGNodeRemoveChild(getNativePointer(), child.getNativePointer()); + jni_YGNodeRemoveChild(mNativePointer, child.mNativePointer); return child; } @@ -213,329 +275,455 @@ public class YogaNode implements Cloneable { return mChildren == null ? -1 : mChildren.indexOf(child); } - private native boolean jni_YGNodeCalculateLayout(long nativePointer, float width, float height); - + private native void jni_YGNodeCalculateLayout(long nativePointer, float width, float height); public void calculateLayout(float width, float height) { - boolean hasNewLayout = jni_YGNodeCalculateLayout(getNativePointer(), width, height); - mDelegate.onAfterCalculateLayout(hasNewLayout); + jni_YGNodeCalculateLayout(mNativePointer, width, height); } public boolean hasNewLayout() { - return mDelegate.hasNewLayout(); + return mHasNewLayout; } private native void jni_YGNodeMarkDirty(long nativePointer); public void dirty() { - jni_YGNodeMarkDirty(getNativePointer()); + jni_YGNodeMarkDirty(mNativePointer); } private native void jni_YGNodeMarkDirtyAndPropogateToDescendants(long nativePointer); public void dirtyAllDescendants() { - jni_YGNodeMarkDirtyAndPropogateToDescendants(getNativePointer()); + jni_YGNodeMarkDirtyAndPropogateToDescendants(mNativePointer); } + private native boolean jni_YGNodeIsDirty(long nativePointer); public boolean isDirty() { - return mDelegate.isDirty(); + return jni_YGNodeIsDirty(mNativePointer); } private native void jni_YGNodeCopyStyle(long dstNativePointer, long srcNativePointer); public void copyStyle(YogaNode srcNode) { - jni_YGNodeCopyStyle(getNativePointer(), srcNode.getNativePointer()); + jni_YGNodeCopyStyle(mNativePointer, srcNode.mNativePointer); } public void markLayoutSeen() { - mDelegate.markLayoutSeen(); + mHasNewLayout = false; } + private native int jni_YGNodeStyleGetDirection(long nativePointer); public YogaDirection getStyleDirection() { - return mDelegate.getStyleDirection(); + return YogaDirection.fromInt(jni_YGNodeStyleGetDirection(mNativePointer)); } + private native void jni_YGNodeStyleSetDirection(long nativePointer, int direction); public void setDirection(YogaDirection direction) { - mDelegate.setDirection(direction); + jni_YGNodeStyleSetDirection(mNativePointer, direction.intValue()); } + private native int jni_YGNodeStyleGetFlexDirection(long nativePointer); public YogaFlexDirection getFlexDirection() { - return mDelegate.getFlexDirection(); + return YogaFlexDirection.fromInt(jni_YGNodeStyleGetFlexDirection(mNativePointer)); } + private native void jni_YGNodeStyleSetFlexDirection(long nativePointer, int flexDirection); public void setFlexDirection(YogaFlexDirection flexDirection) { - mDelegate.setFlexDirection(flexDirection); + jni_YGNodeStyleSetFlexDirection(mNativePointer, flexDirection.intValue()); } + private native int jni_YGNodeStyleGetJustifyContent(long nativePointer); public YogaJustify getJustifyContent() { - return mDelegate.getJustifyContent(); + return YogaJustify.fromInt(jni_YGNodeStyleGetJustifyContent(mNativePointer)); } + private native void jni_YGNodeStyleSetJustifyContent(long nativePointer, int justifyContent); public void setJustifyContent(YogaJustify justifyContent) { - mDelegate.setJustifyContent(justifyContent); + jni_YGNodeStyleSetJustifyContent(mNativePointer, justifyContent.intValue()); } + private native int jni_YGNodeStyleGetAlignItems(long nativePointer); public YogaAlign getAlignItems() { - return mDelegate.getAlignItems(); + return YogaAlign.fromInt(jni_YGNodeStyleGetAlignItems(mNativePointer)); } + private native void jni_YGNodeStyleSetAlignItems(long nativePointer, int alignItems); public void setAlignItems(YogaAlign alignItems) { - mDelegate.setAlignItems(alignItems); + jni_YGNodeStyleSetAlignItems(mNativePointer, alignItems.intValue()); } + private native int jni_YGNodeStyleGetAlignSelf(long nativePointer); public YogaAlign getAlignSelf() { - return mDelegate.getAlignSelf(); + return YogaAlign.fromInt(jni_YGNodeStyleGetAlignSelf(mNativePointer)); } + private native void jni_YGNodeStyleSetAlignSelf(long nativePointer, int alignSelf); public void setAlignSelf(YogaAlign alignSelf) { - mDelegate.setAlignSelf(alignSelf); + jni_YGNodeStyleSetAlignSelf(mNativePointer, alignSelf.intValue()); } + private native int jni_YGNodeStyleGetAlignContent(long nativePointer); public YogaAlign getAlignContent() { - return mDelegate.getAlignContent(); + return YogaAlign.fromInt(jni_YGNodeStyleGetAlignContent(mNativePointer)); } + private native void jni_YGNodeStyleSetAlignContent(long nativePointer, int alignContent); public void setAlignContent(YogaAlign alignContent) { - mDelegate.setAlignContent(alignContent); + jni_YGNodeStyleSetAlignContent(mNativePointer, alignContent.intValue()); } + private native int jni_YGNodeStyleGetPositionType(long nativePointer); public YogaPositionType getPositionType() { - return mDelegate.getPositionType(); + return YogaPositionType.fromInt(jni_YGNodeStyleGetPositionType(mNativePointer)); } + private native void jni_YGNodeStyleSetPositionType(long nativePointer, int positionType); public void setPositionType(YogaPositionType positionType) { - mDelegate.setPositionType(positionType); + jni_YGNodeStyleSetPositionType(mNativePointer, positionType.intValue()); } + private native void jni_YGNodeStyleSetFlexWrap(long nativePointer, int wrapType); public void setWrap(YogaWrap flexWrap) { - mDelegate.setWrap(flexWrap); + jni_YGNodeStyleSetFlexWrap(mNativePointer, flexWrap.intValue()); } + private native int jni_YGNodeStyleGetOverflow(long nativePointer); public YogaOverflow getOverflow() { - return mDelegate.getOverflow(); + return YogaOverflow.fromInt(jni_YGNodeStyleGetOverflow(mNativePointer)); } + private native void jni_YGNodeStyleSetOverflow(long nativePointer, int overflow); public void setOverflow(YogaOverflow overflow) { - mDelegate.setOverflow(overflow); + jni_YGNodeStyleSetOverflow(mNativePointer, overflow.intValue()); } + private native int jni_YGNodeStyleGetDisplay(long nativePointer); public YogaDisplay getDisplay() { - return mDelegate.getDisplay(); + return YogaDisplay.fromInt(jni_YGNodeStyleGetDisplay(mNativePointer)); } + private native void jni_YGNodeStyleSetDisplay(long nativePointer, int display); public void setDisplay(YogaDisplay display) { - mDelegate.setDisplay(display); + jni_YGNodeStyleSetDisplay(mNativePointer, display.intValue()); } + private native void jni_YGNodeStyleSetFlex(long nativePointer, float flex); public void setFlex(float flex) { - mDelegate.setFlex(flex); + jni_YGNodeStyleSetFlex(mNativePointer, flex); } + private native float jni_YGNodeStyleGetFlexGrow(long nativePointer); public float getFlexGrow() { - return mDelegate.getFlexGrow(); + return jni_YGNodeStyleGetFlexGrow(mNativePointer); } + private native void jni_YGNodeStyleSetFlexGrow(long nativePointer, float flexGrow); public void setFlexGrow(float flexGrow) { - mDelegate.setFlexGrow(flexGrow); + jni_YGNodeStyleSetFlexGrow(mNativePointer, flexGrow); } + private native float jni_YGNodeStyleGetFlexShrink(long nativePointer); public float getFlexShrink() { - return mDelegate.getFlexShrink(); + return jni_YGNodeStyleGetFlexShrink(mNativePointer); } + private native void jni_YGNodeStyleSetFlexShrink(long nativePointer, float flexShrink); public void setFlexShrink(float flexShrink) { - mDelegate.setFlexShrink(flexShrink); + jni_YGNodeStyleSetFlexShrink(mNativePointer, flexShrink); } + private native Object jni_YGNodeStyleGetFlexBasis(long nativePointer); public YogaValue getFlexBasis() { - return mDelegate.getFlexBasis(); + return (YogaValue) jni_YGNodeStyleGetFlexBasis(mNativePointer); } + private native void jni_YGNodeStyleSetFlexBasis(long nativePointer, float flexBasis); public void setFlexBasis(float flexBasis) { - mDelegate.setFlexBasis(flexBasis); + jni_YGNodeStyleSetFlexBasis(mNativePointer, flexBasis); } + private native void jni_YGNodeStyleSetFlexBasisPercent(long nativePointer, float percent); public void setFlexBasisPercent(float percent) { - mDelegate.setFlexBasisPercent(percent); + jni_YGNodeStyleSetFlexBasisPercent(mNativePointer, percent); } + private native void jni_YGNodeStyleSetFlexBasisAuto(long nativePointer); public void setFlexBasisAuto() { - mDelegate.setFlexBasisAuto(); + jni_YGNodeStyleSetFlexBasisAuto(mNativePointer); } + private native Object jni_YGNodeStyleGetMargin(long nativePointer, int edge); public YogaValue getMargin(YogaEdge edge) { - return mDelegate.getMargin(edge); + if (!((mEdgeSetFlag & MARGIN) == MARGIN)) { + return YogaValue.UNDEFINED; + } + return (YogaValue) jni_YGNodeStyleGetMargin(mNativePointer, edge.intValue()); } + private native void jni_YGNodeStyleSetMargin(long nativePointer, int edge, float margin); public void setMargin(YogaEdge edge, float margin) { - mDelegate.setMargin(edge, margin); + mEdgeSetFlag |= MARGIN; + jni_YGNodeStyleSetMargin(mNativePointer, edge.intValue(), margin); } + private native void jni_YGNodeStyleSetMarginPercent(long nativePointer, int edge, float percent); public void setMarginPercent(YogaEdge edge, float percent) { - mDelegate.setMarginPercent(edge, percent); + mEdgeSetFlag |= MARGIN; + jni_YGNodeStyleSetMarginPercent(mNativePointer, edge.intValue(), percent); } + private native void jni_YGNodeStyleSetMarginAuto(long nativePointer, int edge); public void setMarginAuto(YogaEdge edge) { - mDelegate.setMarginAuto(edge); + mEdgeSetFlag |= MARGIN; + jni_YGNodeStyleSetMarginAuto(mNativePointer, edge.intValue()); } + private native Object jni_YGNodeStyleGetPadding(long nativePointer, int edge); public YogaValue getPadding(YogaEdge edge) { - return mDelegate.getPadding(edge); + if (!((mEdgeSetFlag & PADDING) == PADDING)) { + return YogaValue.UNDEFINED; + } + return (YogaValue) jni_YGNodeStyleGetPadding(mNativePointer, edge.intValue()); } + private native void jni_YGNodeStyleSetPadding(long nativePointer, int edge, float padding); public void setPadding(YogaEdge edge, float padding) { - mDelegate.setPadding(edge, padding); + mEdgeSetFlag |= PADDING; + jni_YGNodeStyleSetPadding(mNativePointer, edge.intValue(), padding); } + private native void jni_YGNodeStyleSetPaddingPercent(long nativePointer, int edge, float percent); public void setPaddingPercent(YogaEdge edge, float percent) { - mDelegate.setPaddingPercent(edge, percent); + mEdgeSetFlag |= PADDING; + jni_YGNodeStyleSetPaddingPercent(mNativePointer, edge.intValue(), percent); } + private native float jni_YGNodeStyleGetBorder(long nativePointer, int edge); public float getBorder(YogaEdge edge) { - return mDelegate.getBorder(edge); + if (!((mEdgeSetFlag & BORDER) == BORDER)) { + return YogaConstants.UNDEFINED; + } + return jni_YGNodeStyleGetBorder(mNativePointer, edge.intValue()); } + private native void jni_YGNodeStyleSetBorder(long nativePointer, int edge, float border); public void setBorder(YogaEdge edge, float border) { - mDelegate.setBorder(edge, border); + mEdgeSetFlag |= BORDER; + jni_YGNodeStyleSetBorder(mNativePointer, edge.intValue(), border); } + private native Object jni_YGNodeStyleGetPosition(long nativePointer, int edge); public YogaValue getPosition(YogaEdge edge) { - return mDelegate.getPosition(edge); + if (!mHasSetPosition) { + return YogaValue.UNDEFINED; + } + return (YogaValue) jni_YGNodeStyleGetPosition(mNativePointer, edge.intValue()); } + private native void jni_YGNodeStyleSetPosition(long nativePointer, int edge, float position); public void setPosition(YogaEdge edge, float position) { - mDelegate.setPosition(edge, position); + mHasSetPosition = true; + jni_YGNodeStyleSetPosition(mNativePointer, edge.intValue(), position); } + private native void jni_YGNodeStyleSetPositionPercent(long nativePointer, int edge, float percent); public void setPositionPercent(YogaEdge edge, float percent) { - mDelegate.setPositionPercent(edge, percent); + mHasSetPosition = true; + jni_YGNodeStyleSetPositionPercent(mNativePointer, edge.intValue(), percent); } + private native Object jni_YGNodeStyleGetWidth(long nativePointer); public YogaValue getWidth() { - return mDelegate.getWidth(); + return (YogaValue) jni_YGNodeStyleGetWidth(mNativePointer); } + private native void jni_YGNodeStyleSetWidth(long nativePointer, float width); public void setWidth(float width) { - mDelegate.setWidth(width); + jni_YGNodeStyleSetWidth(mNativePointer, width); } + private native void jni_YGNodeStyleSetWidthPercent(long nativePointer, float percent); public void setWidthPercent(float percent) { - mDelegate.setWidthPercent(percent); + jni_YGNodeStyleSetWidthPercent(mNativePointer, percent); } + private native void jni_YGNodeStyleSetWidthAuto(long nativePointer); public void setWidthAuto() { - mDelegate.setWidthAuto(); + jni_YGNodeStyleSetWidthAuto(mNativePointer); } + private native Object jni_YGNodeStyleGetHeight(long nativePointer); public YogaValue getHeight() { - return mDelegate.getHeight(); + return (YogaValue) jni_YGNodeStyleGetHeight(mNativePointer); } + private native void jni_YGNodeStyleSetHeight(long nativePointer, float height); public void setHeight(float height) { - mDelegate.setHeight(height); + jni_YGNodeStyleSetHeight(mNativePointer, height); } + private native void jni_YGNodeStyleSetHeightPercent(long nativePointer, float percent); public void setHeightPercent(float percent) { - mDelegate.setHeightPercent(percent); + jni_YGNodeStyleSetHeightPercent(mNativePointer, percent); } + private native void jni_YGNodeStyleSetHeightAuto(long nativePointer); public void setHeightAuto() { - mDelegate.setHeightAuto(); + jni_YGNodeStyleSetHeightAuto(mNativePointer); } + private native Object jni_YGNodeStyleGetMinWidth(long nativePointer); public YogaValue getMinWidth() { - return mDelegate.getMinWidth(); + return (YogaValue) jni_YGNodeStyleGetMinWidth(mNativePointer); } + private native void jni_YGNodeStyleSetMinWidth(long nativePointer, float minWidth); public void setMinWidth(float minWidth) { - mDelegate.setMinWidth(minWidth); + jni_YGNodeStyleSetMinWidth(mNativePointer, minWidth); } + private native void jni_YGNodeStyleSetMinWidthPercent(long nativePointer, float percent); public void setMinWidthPercent(float percent) { - mDelegate.setMinWidthPercent(percent); + jni_YGNodeStyleSetMinWidthPercent(mNativePointer, percent); } + private native Object jni_YGNodeStyleGetMinHeight(long nativePointer); public YogaValue getMinHeight() { - return mDelegate.getMinHeight(); + return (YogaValue) jni_YGNodeStyleGetMinHeight(mNativePointer); } + private native void jni_YGNodeStyleSetMinHeight(long nativePointer, float minHeight); public void setMinHeight(float minHeight) { - mDelegate.setMinHeight(minHeight); + jni_YGNodeStyleSetMinHeight(mNativePointer, minHeight); } + private native void jni_YGNodeStyleSetMinHeightPercent(long nativePointer, float percent); public void setMinHeightPercent(float percent) { - mDelegate.setMinHeightPercent(percent); + jni_YGNodeStyleSetMinHeightPercent(mNativePointer, percent); } + private native Object jni_YGNodeStyleGetMaxWidth(long nativePointer); public YogaValue getMaxWidth() { - return mDelegate.getMaxWidth(); + return (YogaValue) jni_YGNodeStyleGetMaxWidth(mNativePointer); } + private native void jni_YGNodeStyleSetMaxWidth(long nativePointer, float maxWidth); public void setMaxWidth(float maxWidth) { - mDelegate.setMaxWidth(maxWidth); + jni_YGNodeStyleSetMaxWidth(mNativePointer, maxWidth); } + private native void jni_YGNodeStyleSetMaxWidthPercent(long nativePointer, float percent); public void setMaxWidthPercent(float percent) { - mDelegate.setMaxWidthPercent(percent); + jni_YGNodeStyleSetMaxWidthPercent(mNativePointer, percent); } + private native Object jni_YGNodeStyleGetMaxHeight(long nativePointer); public YogaValue getMaxHeight() { - return mDelegate.getMaxHeight(); + return (YogaValue) jni_YGNodeStyleGetMaxHeight(mNativePointer); } + private native void jni_YGNodeStyleSetMaxHeight(long nativePointer, float maxheight); public void setMaxHeight(float maxheight) { - mDelegate.setMaxHeight(maxheight); + jni_YGNodeStyleSetMaxHeight(mNativePointer, maxheight); } + private native void jni_YGNodeStyleSetMaxHeightPercent(long nativePointer, float percent); public void setMaxHeightPercent(float percent) { - mDelegate.setMaxHeightPercent(percent); + jni_YGNodeStyleSetMaxHeightPercent(mNativePointer, percent); } + private native float jni_YGNodeStyleGetAspectRatio(long nativePointer); public float getAspectRatio() { - return mDelegate.getAspectRatio(); + return jni_YGNodeStyleGetAspectRatio(mNativePointer); } + private native void jni_YGNodeStyleSetAspectRatio(long nativePointer, float aspectRatio); public void setAspectRatio(float aspectRatio) { - mDelegate.setAspectRatio(aspectRatio); + jni_YGNodeStyleSetAspectRatio(mNativePointer, aspectRatio); } public float getLayoutX() { - return mDelegate.getLayoutX(); + return mLeft; } public float getLayoutY() { - return mDelegate.getLayoutY(); + return mTop; } public float getLayoutWidth() { - return mDelegate.getLayoutWidth(); + return mWidth; } public float getLayoutHeight() { - return mDelegate.getLayoutHeight(); + return mHeight; } public boolean getDoesLegacyStretchFlagAffectsLayout() { - return mDelegate.getDoesLegacyStretchFlagAffectsLayout(); + return mDoesLegacyStretchFlagAffectsLayout; } public float getLayoutMargin(YogaEdge edge) { - return mDelegate.getLayoutMargin(edge); + switch (edge) { + case LEFT: + return mMarginLeft; + case TOP: + return mMarginTop; + case RIGHT: + return mMarginRight; + case BOTTOM: + return mMarginBottom; + case START: + return getLayoutDirection() == YogaDirection.RTL ? mMarginRight : mMarginLeft; + case END: + return getLayoutDirection() == YogaDirection.RTL ? mMarginLeft : mMarginRight; + default: + throw new IllegalArgumentException("Cannot get layout margins of multi-edge shorthands"); + } } public float getLayoutPadding(YogaEdge edge) { - return mDelegate.getLayoutPadding(edge); + switch (edge) { + case LEFT: + return mPaddingLeft; + case TOP: + return mPaddingTop; + case RIGHT: + return mPaddingRight; + case BOTTOM: + return mPaddingBottom; + case START: + return getLayoutDirection() == YogaDirection.RTL ? mPaddingRight : mPaddingLeft; + case END: + return getLayoutDirection() == YogaDirection.RTL ? mPaddingLeft : mPaddingRight; + default: + throw new IllegalArgumentException("Cannot get layout paddings of multi-edge shorthands"); + } } public float getLayoutBorder(YogaEdge edge) { - return mDelegate.getLayoutBorder(edge); + switch (edge) { + case LEFT: + return mBorderLeft; + case TOP: + return mBorderTop; + case RIGHT: + return mBorderRight; + case BOTTOM: + return mBorderBottom; + case START: + return getLayoutDirection() == YogaDirection.RTL ? mBorderRight : mBorderLeft; + case END: + return getLayoutDirection() == YogaDirection.RTL ? mBorderLeft : mBorderRight; + default: + throw new IllegalArgumentException("Cannot get layout border of multi-edge shorthands"); + } } public YogaDirection getLayoutDirection() { - return mDelegate.getLayoutDirection(); + return YogaDirection.fromInt(mLayoutDirection); } private native void jni_YGNodeSetHasMeasureFunc(long nativePointer, boolean hasMeasureFunc); public void setMeasureFunction(YogaMeasureFunction measureFunction) { mMeasureFunction = measureFunction; - jni_YGNodeSetHasMeasureFunc(getNativePointer(), measureFunction != null); + jni_YGNodeSetHasMeasureFunc(mNativePointer, measureFunction != null); } // Implementation Note: Why this method needs to stay final @@ -560,7 +748,7 @@ public class YogaNode implements Cloneable { private native void jni_YGNodeSetHasBaselineFunc(long nativePointer, boolean hasMeasureFunc); public void setBaselineFunction(YogaBaselineFunction baselineFunction) { mBaselineFunction = baselineFunction; - jni_YGNodeSetHasBaselineFunc(getNativePointer(), baselineFunction != null); + jni_YGNodeSetHasBaselineFunc(mNativePointer, baselineFunction != null); } @DoNotStrip @@ -587,7 +775,7 @@ public class YogaNode implements Cloneable { * layout of the tree rooted at this node. */ public void print() { - jni_YGNodePrint(getNativePointer()); + jni_YGNodePrint(mNativePointer); } /** @@ -605,6 +793,6 @@ public class YogaNode implements Cloneable { mChildren.remove(childIndex); mChildren.add(childIndex, newNode); newNode.mOwner = this; - return newNode.getNativePointer(); + return newNode.mNativePointer; } } diff --git a/ReactAndroid/src/main/java/com/facebook/yoga/YogaNodeMemoryLayout.java b/ReactAndroid/src/main/java/com/facebook/yoga/YogaNodeMemoryLayout.java deleted file mode 100644 index 212c27ec0..000000000 --- a/ReactAndroid/src/main/java/com/facebook/yoga/YogaNodeMemoryLayout.java +++ /dev/null @@ -1,151 +0,0 @@ -/* - * Copyright (c) 2014-present, Facebook, Inc. - * - * 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; - -import com.facebook.proguard.annotations.DoNotStrip; -import java.nio.ByteBuffer; - -@DoNotStrip -/* package */ final class YogaNodeMemoryLayout { - - private static final int FLOAT_SIZE = 4; - private static final int INT_SIZE = 4; - private static final int VALUE_SIZE = FLOAT_SIZE + INT_SIZE; - private static final byte FALSE = 0; - private static final byte TRUE = 1; - private static final int AUTO = YogaUnit.AUTO.intValue(); - private static final int POINT = YogaUnit.POINT.intValue(); - private static final int PERCENT = YogaUnit.PERCENT.intValue(); - private static final int UNDEFINED = YogaUnit.UNDEFINED.intValue(); - - // TODO(davidaurelio) code-gen these values - static final int styleDirection = 0; - static final int styleFlexDirection = 4; - static final int styleJustifyContent = 8; - static final int styleAlignContent = 12; - static final int styleAlignItems = 16; - static final int styleAlignSelf = 20; - static final int stylePositionType = 24; - static final int styleFlexWrap = 28; - static final int styleOverflow = 32; - static final int styleDisplay = 36; - static final int styleFlex = 40; - static final int styleFlexGrow = 48; - static final int styleFlexShrink = 56; - static final int styleFlexBasis = 64; - static final int styleMargin = 72; - static final int stylePosition = 144; - static final int stylePadding = 216; - static final int styleBorder = 288; - static final int styleDimensions = 360; - static final int styleMinDimensions = 376; - static final int styleMaxDimensions = 392; - static final int styleAspectRatio = 408; - - static final int styleWidth = styleDimensions; - static final int styleHeight = styleDimensions + VALUE_SIZE; - static final int styleMinWidth = styleMinDimensions; - static final int styleMinHeight = styleMinDimensions + VALUE_SIZE; - static final int styleMaxWidth = styleMaxDimensions; - static final int styleMaxHeight = styleMaxDimensions + VALUE_SIZE; - - static final int layoutPosition = 0; - static final int layoutDimensions = 16; - static final int layoutMargin = 24; - static final int layoutBorder = 48; - static final int layoutPadding = 72; - static final int layoutDirection = 96; - static final int layoutComputedFlexBasisGeneration = 100; - static final int layoutComputedFlexBasis = 104; - static final int layoutHadOverflow = 112; - static final int layoutGenerationCount = 116; - static final int layoutLastOwnerDirection = 120; - static final int layoutNextCachedMeasurementsIndex = 124; - static final int layoutCachedMeasurements = 128; - static final int layoutMeasuredDimensions = 512; - static final int layoutCachedLayout = 520; - static final int layoutDidUseLegacyFlag = 544; - static final int layoutDoesLegacyStretchFlagAffectsLayout = 545; - - static final int layoutX = layoutPosition; - static final int layoutY = layoutPosition + FLOAT_SIZE; - static final int layoutWidth = layoutDimensions; - static final int layoutHeight = layoutDimensions + FLOAT_SIZE; - - static int stylePositionOffset(YogaEdge edge) { - return stylePosition + edge.intValue() * VALUE_SIZE; - } - - static int styleMarginOffset(YogaEdge edge) { - return styleMargin + edge.intValue() * VALUE_SIZE; - } - - static int layoutMarginOffset(YogaEdge edge) { - return layoutMargin + edge.intValue() * FLOAT_SIZE; - } - - static int stylePaddingOffset(YogaEdge edge) { - return stylePadding + edge.intValue() * VALUE_SIZE; - } - - static int layoutPaddingOffset(YogaEdge edge) { - return layoutPadding + edge.intValue() * FLOAT_SIZE; - } - - static int styleBorderOffset(YogaEdge edge) { - return styleBorder + edge.intValue() * VALUE_SIZE; - } - - static int layoutBorderOffset(YogaEdge edge) { - return layoutBorder + edge.intValue() * FLOAT_SIZE; - } - - static void putOptional(ByteBuffer buffer, int offset, float value) { - buffer.putFloat(offset, value); - buffer.put( - offset + FLOAT_SIZE, YogaConstants.isUndefined(value) ? TRUE : FALSE); // bool isUndefined_ - } - - static float getOptional(ByteBuffer buffer, int offset) { - return getBoolean(buffer, offset + FLOAT_SIZE) - ? YogaConstants.UNDEFINED - : buffer.getFloat(offset); - } - - private static void putValue(ByteBuffer buffer, int offset, float value, int unit) { - if (YogaConstants.isUndefined(value)) { - value = YogaConstants.UNDEFINED; - unit = UNDEFINED; - } - buffer.putFloat(offset, value); - buffer.putInt(offset + FLOAT_SIZE, unit); - } - - static void putAutoValue(ByteBuffer buffer, int offset) { - putValue(buffer, offset, 0, AUTO); - } - - static void putPointValue(ByteBuffer buffer, int offset, float value) { - putValue(buffer, offset, value, POINT); - } - - static void putPercentValue(ByteBuffer buffer, int offset, float value) { - putValue(buffer, offset, value, PERCENT); - } - - static YogaValue getValue(ByteBuffer buffer, int offset) { - float value = buffer.getFloat(offset); - int unit = buffer.getInt(offset + FLOAT_SIZE); - return new YogaValue(value, YogaUnit.fromInt(unit)); - } - - static boolean getBoolean(ByteBuffer buffer, int offset) { - return buffer.get(offset) != 0; - } -} diff --git a/ReactAndroid/src/main/java/com/facebook/yoga/YogaNodeProperties.java b/ReactAndroid/src/main/java/com/facebook/yoga/YogaNodeProperties.java deleted file mode 100644 index c93145e49..000000000 --- a/ReactAndroid/src/main/java/com/facebook/yoga/YogaNodeProperties.java +++ /dev/null @@ -1,169 +0,0 @@ -/* - * Copyright (c) 2018-present, Facebook, Inc. - * - * 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 YogaNodeProperties { - - YogaNodeProperties clone(YogaNode node); - - long getNativePointer(); - - void onAfterCalculateLayout(boolean hasNewLayout); - - void reset(); - - boolean hasNewLayout(); - - boolean isDirty(); - - void markLayoutSeen(); - - 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); - - YogaOverflow getOverflow(); - - void setOverflow(YogaOverflow overflow); - - YogaDisplay getDisplay(); - - void setDisplay(YogaDisplay display); - - void setFlex(float flex); - - float getFlexGrow(); - - void setFlexGrow(float flexGrow); - - float getFlexShrink(); - - void setFlexShrink(float flexShrink); - - YogaValue getFlexBasis(); - - void setFlexBasis(float flexBasis); - - void setFlexBasisPercent(float percent); - - void setFlexBasisAuto(); - - YogaValue getMargin(YogaEdge edge); - - void setMargin(YogaEdge edge, float margin); - - void setMarginPercent(YogaEdge edge, float percent); - - void setMarginAuto(YogaEdge edge); - - YogaValue getPadding(YogaEdge edge); - - void setPadding(YogaEdge edge, float padding); - - void setPaddingPercent(YogaEdge edge, float percent); - - float getBorder(YogaEdge edge); - - void setBorder(YogaEdge edge, float border); - - YogaValue getPosition(YogaEdge edge); - - void setPosition(YogaEdge edge, float position); - - void setPositionPercent(YogaEdge edge, float percent); - - YogaValue getWidth(); - - void setWidth(float width); - - void setWidthPercent(float percent); - - void setWidthAuto(); - - YogaValue getHeight(); - - void setHeight(float height); - - void setHeightPercent(float percent); - - void setHeightAuto(); - - YogaValue getMinWidth(); - - void setMinWidth(float minWidth); - - void setMinWidthPercent(float percent); - - YogaValue getMinHeight(); - - void setMinHeight(float minHeight); - - void setMinHeightPercent(float percent); - - YogaValue getMaxWidth(); - - void setMaxWidth(float maxWidth); - - void setMaxWidthPercent(float percent); - - YogaValue getMaxHeight(); - - void setMaxHeight(float maxheight); - - void setMaxHeightPercent(float percent); - - float getAspectRatio(); - - void setAspectRatio(float aspectRatio); - - float getLayoutX(); - - float getLayoutY(); - - float getLayoutWidth(); - - float getLayoutHeight(); - - boolean getDoesLegacyStretchFlagAffectsLayout(); - - float getLayoutMargin(YogaEdge edge); - - float getLayoutPadding(YogaEdge edge); - - float getLayoutBorder(YogaEdge edge); - - YogaDirection getLayoutDirection(); - - void freeNatives(); -} diff --git a/ReactAndroid/src/main/java/com/facebook/yoga/YogaNodePropertiesByteBuffer.java b/ReactAndroid/src/main/java/com/facebook/yoga/YogaNodePropertiesByteBuffer.java deleted file mode 100644 index f189a5b41..000000000 --- a/ReactAndroid/src/main/java/com/facebook/yoga/YogaNodePropertiesByteBuffer.java +++ /dev/null @@ -1,515 +0,0 @@ -/* - * Copyright (c) 2018-present, Facebook, Inc. - * - * 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; - -import com.facebook.proguard.annotations.DoNotStrip; -import com.facebook.soloader.SoLoader; -import java.nio.ByteBuffer; -import java.nio.ByteOrder; - -@DoNotStrip -public class YogaNodePropertiesByteBuffer implements YogaNodeProperties, Cloneable { - - static { - SoLoader.loadLibrary("yoga"); - } - - private static final int RTL = YogaDirection.RTL.intValue(); - private final ByteBuffer mStyleBuffer; - private final ByteBuffer mLayoutBuffer; - private final long mNativePointer; - private boolean mHasBorderSet = false; - private boolean mHasNewLayout = true; - private boolean isFreed = false; - - private static native ByteBuffer jni_getStyleBuffer(long nativePointer); - - private static native ByteBuffer jni_getLayoutBuffer(long nativePointer); - - private static native long jni_YGNodeNewNoProps(YogaNode node); - - public YogaNodePropertiesByteBuffer(YogaNode node) { - this(jni_YGNodeNewNoProps(node)); - } - - private static native long jni_YGNodeNewNoPropsWithConfig(YogaNode node, long configPointer); - - public YogaNodePropertiesByteBuffer(YogaNode node, YogaConfig config) { - this(jni_YGNodeNewNoPropsWithConfig(node, config.mNativePointer)); - } - - public YogaNodePropertiesByteBuffer(long nativePointer) { - mNativePointer = nativePointer; - mStyleBuffer = jni_getStyleBuffer(nativePointer).order(ByteOrder.LITTLE_ENDIAN); - mLayoutBuffer = jni_getLayoutBuffer(nativePointer).order(ByteOrder.LITTLE_ENDIAN); - } - - @Override - protected void finalize() throws Throwable { - try { - freeNatives(); - } finally { - super.finalize(); - } - } - - private static native long jni_YGNodeCloneNoProps(long nativePointer, YogaNode newNode); - - @Override - public YogaNodeProperties clone(YogaNode node) { - long clonedNativePointer = jni_YGNodeCloneNoProps(getNativePointer(), node); - YogaNodePropertiesByteBuffer clone = new YogaNodePropertiesByteBuffer(clonedNativePointer); - clone.mHasBorderSet = mHasBorderSet; - clone.mHasNewLayout = mHasNewLayout; - return clone; - } - - @Override - public long getNativePointer() { - return mNativePointer; - } - - @Override - public void onAfterCalculateLayout(boolean hasNewLayout) { - mHasNewLayout = hasNewLayout; - } - - private static native void jni_YGNodeReset(long nativePointer); - - @Override - public void reset() { - mHasBorderSet = false; - mHasNewLayout = true; - jni_YGNodeReset(getNativePointer()); - } - - @Override - public boolean hasNewLayout() { - return mHasNewLayout; - } - - private static native boolean jni_YGNodeIsDirty(long nativePointer); - - @Override - public boolean isDirty() { - return jni_YGNodeIsDirty(mNativePointer); - } - - @Override - public void markLayoutSeen() { - mHasNewLayout = false; - } - - @Override - public YogaDirection getStyleDirection() { - return YogaDirection.fromInt(mStyleBuffer.getInt(YogaNodeMemoryLayout.styleDirection)); - } - - @Override - public YogaValue getPosition(YogaEdge edge) { - return YogaNodeMemoryLayout.getValue( - mStyleBuffer, YogaNodeMemoryLayout.stylePositionOffset(edge)); - } - - @Override - public YogaValue getMargin(YogaEdge edge) { - return YogaNodeMemoryLayout.getValue( - mStyleBuffer, YogaNodeMemoryLayout.styleMarginOffset(edge)); - } - - @Override - public YogaValue getPadding(YogaEdge edge) { - return YogaNodeMemoryLayout.getValue( - mStyleBuffer, YogaNodeMemoryLayout.stylePaddingOffset(edge)); - } - - @Override - public float getBorder(YogaEdge edge) { - return mHasBorderSet - ? mStyleBuffer.getFloat(YogaNodeMemoryLayout.styleBorderOffset(edge)) - : YogaConstants.UNDEFINED; - } - - @Override - public void setDirection(YogaDirection direction) { - mStyleBuffer.putInt(YogaNodeMemoryLayout.styleDirection, direction.intValue()); - } - - @Override - public YogaFlexDirection getFlexDirection() { - return YogaFlexDirection.fromInt(mStyleBuffer.getInt(YogaNodeMemoryLayout.styleFlexDirection)); - } - - @Override - public void setFlexDirection(YogaFlexDirection flexDirection) { - mStyleBuffer.putInt(YogaNodeMemoryLayout.styleFlexDirection, flexDirection.intValue()); - } - - @Override - public YogaJustify getJustifyContent() { - return YogaJustify.fromInt(mStyleBuffer.getInt(YogaNodeMemoryLayout.styleJustifyContent)); - } - - @Override - public void setJustifyContent(YogaJustify justifyContent) { - mStyleBuffer.putInt(YogaNodeMemoryLayout.styleJustifyContent, justifyContent.intValue()); - } - - @Override - public YogaAlign getAlignItems() { - return YogaAlign.fromInt(mStyleBuffer.getInt(YogaNodeMemoryLayout.styleAlignItems)); - } - - @Override - public void setAlignItems(YogaAlign alignItems) { - mStyleBuffer.putInt(YogaNodeMemoryLayout.styleAlignItems, alignItems.intValue()); - } - - @Override - public YogaAlign getAlignSelf() { - return YogaAlign.fromInt(mStyleBuffer.getInt(YogaNodeMemoryLayout.styleAlignSelf)); - } - - @Override - public void setAlignSelf(YogaAlign alignSelf) { - mStyleBuffer.putInt(YogaNodeMemoryLayout.styleAlignSelf, alignSelf.intValue()); - } - - @Override - public YogaAlign getAlignContent() { - return YogaAlign.fromInt(mStyleBuffer.getInt(YogaNodeMemoryLayout.styleAlignContent)); - } - - @Override - public void setAlignContent(YogaAlign alignContent) { - mStyleBuffer.putInt(YogaNodeMemoryLayout.styleAlignContent, alignContent.intValue()); - } - - @Override - public YogaPositionType getPositionType() { - return YogaPositionType.fromInt(mStyleBuffer.getInt(YogaNodeMemoryLayout.stylePositionType)); - } - - @Override - public void setPositionType(YogaPositionType positionType) { - mStyleBuffer.putInt(YogaNodeMemoryLayout.stylePositionType, positionType.intValue()); - } - - @Override - public void setWrap(YogaWrap flexWrap) { - mStyleBuffer.putInt(YogaNodeMemoryLayout.styleFlexWrap, flexWrap.intValue()); - } - - @Override - public YogaOverflow getOverflow() { - return YogaOverflow.fromInt(mStyleBuffer.getInt(YogaNodeMemoryLayout.styleOverflow)); - } - - @Override - public void setOverflow(YogaOverflow overflow) { - mStyleBuffer.putInt(YogaNodeMemoryLayout.styleOverflow, overflow.intValue()); - } - - @Override - public YogaDisplay getDisplay() { - return YogaDisplay.fromInt(mStyleBuffer.getInt(YogaNodeMemoryLayout.styleDisplay)); - } - - @Override - public void setDisplay(YogaDisplay display) { - mStyleBuffer.putInt(YogaNodeMemoryLayout.styleDisplay, display.intValue()); - } - - @Override - public void setFlex(float flex) { - YogaNodeMemoryLayout.putOptional(mStyleBuffer, YogaNodeMemoryLayout.styleFlex, flex); - } - - @Override - public float getFlexGrow() { - return mStyleBuffer.getFloat(YogaNodeMemoryLayout.styleFlexGrow); - } - - @Override - public void setFlexGrow(float flexGrow) { - YogaNodeMemoryLayout.putOptional(mStyleBuffer, YogaNodeMemoryLayout.styleFlexGrow, flexGrow); - } - - @Override - public float getFlexShrink() { - return mStyleBuffer.getFloat(YogaNodeMemoryLayout.styleFlexShrink); - } - - @Override - public void setFlexShrink(float flexShrink) { - YogaNodeMemoryLayout.putOptional( - mStyleBuffer, YogaNodeMemoryLayout.styleFlexShrink, flexShrink); - } - - @Override - public YogaValue getFlexBasis() { - return YogaNodeMemoryLayout.getValue(mStyleBuffer, YogaNodeMemoryLayout.styleFlexBasis); - } - - @Override - public void setFlexBasis(float flexBasis) { - YogaNodeMemoryLayout.putPointValue( - mStyleBuffer, YogaNodeMemoryLayout.styleFlexBasis, flexBasis); - } - - @Override - public void setFlexBasisPercent(float percent) { - YogaNodeMemoryLayout.putPercentValue( - mStyleBuffer, YogaNodeMemoryLayout.styleFlexBasis, percent); - } - - @Override - public void setFlexBasisAuto() { - YogaNodeMemoryLayout.putAutoValue(mStyleBuffer, YogaNodeMemoryLayout.styleFlexBasis); - } - - @Override - public void setMargin(YogaEdge edge, float margin) { - YogaNodeMemoryLayout.putPointValue( - mStyleBuffer, YogaNodeMemoryLayout.styleMarginOffset(edge), margin); - } - - @Override - public void setMarginPercent(YogaEdge edge, float percent) { - YogaNodeMemoryLayout.putPercentValue( - mStyleBuffer, YogaNodeMemoryLayout.styleMarginOffset(edge), percent); - } - - @Override - public void setMarginAuto(YogaEdge edge) { - YogaNodeMemoryLayout.putAutoValue(mStyleBuffer, YogaNodeMemoryLayout.styleMarginOffset(edge)); - } - - @Override - public void setPadding(YogaEdge edge, float padding) { - YogaNodeMemoryLayout.putPointValue( - mStyleBuffer, YogaNodeMemoryLayout.stylePaddingOffset(edge), padding); - } - - @Override - public void setPaddingPercent(YogaEdge edge, float percent) { - YogaNodeMemoryLayout.putPercentValue( - mStyleBuffer, YogaNodeMemoryLayout.stylePaddingOffset(edge), percent); - } - - @Override - public void setBorder(YogaEdge edge, float border) { - mHasBorderSet = true; - YogaNodeMemoryLayout.putPointValue( - mStyleBuffer, YogaNodeMemoryLayout.styleBorderOffset(edge), border); - } - - @Override - public void setPosition(YogaEdge edge, float position) { - YogaNodeMemoryLayout.putPointValue( - mStyleBuffer, YogaNodeMemoryLayout.stylePositionOffset(edge), position); - } - - @Override - public void setPositionPercent(YogaEdge edge, float percent) { - YogaNodeMemoryLayout.putPercentValue( - mStyleBuffer, YogaNodeMemoryLayout.stylePositionOffset(edge), percent); - } - - @Override - public YogaValue getWidth() { - return YogaNodeMemoryLayout.getValue(mStyleBuffer, YogaNodeMemoryLayout.styleWidth); - } - - @Override - public void setWidth(float width) { - YogaNodeMemoryLayout.putPointValue(mStyleBuffer, YogaNodeMemoryLayout.styleWidth, width); - } - - @Override - public void setWidthPercent(float percent) { - YogaNodeMemoryLayout.putPercentValue(mStyleBuffer, YogaNodeMemoryLayout.styleWidth, percent); - } - - @Override - public void setWidthAuto() { - YogaNodeMemoryLayout.putAutoValue(mStyleBuffer, YogaNodeMemoryLayout.styleWidth); - } - - @Override - public YogaValue getHeight() { - return YogaNodeMemoryLayout.getValue(mStyleBuffer, YogaNodeMemoryLayout.styleHeight); - } - - @Override - public void setHeight(float height) { - YogaNodeMemoryLayout.putPointValue(mStyleBuffer, YogaNodeMemoryLayout.styleHeight, height); - } - - @Override - public void setHeightPercent(float percent) { - YogaNodeMemoryLayout.putPercentValue(mStyleBuffer, YogaNodeMemoryLayout.styleHeight, percent); - } - - @Override - public void setHeightAuto() { - YogaNodeMemoryLayout.putAutoValue(mStyleBuffer, YogaNodeMemoryLayout.styleHeight); - } - - @Override - public YogaValue getMinWidth() { - return YogaNodeMemoryLayout.getValue(mStyleBuffer, YogaNodeMemoryLayout.styleMinWidth); - } - - @Override - public void setMinWidth(float minWidth) { - YogaNodeMemoryLayout.putPointValue(mStyleBuffer, YogaNodeMemoryLayout.styleMinWidth, minWidth); - } - - @Override - public void setMinWidthPercent(float percent) { - YogaNodeMemoryLayout.putPercentValue(mStyleBuffer, YogaNodeMemoryLayout.styleMinWidth, percent); - } - - @Override - public YogaValue getMinHeight() { - return YogaNodeMemoryLayout.getValue(mStyleBuffer, YogaNodeMemoryLayout.styleMinHeight); - } - - @Override - public void setMinHeight(float minHeight) { - YogaNodeMemoryLayout.putPointValue( - mStyleBuffer, YogaNodeMemoryLayout.styleMinHeight, minHeight); - } - - @Override - public void setMinHeightPercent(float percent) { - YogaNodeMemoryLayout.putPercentValue( - mStyleBuffer, YogaNodeMemoryLayout.styleMinHeight, percent); - } - - @Override - public YogaValue getMaxWidth() { - return YogaNodeMemoryLayout.getValue(mStyleBuffer, YogaNodeMemoryLayout.styleMaxWidth); - } - - @Override - public void setMaxWidth(float maxWidth) { - YogaNodeMemoryLayout.putPointValue(mStyleBuffer, YogaNodeMemoryLayout.styleMaxWidth, maxWidth); - } - - @Override - public void setMaxWidthPercent(float percent) { - YogaNodeMemoryLayout.putPercentValue(mStyleBuffer, YogaNodeMemoryLayout.styleMaxWidth, percent); - } - - @Override - public YogaValue getMaxHeight() { - return YogaNodeMemoryLayout.getValue(mStyleBuffer, YogaNodeMemoryLayout.styleMaxHeight); - } - - @Override - public void setMaxHeight(float maxHeight) { - YogaNodeMemoryLayout.putPointValue( - mStyleBuffer, YogaNodeMemoryLayout.styleMaxHeight, maxHeight); - } - - @Override - public void setMaxHeightPercent(float percent) { - YogaNodeMemoryLayout.putPercentValue( - mStyleBuffer, YogaNodeMemoryLayout.styleMaxHeight, percent); - } - - @Override - public float getAspectRatio() { - return YogaNodeMemoryLayout.getOptional(mStyleBuffer, YogaNodeMemoryLayout.styleAspectRatio); - } - - @Override - public void setAspectRatio(float aspectRatio) { - YogaNodeMemoryLayout.putOptional( - mStyleBuffer, YogaNodeMemoryLayout.styleAspectRatio, aspectRatio); - } - - @Override - public float getLayoutX() { - return mLayoutBuffer.getFloat(YogaNodeMemoryLayout.layoutX); - } - - @Override - public float getLayoutY() { - return mLayoutBuffer.getFloat(YogaNodeMemoryLayout.layoutY); - } - - @Override - public float getLayoutWidth() { - return mLayoutBuffer.getFloat(YogaNodeMemoryLayout.layoutWidth); - } - - @Override - public float getLayoutHeight() { - return mLayoutBuffer.getFloat(YogaNodeMemoryLayout.layoutHeight); - } - - @Override - public boolean getDoesLegacyStretchFlagAffectsLayout() { - return YogaNodeMemoryLayout.getBoolean( - mLayoutBuffer, YogaNodeMemoryLayout.layoutDoesLegacyStretchFlagAffectsLayout); - } - - @Override - public float getLayoutMargin(YogaEdge edge) { - return mLayoutBuffer.getFloat(YogaNodeMemoryLayout.layoutMarginOffset(layoutEdge(edge))); - } - - @Override - public float getLayoutPadding(YogaEdge edge) { - return mLayoutBuffer.getFloat(YogaNodeMemoryLayout.layoutPaddingOffset(layoutEdge(edge))); - } - - @Override - public float getLayoutBorder(YogaEdge edge) { - return mLayoutBuffer.getFloat(YogaNodeMemoryLayout.layoutBorderOffset(layoutEdge(edge))); - } - - @Override - public YogaDirection getLayoutDirection() { - return YogaDirection.fromInt(getLayoutDirectionInt()); - } - - private static native void jni_YGNodeFree(long nativePointer); - - @Override - public void freeNatives() { - if (!isFreed) { - isFreed = true; - jni_YGNodeFree(mNativePointer); - } - } - - private int getLayoutDirectionInt() { - return mLayoutBuffer.getInt(YogaNodeMemoryLayout.layoutDirection); - } - - private YogaEdge layoutEdge(YogaEdge edge) { - int layoutDirection = getLayoutDirectionInt(); - switch (edge) { - case LEFT: - return layoutDirection == RTL ? YogaEdge.END : YogaEdge.START; - case RIGHT: - return layoutDirection == RTL ? YogaEdge.START : YogaEdge.END; - case TOP: - case BOTTOM: - case START: - case END: - return edge; - default: - throw new IllegalArgumentException("Cannot get layout properties of multi-edge shorthands"); - } - } -} diff --git a/ReactAndroid/src/main/java/com/facebook/yoga/YogaNodePropertiesHybrid.java b/ReactAndroid/src/main/java/com/facebook/yoga/YogaNodePropertiesHybrid.java deleted file mode 100644 index dc727cccd..000000000 --- a/ReactAndroid/src/main/java/com/facebook/yoga/YogaNodePropertiesHybrid.java +++ /dev/null @@ -1,261 +0,0 @@ -/* - * Copyright (c) 2018-present, Facebook, Inc. - * - * 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; - -import com.facebook.proguard.annotations.DoNotStrip; -import com.facebook.soloader.SoLoader; -import java.nio.ByteBuffer; -import java.nio.ByteOrder; - -@DoNotStrip -public class YogaNodePropertiesHybrid extends YogaNodePropertiesJNI { - - static { - SoLoader.loadLibrary("yoga"); - } - - private ByteBuffer mStyleBuffer; - - private static native ByteBuffer jni_getStyleBuffer(long nativePointer); - - public YogaNodePropertiesHybrid(YogaNode node) { - super(node); - mStyleBuffer = jni_getStyleBuffer(getNativePointer()).order(ByteOrder.LITTLE_ENDIAN); - } - - public YogaNodePropertiesHybrid(YogaNode node, YogaConfig config) { - super(node, config); - mStyleBuffer = jni_getStyleBuffer(getNativePointer()).order(ByteOrder.LITTLE_ENDIAN); - } - - @Override - public void setDirection(YogaDirection direction) { - mStyleBuffer.putInt(YogaNodeMemoryLayout.styleDirection, direction.intValue()); - } - - @Override - public void setFlexDirection(YogaFlexDirection flexDirection) { - mStyleBuffer.putInt(YogaNodeMemoryLayout.styleFlexDirection, flexDirection.intValue()); - } - - @Override - public void setJustifyContent(YogaJustify justifyContent) { - mStyleBuffer.putInt(YogaNodeMemoryLayout.styleJustifyContent, justifyContent.intValue()); - } - - @Override - public void setAlignItems(YogaAlign alignItems) { - mStyleBuffer.putInt(YogaNodeMemoryLayout.styleAlignItems, alignItems.intValue()); - } - - @Override - public void setAlignSelf(YogaAlign alignSelf) { - mStyleBuffer.putInt(YogaNodeMemoryLayout.styleAlignSelf, alignSelf.intValue()); - } - - @Override - public void setAlignContent(YogaAlign alignContent) { - mStyleBuffer.putInt(YogaNodeMemoryLayout.styleAlignContent, alignContent.intValue()); - } - - @Override - public void setPositionType(YogaPositionType positionType) { - mStyleBuffer.putInt(YogaNodeMemoryLayout.stylePositionType, positionType.intValue()); - } - - @Override - public void setWrap(YogaWrap flexWrap) { - mStyleBuffer.putInt(YogaNodeMemoryLayout.styleFlexWrap, flexWrap.intValue()); - } - - @Override - public void setOverflow(YogaOverflow overflow) { - mStyleBuffer.putInt(YogaNodeMemoryLayout.styleOverflow, overflow.intValue()); - } - - @Override - public void setDisplay(YogaDisplay display) { - mStyleBuffer.putInt(YogaNodeMemoryLayout.styleDisplay, display.intValue()); - } - - @Override - public void setFlex(float flex) { - YogaNodeMemoryLayout.putOptional(mStyleBuffer, YogaNodeMemoryLayout.styleFlex, flex); - } - - @Override - public void setFlexGrow(float flexGrow) { - YogaNodeMemoryLayout.putOptional(mStyleBuffer, YogaNodeMemoryLayout.styleFlexGrow, flexGrow); - } - - @Override - public void setFlexShrink(float flexShrink) { - YogaNodeMemoryLayout.putOptional( - mStyleBuffer, YogaNodeMemoryLayout.styleFlexShrink, flexShrink); - } - - @Override - public void setFlexBasis(float flexBasis) { - YogaNodeMemoryLayout.putPointValue( - mStyleBuffer, YogaNodeMemoryLayout.styleFlexBasis, flexBasis); - } - - @Override - public void setFlexBasisPercent(float percent) { - YogaNodeMemoryLayout.putPercentValue( - mStyleBuffer, YogaNodeMemoryLayout.styleFlexBasis, percent); - } - - @Override - public void setFlexBasisAuto() { - YogaNodeMemoryLayout.putAutoValue(mStyleBuffer, YogaNodeMemoryLayout.styleFlexBasis); - } - - @Override - public void setMargin(YogaEdge edge, float margin) { - mEdgeSetFlag |= MARGIN; - YogaNodeMemoryLayout.putPointValue( - mStyleBuffer, YogaNodeMemoryLayout.styleMarginOffset(edge), margin); - } - - @Override - public void setMarginPercent(YogaEdge edge, float percent) { - mEdgeSetFlag |= MARGIN; - YogaNodeMemoryLayout.putPercentValue( - mStyleBuffer, YogaNodeMemoryLayout.styleMarginOffset(edge), percent); - } - - @Override - public void setMarginAuto(YogaEdge edge) { - mEdgeSetFlag |= MARGIN; - YogaNodeMemoryLayout.putAutoValue(mStyleBuffer, YogaNodeMemoryLayout.styleMarginOffset(edge)); - } - - @Override - public void setPadding(YogaEdge edge, float padding) { - mEdgeSetFlag |= PADDING; - YogaNodeMemoryLayout.putPointValue( - mStyleBuffer, YogaNodeMemoryLayout.stylePaddingOffset(edge), padding); - } - - @Override - public void setPaddingPercent(YogaEdge edge, float percent) { - mEdgeSetFlag |= PADDING; - YogaNodeMemoryLayout.putPercentValue( - mStyleBuffer, YogaNodeMemoryLayout.stylePaddingOffset(edge), percent); - } - - @Override - public void setBorder(YogaEdge edge, float border) { - mEdgeSetFlag |= BORDER; - YogaNodeMemoryLayout.putPointValue( - mStyleBuffer, YogaNodeMemoryLayout.styleBorderOffset(edge), border); - } - - @Override - public void setPosition(YogaEdge edge, float position) { - mHasSetPosition = true; - YogaNodeMemoryLayout.putPointValue( - mStyleBuffer, YogaNodeMemoryLayout.stylePositionOffset(edge), position); - } - - @Override - public void setPositionPercent(YogaEdge edge, float percent) { - mHasSetPosition = true; - YogaNodeMemoryLayout.putPercentValue( - mStyleBuffer, YogaNodeMemoryLayout.stylePositionOffset(edge), percent); - } - - @Override - public void setWidth(float width) { - YogaNodeMemoryLayout.putPointValue(mStyleBuffer, YogaNodeMemoryLayout.styleWidth, width); - } - - @Override - public void setWidthPercent(float percent) { - YogaNodeMemoryLayout.putPercentValue(mStyleBuffer, YogaNodeMemoryLayout.styleWidth, percent); - } - - @Override - public void setWidthAuto() { - YogaNodeMemoryLayout.putAutoValue(mStyleBuffer, YogaNodeMemoryLayout.styleWidth); - } - - @Override - public void setHeight(float height) { - YogaNodeMemoryLayout.putPointValue(mStyleBuffer, YogaNodeMemoryLayout.styleHeight, height); - } - - @Override - public void setHeightPercent(float percent) { - YogaNodeMemoryLayout.putPercentValue(mStyleBuffer, YogaNodeMemoryLayout.styleHeight, percent); - } - - @Override - public void setHeightAuto() { - YogaNodeMemoryLayout.putAutoValue(mStyleBuffer, YogaNodeMemoryLayout.styleHeight); - } - - @Override - public void setMinWidth(float minWidth) { - YogaNodeMemoryLayout.putPointValue(mStyleBuffer, YogaNodeMemoryLayout.styleMinWidth, minWidth); - } - - @Override - public void setMinWidthPercent(float percent) { - YogaNodeMemoryLayout.putPercentValue(mStyleBuffer, YogaNodeMemoryLayout.styleMinWidth, percent); - } - - @Override - public void setMinHeight(float minHeight) { - YogaNodeMemoryLayout.putPointValue( - mStyleBuffer, YogaNodeMemoryLayout.styleMinHeight, minHeight); - } - - @Override - public void setMinHeightPercent(float percent) { - YogaNodeMemoryLayout.putPercentValue( - mStyleBuffer, YogaNodeMemoryLayout.styleMinHeight, percent); - } - - @Override - public void setMaxWidth(float maxWidth) { - YogaNodeMemoryLayout.putPointValue(mStyleBuffer, YogaNodeMemoryLayout.styleMaxWidth, maxWidth); - } - - @Override - public void setMaxWidthPercent(float percent) { - YogaNodeMemoryLayout.putPercentValue(mStyleBuffer, YogaNodeMemoryLayout.styleMaxWidth, percent); - } - - @Override - public void setMaxHeight(float maxHeight) { - YogaNodeMemoryLayout.putPointValue( - mStyleBuffer, YogaNodeMemoryLayout.styleMaxHeight, maxHeight); - } - - @Override - public void setMaxHeightPercent(float percent) { - YogaNodeMemoryLayout.putPercentValue( - mStyleBuffer, YogaNodeMemoryLayout.styleMaxHeight, percent); - } - - @Override - public void setAspectRatio(float aspectRatio) { - YogaNodeMemoryLayout.putOptional( - mStyleBuffer, YogaNodeMemoryLayout.styleAspectRatio, aspectRatio); - } - - @Override - public YogaNodeProperties clone(YogaNode node) { - YogaNodePropertiesHybrid clone = (YogaNodePropertiesHybrid) super.clone(node); - clone.mStyleBuffer = - jni_getStyleBuffer(clone.getNativePointer()).order(ByteOrder.LITTLE_ENDIAN); - return clone; - } -} diff --git a/ReactAndroid/src/main/java/com/facebook/yoga/YogaNodePropertiesJNI.java b/ReactAndroid/src/main/java/com/facebook/yoga/YogaNodePropertiesJNI.java deleted file mode 100644 index 2322193c0..000000000 --- a/ReactAndroid/src/main/java/com/facebook/yoga/YogaNodePropertiesJNI.java +++ /dev/null @@ -1,704 +0,0 @@ -/* - * Copyright (c) 2018-present, Facebook, Inc. - * - * 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; - -import com.facebook.proguard.annotations.DoNotStrip; -import com.facebook.soloader.SoLoader; - -@DoNotStrip -public class YogaNodePropertiesJNI implements Cloneable, YogaNodeProperties { - - static { - SoLoader.loadLibrary("yoga"); - } - - private long mNativePointer; - - /* Those flags needs be in sync with YGJNI.cpp */ - protected static final int MARGIN = 1; - protected static final int PADDING = 2; - protected static final int BORDER = 4; - - @DoNotStrip protected int mEdgeSetFlag = 0; - - protected 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 float mMarginLeft = 0; - @DoNotStrip private float mMarginTop = 0; - @DoNotStrip private float mMarginRight = 0; - @DoNotStrip private float mMarginBottom = 0; - @DoNotStrip private float mPaddingLeft = 0; - @DoNotStrip private float mPaddingTop = 0; - @DoNotStrip private float mPaddingRight = 0; - @DoNotStrip private float mPaddingBottom = 0; - @DoNotStrip private float mBorderLeft = 0; - @DoNotStrip private float mBorderTop = 0; - @DoNotStrip private float mBorderRight = 0; - @DoNotStrip private float mBorderBottom = 0; - @DoNotStrip private int mLayoutDirection = 0; - @DoNotStrip private boolean mHasNewLayout = true; - @DoNotStrip private boolean mDoesLegacyStretchFlagAffectsLayout = false; - - private native long jni_YGNodeNew(YogaNode node); - - public YogaNodePropertiesJNI(YogaNode node) { - mNativePointer = jni_YGNodeNew(node); - if (mNativePointer == 0) { - throw new IllegalStateException("Failed to allocate native memory"); - } - } - - private native long jni_YGNodeNewWithConfig(YogaNode node, long configPointer); - - public YogaNodePropertiesJNI(YogaNode node, YogaConfig config) { - mNativePointer = jni_YGNodeNewWithConfig(node, config.mNativePointer); - if (mNativePointer == 0) { - throw new IllegalStateException("Failed to allocate native memory"); - } - } - - private static native void jni_YGNodeFree(long nativePointer); - - @Override - public void freeNatives() { - long nativePointer = mNativePointer; - mNativePointer = 0; - jni_YGNodeFree(nativePointer); - } - - @Override - protected void finalize() throws Throwable { - try { - freeNatives(); - } finally { - super.finalize(); - } - } - - private static native long jni_YGNodeClone( - long nativePointer, YogaNode newNode, YogaNodePropertiesJNI newProps); - - @Override - public YogaNodeProperties clone(YogaNode node) { - try { - YogaNodePropertiesJNI clonedProperties = (YogaNodePropertiesJNI) clone(); - clonedProperties.mNativePointer = jni_YGNodeClone(getNativePointer(), node, clonedProperties); - return clonedProperties; - } catch (CloneNotSupportedException ex) { - // This class implements Cloneable, this should not happen - throw new RuntimeException(ex); - } - } - - @Override - public long getNativePointer() { - return mNativePointer; - } - - private static native void jni_YGTransferLayoutOutputsRecursive(long nativePointer); - - @Override - public void onAfterCalculateLayout(boolean hasNewLayoutIgnoredSetByNative) { - jni_YGTransferLayoutOutputsRecursive(mNativePointer); - } - - private native void jni_YGNodeReset(long nativePointer); - - @Override - public void reset() { - mHasSetPosition = false; - mEdgeSetFlag = 0; - mHasNewLayout = true; - mDoesLegacyStretchFlagAffectsLayout = false; - - mWidth = YogaConstants.UNDEFINED; - mHeight = YogaConstants.UNDEFINED; - mTop = YogaConstants.UNDEFINED; - mLeft = YogaConstants.UNDEFINED; - mMarginLeft = 0; - mMarginTop = 0; - mMarginRight = 0; - mMarginBottom = 0; - mPaddingLeft = 0; - mPaddingTop = 0; - mPaddingRight = 0; - mPaddingBottom = 0; - mBorderLeft = 0; - mBorderTop = 0; - mBorderRight = 0; - mBorderBottom = 0; - mLayoutDirection = 0; - jni_YGNodeReset(getNativePointer()); - } - - @Override - public boolean hasNewLayout() { - return mHasNewLayout; - } - - private native boolean jni_YGNodeIsDirty(long nativePointer); - - @Override - public boolean isDirty() { - return jni_YGNodeIsDirty(mNativePointer); - } - - @Override - public void markLayoutSeen() { - mHasNewLayout = false; - } - - private native int jni_YGNodeStyleGetDirection(long nativePointer); - - @Override - public YogaDirection getStyleDirection() { - return YogaDirection.fromInt(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.fromInt(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.fromInt(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.fromInt(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.fromInt(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.fromInt(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.fromInt(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.fromInt(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 int jni_YGNodeStyleGetDisplay(long nativePointer); - - @Override - public YogaDisplay getDisplay() { - return YogaDisplay.fromInt(jni_YGNodeStyleGetDisplay(mNativePointer)); - } - - private native void jni_YGNodeStyleSetDisplay(long nativePointer, int display); - - @Override - public void setDisplay(YogaDisplay display) { - jni_YGNodeStyleSetDisplay(mNativePointer, display.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 Object jni_YGNodeStyleGetFlexBasis(long nativePointer); - - @Override - public YogaValue getFlexBasis() { - return (YogaValue) jni_YGNodeStyleGetFlexBasis(mNativePointer); - } - - private native void jni_YGNodeStyleSetFlexBasis(long nativePointer, float flexBasis); - - @Override - public void setFlexBasis(float flexBasis) { - jni_YGNodeStyleSetFlexBasis(mNativePointer, flexBasis); - } - - private native void jni_YGNodeStyleSetFlexBasisPercent(long nativePointer, float percent); - - @Override - public void setFlexBasisPercent(float percent) { - jni_YGNodeStyleSetFlexBasisPercent(mNativePointer, percent); - } - - private native void jni_YGNodeStyleSetFlexBasisAuto(long nativePointer); - - @Override - public void setFlexBasisAuto() { - jni_YGNodeStyleSetFlexBasisAuto(mNativePointer); - } - - private native Object jni_YGNodeStyleGetMargin(long nativePointer, int edge); - - @Override - public YogaValue getMargin(YogaEdge edge) { - if (!((mEdgeSetFlag & MARGIN) == MARGIN)) { - return YogaValue.UNDEFINED; - } - return (YogaValue) jni_YGNodeStyleGetMargin(mNativePointer, edge.intValue()); - } - - private native void jni_YGNodeStyleSetMargin(long nativePointer, int edge, float margin); - - @Override - public void setMargin(YogaEdge edge, float margin) { - mEdgeSetFlag |= MARGIN; - jni_YGNodeStyleSetMargin(mNativePointer, edge.intValue(), margin); - } - - private native void jni_YGNodeStyleSetMarginPercent(long nativePointer, int edge, float percent); - - @Override - public void setMarginPercent(YogaEdge edge, float percent) { - mEdgeSetFlag |= MARGIN; - jni_YGNodeStyleSetMarginPercent(mNativePointer, edge.intValue(), percent); - } - - private native void jni_YGNodeStyleSetMarginAuto(long nativePointer, int edge); - - @Override - public void setMarginAuto(YogaEdge edge) { - mEdgeSetFlag |= MARGIN; - jni_YGNodeStyleSetMarginAuto(mNativePointer, edge.intValue()); - } - - private native Object jni_YGNodeStyleGetPadding(long nativePointer, int edge); - - @Override - public YogaValue getPadding(YogaEdge edge) { - if (!((mEdgeSetFlag & PADDING) == PADDING)) { - return YogaValue.UNDEFINED; - } - return (YogaValue) jni_YGNodeStyleGetPadding(mNativePointer, edge.intValue()); - } - - private native void jni_YGNodeStyleSetPadding(long nativePointer, int edge, float padding); - - @Override - public void setPadding(YogaEdge edge, float padding) { - mEdgeSetFlag |= PADDING; - jni_YGNodeStyleSetPadding(mNativePointer, edge.intValue(), padding); - } - - private native void jni_YGNodeStyleSetPaddingPercent(long nativePointer, int edge, float percent); - - @Override - public void setPaddingPercent(YogaEdge edge, float percent) { - mEdgeSetFlag |= PADDING; - jni_YGNodeStyleSetPaddingPercent(mNativePointer, edge.intValue(), percent); - } - - private native float jni_YGNodeStyleGetBorder(long nativePointer, int edge); - - @Override - public float getBorder(YogaEdge edge) { - if (!((mEdgeSetFlag & BORDER) == BORDER)) { - return 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) { - mEdgeSetFlag |= BORDER; - jni_YGNodeStyleSetBorder(mNativePointer, edge.intValue(), border); - } - - private native Object jni_YGNodeStyleGetPosition(long nativePointer, int edge); - - @Override - public YogaValue getPosition(YogaEdge edge) { - if (!mHasSetPosition) { - return YogaValue.UNDEFINED; - } - return (YogaValue) 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 void jni_YGNodeStyleSetPositionPercent( - long nativePointer, int edge, float percent); - - @Override - public void setPositionPercent(YogaEdge edge, float percent) { - mHasSetPosition = true; - jni_YGNodeStyleSetPositionPercent(mNativePointer, edge.intValue(), percent); - } - - private native Object jni_YGNodeStyleGetWidth(long nativePointer); - - @Override - public YogaValue getWidth() { - return (YogaValue) jni_YGNodeStyleGetWidth(mNativePointer); - } - - private native void jni_YGNodeStyleSetWidth(long nativePointer, float width); - - @Override - public void setWidth(float width) { - jni_YGNodeStyleSetWidth(mNativePointer, width); - } - - private native void jni_YGNodeStyleSetWidthPercent(long nativePointer, float percent); - - @Override - public void setWidthPercent(float percent) { - jni_YGNodeStyleSetWidthPercent(mNativePointer, percent); - } - - private native void jni_YGNodeStyleSetWidthAuto(long nativePointer); - - @Override - public void setWidthAuto() { - jni_YGNodeStyleSetWidthAuto(mNativePointer); - } - - private native Object jni_YGNodeStyleGetHeight(long nativePointer); - - @Override - public YogaValue getHeight() { - return (YogaValue) jni_YGNodeStyleGetHeight(mNativePointer); - } - - private native void jni_YGNodeStyleSetHeight(long nativePointer, float height); - - @Override - public void setHeight(float height) { - jni_YGNodeStyleSetHeight(mNativePointer, height); - } - - private native void jni_YGNodeStyleSetHeightPercent(long nativePointer, float percent); - - @Override - public void setHeightPercent(float percent) { - jni_YGNodeStyleSetHeightPercent(mNativePointer, percent); - } - - private native void jni_YGNodeStyleSetHeightAuto(long nativePointer); - - @Override - public void setHeightAuto() { - jni_YGNodeStyleSetHeightAuto(mNativePointer); - } - - private native Object jni_YGNodeStyleGetMinWidth(long nativePointer); - - @Override - public YogaValue getMinWidth() { - return (YogaValue) jni_YGNodeStyleGetMinWidth(mNativePointer); - } - - private native void jni_YGNodeStyleSetMinWidth(long nativePointer, float minWidth); - - @Override - public void setMinWidth(float minWidth) { - jni_YGNodeStyleSetMinWidth(mNativePointer, minWidth); - } - - private native void jni_YGNodeStyleSetMinWidthPercent(long nativePointer, float percent); - - @Override - public void setMinWidthPercent(float percent) { - jni_YGNodeStyleSetMinWidthPercent(mNativePointer, percent); - } - - private native Object jni_YGNodeStyleGetMinHeight(long nativePointer); - - @Override - public YogaValue getMinHeight() { - return (YogaValue) jni_YGNodeStyleGetMinHeight(mNativePointer); - } - - private native void jni_YGNodeStyleSetMinHeight(long nativePointer, float minHeight); - - @Override - public void setMinHeight(float minHeight) { - jni_YGNodeStyleSetMinHeight(mNativePointer, minHeight); - } - - private native void jni_YGNodeStyleSetMinHeightPercent(long nativePointer, float percent); - - @Override - public void setMinHeightPercent(float percent) { - jni_YGNodeStyleSetMinHeightPercent(mNativePointer, percent); - } - - private native Object jni_YGNodeStyleGetMaxWidth(long nativePointer); - - @Override - public YogaValue getMaxWidth() { - return (YogaValue) jni_YGNodeStyleGetMaxWidth(mNativePointer); - } - - private native void jni_YGNodeStyleSetMaxWidth(long nativePointer, float maxWidth); - - @Override - public void setMaxWidth(float maxWidth) { - jni_YGNodeStyleSetMaxWidth(mNativePointer, maxWidth); - } - - private native void jni_YGNodeStyleSetMaxWidthPercent(long nativePointer, float percent); - - @Override - public void setMaxWidthPercent(float percent) { - jni_YGNodeStyleSetMaxWidthPercent(mNativePointer, percent); - } - - private native Object jni_YGNodeStyleGetMaxHeight(long nativePointer); - - @Override - public YogaValue getMaxHeight() { - return (YogaValue) jni_YGNodeStyleGetMaxHeight(mNativePointer); - } - - private native void jni_YGNodeStyleSetMaxHeight(long nativePointer, float maxheight); - - @Override - public void setMaxHeight(float maxheight) { - jni_YGNodeStyleSetMaxHeight(mNativePointer, maxheight); - } - - private native void jni_YGNodeStyleSetMaxHeightPercent(long nativePointer, float percent); - - @Override - public void setMaxHeightPercent(float percent) { - jni_YGNodeStyleSetMaxHeightPercent(mNativePointer, percent); - } - - private native float jni_YGNodeStyleGetAspectRatio(long nativePointer); - - @Override - public float getAspectRatio() { - return jni_YGNodeStyleGetAspectRatio(mNativePointer); - } - - private native void jni_YGNodeStyleSetAspectRatio(long nativePointer, float aspectRatio); - - @Override - 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 boolean getDoesLegacyStretchFlagAffectsLayout() { - return mDoesLegacyStretchFlagAffectsLayout; - } - - @Override - public float getLayoutMargin(YogaEdge edge) { - switch (edge) { - case LEFT: - return mMarginLeft; - case TOP: - return mMarginTop; - case RIGHT: - return mMarginRight; - case BOTTOM: - return mMarginBottom; - case START: - return getLayoutDirection() == YogaDirection.RTL ? mMarginRight : mMarginLeft; - case END: - return getLayoutDirection() == YogaDirection.RTL ? mMarginLeft : mMarginRight; - default: - throw new IllegalArgumentException("Cannot get layout margins of multi-edge shorthands"); - } - } - - @Override - public float getLayoutPadding(YogaEdge edge) { - switch (edge) { - case LEFT: - return mPaddingLeft; - case TOP: - return mPaddingTop; - case RIGHT: - return mPaddingRight; - case BOTTOM: - return mPaddingBottom; - case START: - return getLayoutDirection() == YogaDirection.RTL ? mPaddingRight : mPaddingLeft; - case END: - return getLayoutDirection() == YogaDirection.RTL ? mPaddingLeft : mPaddingRight; - default: - throw new IllegalArgumentException("Cannot get layout paddings of multi-edge shorthands"); - } - } - - @Override - public float getLayoutBorder(YogaEdge edge) { - switch (edge) { - case LEFT: - return mBorderLeft; - case TOP: - return mBorderTop; - case RIGHT: - return mBorderRight; - case BOTTOM: - return mBorderBottom; - case START: - return getLayoutDirection() == YogaDirection.RTL ? mBorderRight : mBorderLeft; - case END: - return getLayoutDirection() == YogaDirection.RTL ? mBorderLeft : mBorderRight; - default: - throw new IllegalArgumentException("Cannot get layout border of multi-edge shorthands"); - } - } - - @Override - public YogaDirection getLayoutDirection() { - return YogaDirection.fromInt(mLayoutDirection); - } -} diff --git a/ReactAndroid/src/main/java/com/facebook/yoga/YogaNodePropertiesUnsafe.java b/ReactAndroid/src/main/java/com/facebook/yoga/YogaNodePropertiesUnsafe.java deleted file mode 100644 index f8af890b4..000000000 --- a/ReactAndroid/src/main/java/com/facebook/yoga/YogaNodePropertiesUnsafe.java +++ /dev/null @@ -1,580 +0,0 @@ -/* - * Copyright (c) 2018-present, Facebook, Inc. - * - * 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; - -import com.facebook.proguard.annotations.DoNotStrip; -import com.facebook.soloader.SoLoader; -import java.lang.reflect.Field; -import sun.misc.Unsafe; - -@DoNotStrip -public class YogaNodePropertiesUnsafe implements YogaNodeProperties { - - private static final int TRUE_BITS = 0x01000001; - private static final int FLOAT_SIZE = 4; - private static final int AUTO = YogaUnit.AUTO.intValue(); - private static final int POINT = YogaUnit.POINT.intValue(); - private static final int PERCENT = YogaUnit.PERCENT.intValue(); - private static final int UNDEFINED = YogaUnit.UNDEFINED.intValue(); - private static final int RTL = YogaDirection.RTL.intValue(); - private static final Unsafe UNSAFE; - - private final long mNativePointer; - private final long mStyleNativePointer; - private final long mLayoutNativePointer; - private boolean mHasBorderSet = false; - private boolean mHasNewLayout = true; - private boolean mIsFreed = false; - - static { - SoLoader.loadLibrary("yoga"); - Field instanceField = null; - try { - instanceField = Unsafe.class.getDeclaredField("theUnsafe"); - } catch (NoSuchFieldException e) { - throw new RuntimeException(e); - } - instanceField.setAccessible(true); - try { - UNSAFE = (Unsafe) instanceField.get(null); - } catch (IllegalAccessException e) { - throw new RuntimeException(e); - } - } - - private static native long jni_YGNodeNewNoProps(YogaNode node); - private static native long jni_YGNodeNewNoPropsWithConfig(YogaNode node, long configPointer); - private static native long jni_YGNodeStylePointer(long nativePointer); - private static native long jni_YGNodeLayoutPointer(long nativePointer); - - public YogaNodePropertiesUnsafe(YogaNode node) { - this(jni_YGNodeNewNoProps(node)); - } - - public YogaNodePropertiesUnsafe(YogaNode node, YogaConfig config) { - this(jni_YGNodeNewNoPropsWithConfig(node, config.mNativePointer)); - } - - public YogaNodePropertiesUnsafe(long nativePointer) { - mNativePointer = nativePointer; - mStyleNativePointer = jni_YGNodeStylePointer(nativePointer); - mLayoutNativePointer = jni_YGNodeLayoutPointer(nativePointer); - } - - private static native long jni_YGNodeCloneNoProps(long nativePointer, YogaNode newNode); - - @Override - public YogaNodeProperties clone(YogaNode node) { - long clonedNativePointer = jni_YGNodeCloneNoProps(getNativePointer(), node); - YogaNodePropertiesUnsafe clone = - new YogaNodePropertiesUnsafe(clonedNativePointer); - clone.mHasBorderSet = mHasBorderSet; - clone.mHasNewLayout = mHasNewLayout; - return clone; - } - - @Override - public long getNativePointer() { - return mNativePointer; - } - - @Override - public void onAfterCalculateLayout(boolean hasNewLayout) { - mHasNewLayout = hasNewLayout; - } - - private static native void jni_YGNodeReset(long nativePointer); - - @Override - public void reset() { - mHasNewLayout = true; - jni_YGNodeReset(getNativePointer()); - } - - @Override - public boolean hasNewLayout() { - return mHasNewLayout; - } - - private static native boolean jni_YGNodeIsDirty(long nativePointer); - - @Override - public boolean isDirty() { - return jni_YGNodeIsDirty(mNativePointer); - } - - @Override - public void markLayoutSeen() { - mHasNewLayout = false; - } - - @Override - public YogaDirection getStyleDirection() { - return YogaDirection.fromInt(getStyleInt(YogaNodeMemoryLayout.styleDirection)); - } - - @Override - public void setDirection(YogaDirection direction) { - putStyleInt(YogaNodeMemoryLayout.styleDirection, direction.intValue()); - } - - @Override - public YogaFlexDirection getFlexDirection() { - return YogaFlexDirection.fromInt(getStyleInt(YogaNodeMemoryLayout.styleFlexDirection)); - } - - @Override - public void setFlexDirection(YogaFlexDirection flexDirection) { - putStyleInt(YogaNodeMemoryLayout.styleFlexDirection, flexDirection.intValue()); - } - - @Override - public YogaJustify getJustifyContent() { - return YogaJustify.fromInt(getStyleInt(YogaNodeMemoryLayout.styleJustifyContent)); - } - - @Override - public void setJustifyContent(YogaJustify justifyContent) { - putStyleInt(YogaNodeMemoryLayout.styleJustifyContent, justifyContent.intValue()); - } - - @Override - public YogaAlign getAlignItems() { - return YogaAlign.fromInt(getStyleInt(YogaNodeMemoryLayout.styleAlignItems)); - } - - @Override - public void setAlignItems(YogaAlign alignItems) { - putStyleInt(YogaNodeMemoryLayout.styleAlignItems, alignItems.intValue()); - } - - @Override - public YogaAlign getAlignSelf() { - return YogaAlign.fromInt(getStyleInt(YogaNodeMemoryLayout.styleAlignSelf)); - } - - @Override - public void setAlignSelf(YogaAlign alignSelf) { - putStyleInt(YogaNodeMemoryLayout.styleAlignSelf, alignSelf.intValue()); - } - - @Override - public YogaAlign getAlignContent() { - return YogaAlign.fromInt(getStyleInt(YogaNodeMemoryLayout.styleAlignContent)); - } - - @Override - public void setAlignContent(YogaAlign alignContent) { - putStyleInt(YogaNodeMemoryLayout.styleAlignContent, alignContent.intValue()); - } - - @Override - public YogaPositionType getPositionType() { - return YogaPositionType.fromInt(getStyleInt(YogaNodeMemoryLayout.stylePositionType)); - } - - @Override - public void setPositionType(YogaPositionType positionType) { - putStyleInt(YogaNodeMemoryLayout.stylePositionType, positionType.intValue()); - } - - @Override - public void setWrap(YogaWrap flexWrap) { - putStyleInt(YogaNodeMemoryLayout.styleFlexWrap, flexWrap.intValue()); - } - - @Override - public YogaOverflow getOverflow() { - return YogaOverflow.fromInt(getStyleInt(YogaNodeMemoryLayout.styleOverflow)); - } - - @Override - public void setOverflow(YogaOverflow overflow) { - putStyleInt(YogaNodeMemoryLayout.styleOverflow, overflow.intValue()); - } - - @Override - public YogaDisplay getDisplay() { - return YogaDisplay.fromInt(getStyleInt(YogaNodeMemoryLayout.styleDisplay)); - } - - @Override - public void setDisplay(YogaDisplay display) { - putStyleInt(YogaNodeMemoryLayout.styleDisplay, display.intValue()); - } - - @Override - public void setFlex(float flex) { - putStyleOptional(YogaNodeMemoryLayout.styleFlex, flex); - } - - @Override - public float getFlexGrow() { - return getStyleFloat(YogaNodeMemoryLayout.styleFlexGrow); - } - - @Override - public void setFlexGrow(float flexGrow) { - putStyleOptional(YogaNodeMemoryLayout.styleFlexGrow, flexGrow); - } - - @Override - public float getFlexShrink() { - return getStyleFloat(YogaNodeMemoryLayout.styleFlexShrink); - } - - @Override - public void setFlexShrink(float flexShrink) { - putStyleOptional(YogaNodeMemoryLayout.styleFlexShrink, flexShrink); - } - - @Override - public YogaValue getFlexBasis() { - return getStyleValue(YogaNodeMemoryLayout.styleFlexBasis); - } - - @Override - public void setFlexBasis(float flexBasis) { - putStylePoints(YogaNodeMemoryLayout.styleFlexBasis, flexBasis); - } - - @Override - public void setFlexBasisPercent(float percent) { - putStylePercent(YogaNodeMemoryLayout.styleFlexBasis, percent); - } - - @Override - public void setFlexBasisAuto() { - putStyleAuto(YogaNodeMemoryLayout.styleFlexBasis); - } - - @Override - public YogaValue getMargin(YogaEdge edge) { - return getStyleValue(YogaNodeMemoryLayout.styleMarginOffset(edge)); - } - - @Override - public void setMargin(YogaEdge edge, float margin) { - putStylePoints(YogaNodeMemoryLayout.styleMarginOffset(edge), margin); - } - - @Override - public void setMarginPercent(YogaEdge edge, float percent) { - putStylePercent(YogaNodeMemoryLayout.styleMarginOffset(edge), percent); - } - - @Override - public void setMarginAuto(YogaEdge edge) { - putStyleAuto(YogaNodeMemoryLayout.styleMarginOffset(edge)); - } - - @Override - public YogaValue getPadding(YogaEdge edge) { - return getStyleValue(YogaNodeMemoryLayout.stylePaddingOffset(edge)); - } - - @Override - public void setPadding(YogaEdge edge, float padding) { - putStylePoints(YogaNodeMemoryLayout.stylePaddingOffset(edge), padding); - } - - @Override - public void setPaddingPercent(YogaEdge edge, float percent) { - putStylePercent(YogaNodeMemoryLayout.stylePaddingOffset(edge), percent); - } - - @Override - public float getBorder(YogaEdge edge) { - return mHasBorderSet - ? getStyleFloat(YogaNodeMemoryLayout.styleBorderOffset(edge)) - : YogaConstants.UNDEFINED; - } - - @Override - public void setBorder(YogaEdge edge, float border) { - mHasBorderSet = true; - putStylePoints(YogaNodeMemoryLayout.styleBorderOffset(edge), border); - } - - @Override - public YogaValue getPosition(YogaEdge edge) { - return getStyleValue(YogaNodeMemoryLayout.stylePositionOffset(edge)); - } - - @Override - public void setPosition(YogaEdge edge, float position) { - putStylePoints(YogaNodeMemoryLayout.stylePositionOffset(edge), position); - } - - @Override - public void setPositionPercent(YogaEdge edge, float percent) { - putStylePercent(YogaNodeMemoryLayout.stylePositionOffset(edge), percent); - } - - @Override - public YogaValue getWidth() { - return getStyleValue(YogaNodeMemoryLayout.styleWidth); - } - - @Override - public void setWidth(float width) { - putStylePoints(YogaNodeMemoryLayout.styleWidth, width); - } - - @Override - public void setWidthPercent(float percent) { - putStylePercent(YogaNodeMemoryLayout.styleWidth, percent); - } - - @Override - public void setWidthAuto() { - putStyleAuto(YogaNodeMemoryLayout.styleWidth); - } - - @Override - public YogaValue getHeight() { - return getStyleValue(YogaNodeMemoryLayout.styleHeight); - } - - @Override - public void setHeight(float height) { - putStylePoints(YogaNodeMemoryLayout.styleHeight, height); - } - - @Override - public void setHeightPercent(float percent) { - putStylePercent(YogaNodeMemoryLayout.styleHeight, percent); - } - - @Override - public void setHeightAuto() { - putStyleAuto(YogaNodeMemoryLayout.styleHeight); - } - - @Override - public YogaValue getMinWidth() { - return getStyleValue(YogaNodeMemoryLayout.styleMinWidth); - } - - @Override - public void setMinWidth(float minWidth) { - putStylePoints(YogaNodeMemoryLayout.styleMinWidth, minWidth); - } - - @Override - public void setMinWidthPercent(float percent) { - putStylePercent(YogaNodeMemoryLayout.styleMinWidth, percent); - } - - @Override - public YogaValue getMinHeight() { - return getStyleValue(YogaNodeMemoryLayout.styleMinHeight); - } - - @Override - public void setMinHeight(float minHeight) { - putStylePoints(YogaNodeMemoryLayout.styleMinHeight, minHeight); - } - - @Override - public void setMinHeightPercent(float percent) { - putStylePercent(YogaNodeMemoryLayout.styleMinHeight, percent); - } - - @Override - public YogaValue getMaxWidth() { - return getStyleValue(YogaNodeMemoryLayout.styleMaxWidth); - } - - @Override - public void setMaxWidth(float maxWidth) { - putStylePoints(YogaNodeMemoryLayout.styleMaxWidth, maxWidth); - } - - @Override - public void setMaxWidthPercent(float percent) { - putStylePercent(YogaNodeMemoryLayout.styleMaxWidth, percent); - } - - @Override - public YogaValue getMaxHeight() { - return getStyleValue(YogaNodeMemoryLayout.styleMaxHeight); - } - - @Override - public void setMaxHeight(float maxHeight) { - putStylePoints(YogaNodeMemoryLayout.styleMaxHeight, maxHeight); - } - - @Override - public void setMaxHeightPercent(float percent) { - putStylePercent(YogaNodeMemoryLayout.styleMaxHeight, percent); - } - - @Override - public float getAspectRatio() { - return getStyleOptional(YogaNodeMemoryLayout.styleAspectRatio); - } - - @Override - public void setAspectRatio(float aspectRatio) { - putStyleOptional(YogaNodeMemoryLayout.styleAspectRatio, aspectRatio); - } - - @Override - public float getLayoutX() { - return getLayoutFloat(YogaNodeMemoryLayout.layoutX); - } - - @Override - public float getLayoutY() { - return getLayoutFloat(YogaNodeMemoryLayout.layoutY); - } - - @Override - public float getLayoutWidth() { - return getLayoutFloat(YogaNodeMemoryLayout.layoutWidth); - } - - @Override - public float getLayoutHeight() { - return getLayoutFloat(YogaNodeMemoryLayout.layoutHeight); - } - - @Override - public boolean getDoesLegacyStretchFlagAffectsLayout() { - return getBool(mLayoutNativePointer + YogaNodeMemoryLayout.layoutDoesLegacyStretchFlagAffectsLayout); - } - - @Override - public float getLayoutMargin(YogaEdge edge) { - return getLayoutFloat(YogaNodeMemoryLayout.layoutMarginOffset(layoutEdge(edge))); - } - - @Override - public float getLayoutPadding(YogaEdge edge) { - return getLayoutFloat(YogaNodeMemoryLayout.layoutPaddingOffset(layoutEdge(edge))); - } - - @Override - public float getLayoutBorder(YogaEdge edge) { - return getLayoutFloat(YogaNodeMemoryLayout.layoutBorderOffset(layoutEdge(edge))); - } - - @Override - public YogaDirection getLayoutDirection() { - return YogaDirection.fromInt(getLayoutDirectionInt()); - } - - private static native void jni_YGNodeFree(long nativePointer); - - @Override - public void freeNatives() { - if (!mIsFreed) { - mIsFreed = true; - jni_YGNodeFree(mNativePointer); - } - } - - private int getLayoutDirectionInt() { - return UNSAFE.getInt(null, mLayoutNativePointer + YogaNodeMemoryLayout.layoutDirection); - } - - private YogaEdge layoutEdge(YogaEdge edge) { - int layoutDirection = getLayoutDirectionInt(); - switch (edge) { - case LEFT: - return layoutDirection == RTL ? YogaEdge.END : YogaEdge.START; - case RIGHT: - return layoutDirection == RTL ? YogaEdge.START : YogaEdge.END; - case TOP: - case BOTTOM: - case START: - case END: - return edge; - default: - throw new IllegalArgumentException("Cannot get layout properties of multi-edge shorthands"); - } - } - - private int getStyleInt(int offset) { - return UNSAFE.getInt(null, mStyleNativePointer + offset); - } - - private void putStyleInt(int offset, int value) { - UNSAFE.putInt(null, mStyleNativePointer + offset, value); - } - - private float getStyleFloat(int offset) { - return getFloat(mStyleNativePointer + offset); - } - - private void putStyleFloat(int offset, float value) { - putFloat(mStyleNativePointer + offset, value); - } - - private void putStylePoints(int offset, float value) { - putStyleValue(offset, value, POINT); - } - - private void putStylePercent(int offset, float value) { - putStyleValue(offset, value, PERCENT); - } - - private void putStyleAuto(int offset) { - putStyleValue(offset, 0, AUTO); - } - - private void putStyleValue(int offset, float value, int unit) { - if (YogaConstants.isUndefined(value)) { - value = YogaConstants.UNDEFINED; - unit = UNDEFINED; - } - putStyleFloat(offset, value); - putStyleInt(offset + FLOAT_SIZE, unit); - } - - private YogaValue getStyleValue(int offset) { - float value = getStyleFloat(offset); - int unit = getStyleInt(offset + FLOAT_SIZE); - return new YogaValue(value, YogaUnit.fromInt(unit)); - } - - private void putStyleOptional(int offset, float value) { - int isUndefinedBits = YogaConstants.isUndefined(value) ? TRUE_BITS : 0; - putStyleFloat(offset, value); - putStyleInt(offset + FLOAT_SIZE, isUndefinedBits); - } - - private float getStyleOptional(int offset) { - boolean isUndefined = getBool(mStyleNativePointer + offset + FLOAT_SIZE); - return isUndefined - ? YogaConstants.UNDEFINED - : getStyleFloat(offset); - } - - private float getLayoutFloat(int offset) { - return getFloat(mLayoutNativePointer + offset); - } - - private static float getFloat(long offset) { - int intBits = UNSAFE.getInt(null, offset); - return Float.intBitsToFloat(intBits); - } - - private static void putFloat(long offset, float value) { - int intBits = Float.floatToRawIntBits(value); - UNSAFE.putInt(null, offset, intBits); - } - - private static boolean getBool(long offset) { - // assumes little endian - return (UNSAFE.getInt(null, offset) & 0xFF) != 0; - } - -} diff --git a/ReactAndroid/src/main/jni/first-party/yogajni/jni/YGJNI.cpp b/ReactAndroid/src/main/jni/first-party/yogajni/jni/YGJNI.cpp index 482c14aed..6233cc231 100644 --- a/ReactAndroid/src/main/jni/first-party/yogajni/jni/YGJNI.cpp +++ b/ReactAndroid/src/main/jni/first-party/yogajni/jni/YGJNI.cpp @@ -6,7 +6,6 @@ * */ #include -#include #include #include #include @@ -22,23 +21,6 @@ struct JYogaConfig : public JavaClass { static constexpr auto kJavaDescriptor = "Lcom/facebook/yoga/YogaConfig;"; }; -struct JYogaNodePropertiesJNI : public JavaClass { - static constexpr auto kJavaDescriptor = - "Lcom/facebook/yoga/YogaNodePropertiesJNI;"; -}; - -struct JYogaNodePropertiesByteBuffer - : public JavaClass { - static constexpr auto kJavaDescriptor = - "Lcom/facebook/yoga/YogaNodePropertiesByteBuffer"; -}; - -struct JYogaNodePropertiesHybrid - : public JavaClass { - static constexpr auto kJavaDescriptor = - "Lcom/facebook/yoga/YogaNodePropertiesHybrid"; -}; - struct YGConfigContext { global_ref* logger; global_ref* config; @@ -51,34 +33,16 @@ struct YGConfigContext { } }; -struct JNINodeContext { - weak_ref node; - weak_ref props; -}; - static inline weak_ref* YGNodeJobject(YGNodeRef node) { - return &reinterpret_cast(node->getContext())->node; -} - -static inline weak_ref* YGNodePropsJObject( - YGNodeRef node) { - return &reinterpret_cast(node->getContext())->props; -} - -static inline void setNodeContext( - YGNodeRef node, - alias_ref javaNode, - alias_ref javaNodeProps) { - node->setContext( - new JNINodeContext{make_weak(javaNode), make_weak(javaNodeProps)}); + return reinterpret_cast*>(node->getContext()); } static void YGTransferLayoutDirection( YGNodeRef node, - alias_ref javaProps) { + alias_ref javaNode) { static auto layoutDirectionField = - javaProps->getClass()->getField("mLayoutDirection"); - javaProps->setFieldValue( + javaNode->getClass()->getField("mLayoutDirection"); + javaNode->setFieldValue( layoutDirectionField, static_cast(YGNodeLayoutGetDirection(node))); } @@ -86,7 +50,7 @@ static void YGTransferLayoutOutputsRecursive(YGNodeRef root) { if (!root->getHasNewLayout()) { return; } - auto obj = YGNodePropsJObject(root)->lockLocal(); + auto obj = YGNodeJobject(root)->lockLocal(); if (!obj) { YGLog( root, @@ -259,9 +223,7 @@ static YGSize YGJNIMeasureFunc( findClassStatic("com/facebook/yoga/YogaNode") ->getMethod("measure"); - if (auto jProps = YGNodePropsJObject(node)->lockLocal()) { - YGTransferLayoutDirection(node, jProps); - } + YGTransferLayoutDirection(node, obj); const auto measureResult = measureFunc(obj, width, widthMode, height, heightMode); @@ -325,36 +287,22 @@ static int YGJNILogFunc( return result; } -jlong jni_YGNodeNew( - alias_ref javaProps, - alias_ref javaNode) { +jlong jni_YGNodeNew(alias_ref thiz) { const YGNodeRef node = YGNodeNew(); - setNodeContext(node, javaNode, javaProps); + node->setContext(new weak_ref(make_weak(thiz))); + // YGNodeSetContext(node, new weak_ref(make_weak(thiz))); node->setPrintFunc(YGPrint); + // YGNodeSetPrintFunc(node, YGPrint); return reinterpret_cast(node); } -jlong jni_YGNodeNewWithConfig( - alias_ref javaProps, - alias_ref javaNode, - jlong configPointer) { +jlong jni_YGNodeNewWithConfig(alias_ref thiz, jlong configPointer) { const YGNodeRef node = YGNodeNewWithConfig(_jlong2YGConfigRef(configPointer)); - setNodeContext(node, javaNode, javaProps); + node->setContext(new weak_ref(make_weak(thiz))); node->setPrintFunc(YGPrint); return reinterpret_cast(node); } -jlong jni_YGNodeNewNoProps(alias_ref, alias_ref javaNode) { - return jni_YGNodeNew(nullptr, javaNode); -} - -jlong jni_YGNodeNewNoPropsWithConfig( - alias_ref, - alias_ref javaNode, - jlong configPointer) { - return jni_YGNodeNewWithConfig(nullptr, javaNode, configPointer); -} - void jni_YGNodeSetOwner( alias_ref thiz, jlong nativePointer, @@ -366,28 +314,21 @@ void jni_YGNodeSetOwner( } jlong jni_YGNodeClone( - alias_ref, + alias_ref thiz, jlong nativePointer, - alias_ref clonedJavaObject, - alias_ref clonedJavaProps) { + alias_ref clonedJavaObject) { const YGNodeRef clonedYogaNode = YGNodeClone(_jlong2YGNodeRef(nativePointer)); - setNodeContext(clonedYogaNode, clonedJavaObject, clonedJavaProps); + clonedYogaNode->setContext( + new weak_ref(make_weak(clonedJavaObject))); return reinterpret_cast(clonedYogaNode); } -jlong jni_YGNodeCloneNoProps( - alias_ref cls, - jlong nativePointer, - alias_ref clonedJavaObject) { - return jni_YGNodeClone(cls, nativePointer, clonedJavaObject, nullptr); -} - -void jni_YGNodeFree(alias_ref thiz, jlong nativePointer) { +void jni_YGNodeFree(alias_ref, jlong nativePointer) { if (nativePointer == 0) { return; } const YGNodeRef node = _jlong2YGNodeRef(nativePointer); - delete reinterpret_cast(node->getContext()); + delete YGNodeJobject(node); YGNodeFree(node); } @@ -438,7 +379,7 @@ void jni_YGNodeRemoveChild( _jlong2YGNodeRef(nativePointer), _jlong2YGNodeRef(childPointer)); } -jboolean jni_YGNodeCalculateLayout( +void jni_YGNodeCalculateLayout( alias_ref, jlong nativePointer, jfloat width, @@ -449,13 +390,6 @@ jboolean jni_YGNodeCalculateLayout( static_cast(width), static_cast(height), YGNodeStyleGetDirection(_jlong2YGNodeRef(nativePointer))); - return root->getHasNewLayout(); -} - -static void jni_YGTransferLayoutOutputsRecursive( - alias_ref, - jlong nativePointer) { - const YGNodeRef root = _jlong2YGNodeRef(nativePointer); YGTransferLayoutOutputsRecursive(root); } @@ -729,43 +663,29 @@ void jni_YGConfigSetLogger( jint jni_YGNodeGetInstanceCount(alias_ref clazz) { return YGNodeGetInstanceCount(); } -local_ref jni_getStyleBuffer( - alias_ref, - jlong nativePointer) { - YGStyle* style = &_jlong2YGNodeRef(nativePointer)->getStyle(); - return JByteBuffer::wrapBytes( - reinterpret_cast(style), sizeof(YGStyle)); -} - -local_ref jni_getLayoutBuffer( - alias_ref, - jlong nativePointer) { - YGLayout* layout = &_jlong2YGNodeRef(nativePointer)->getLayout(); - return JByteBuffer::wrapBytes( - reinterpret_cast(layout), sizeof(YGLayout)); -} - -jlong jni_YGNodeStylePointer(alias_ref, jlong nativePointer) { - return reinterpret_cast(&_jlong2YGNodeRef(nativePointer)->getStyle()); -} - -jlong jni_YGNodeLayoutPointer(alias_ref, jlong nativePointer) { - return reinterpret_cast(&_jlong2YGNodeRef(nativePointer)->getLayout()); -} #define YGMakeNativeMethod(name) makeNativeMethod(#name, name) jint JNI_OnLoad(JavaVM* vm, void*) { return initialize(vm, [] { registerNatives( - "com/facebook/yoga/YogaNodePropertiesJNI", + "com/facebook/yoga/YogaNode", { - YGMakeNativeMethod(jni_YGNodeClone), YGMakeNativeMethod(jni_YGNodeNew), YGMakeNativeMethod(jni_YGNodeNewWithConfig), YGMakeNativeMethod(jni_YGNodeFree), YGMakeNativeMethod(jni_YGNodeReset), + YGMakeNativeMethod(jni_YGNodeClearChildren), + YGMakeNativeMethod(jni_YGNodeInsertChild), + YGMakeNativeMethod(jni_YGNodeInsertSharedChild), + YGMakeNativeMethod(jni_YGNodeRemoveChild), + YGMakeNativeMethod(jni_YGNodeCalculateLayout), + YGMakeNativeMethod(jni_YGNodeMarkDirty), + YGMakeNativeMethod(jni_YGNodeMarkDirtyAndPropogateToDescendants), YGMakeNativeMethod(jni_YGNodeIsDirty), + YGMakeNativeMethod(jni_YGNodeSetHasMeasureFunc), + YGMakeNativeMethod(jni_YGNodeSetHasBaselineFunc), + YGMakeNativeMethod(jni_YGNodeCopyStyle), YGMakeNativeMethod(jni_YGNodeStyleGetDirection), YGMakeNativeMethod(jni_YGNodeStyleSetDirection), YGMakeNativeMethod(jni_YGNodeStyleGetFlexDirection), @@ -828,23 +748,9 @@ jint JNI_OnLoad(JavaVM* vm, void*) { YGMakeNativeMethod(jni_YGNodeStyleSetMaxHeightPercent), YGMakeNativeMethod(jni_YGNodeStyleGetAspectRatio), YGMakeNativeMethod(jni_YGNodeStyleSetAspectRatio), - YGMakeNativeMethod(jni_YGTransferLayoutOutputsRecursive), - }); - registerNatives( - "com/facebook/yoga/YogaNode", - { - YGMakeNativeMethod(jni_YGNodeClearChildren), - YGMakeNativeMethod(jni_YGNodeInsertChild), - YGMakeNativeMethod(jni_YGNodeInsertSharedChild), - YGMakeNativeMethod(jni_YGNodeRemoveChild), - YGMakeNativeMethod(jni_YGNodeCalculateLayout), - YGMakeNativeMethod(jni_YGNodeMarkDirty), - YGMakeNativeMethod(jni_YGNodeMarkDirtyAndPropogateToDescendants), - YGMakeNativeMethod(jni_YGNodeSetHasMeasureFunc), - YGMakeNativeMethod(jni_YGNodeSetHasBaselineFunc), - YGMakeNativeMethod(jni_YGNodeCopyStyle), YGMakeNativeMethod(jni_YGNodeGetInstanceCount), YGMakeNativeMethod(jni_YGNodePrint), + YGMakeNativeMethod(jni_YGNodeClone), YGMakeNativeMethod(jni_YGNodeSetOwner), }); registerNatives( @@ -861,34 +767,5 @@ jint JNI_OnLoad(JavaVM* vm, void*) { YGMakeNativeMethod( jni_YGConfigSetShouldDiffLayoutWithoutLegacyStretchBehaviour), }); - registerNatives( - "com/facebook/yoga/YogaNodePropertiesByteBuffer", - { - YGMakeNativeMethod(jni_YGNodeCloneNoProps), - YGMakeNativeMethod(jni_YGNodeFree), - YGMakeNativeMethod(jni_YGNodeNewNoProps), - YGMakeNativeMethod(jni_YGNodeNewNoPropsWithConfig), - YGMakeNativeMethod(jni_YGNodeReset), - YGMakeNativeMethod(jni_YGNodeIsDirty), - YGMakeNativeMethod(jni_getStyleBuffer), - YGMakeNativeMethod(jni_getLayoutBuffer), - }); - registerNatives( - "com/facebook/yoga/YogaNodePropertiesHybrid", - { - YGMakeNativeMethod(jni_getStyleBuffer), - }); - registerNatives( - "com/facebook/yoga/YogaNodePropertiesUnsafe", - { - YGMakeNativeMethod(jni_YGNodeCloneNoProps), - YGMakeNativeMethod(jni_YGNodeFree), - YGMakeNativeMethod(jni_YGNodeNewNoProps), - YGMakeNativeMethod(jni_YGNodeNewNoPropsWithConfig), - YGMakeNativeMethod(jni_YGNodeStylePointer), - YGMakeNativeMethod(jni_YGNodeLayoutPointer), - YGMakeNativeMethod(jni_YGNodeIsDirty), - YGMakeNativeMethod(jni_YGNodeReset), - }); }); } diff --git a/ReactAndroid/stubs/build.gradle b/ReactAndroid/stubs/build.gradle deleted file mode 100644 index f2faa4464..000000000 --- a/ReactAndroid/stubs/build.gradle +++ /dev/null @@ -1,10 +0,0 @@ -apply plugin: 'java' - -sourceSets { - main { - java { - srcDirs = ['src'] - } - } -} - diff --git a/ReactAndroid/stubs/src/sun/misc/Unsafe.java b/ReactAndroid/stubs/src/sun/misc/Unsafe.java deleted file mode 100644 index 01ff08dc8..000000000 --- a/ReactAndroid/stubs/src/sun/misc/Unsafe.java +++ /dev/null @@ -1,27 +0,0 @@ -/* - * Copyright (c) 2018-present, Facebook, Inc. - * - * This source code is licensed under the MIT license found in the LICENSE - * file in the root directory of this source tree. - * - */ - -package sun.misc; - -/** - * Stub for sun.misc.Unsafe, which is not exposed by the Android SDK. - * - * This only contains the methods and fields we need for Yoga. - */ -public final class Unsafe { - private static final Unsafe theUnsafe = null; - - public final int getInt(Object object, long offset) { - throw new RuntimeException("Stub!"); - } - - public final void putInt(Object object, long offset, int value) { - throw new RuntimeException("Stub!"); - } -} - diff --git a/ReactNative/DEFS.bzl b/ReactNative/DEFS.bzl index a54788fe1..1f50344f6 100644 --- a/ReactNative/DEFS.bzl +++ b/ReactNative/DEFS.bzl @@ -271,5 +271,3 @@ def jni_instrumentation_test_lib(**kwargs): def fb_xplat_cxx_test(**kwargs): """A noop stub for OSS build.""" pass - -JAVA_STUBS_TARGET = "//ReactAndroid:stubs" diff --git a/build.gradle b/build.gradle index 0b249a64d..71634a0cb 100644 --- a/build.gradle +++ b/build.gradle @@ -6,7 +6,6 @@ buildscript { repositories { jcenter() - google() mavenLocal() maven { url 'https://maven.google.com/' @@ -14,7 +13,7 @@ buildscript { } } dependencies { - classpath 'com.android.tools.build:gradle:3.0.0' + classpath 'com.android.tools.build:gradle:2.3.3' classpath 'de.undercouch:gradle-download-task:3.4.3' // NOTE: Do not place your application dependencies here; they belong diff --git a/settings.gradle b/settings.gradle index 82bef34dc..c68c5a20f 100644 --- a/settings.gradle +++ b/settings.gradle @@ -3,4 +3,4 @@ // This source code is licensed under the MIT license found in the // LICENSE file in the root directory of this source tree. -include ':ReactAndroid', ':RNTester:android:app', ':ReactAndroid:stubs' +include ':ReactAndroid', ':RNTester:android:app'